From 90e452f0c9103ab3cb4a3432ad076f0face3baa4 Mon Sep 17 00:00:00 2001 From: gfuse Date: Mon, 23 Aug 2021 15:35:30 +0200 Subject: [PATCH] add banchmark image alignment 2 --- .idea/.gitignore | 8 + .idea/.name | 1 + .idea/Benchmark_openCL.iml | 2 + .idea/misc.xml | 4 + .idea/modules.xml | 8 + .idea/vcs.xml | 6 + CMakeModules/FindEigen.cmake | 81 ++ include/aligned_mem.h | 127 +++ include/math_utils.h | 172 ++++ include/nlls_solver.h | 173 ++++ include/nlls_solver_impl.hpp | 315 +++++++ include/robust_cost.h | 156 ++++ include/sparse_img_align_gpu.h | 75 ++ include/vision.h | 80 ++ kernel/Freak c++ files/freak.cpp | 844 ++++++++++++++++++ .../preprocessing_befor_kernel.cpp | 172 ++++ kernel/compute-residual.cl | 165 ++++ kernel/freak.cl | 129 +++ kernel/integral_image.cl | 13 + main2.cpp | 42 + src/math_utils.cpp | 202 +++++ src/robust_cost.cpp | 166 ++++ src/sparse_img_align_gpu.cpp | 268 ++++++ test/data/cur2.png | Bin 0 -> 11799 bytes test/data/cur3.png | Bin 0 -> 3536 bytes test/data/cur4.png | Bin 0 -> 1084 bytes test/data/data.txt | 85 ++ test/data/fer2.png | Bin 0 -> 11824 bytes test/data/fer3.png | Bin 0 -> 3545 bytes test/data/fer4.png | Bin 0 -> 1081 bytes test/data0/test1.png | Bin 0 -> 362086 bytes test/res/ref2.png | Bin 0 -> 32844 bytes test/res/ref3.png | Bin 0 -> 9708 bytes test/res/ref4.png | Bin 0 -> 2887 bytes 34 files changed, 3294 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/.name create mode 100644 .idea/Benchmark_openCL.iml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 CMakeModules/FindEigen.cmake create mode 100644 include/aligned_mem.h create mode 100644 include/math_utils.h create mode 100644 include/nlls_solver.h create mode 100644 include/nlls_solver_impl.hpp create mode 100644 include/robust_cost.h create mode 100644 include/sparse_img_align_gpu.h create mode 100644 include/vision.h create mode 100644 kernel/Freak c++ files/freak.cpp create mode 100644 kernel/Freak c++ files/preprocessing_befor_kernel.cpp create mode 100644 kernel/compute-residual.cl create mode 100644 kernel/freak.cl create mode 100644 kernel/integral_image.cl create mode 100644 main2.cpp create mode 100644 src/math_utils.cpp create mode 100644 src/robust_cost.cpp create mode 100644 src/sparse_img_align_gpu.cpp create mode 100644 test/data/cur2.png create mode 100644 test/data/cur3.png create mode 100644 test/data/cur4.png create mode 100644 test/data/data.txt create mode 100644 test/data/fer2.png create mode 100644 test/data/fer3.png create mode 100644 test/data/fer4.png create mode 100644 test/data0/test1.png create mode 100644 test/res/ref2.png create mode 100644 test/res/ref3.png create mode 100644 test/res/ref4.png diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/.name b/.idea/.name new file mode 100644 index 0000000..8d3ae0f --- /dev/null +++ b/.idea/.name @@ -0,0 +1 @@ +Vio_OpenCL \ No newline at end of file diff --git a/.idea/Benchmark_openCL.iml b/.idea/Benchmark_openCL.iml new file mode 100644 index 0000000..f08604b --- /dev/null +++ b/.idea/Benchmark_openCL.iml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..79b3c94 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..2cc944c --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/CMakeModules/FindEigen.cmake b/CMakeModules/FindEigen.cmake new file mode 100644 index 0000000..8587367 --- /dev/null +++ b/CMakeModules/FindEigen.cmake @@ -0,0 +1,81 @@ +############################################################################### +# +# CMake script for finding the Eigen library. +# +# http://eigen.tuxfamily.org/index.php?title=Main_Page +# +# Copyright (c) 2006, 2007 Montel Laurent, +# Copyright (c) 2008, 2009 Gael Guennebaud, +# Copyright (c) 2009 Benoit Jacob +# Redistribution and use is allowed according to the terms of the 2-clause BSD +# license. +# +# +# Input variables: +# +# - Eigen_ROOT_DIR (optional): When specified, header files and libraries +# will be searched for in `${Eigen_ROOT_DIR}/include` and +# `${Eigen_ROOT_DIR}/libs` respectively, and the default CMake search order +# will be ignored. When unspecified, the default CMake search order is used. +# This variable can be specified either as a CMake or environment variable. +# If both are set, preference is given to the CMake variable. +# Use this variable for finding packages installed in a nonstandard location, +# or for enforcing that one of multiple package installations is picked up. +# +# Cache variables (not intended to be used in CMakeLists.txt files) +# +# - Eigen_INCLUDE_DIR: Absolute path to package headers. +# +# +# Output variables: +# +# - Eigen_FOUND: Boolean that indicates if the package was found +# - Eigen_INCLUDE_DIRS: Paths to the necessary header files +# - Eigen_VERSION: Version of Eigen library found +# - Eigen_DEFINITIONS: Definitions to be passed on behalf of eigen +# +# +# Example usage: +# +# # Passing the version means Eigen_FOUND will only be TRUE if a +# # version >= the provided version is found. +# find_package(Eigen 3.1.2) +# if(NOT Eigen_FOUND) +# # Error handling +# endif() +# ... +# add_definitions(${Eigen_DEFINITIONS}) +# ... +# include_directories(${Eigen_INCLUDE_DIRS} ...) +# +############################################################################### + +find_package(PkgConfig) +pkg_check_modules(PC_EIGEN eigen3) +set(EIGEN_DEFINITIONS ${PC_EIGEN_CFLAGS_OTHER}) + + +find_path(EIGEN_INCLUDE_DIR Eigen/Core + HINTS ${PC_EIGEN_INCLUDEDIR} ${PC_EIGEN_INCLUDE_DIRS} + "${Eigen_ROOT_DIR}" "$ENV{EIGEN_ROOT_DIR}" + "${EIGEN_ROOT}" "$ENV{EIGEN_ROOT}" # Backwards Compatibility + PATHS "$ENV{PROGRAMFILES}/Eigen" "$ENV{PROGRAMW6432}/Eigen" + "$ENV{PROGRAMFILES}/Eigen 3.0.0" "$ENV{PROGRAMW6432}/Eigen 3.0.0" + PATH_SUFFIXES eigen3 include/eigen3 include) + +set(EIGEN_INCLUDE_DIRS ${EIGEN_INCLUDE_DIR}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Eigen DEFAULT_MSG EIGEN_INCLUDE_DIR) + +mark_as_advanced(EIGEN_INCLUDE_DIR) + +if(EIGEN_FOUND) + message(STATUS "Eigen found (include: ${EIGEN_INCLUDE_DIRS})") +endif(EIGEN_FOUND) + + +set(Eigen_INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}) +set(Eigen_FOUND ${EIGEN_FOUND}) +set(Eigen_VERSION ${EIGEN_VERSION}) +set(Eigen_DEFINITIONS ${EIGEN_DEFINITIONS}) diff --git a/include/aligned_mem.h b/include/aligned_mem.h new file mode 100644 index 0000000..ef14742 --- /dev/null +++ b/include/aligned_mem.h @@ -0,0 +1,127 @@ +/* + * aligned_mem.h + * + * Created on: May 14, 2013 + * Author: cforster + * + * Code from libcvd: cvd/internal/aligned_mem.h + * https://github.com/edrosten/libcvd + * Licence: LGPL 2.1 + */ + +#ifndef VIKIT_ALIGNED_MEM_H_ +#define VIKIT_ALIGNED_MEM_H_ + +#include // memset +#include // memset +#include +#include + +namespace vk { +namespace aligned_mem { + + /// Check if the pointer is aligned to the specified byte granularity + inline bool + is_aligned8(const void* ptr) + { + return ((reinterpret_cast(ptr)) & 0x7) == 0; + } + + inline bool + is_aligned16(const void* ptr) + { + return ((reinterpret_cast(ptr)) & 0xF) == 0; + } + + template struct placement_delete + { + enum { Size = (1<= Size) { + placement_delete::free(buf+Size,M-Size); + placement_delete::destruct(buf); + } else { + placement_delete::free(buf, M); + } + } + }; + + template struct placement_delete + { + static inline void free(T*, size_t ) {} + }; + + inline void * aligned_alloc(size_t count, size_t alignment){ + void * mem = NULL; + assert(posix_memalign(&mem, alignment, count) == 0); + return mem; + } + + inline void aligned_free(void * memory) { + free(memory); + } + + template + inline T * aligned_alloc(size_t count, size_t alignment){ + void * data = aligned_alloc(sizeof(T)* count, alignment); + return new (data) T[count]; + } + + template + inline void aligned_free(T * memory, size_t count){ + placement_delete::free(memory, count); + aligned_free(memory); + } + + template inline void memfill(T* data, int n, const T val) + { + T* de = data + n; + for(;data < de; data++) + *data=val; + } + + template<> inline void memfill(unsigned char* data, int n, const unsigned char val) + { + memset(data, val, n); + } + + template<> inline void memfill(signed char* data, int n, const signed char val) + { + memset(data, val, n); + } + + template<> inline void memfill(char* data, int n, const char val) + { + memset(data, val, n); + } + + template + struct AlignedMem { + T* mem; + size_t count; + AlignedMem(size_t c) : count(c) { + mem = aligned_alloc(count, N); + } + ~AlignedMem() { + aligned_free(mem, count); + } + T* data() { return mem; } + const T* data() const { return mem; } + }; + +} // namespace aligned_mem +} // namespace vikit + + +#endif // VIKIT_ALIGNED_MEM_H_ diff --git a/include/math_utils.h b/include/math_utils.h new file mode 100644 index 0000000..05cd7a0 --- /dev/null +++ b/include/math_utils.h @@ -0,0 +1,172 @@ +/* + * math_utils.h + * + * Created on: Jul 20, 2012 + * Author: cforster + */ + +#ifndef MATH_UTILS_H_ +#define MATH_UTILS_H_ + + +#include +#include +#include +#include + +namespace vk +{ + +using namespace Eigen; +using namespace std; +using namespace Sophus; + +Vector3d triangulateFeatureNonLin( + const Matrix3d& R, + const Vector3d& t, + const Vector3d& feature1, + const Vector3d& feature2); + +/// Assumes the bearing vectors f_c and f_r are on the epipolar plane, i.e. +/// perfect triangulation without noise! +bool depthFromTriangulationExact( + const Matrix3d& R_r_c, + const Vector3d& t_r_c, + const Vector3d& f_r, + const Vector3d& f_c, + double& depth_in_r, + double& depth_in_c); + +double reprojError( + const Vector3d& f1, + const Vector3d& f2, + double error_multiplier2); + +double computeInliers( + const vector& features1, + const vector& features2, + const Matrix3d& R, + const Vector3d& t, + const double reproj_thresh, + double error_multiplier2, + vector& xyz_vec, + vector& inliers, + vector& outliers); + +void computeInliersOneView( + const vector & feature_sphere_vec, + const vector & xyz_vec, + const Matrix3d &R, + const Vector3d &t, + const double reproj_thresh, + const double error_multiplier2, + vector& inliers, + vector& outliers); + +//! Direct Cosine Matrix to Roll Pitch Yaw +Vector3d dcm2rpy(const Matrix3d &R); + +//! Roll Pitch Yaw to Direct Cosine Matrix +Matrix3d rpy2dcm(const Vector3d &rpy); + +//! Angle Axis parametrization to Quaternion +Quaterniond angax2quat(const Vector3d& n, const double& angle); + +//! Angle Axis parametrization to Matrix representation +Matrix3d angax2dcm(const Vector3d& n, const double& angle); + +double sampsonusError( + const Vector2d &v2Dash, + const Matrix3d& m3Essential, + const Vector2d& v2); + +inline Matrix3d sqew(const Vector3d& v) +{ + Matrix3d v_sqew; + v_sqew << 0, -v[2], v[1], + v[2], 0, -v[0], + -v[1], v[0], 0; + return v_sqew; +} + +inline double norm_max(const Eigen::VectorXd & v) +{ + double max = -1; + for (int i=0; imax){ + max = abs; + } + } + return max; +} + +inline Vector2d project2d(const Vector3d& v) +{ + return v.head<2>()/v[2]; +} + +inline Vector3d unproject2d(const Vector2d& v) +{ + return Vector3d(v[0], v[1], 1.0); +} + +inline Vector3d project3d(const Vector4d& v) +{ + return v.head<3>()/v[3]; +} + +inline Vector4d unproject3d(const Vector3d& v) +{ + return Vector4d(v[0], v[1], v[2], 1.0); +} + +template +T getMedian(vector& data_vec) +{ + assert(!data_vec.empty()); + typename vector::iterator it = data_vec.begin()+floor(data_vec.size()/2); + nth_element(data_vec.begin(), it, data_vec.end()); + return *it; +} + +inline double pyrFromZero_d(double x_0, int level) +{ + return x_0/(1< & frame_jac) +{ + const double x = xyz[0]; + const double y = xyz[1]; + const double z = xyz[2]; + const double z_2 = z*z; + + frame_jac(0,0) = -1./z *focal_length; + frame_jac(0,1) = 0; + frame_jac(0,2) = x/z_2 *focal_length; + frame_jac(0,3) = x*y/z_2 * focal_length; + frame_jac(0,4) = -(1+(x*x/z_2)) *focal_length; + frame_jac(0,5) = y/z *focal_length; + + frame_jac(1,0) = 0; + frame_jac(1,1) = -1./z *focal_length; + frame_jac(1,2) = y/z_2 *focal_length; + frame_jac(1,3) = (1+y*y/z_2) *focal_length; + frame_jac(1,4) = -x*y/z_2 *focal_length; + frame_jac(1,5) = -x/z *focal_length; +} + +} // end namespace vk + +#endif /* MATH_UTILS_H_ */ diff --git a/include/nlls_solver.h b/include/nlls_solver.h new file mode 100644 index 0000000..e3695ab --- /dev/null +++ b/include/nlls_solver.h @@ -0,0 +1,173 @@ +/* + * Abstract Nonlinear Least-Squares Solver Class + * + * nlls_solver.h + * + * Created on: Nov 5, 2012 + * Author: cforster + */ + +#ifndef LM_SOLVER_H_ +#define LM_SOLVER_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace vk { + +using namespace std; +using namespace Eigen; + +/** + * \brief Abstract Class for solving nonlinear least-squares (NLLS) problems. + * + * The function implements two algorithms: Levenberg Marquardt and Gauss Newton + * + * Example implementations of this function can be found in the rpl_examples + * package: img_align_2d.cpp, img_align_3d.cpp + * + * Template Parameters: + * D : dimension of the residual + * T : type of the model, e.g. SE2, SE3 + */ + +template +class NLLSSolver { + +public: + typedef T ModelType; + enum Method{GaussNewton, LevenbergMarquardt}; + enum ScaleEstimatorType{UnitScale, TDistScale, MADScale, NormalScale}; + enum WeightFunctionType{UnitWeight, TDistWeight, TukeyWeight, HuberWeight}; + +protected: + Matrix H_; //!< Hessian approximation + Matrix Jres_; //!< Jacobian x Residual + Matrix x_; //!< update step + bool have_prior_; + ModelType prior_; + Matrix I_prior_; //!< Prior information matrix (inverse covariance) + double chi2_; + double rho_; + Method method_; + + /// If the flag linearize_system is set, the function must also compute the + /// Jacobian and set the member variables H_, Jres_ + virtual double + computeResiduals (const ModelType& model, + bool linearize_system, + bool compute_weight_scale) = 0; + virtual double + computeResiduals (bool linearize_system, + bool compute_weight_scale) = 0; + + /// Solve the linear system H*x = Jres. This function must set the update + /// step in the member variable x_. Must return true if the system could be + /// solved and false if it was singular. + virtual int + solve () = 0; + + virtual void + update (const ModelType& old_model, ModelType& new_model) = 0; + virtual void + update () = 0; + + virtual void + applyPrior (const ModelType& current_model) { } + + virtual void + startIteration () { } + + virtual void + finishIteration () { } + + virtual void + finishTrial () { } + +public: + + /// Damping parameter. If mu > 0, coefficient matrix is positive definite, this + /// ensures that x is a descent direction. If mu is large, x is a short step in + /// the steepest direction. This is good if the current iterate is far from the + /// solution. If mu is small, LM approximates gauss newton iteration and we + /// have (almost) quadratic convergence in the final stages. + double mu_init_, mu_; + double nu_init_, nu_; //!< Increase factor of mu after fail + size_t n_iter_init_, n_iter_; //!< Number of Iterations + size_t n_trials_; //!< Number of trials + size_t n_trials_max_; //!< Max number of trials + size_t n_meas_; //!< Number of measurements + bool stop_; //!< Stop flag + bool verbose_; //!< Output Statistics + double eps_; //!< Stop if update norm is smaller than eps + size_t iter_; //!< Current Iteration + + // robust least squares + bool use_weights_; + float scale_=2.0; + vk::robust_cost::ScaleEstimatorPtr scale_estimator_; + vk::robust_cost::WeightFunctionPtr weight_function_; + + NLLSSolver() : + have_prior_(false), + method_(LevenbergMarquardt), + mu_init_(0.01f), + mu_(mu_init_), + nu_init_(2.0), + nu_(nu_init_), + n_iter_init_(15), + n_iter_(n_iter_init_), + n_trials_(0), + n_trials_max_(5), + n_meas_(0), + stop_(false), + verbose_(true), + eps_(0.0000000001), + iter_(0), + use_weights_(false), + scale_estimator_(NULL), + weight_function_(NULL) + { } + + virtual ~NLLSSolver() {} + + /// Calls the GaussNewton or LevenbergMarquardt optimization strategy + void optimize(ModelType& model); + + /// Gauss Newton optimization strategy + void optimizeGaussNewton(); + + /// Levenberg Marquardt optimization strategy + void optimizeLevenbergMarquardt(ModelType& model); + + /// Specify the robust cost that should be used and the appropriate scale estimator + void setRobustCostFunction( + ScaleEstimatorType scale_estimator, + WeightFunctionType weight_function); + + /// Add prior to optimization. + void setPrior( + const ModelType& prior, + const Matrix& Information); + + /// Reset all parameters to restart the optimization + void reset(); + + /// Get the squared error + const double& getChi2() const; + + /// The Information matrix is equal to the inverse covariance matrix. + const Matrix& getInformationMatrix() const; +}; + +} // end namespace vk + +#include "nlls_solver_impl.hpp" + +#endif /* LM_SOLVER_H_ */ diff --git a/include/nlls_solver_impl.hpp b/include/nlls_solver_impl.hpp new file mode 100644 index 0000000..edc3174 --- /dev/null +++ b/include/nlls_solver_impl.hpp @@ -0,0 +1,315 @@ +/* + * Abstract Nonlinear Least-Squares Solver Class + * + * nlls_solver.h + * + * Created on: Nov 5, 2012 + * Author: cforster + */ + +#ifndef LM_SOLVER_IMPL_HPP_ +#define LM_SOLVER_IMPL_HPP_ + +#include + +template +void vk::NLLSSolver::optimize(ModelType& model) +{ + if(method_ == GaussNewton) + optimizeGaussNewton(); + else if(method_ == LevenbergMarquardt) + optimizeLevenbergMarquardt(model); +} + +template +void vk::NLLSSolver::optimizeGaussNewton() +{ + // Compute weight scale + if(use_weights_) + computeResiduals(false, true); + // perform iterative estimation + for (iter_ = 0; iter_ 0 && new_chi2 > chi2_) || stop_) + { + if(verbose_) + { + std::cerr << "It. " << iter_ + << "\t Failure" + << "\t new_chi2 = " << new_chi2 + << "\t Error increased. Stop optimizing.\n"; + } + break; + } + // update the model + update(); + chi2_ = new_chi2; + if(verbose_) + { + std::cerr << "It. " << iter_ + << "\t Success" + << "\t new_chi2 = " << new_chi2 + << "\t x_norm = " << vk::norm_max(x_)<<'\n'; + } + // stop when converged, i.e. update step too small + if(vk::norm_max(x_)<=eps_) + break; + } +} + +template +void vk::NLLSSolver::optimizeLevenbergMarquardt(ModelType& model) +{ + // Compute weight scale + if(use_weights_) + computeResiduals(model, false, true); + + // compute the initial error + chi2_ = computeResiduals(model, true, false); + + if(verbose_) + cout << "init chi2 = " << chi2_ + << "\t n_meas = " << n_meas_ + << endl; + + // TODO: compute initial lambda + // Hartley and Zisserman: "A typical init value of lambda is 10^-3 times the + // average of the diagonal elements of J'J" + + // Compute Initial Lambda + if(mu_ < 0) + { + double H_max_diag = 0; + double tau = 1e-4; + for(size_t j=0; j::Identity(D,D); + Jres_.setZero(); + + // compute initial error + n_meas_ = 0; + computeResiduals(model, true, false); + + // add damping term: + H_ += (H_.diagonal()*mu_).asDiagonal(); + + // add prior + if(have_prior_) + applyPrior(model); + + // solve the linear system + if(solve()) + { + // update the model + update(model, new_model); + + // compute error with new model and compare to old error + n_meas_ = 0; + new_chi2 = computeResiduals(new_model, true, false); + rho_ = chi2_-new_chi2; + } + else + { + // matrix was singular and could not be computed + cout << "Matrix is close to singular!" << endl; + cout << "H = " << H_ << endl; + cout << "Jres = " << Jres_ << endl; + rho_ = -1; + } + + if(rho_>0) + { + // update decrased the error -> success + model = new_model; + chi2_ = new_chi2; + stop_ = vk::norm_max(x_)<=eps_ ? true : false; + mu_ *= max(1./3., min(1.-pow(2*rho_-1,3), 2./3.)); + nu_ = 2.; + if(verbose_) + { + cout << "It. " << iter_ + << "\t Trial " << n_trials_ + << "\t Success" + << "\t n_meas = " << n_meas_ + << "\t new_chi2 = " << new_chi2 + << "\t mu = " << mu_ + << "\t nu = " << nu_ + << "\t x_norm = " << vk::norm_max(x_) + << endl; + } + } + else + { + if(sign){ + if(verbose_) + { + cout << "It. " << iter_ + << "\t Trial " << n_trials_ + << "\t Failure" + << "\t n_meas = " << n_meas_ + << "\t new_chi2 = " << new_chi2 + << "\t mu = " << mu_ + << "\t nu = " << nu_ + << "\t x_norm = " << vk::norm_max(x_) + << endl; + } + mu_ /= nu_; + nu_ /= 2.; + ++n_trials_; + if (n_trials_ >= n_trials_max_) + stop_ = true; + sign=false; + }else{ + if(verbose_) + { + cout << "It. " << iter_ + << "\t Trial " << n_trials_ + << "\t Failure" + << "\t n_meas = " << n_meas_ + << "\t new_chi2 = " << new_chi2 + << "\t mu = " << mu_ + << "\t nu = " << nu_ + << "\t x_norm = " << vk::norm_max(x_) + << endl; + } + mu_ *= nu_; + nu_ *= 2.; + ++n_trials_; + if (n_trials_ >= n_trials_max_) + stop_ = true; + sign=true; + } + + } + + finishTrial(); + + } while(!(rho_>0 || stop_)); + if (stop_) + break; + + finishIteration(); + } +} + + +template +void vk::NLLSSolver::setRobustCostFunction( + ScaleEstimatorType scale_estimator, + WeightFunctionType weight_function) +{ + switch(scale_estimator) + { + case TDistScale: + if(verbose_) + printf("Using TDistribution Scale Estimator\n"); + scale_estimator_.reset(new robust_cost::TDistributionScaleEstimator()); + use_weights_=true; + break; + case MADScale: + if(verbose_) + printf("Using MAD Scale Estimator\n"); + scale_estimator_.reset(new robust_cost::MADScaleEstimator()); + use_weights_=true; + break; + case NormalScale: + if(verbose_) + printf("Using Normal Scale Estimator\n"); + scale_estimator_.reset(new robust_cost::NormalDistributionScaleEstimator()); + use_weights_=true; + break; + default: + if(verbose_) + printf("Using Unit Scale Estimator\n"); + scale_estimator_.reset(new robust_cost::UnitScaleEstimator()); + use_weights_=false; + } + + switch(weight_function) + { + case TDistWeight: + if(verbose_) + printf("Using TDistribution Weight Function\n"); + weight_function_.reset(new robust_cost::TDistributionWeightFunction()); + break; + case TukeyWeight: + if(verbose_) + printf("Using Tukey Weight Function\n"); + weight_function_.reset(new robust_cost::TukeyWeightFunction()); + break; + case HuberWeight: + if(verbose_) + printf("Using Huber Weight Function\n"); + weight_function_.reset(new robust_cost::HuberWeightFunction()); + break; + default: + if(verbose_) + printf("Using Unit Weight Function\n"); + weight_function_.reset(new robust_cost::UnitWeightFunction()); + } +} + +template +void vk::NLLSSolver::setPrior( + const T& prior, + const Matrix& Information) +{ + have_prior_ = true; + prior_ = prior; + I_prior_ = Information; +} + +template +void vk::NLLSSolver::reset() +{ + have_prior_ = false; + chi2_ = 1e10; + mu_ = mu_init_; + nu_ = nu_init_; + n_meas_ = 0; + n_iter_ = n_iter_init_; + iter_ = 0; + stop_ = false; +} + +template +inline const double& vk::NLLSSolver::getChi2() const +{ + return chi2_; +} + +template +inline const vk::Matrix& vk::NLLSSolver::getInformationMatrix() const +{ + return H_; +} + +#endif /* LM_SOLVER_IMPL_HPP_ */ diff --git a/include/robust_cost.h b/include/robust_cost.h new file mode 100644 index 0000000..d03881a --- /dev/null +++ b/include/robust_cost.h @@ -0,0 +1,156 @@ +/** +* This file is part of dvo. +* +* Copyright 2012 Christian Kerl (Technical University of Munich) +* For more information see . +* +* dvo is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* dvo is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with dvo. If not, see . +*/ + +#ifndef VIKIT_ROBUST_COST_H_ +#define VIKIT_ROBUST_COST_H_ + +#include +#include +#include +namespace vk { +namespace robust_cost { + +// interface for scale estimators +class ScaleEstimator +{ +public: + virtual ~ScaleEstimator() {}; + virtual float compute(std::vector& errors) const = 0; +}; +typedef std::shared_ptr ScaleEstimatorPtr; + +class UnitScaleEstimator : public ScaleEstimator +{ +public: + UnitScaleEstimator() {} + virtual ~UnitScaleEstimator() {} + virtual float compute(std::vector& errors) const { return 1.0f; }; +}; + +// estimates scale by fitting a t-distribution to the data with the given degrees of freedom +class TDistributionScaleEstimator : public ScaleEstimator +{ +public: + TDistributionScaleEstimator(const float dof = DEFAULT_DOF); + virtual ~TDistributionScaleEstimator() {}; + virtual float compute(std::vector& errors) const; + + static const float DEFAULT_DOF; + static const float INITIAL_SIGMA; +protected: + float dof_; + float initial_sigma_; +}; + +// estimates scale by computing the median absolute deviation +class MADScaleEstimator : public ScaleEstimator +{ +public: + MADScaleEstimator() {}; + virtual ~MADScaleEstimator() {}; + virtual float compute(std::vector& errors) const; + +private: + static const float NORMALIZER;; +}; + +// estimates scale by computing the standard deviation +class NormalDistributionScaleEstimator : public ScaleEstimator +{ +public: + NormalDistributionScaleEstimator() {}; + virtual ~NormalDistributionScaleEstimator() {}; + virtual float compute(std::vector& errors) const; +private: +}; + +/** + * Interface for weight functions. A weight function is the first derivative of a symmetric robust function p(sqrt(t)). + * The errors are assumed to be normalized to unit variance. + * + * See: + * "Lucas-Kanade 20 Years On: A Unifying Framework: Part 2" - Page 23, Equation (54) + */ +class WeightFunction +{ +public: + virtual ~WeightFunction() {}; + virtual float value(const float& x) const = 0; + virtual void configure(const float& param) {}; +}; +typedef std::shared_ptr WeightFunctionPtr; + +class UnitWeightFunction : public WeightFunction +{ +public: + UnitWeightFunction() {}; + virtual ~UnitWeightFunction() {}; + virtual float value(const float& x) const { return 1.0f; }; +}; + +/** + * Tukey's hard re-descending function. + * + * See: + * http://en.wikipedia.org/wiki/Redescending_M-estimator + */ +class TukeyWeightFunction : public WeightFunction +{ +public: + TukeyWeightFunction(const float b = DEFAULT_B); + virtual ~TukeyWeightFunction() {}; + virtual float value(const float& x) const; + virtual void configure(const float& param); + + static const float DEFAULT_B; +private: + float b_square; +}; + +class TDistributionWeightFunction : public WeightFunction +{ +public: + TDistributionWeightFunction(const float dof = DEFAULT_DOF); + virtual ~TDistributionWeightFunction() {}; + virtual float value(const float& x) const; + virtual void configure(const float& param); + + static const float DEFAULT_DOF; +private: + float dof_; + float normalizer_; +}; + +class HuberWeightFunction : public WeightFunction +{ +public: + HuberWeightFunction(const float k = DEFAULT_K); + virtual ~HuberWeightFunction() {}; + virtual float value(const float& x) const; + virtual void configure(const float& param); + + static const float DEFAULT_K; +private: + float k; +}; + +} // namespace robust_cost +} // namespace vk +#endif // VIKIT_ROBUST_COST_H_ diff --git a/include/sparse_img_align_gpu.h b/include/sparse_img_align_gpu.h new file mode 100644 index 0000000..6e691a0 --- /dev/null +++ b/include/sparse_img_align_gpu.h @@ -0,0 +1,75 @@ +// This file is part of SVO - Semi-direct Visual Odometry. +// +// Copyright (C) 2014 Christian Forster +// (Robotics and Perception Group, University of Zurich, Switzerland). +// +// SVO is free software: you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the Free Software +// Foundation, either version 3 of the License, or any later version. +// +// SVO is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#ifndef VIO_SPARSE_IMG_ALIGN_GPU_H_ +#define VIO_SPARSE_IMG_ALIGN_GPU_H_ + +#include +#include +#include +#include +#include + +namespace vio { + +class Feature; + +/// Optimize the pose of the frame by minimizing the photometric error of feature patches. +class SparseImgAlignGpu : public vk::NLLSSolver<3, Sophus::SE2> +{ + static const int patch_halfsize_ = 12; + static const int patch_size_ = 12*patch_halfsize_; + static const int patch_area_ = patch_size_*patch_size_; +public: + + SparseImgAlignGpu( + int max_level, + int min_level, + int n_iter, + Method method, + bool verbose, + opencl* residual); + + size_t run(); + void data_reader(std::string filename, float *rp, float *cp, float *c, float *fts, float* fts_px); + int feature_counter(std::string filename); + // FILE* data= nullptr; + +protected: + int level_; //!< current pyramid level on which the optimization runs. + int max_level_; //!< coarsest pyramid level for the alignment. + int min_level_; //!< finest pyramid level for the alignment. + size_t feature_counter_=0; + opencl* residual_= nullptr; + + // cache: + std::vector visible_fts_; + virtual double computeResiduals(const ModelType& model, + bool linearize_system, + bool compute_weight_scale) { + return 0.0; + }; + virtual double computeResiduals(bool linearize_system, bool compute_weight_scale = false); + virtual int solve(); + virtual void update(); + virtual void update(const ModelType& old_model, ModelType& new_model) { }; + virtual void startIteration(); + virtual void finishIteration(); +}; + +} // namespace vio + +#endif // VIO_SPARSE_IMG_ALIGN_GPU_H_ diff --git a/include/vision.h b/include/vision.h new file mode 100644 index 0000000..7a9c759 --- /dev/null +++ b/include/vision.h @@ -0,0 +1,80 @@ +/* + * vision.h + * + * Created on: May 14, 2013 + * Author: cforster + */ + +#ifndef VIKIT_VISION_H_ +#define VIKIT_VISION_H_ + +#include +#include +#include + +namespace vk +{ + +//! Return value between 0 and 1 +//! WARNING This function does not check whether the x/y is within the border +inline float +interpolateMat_32f(const cv::Mat& mat, float u, float v) +{ + assert(mat.type()==CV_32F); + float x = floor(u); + float y = floor(v); + float subpix_x = u-x; + float subpix_y = v-y; + float wx0 = 1.0-subpix_x; + float wx1 = subpix_x; + float wy0 = 1.0-subpix_y; + float wy1 = subpix_y; + + float val00 = mat.at(y,x); + float val10 = mat.at(y,x+1); + float val01 = mat.at(y+1,x); + float val11 = mat.at(y+1,x+1); + return (wx0*wy0)*val00 + (wx1*wy0)*val10 + (wx0*wy1)*val01 + (wx1*wy1)*val11; +} + +//! Return value between 0 and 255 +//! WARNING This function does not check whether the x/y is within the border +inline float +interpolateMat_8u(const cv::Mat& mat, float u, float v) +{ + if(mat.empty())return 0.0; + if(mat.type()!=CV_8U)return 0.0; + int x = floor(u); + int y = floor(v); + float subpix_x = u-x; + float subpix_y = v-y; + + float w00 = (1.0f-subpix_x)*(1.0f-subpix_y); + float w01 = (1.0f-subpix_x)*subpix_y; + float w10 = subpix_x*(1.0f-subpix_y); + float w11 = 1.0f - w00 - w01 - w10; + + const int stride = mat.step.p[0]; + unsigned char* ptr = mat.data + y*stride + x; + if(isnan(w00) || isnan(w01 )||isnan( w10) || isnan(w11) || isinf(w00) || isinf(w01)|| isinf(w10)|| isinf(w11))return 0.0; + if(ptr[0] == NULL || ptr[1]== NULL || ptr[stride]==NULL ||ptr[stride+1]==NULL)return 0.0; + return w00*ptr[0] + w01*ptr[stride] + w10*ptr[1] + w11*ptr[stride+1]; +} + +void halfSample(const cv::Mat& in, cv::Mat& out); + +float shiTomasiScore(const cv::Mat& img, int u, int v); + +void calcSharrDeriv(const cv::Mat& src, cv::Mat& dst); + +#ifdef __SSE2__ + +/// Used to convert a Kinect depthmap +/// Code by Christian Kerl DVO, GPL Licence +void convertRawDepthImageSse_16u_to_32f(cv::Mat& depth_16u, cv::Mat& depth_32f, float scale); + +#endif + +} // namespace vk + +#endif // VIKIT_VISION_H_ diff --git a/kernel/Freak c++ files/freak.cpp b/kernel/Freak c++ files/freak.cpp new file mode 100644 index 0000000..8d1b61d --- /dev/null +++ b/kernel/Freak c++ files/freak.cpp @@ -0,0 +1,844 @@ +// freak.cpp +// +// Copyright (C) 2011-2012 Signal processing laboratory 2, EPFL, +// Kirell Benzi (kirell.benzi@epfl.ch), +// Raphael Ortiz (raphael.ortiz@a3.epfl.ch) +// Alexandre Alahi (alexandre.alahi@epfl.ch) +// and Pierre Vandergheynst (pierre.vandergheynst@epfl.ch) +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. + +#include "precomp.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace cv +{ +namespace xfeatures2d +{ + +/*! + FREAK implementation + */ +class FREAK_Impl CV_FINAL : public FREAK +{ +public: + /** Constructor + * @param orientationNormalized enable orientation normalization + * @param scaleNormalized enable scale normalization + * @param patternScale scaling of the description pattern + * @param nbOctave number of octaves covered by the detected keypoints + * @param selectedPairs (optional) user defined selected pairs + */ + explicit FREAK_Impl( bool orientationNormalized = true, + bool scaleNormalized = true, + float patternScale = 22.0f, + int nOctaves = 4, + const std::vector& selectedPairs = std::vector()); + + virtual ~FREAK_Impl(); + + /** returns the descriptor length in bytes */ + virtual int descriptorSize() const CV_OVERRIDE; + + /** returns the descriptor type */ + virtual int descriptorType() const CV_OVERRIDE; + + /** returns the default norm type */ + virtual int defaultNorm() const CV_OVERRIDE; + + /** select the 512 "best description pairs" + * @param images grayscale images set + * @param keypoints set of detected keypoints + * @param corrThresh correlation threshold + * @param verbose print construction information + * @return list of best pair indexes + */ + std::vector selectPairs( const std::vector& images, std::vector >& keypoints, + const double corrThresh = 0.7, bool verbose = true ); + virtual void compute( InputArray image, std::vector& keypoints, OutputArray descriptors ) CV_OVERRIDE; + +protected: + + void buildPattern(); + + template + imgType meanIntensity( InputArray image, InputArray integral, const float kp_x, const float kp_y, + const unsigned int scale, const unsigned int rot, const unsigned int point ); + + template + void computeDescriptors( InputArray image, std::vector& keypoints, OutputArray descriptors ); + + template + void extractDescriptor(srcMatType *pointsValue, void ** ptr); + + bool orientationNormalized; //true if the orientation is normalized, false otherwise + bool scaleNormalized; //true if the scale is normalized, false otherwise + double patternScale; //scaling of the pattern + int nOctaves; //number of octaves + bool extAll; // true if all pairs need to be extracted for pairs selection + + double patternScale0; + int nOctaves0; + std::vector selectedPairs0; + + struct PatternPoint + { + float x; // x coordinate relative to center + float y; // x coordinate relative to center + float sigma; // Gaussian smoothing sigma + }; + + struct DescriptionPair + { + uchar i; // index of the first point + uchar j; // index of the second point + }; + + struct OrientationPair + { + uchar i; // index of the first point + uchar j; // index of the second point + int weight_dx; // dx/(norm_sq))*4096 + int weight_dy; // dy/(norm_sq))*4096 + }; + + std::vector patternLookup; // look-up table for the pattern points (position+sigma of all points at all scales and orientation) + int patternSizes[NB_SCALES]; // size of the pattern at a specific scale (used to check if a point is within image boundaries) + DescriptionPair descriptionPairs[NB_PAIRS]; + OrientationPair orientationPairs[NB_ORIENPAIRS]; +}; + +static const double FREAK_LOG2 = 0.693147180559945; +static const int FREAK_NB_ORIENTATION = 256; +static const int FREAK_NB_POINTS = 43; +static const int FREAK_SMALLEST_KP_SIZE = 7; // smallest size of keypoints + +// default pairs +static const int FREAK_DEF_PAIRS[FREAK_Impl::NB_PAIRS] = +{ + 404,431,818,511,181,52,311,874,774,543,719,230,417,205,11, + 560,149,265,39,306,165,857,250,8,61,15,55,717,44,412, + 592,134,761,695,660,782,625,487,549,516,271,665,762,392,178, + 796,773,31,672,845,548,794,677,654,241,831,225,238,849,83, + 691,484,826,707,122,517,583,731,328,339,571,475,394,472,580, + 381,137,93,380,327,619,729,808,218,213,459,141,806,341,95, + 382,568,124,750,193,749,706,843,79,199,317,329,768,198,100, + 466,613,78,562,783,689,136,838,94,142,164,679,219,419,366, + 418,423,77,89,523,259,683,312,555,20,470,684,123,458,453,833, + 72,113,253,108,313,25,153,648,411,607,618,128,305,232,301,84, + 56,264,371,46,407,360,38,99,176,710,114,578,66,372,653, + 129,359,424,159,821,10,323,393,5,340,891,9,790,47,0,175,346, + 236,26,172,147,574,561,32,294,429,724,755,398,787,288,299, + 769,565,767,722,757,224,465,723,498,467,235,127,802,446,233, + 544,482,800,318,16,532,801,441,554,173,60,530,713,469,30, + 212,630,899,170,266,799,88,49,512,399,23,500,107,524,90, + 194,143,135,192,206,345,148,71,119,101,563,870,158,254,214, + 276,464,332,725,188,385,24,476,40,231,620,171,258,67,109, + 844,244,187,388,701,690,50,7,850,479,48,522,22,154,12,659, + 736,655,577,737,830,811,174,21,237,335,353,234,53,270,62, + 182,45,177,245,812,673,355,556,612,166,204,54,248,365,226, + 242,452,700,685,573,14,842,481,468,781,564,416,179,405,35, + 819,608,624,367,98,643,448,2,460,676,440,240,130,146,184, + 185,430,65,807,377,82,121,708,239,310,138,596,730,575,477, + 851,797,247,27,85,586,307,779,326,494,856,324,827,96,748, + 13,397,125,688,702,92,293,716,277,140,112,4,80,855,839,1, + 413,347,584,493,289,696,19,751,379,76,73,115,6,590,183,734, + 197,483,217,344,330,400,186,243,587,220,780,200,793,246,824, + 41,735,579,81,703,322,760,720,139,480,490,91,814,813,163, + 152,488,763,263,425,410,576,120,319,668,150,160,302,491,515, + 260,145,428,97,251,395,272,252,18,106,358,854,485,144,550, + 131,133,378,68,102,104,58,361,275,209,697,582,338,742,589, + 325,408,229,28,304,191,189,110,126,486,211,547,533,70,215, + 670,249,36,581,389,605,331,518,442,822 +}; + +// used to sort pairs during pairs selection +struct PairStat +{ + double mean; + int idx; +}; + +struct sortMean +{ + bool operator()( const PairStat& a, const PairStat& b ) const + { + return a.mean < b.mean; + } +}; + +void FREAK_Impl::buildPattern() +{ + if( patternScale == patternScale0 && nOctaves == nOctaves0 && !patternLookup.empty() ) + return; + + nOctaves0 = nOctaves; + patternScale0 = patternScale; + +patternLookup.resize(FREAK::NB_SCALES*FREAK_NB_ORIENTATION*FREAK_NB_POINTS); + double scaleStep = std::pow(2.0, (double)(nOctaves)/FREAK::NB_SCALES ); // 2 ^ ( (nOctaves-1) /nbScales) + double scalingFactor, alpha, beta, theta = 0; + + // pattern definition, radius normalized to 1.0 (outer point position+sigma=1.0) + const int n[8] = {6,6,6,6,6,6,6,1}; // number of points on each concentric circle (from outer to inner) + const double bigR(2.0/3.0); // bigger radius + const double smallR(2.0/24.0); // smaller radius + const double unitSpace( (bigR-smallR)/21.0 ); // define spaces between concentric circles (from center to outer: 1,2,3,4,5,6) + // radii of the concentric cirles (from outer to inner) + const double radius[8] = {bigR, bigR-6*unitSpace, bigR-11*unitSpace, bigR-15*unitSpace, bigR-18*unitSpace, bigR-20*unitSpace, smallR, 0.0}; + // sigma of pattern points (each group of 6 points on a concentric cirle has the same sigma) + const double sigma[8] = {radius[0]/2.0, radius[1]/2.0, radius[2]/2.0, + radius[3]/2.0, radius[4]/2.0, radius[5]/2.0, + radius[6]/2.0, radius[6]/2.0 + }; + // fill the lookup table + for( int scaleIdx=0; scaleIdx < FREAK::NB_SCALES; ++scaleIdx ) + { + patternSizes[scaleIdx] = 0; // proper initialization + scalingFactor = std::pow(scaleStep,scaleIdx); //scale of the pattern, scaleStep ^ scaleIdx + + for( int orientationIdx = 0; orientationIdx < FREAK_NB_ORIENTATION; ++orientationIdx ) + { + theta = double(orientationIdx)* 2*CV_PI/double(FREAK_NB_ORIENTATION); // orientation of the pattern + int pointIdx = 0; + + PatternPoint* patternLookupPtr = &patternLookup[0]; + for( size_t i = 0; i < 8; ++i ) + { + for( int k = 0 ; k < n[i]; ++k ) + { + beta = CV_PI/n[i] * (i%2); // orientation offset so that groups of points on each circles are staggered + alpha = double(k)* 2*CV_PI/double(n[i])+beta+theta; + + // add the point to the look-up table + PatternPoint& point = patternLookupPtr[ scaleIdx*FREAK_NB_ORIENTATION*FREAK_NB_POINTS+orientationIdx*FREAK_NB_POINTS+pointIdx ]; + point.x = static_cast(radius[i] * cos(alpha) * scalingFactor * patternScale); + point.y = static_cast(radius[i] * sin(alpha) * scalingFactor * patternScale); + point.sigma = static_cast(sigma[i] * scalingFactor * patternScale); + + // adapt the sizeList if necessary + const int sizeMax = static_cast(ceil((radius[i]+sigma[i])*scalingFactor*patternScale)) + 1; + if( patternSizes[scaleIdx] < sizeMax ) + patternSizes[scaleIdx] = sizeMax; + + ++pointIdx; + } + } + } + } + + // build the list of orientation pairs + orientationPairs[0].i=0; orientationPairs[0].j=3; orientationPairs[1].i=1; orientationPairs[1].j=4; orientationPairs[2].i=2; orientationPairs[2].j=5; + orientationPairs[3].i=0; orientationPairs[3].j=2; orientationPairs[4].i=1; orientationPairs[4].j=3; orientationPairs[5].i=2; orientationPairs[5].j=4; + orientationPairs[6].i=3; orientationPairs[6].j=5; orientationPairs[7].i=4; orientationPairs[7].j=0; orientationPairs[8].i=5; orientationPairs[8].j=1; + + orientationPairs[9].i=6; orientationPairs[9].j=9; orientationPairs[10].i=7; orientationPairs[10].j=10; orientationPairs[11].i=8; orientationPairs[11].j=11; + orientationPairs[12].i=6; orientationPairs[12].j=8; orientationPairs[13].i=7; orientationPairs[13].j=9; orientationPairs[14].i=8; orientationPairs[14].j=10; + orientationPairs[15].i=9; orientationPairs[15].j=11; orientationPairs[16].i=10; orientationPairs[16].j=6; orientationPairs[17].i=11; orientationPairs[17].j=7; + + orientationPairs[18].i=12; orientationPairs[18].j=15; orientationPairs[19].i=13; orientationPairs[19].j=16; orientationPairs[20].i=14; orientationPairs[20].j=17; + orientationPairs[21].i=12; orientationPairs[21].j=14; orientationPairs[22].i=13; orientationPairs[22].j=15; orientationPairs[23].i=14; orientationPairs[23].j=16; + orientationPairs[24].i=15; orientationPairs[24].j=17; orientationPairs[25].i=16; orientationPairs[25].j=12; orientationPairs[26].i=17; orientationPairs[26].j=13; + + orientationPairs[27].i=18; orientationPairs[27].j=21; orientationPairs[28].i=19; orientationPairs[28].j=22; orientationPairs[29].i=20; orientationPairs[29].j=23; + orientationPairs[30].i=18; orientationPairs[30].j=20; orientationPairs[31].i=19; orientationPairs[31].j=21; orientationPairs[32].i=20; orientationPairs[32].j=22; + orientationPairs[33].i=21; orientationPairs[33].j=23; orientationPairs[34].i=22; orientationPairs[34].j=18; orientationPairs[35].i=23; orientationPairs[35].j=19; + + orientationPairs[36].i=24; orientationPairs[36].j=27; orientationPairs[37].i=25; orientationPairs[37].j=28; orientationPairs[38].i=26; orientationPairs[38].j=29; + orientationPairs[39].i=30; orientationPairs[39].j=33; orientationPairs[40].i=31; orientationPairs[40].j=34; orientationPairs[41].i=32; orientationPairs[41].j=35; + orientationPairs[42].i=36; orientationPairs[42].j=39; orientationPairs[43].i=37; orientationPairs[43].j=40; orientationPairs[44].i=38; orientationPairs[44].j=41; + + for( unsigned m = FREAK::NB_ORIENPAIRS; m--; ) + { + const float dx = patternLookup[orientationPairs[m].i].x-patternLookup[orientationPairs[m].j].x; + const float dy = patternLookup[orientationPairs[m].i].y-patternLookup[orientationPairs[m].j].y; + const float norm_sq = (dx*dx+dy*dy); + orientationPairs[m].weight_dx = cvRound((dx/(norm_sq))*4096.0); + orientationPairs[m].weight_dy = cvRound((dy/(norm_sq))*4096.0); + } + + // build the list of description pairs + std::vector allPairs; + for( unsigned int i = 1; i < (unsigned int)FREAK_NB_POINTS; ++i ) + { + // (generate all the pairs) + for( unsigned int j = 0; (unsigned int)j < i; ++j ) + { + DescriptionPair pair = {(uchar)i,(uchar)j}; + allPairs.push_back(pair); + } + } + // Input vector provided + if( !selectedPairs0.empty() ) + { + if( (int)selectedPairs0.size() == FREAK::NB_PAIRS ) + { + for( int i = 0; i < FREAK::NB_PAIRS; ++i ) + descriptionPairs[i] = allPairs[selectedPairs0.at(i)]; + } + else + { + CV_Error(Error::StsVecLengthErr, "Input vector does not match the required size"); + } + } + else // default selected pairs + { + for( int i = 0; i < FREAK::NB_PAIRS; ++i ) + descriptionPairs[i] = allPairs[FREAK_DEF_PAIRS[i]]; + } +} + +void FREAK_Impl::compute( InputArray _image, std::vector& keypoints, OutputArray _descriptors ) +{ + Mat image = _image.getMat(); + if( image.empty() ) + return; + if( keypoints.empty() ) + return; + + ((FREAK_Impl*)this)->buildPattern(); + + // Convert to gray if not already + Mat grayImage; + if( image.channels() == 3 || image.channels() == 4 ) + cvtColor(image, grayImage, COLOR_BGR2GRAY); + else { + CV_Assert(image.channels() == 1); + grayImage = image; + } + + // Use 32-bit integers if we won't overflow in the integral image + if ((image.depth() == CV_8U || image.depth() == CV_8S) && + (image.rows * image.cols) < 8388608 ) // 8388608 = 2 ^ (32 - 8(bit depth) - 1(sign bit)) + { + // Create the integral image appropriate for our type & usage + if (image.depth() == CV_8U) + computeDescriptors(grayImage, keypoints, _descriptors); + else if (image.depth() == CV_8S) + computeDescriptors(grayImage, keypoints, _descriptors); + else + CV_Error( Error::StsUnsupportedFormat, "" ); + } else { + // Create the integral image appropriate for our type & usage + if ( image.depth() == CV_8U ) + computeDescriptors(grayImage, keypoints, _descriptors); + else if ( image.depth() == CV_8S ) + computeDescriptors(grayImage, keypoints, _descriptors); + else if ( image.depth() == CV_16U ) + computeDescriptors(grayImage, keypoints, _descriptors); + else if ( image.depth() == CV_16S ) + computeDescriptors(grayImage, keypoints, _descriptors); + else + CV_Error( Error::StsUnsupportedFormat, "" ); + } +} + +template +void FREAK_Impl::extractDescriptor(srcMatType *pointsValue, void ** ptr) +{ + std::bitset** ptrScalar = (std::bitset**) ptr; + + // extracting descriptor preserving the order of SSE version + int cnt = 0; + for( int n = 7; n < FREAK::NB_PAIRS; n += 128) + { + for( int m = 8; m--; ) + { + int nm = n-m; + for(int kk = nm+15*8; kk >= nm; kk-=8, ++cnt) + { + (*ptrScalar)->set(kk, pointsValue[descriptionPairs[cnt].i] >= pointsValue[descriptionPairs[cnt].j]); + } + } + } + --(*ptrScalar); +} + +#if CV_SSE2 +template <> +void FREAK_Impl::extractDescriptor(uchar *pointsValue, void ** ptr) +{ + __m128i** ptrSSE = (__m128i**) ptr; + + // note that comparisons order is modified in each block (but first 128 comparisons remain globally the same-->does not affect the 128,384 bits segmanted matching strategy) + int cnt = 0; + for( int n = FREAK::NB_PAIRS/128; n-- ; ) + { + __m128i result128 = _mm_setzero_si128(); + for( int m = 128/16; m--; cnt += 16 ) + { + __m128i operand1 = _mm_set_epi8(pointsValue[descriptionPairs[cnt+0].i], + pointsValue[descriptionPairs[cnt+1].i], + pointsValue[descriptionPairs[cnt+2].i], + pointsValue[descriptionPairs[cnt+3].i], + pointsValue[descriptionPairs[cnt+4].i], + pointsValue[descriptionPairs[cnt+5].i], + pointsValue[descriptionPairs[cnt+6].i], + pointsValue[descriptionPairs[cnt+7].i], + pointsValue[descriptionPairs[cnt+8].i], + pointsValue[descriptionPairs[cnt+9].i], + pointsValue[descriptionPairs[cnt+10].i], + pointsValue[descriptionPairs[cnt+11].i], + pointsValue[descriptionPairs[cnt+12].i], + pointsValue[descriptionPairs[cnt+13].i], + pointsValue[descriptionPairs[cnt+14].i], + pointsValue[descriptionPairs[cnt+15].i]); + + __m128i operand2 = _mm_set_epi8(pointsValue[descriptionPairs[cnt+0].j], + pointsValue[descriptionPairs[cnt+1].j], + pointsValue[descriptionPairs[cnt+2].j], + pointsValue[descriptionPairs[cnt+3].j], + pointsValue[descriptionPairs[cnt+4].j], + pointsValue[descriptionPairs[cnt+5].j], + pointsValue[descriptionPairs[cnt+6].j], + pointsValue[descriptionPairs[cnt+7].j], + pointsValue[descriptionPairs[cnt+8].j], + pointsValue[descriptionPairs[cnt+9].j], + pointsValue[descriptionPairs[cnt+10].j], + pointsValue[descriptionPairs[cnt+11].j], + pointsValue[descriptionPairs[cnt+12].j], + pointsValue[descriptionPairs[cnt+13].j], + pointsValue[descriptionPairs[cnt+14].j], + pointsValue[descriptionPairs[cnt+15].j]); + + __m128i workReg = _mm_min_epu8(operand1, operand2); // emulated "not less than" for 8-bit UNSIGNED integers + workReg = _mm_cmpeq_epi8(workReg, operand2); // emulated "not less than" for 8-bit UNSIGNED integers + + workReg = _mm_and_si128(_mm_set1_epi16(short(0x8080 >> m)), workReg); // merge the last 16 bits with the 128bits std::vector until full + result128 = _mm_or_si128(result128, workReg); + } + (**ptrSSE) = result128; + ++(*ptrSSE); + } + (*ptrSSE) -= 8; +} +#endif + +template +void FREAK_Impl::computeDescriptors( InputArray _image, std::vector& keypoints, OutputArray _descriptors ){ + + Mat image = _image.getMat(); + Mat imgIntegral; + integral(image, imgIntegral, DataType::type); + std::vector kpScaleIdx(keypoints.size()); // used to save pattern scale index corresponding to each keypoints + const std::vector::iterator ScaleIdxBegin = kpScaleIdx.begin(); // used in std::vector erase function + const std::vector::iterator kpBegin = keypoints.begin(); // used in std::vector erase function + const float sizeCst = static_cast(FREAK::NB_SCALES/(FREAK_LOG2* nOctaves)); + srcMatType pointsValue[FREAK_NB_POINTS]; + int thetaIdx = 0; + int direction0; + int direction1; + + // compute the scale index corresponding to the keypoint size and remove keypoints close to the border + if( scaleNormalized ) + { + for( size_t k = keypoints.size(); k--; ) + { + //Is k non-zero? If so, decrement it and continue" + kpScaleIdx[k] = std::max( (int)(std::log(keypoints[k].size/FREAK_SMALLEST_KP_SIZE)*sizeCst+0.5) ,0); + if( kpScaleIdx[k] >= FREAK::NB_SCALES ) + kpScaleIdx[k] = FREAK::NB_SCALES-1; + + if( keypoints[k].pt.x <= patternSizes[kpScaleIdx[k]] || //check if the description at this specific position and scale fits inside the image + keypoints[k].pt.y <= patternSizes[kpScaleIdx[k]] || + keypoints[k].pt.x >= image.cols-patternSizes[kpScaleIdx[k]] || + keypoints[k].pt.y >= image.rows-patternSizes[kpScaleIdx[k]] + ) + { + keypoints.erase(kpBegin+k); + kpScaleIdx.erase(ScaleIdxBegin+k); + } + } + } + else + { + const int scIdx = std::max( cvRound(1.0986122886681*sizeCst) ,0); + for( size_t k = keypoints.size(); k--; ) + { + kpScaleIdx[k] = scIdx; // equivalent to the formule when the scale is normalized with a constant size of keypoints[k].size=3*SMALLEST_KP_SIZE + if( kpScaleIdx[k] >= FREAK::NB_SCALES ) + { + kpScaleIdx[k] = FREAK::NB_SCALES-1; + } + if( keypoints[k].pt.x <= patternSizes[kpScaleIdx[k]] || + keypoints[k].pt.y <= patternSizes[kpScaleIdx[k]] || + keypoints[k].pt.x >= image.cols-patternSizes[kpScaleIdx[k]] || + keypoints[k].pt.y >= image.rows-patternSizes[kpScaleIdx[k]] + ) + { + keypoints.erase(kpBegin+k); + kpScaleIdx.erase(ScaleIdxBegin+k); + } + } + } + + // allocate descriptor memory, estimate orientations, extract descriptors + if( !extAll ) + { + // extract the best comparisons only + _descriptors.create((int)keypoints.size(), FREAK::NB_PAIRS/8, CV_8U); + _descriptors.setTo(Scalar::all(0)); + Mat descriptors = _descriptors.getMat(); + + void *ptr = descriptors.data+(keypoints.size()-1)*descriptors.step[0]; + + for( size_t k = keypoints.size(); k--; ) { + // estimate orientation (gradient) + if( !orientationNormalized ) + { + thetaIdx = 0; // assign 0° to all keypoints + keypoints[k].angle = 0.0; + } + else + { + // get the points intensity value in the un-rotated pattern + for( int i = FREAK_NB_POINTS; i--; ) { + pointsValue[i] = meanIntensity(image, imgIntegral, + keypoints[k].pt.x, keypoints[k].pt.y, + kpScaleIdx[k], 0, i); + } + direction0 = 0; + direction1 = 0; + for( int m = 45; m--; ) + { + //iterate through the orientation pairs + const int delta = (pointsValue[ orientationPairs[m].i ]-pointsValue[ orientationPairs[m].j ]); + direction0 += delta*(orientationPairs[m].weight_dx)/2048; + direction1 += delta*(orientationPairs[m].weight_dy)/2048; + } + + keypoints[k].angle = static_cast(atan2((float)direction1,(float)direction0)*(180.0/CV_PI));//estimate orientation + + thetaIdx = cvRound(FREAK_NB_ORIENTATION*keypoints[k].angle*(1/360.0)); + + if( thetaIdx < 0 ) + thetaIdx += FREAK_NB_ORIENTATION; + + if( thetaIdx >= FREAK_NB_ORIENTATION ) + thetaIdx -= FREAK_NB_ORIENTATION; + } + // extract descriptor at the computed orientation + for( int i = FREAK_NB_POINTS; i--; ) { + pointsValue[i] = meanIntensity(image, imgIntegral, + keypoints[k].pt.x, keypoints[k].pt.y, + kpScaleIdx[k], thetaIdx, i); + } + + // Extract descriptor + extractDescriptor(pointsValue, &ptr); + } + } + else // extract all possible comparisons for selection + { + _descriptors.create((int)keypoints.size(), 128, CV_8U); + _descriptors.setTo(Scalar::all(0)); + Mat descriptors = _descriptors.getMat(); + std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(keypoints.size()-1)*descriptors.step[0]); + + for( size_t k = keypoints.size(); k--; ) + { + //estimate orientation (gradient) + if( !orientationNormalized ) + { + thetaIdx = 0;//assign 0° to all keypoints + keypoints[k].angle = 0.0; + } + else + { + //get the points intensity value in the un-rotated pattern + for( int i = FREAK_NB_POINTS;i--; ) + pointsValue[i] = meanIntensity(image, imgIntegral, + keypoints[k].pt.x,keypoints[k].pt.y, + kpScaleIdx[k], 0, i); + + direction0 = 0; + direction1 = 0; + for( int m = 45; m--; ) + { + //iterate through the orientation pairs + const int delta = (pointsValue[ orientationPairs[m].i ]-pointsValue[ orientationPairs[m].j ]); + direction0 += delta*(orientationPairs[m].weight_dx)/2048; + direction1 += delta*(orientationPairs[m].weight_dy)/2048; + } + + keypoints[k].angle = static_cast(atan2((float)direction1,(float)direction0)*(180.0/CV_PI)); //estimate orientation + + thetaIdx = cvRound(FREAK_NB_ORIENTATION*keypoints[k].angle*(1/360.0)); + + if( thetaIdx < 0 ) + thetaIdx += FREAK_NB_ORIENTATION; + + if( thetaIdx >= FREAK_NB_ORIENTATION ) + thetaIdx -= FREAK_NB_ORIENTATION; + } + // get the points intensity value in the rotated pattern + for( int i = FREAK_NB_POINTS; i--; ) { + pointsValue[i] = meanIntensity(image, imgIntegral, + keypoints[k].pt.x, keypoints[k].pt.y, + kpScaleIdx[k], thetaIdx, i); + } + + int cnt(0); + for( int i = 1; i < FREAK_NB_POINTS; ++i ) + { + //(generate all the pairs) + for( int j = 0; j < i; ++j ) + { + ptr->set(cnt, pointsValue[i] >= pointsValue[j] ); + ++cnt; + } + } + --ptr; + } + } +} + +// simply take average on a square patch, not even gaussian approx +template +imgType FREAK_Impl::meanIntensity( InputArray _image, InputArray _integral, + const float kp_x, + const float kp_y, + const unsigned int scale, + const unsigned int rot, + const unsigned int point) +{ + Mat image = _image.getMat(), integral = _integral.getMat(); + // get point position in image + const PatternPoint& FreakPoint = patternLookup[scale*FREAK_NB_ORIENTATION*FREAK_NB_POINTS + rot*FREAK_NB_POINTS + point]; + const float xf = FreakPoint.x+kp_x; + const float yf = FreakPoint.y+kp_y; + const int x = int(xf); + const int y = int(yf); + + // get the sigma: + const float radius = FreakPoint.sigma; + + // calculate output: + if( radius < 0.5 ) + { + // interpolation multipliers: + const int r_x = static_cast((xf-x)*1024); + const int r_y = static_cast((yf-y)*1024); + const int r_x_1 = (1024-r_x); + const int r_y_1 = (1024-r_y); + unsigned int ret_val; + // linear interpolation: + ret_val = r_x_1*r_y_1*int(image.at(y , x )) + + r_x *r_y_1*int(image.at(y , x+1)) + + r_x_1*r_y *int(image.at(y+1, x )) + + r_x *r_y *int(image.at(y+1, x+1)); + //return the rounded mean + ret_val += 2 * 1024 * 1024; + return static_cast(ret_val / (4 * 1024 * 1024)); + } + + // expected case: + + // calculate borders + const int x_left = cvRound(xf-radius); + const int y_top = cvRound(yf-radius); + const int x_right = cvRound(xf+radius+1);//integral image is 1px wider + const int y_bottom = cvRound(yf+radius+1);//integral image is 1px higher + iiType ret_val; + + ret_val = integral.at(y_bottom,x_right);//bottom right corner + ret_val -= integral.at(y_bottom,x_left); + ret_val += integral.at(y_top,x_left); + ret_val -= integral.at(y_top,x_right); + const int area = (x_right - x_left) * (y_bottom - y_top); + ret_val = (ret_val + area/2) / area; + //~ std::cout<(ret_val); +} + +// pair selection algorithm from a set of training images and corresponding keypoints +std::vector FREAK_Impl::selectPairs(const std::vector& images + , std::vector >& keypoints + , const double corrTresh + , bool verbose ) +{ + extAll = true; + // compute descriptors with all pairs + Mat descriptors; + + if( verbose ) + std::cout << "Number of images: " << images.size() << std::endl; + + for( size_t i = 0;i < images.size(); ++i ) + { + Mat descriptorsTmp; + compute(images[i],keypoints[i],descriptorsTmp); + descriptors.push_back(descriptorsTmp); + } + + if( verbose ) + std::cout << "number of keypoints: " << descriptors.rows << std::endl; + + //descriptor in floating point format (each bit is a float) + Mat descriptorsFloat = Mat::zeros(descriptors.rows, 903, CV_32F); + + std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(descriptors.rows-1)*descriptors.step[0]); + for( int m = descriptors.rows; m--; ) + { + for( int n = 903; n--; ) + { + if( ptr->test(n) == true ) + descriptorsFloat.at(m,n)=1.0f; + } + --ptr; + } + + std::vector pairStat; + for( int n = 903; n--; ) + { + // the higher the variance, the better --> mean = 0.5 + PairStat tmp = { fabs( mean(descriptorsFloat.col(n))[0]-0.5 ) ,n}; + pairStat.push_back(tmp); + } + + std::sort( pairStat.begin(),pairStat.end(), sortMean() ); + + std::vector bestPairs; + for( int m = 0; m < 903; ++m ) + { + if( verbose ) + std::cout << m << ":" << bestPairs.size() << " " << std::flush; + double corrMax(0); + + for( size_t n = 0; n < bestPairs.size(); ++n ) + { + int idxA = bestPairs[n].idx; + int idxB = pairStat[m].idx; + double corr(0); + // compute correlation between 2 pairs + corr = fabs(compareHist(descriptorsFloat.col(idxA), descriptorsFloat.col(idxB), HISTCMP_CORREL)); + + if( corr > corrMax ) + { + corrMax = corr; + if( corrMax >= corrTresh ) + break; + } + } + + if( corrMax < corrTresh/*0.7*/ ) + bestPairs.push_back(pairStat[m]); + + if( bestPairs.size() >= 512 ) + { + if( verbose ) + std::cout << m << std::endl; + break; + } + } + + std::vector idxBestPairs; + if( (int)bestPairs.size() >= FREAK::NB_PAIRS ) + { + for( int i = 0; i < FREAK::NB_PAIRS; ++i ) + idxBestPairs.push_back(bestPairs[i].idx); + } + else + { + if( verbose ) + std::cout << "correlation threshold too small (restrictive)" << std::endl; + CV_Error(Error::StsError, "correlation threshold too small (restrictive)"); + } + extAll = false; + return idxBestPairs; +} + + +/* +// create an image showing the brisk pattern +void FREAKImpl::drawPattern() +{ + Mat pattern = Mat::zeros(1000, 1000, CV_8UC3) + Scalar(255,255,255); + int sFac = 500 / patternScale; + for( int n = 0; n < kNB_POINTS; ++n ) + { + PatternPoint& pt = patternLookup[n]; + circle(pattern, Point( pt.x*sFac,pt.y*sFac)+Point(500,500), pt.sigma*sFac, Scalar(0,0,255),2); + // rectangle(pattern, Point( (pt.x-pt.sigma)*sFac,(pt.y-pt.sigma)*sFac)+Point(500,500), Point( (pt.x+pt.sigma)*sFac,(pt.y+pt.sigma)*sFac)+Point(500,500), Scalar(0,0,255),2); + + circle(pattern, Point( pt.x*sFac,pt.y*sFac)+Point(500,500), 1, Scalar(0,0,0),3); + std::ostringstream oss; + oss << n; + putText( pattern, oss.str(), Point( pt.x*sFac,pt.y*sFac)+Point(500,500), FONT_HERSHEY_SIMPLEX,0.5, Scalar(0,0,0), 1); + } + imshow( "FreakDescriptorExtractor pattern", pattern ); + waitKey(0); +} +*/ + +// ------------------------------------------------- +/* FREAK interface implementation */ +FREAK_Impl::FREAK_Impl( bool _orientationNormalized, bool _scaleNormalized + , float _patternScale, int _nOctaves, const std::vector& _selectedPairs ) + : orientationNormalized(_orientationNormalized), scaleNormalized(_scaleNormalized), + patternScale(_patternScale), nOctaves(_nOctaves), extAll(false), + patternScale0(0.0), nOctaves0(0), selectedPairs0(_selectedPairs) +{ +} + +FREAK_Impl::~FREAK_Impl() +{ +} + +int FREAK_Impl::descriptorSize() const +{ + return FREAK::NB_PAIRS / 8; // descriptor length in bytes +} + +int FREAK_Impl::descriptorType() const +{ + return CV_8U; +} + +int FREAK_Impl::defaultNorm() const +{ + return NORM_HAMMING; +} + +Ptr FREAK::create(bool orientationNormalized, + bool scaleNormalized, + float patternScale, + int nOctaves, + const std::vector& selectedPairs) +{ + return makePtr(orientationNormalized, scaleNormalized, + patternScale, nOctaves, selectedPairs); +} + +} +} // END NAMESPACE CV diff --git a/kernel/Freak c++ files/preprocessing_befor_kernel.cpp b/kernel/Freak c++ files/preprocessing_befor_kernel.cpp new file mode 100644 index 0000000..143c2dd --- /dev/null +++ b/kernel/Freak c++ files/preprocessing_befor_kernel.cpp @@ -0,0 +1,172 @@ +static const float FREAK_LOG2 = 0.693147180559945; +static const int FREAK_NB_ORIENTATION = 256; +static const int NB_ORIENPAIRS = 45; +static const int FREAK_NB_POINTS = 43; +static const int FREAK_SMALLEST_KP_SIZE = 7; // smallest size of keypoints +static const int NB_PAIRS = 512; +static const int NB_SCALES = 64; + +bool orientationNormalized = true; +bool scaleNormalized = true; +float patternScale = 22.0f; +int nOctaves = 4; +//float patternScale0 = 0.0; +//int nOctaves0 = 0; +bool extAll = false; // true if all pairs need to be extracted for pairs selection +//int* selectedPairs0; + +float3 patternLookup[NB_SCALES * FREAK_NB_ORIENTATION * FREAK_NB_POINTS]; // look-up table for the pattern points (position+sigma of all points at all scales and orientation) +int patternSizes[NB_SCALES]; // size of the pattern at a specific scale (used to check if a point is within image boundaries) +uchar2 descriptionPairs[NB_PAIRS]; +int4 orientationPairs[NB_ORIENPAIRS]; + +// default pairs +static const int FREAK_DEF_PAIRS[NB_PAIRS] = + { + 404,431,818,511,181,52,311,874,774,543,719,230,417,205,11, + 560,149,265,39,306,165,857,250,8,61,15,55,717,44,412, + 592,134,761,695,660,782,625,487,549,516,271,665,762,392,178, + 796,773,31,672,845,548,794,677,654,241,831,225,238,849,83, + 691,484,826,707,122,517,583,731,328,339,571,475,394,472,580, + 381,137,93,380,327,619,729,808,218,213,459,141,806,341,95, + 382,568,124,750,193,749,706,843,79,199,317,329,768,198,100, + 466,613,78,562,783,689,136,838,94,142,164,679,219,419,366, + 418,423,77,89,523,259,683,312,555,20,470,684,123,458,453,833, + 72,113,253,108,313,25,153,648,411,607,618,128,305,232,301,84, + 56,264,371,46,407,360,38,99,176,710,114,578,66,372,653, + 129,359,424,159,821,10,323,393,5,340,891,9,790,47,0,175,346, + 236,26,172,147,574,561,32,294,429,724,755,398,787,288,299, + 769,565,767,722,757,224,465,723,498,467,235,127,802,446,233, + 544,482,800,318,16,532,801,441,554,173,60,530,713,469,30, + 212,630,899,170,266,799,88,49,512,399,23,500,107,524,90, + 194,143,135,192,206,345,148,71,119,101,563,870,158,254,214, + 276,464,332,725,188,385,24,476,40,231,620,171,258,67,109, + 844,244,187,388,701,690,50,7,850,479,48,522,22,154,12,659, + 736,655,577,737,830,811,174,21,237,335,353,234,53,270,62, + 182,45,177,245,812,673,355,556,612,166,204,54,248,365,226, + 242,452,700,685,573,14,842,481,468,781,564,416,179,405,35, + 819,608,624,367,98,643,448,2,460,676,440,240,130,146,184, + 185,430,65,807,377,82,121,708,239,310,138,596,730,575,477, + 851,797,247,27,85,586,307,779,326,494,856,324,827,96,748, + 13,397,125,688,702,92,293,716,277,140,112,4,80,855,839,1, + 413,347,584,493,289,696,19,751,379,76,73,115,6,590,183,734, + 197,483,217,344,330,400,186,243,587,220,780,200,793,246,824, + 41,735,579,81,703,322,760,720,139,480,490,91,814,813,163, + 152,488,763,263,425,410,576,120,319,668,150,160,302,491,515, + 260,145,428,97,251,395,272,252,18,106,358,854,485,144,550, + 131,133,378,68,102,104,58,361,275,209,697,582,338,742,589, + 325,408,229,28,304,191,189,110,126,486,211,547,533,70,215, + 670,249,36,581,389,605,331,518,442,822 + }; + +float scaleStep = pow(2.0, (float)(nOctaves)/FREAK_NB_SCALES ); // 2 ^ ( (nOctaves-1) /nbScales) + +const int n[8] = {6, 6, 6, 6, 6, 6, 6, 1}; // number of points on each concentric circle (from outer to inner) +const float bigR = (float)(2.0 / 3.0); // bigger radius +const float smallR = (float)(2.0 / 24.0); // smaller radius +const float unitSpace = (float)((bigR - smallR) / 21.0 ); // define spaces between concentric circles (from center to outer: 1,2,3,4,5,6) +// radii of the concentric cirles (from outer to inner) +const float radius[8] = {bigR , bigR - 6 * unitSpace, bigR - 11 * unitSpace, bigR - 15 * unitSpace, + bigR - 18 * unitSpace, bigR - 20 * unitSpace, smallR , 0.0}; +// sigma of pattern points (each group of 6 points on a concentric cirle has the same sigma) +const float sigma[8] = {radius[0] / 2.0, radius[1] / 2.0, radius[2] / 2.0, radius[3] / 2.0, + radius[4] / 2.0, radius[5] / 2.0, radius[6] / 2.0, radius[6] / 2.0}; + +for( int scaleIdx=0; scaleIdx < NB_SCALES; ++scaleIdx ) +{ +patternSizes[scaleIdx] = 0; // proper initialization +float scalingFactor = pow(scaleStep,scaleIdx); //scale of the pattern, scaleStep ^ scaleIdx + +for( int orientationIdx = 0; orientationIdx < FREAK_NB_ORIENTATION; ++orientationIdx ) +{ +int pointIdx = 0; + +for( size_t i = 0; i < 8; ++i ) +{ +for( int k = 0 ; k < n[i]; ++k ) +{ +float alpha = (float)(k) * 2 * (float)3.141592653589793238462643383279502884197169399375 / (float)(n[i]) + + ((float)3.141592653589793238462643383279502884197169399375 / n[i] * ( i % 2 )/*beta*/) + + ((float)(orientationIdx * 2 * (float)3.141592653589793238462643383279502884197169399375 / (float)(FREAK_NB_ORIENTATION)) /* theta*/); + +// add the point to the look-up table +float3* point = patternLookup[ scaleIdx * FREAK_NB_ORIENTATION * FREAK_NB_POINTS + orientationIdx * FREAK_NB_POINTS + pointIdx]; +point->x = (float)(radius[i] * cos(alpha) * scalingFactor * patternScale); //x +point->y = (float)(radius[i] * sin(alpha) * scalingFactor * patternScale); //y +point->z = (float)(sigma[i] * scalingFactor * patternScale); //sigma + +// adapt the sizeList if necessary +const int sizeMax = (int)(ceil((radius[i] + sigma[i]) * scalingFactor * patternScale)) + 1; +if( patternSizes[scaleIdx] < sizeMax ) +patternSizes[scaleIdx] = sizeMax; + +++pointIdx; +} +} +} +} + +// build the list of orientation pairs +orientationPairs[0].w=0; orientationPairs[0].x=3; orientationPairs[1].w=1; orientationPairs[1].x=4; orientationPairs[2].w=2; orientationPairs[2].x=5; +orientationPairs[3].w=0; orientationPairs[3].x=2; orientationPairs[4].w=1; orientationPairs[4].x=3; orientationPairs[5].w=2; orientationPairs[5].x=4; +orientationPairs[6].w=3; orientationPairs[6].x=5; orientationPairs[7].w=4; orientationPairs[7].x=0; orientationPairs[8].w=5; orientationPairs[8].x=1; + +orientationPairs[9].w=6; orientationPairs[9].x=9; orientationPairs[10].w=7; orientationPairs[10].x=10; orientationPairs[11].w=8; orientationPairs[11].x=11; +orientationPairs[12].w=6; orientationPairs[12].x=8; orientationPairs[13].w=7; orientationPairs[13].x=9; orientationPairs[14].w=8; orientationPairs[14].x=10; +orientationPairs[15].w=9; orientationPairs[15].x=11; orientationPairs[16].w=10; orientationPairs[16].x=6; orientationPairs[17].w=11; orientationPairs[17].x=7; + +orientationPairs[18].w=12; orientationPairs[18].x=15; orientationPairs[19].w=13; orientationPairs[19].x=16; orientationPairs[20].w=14; orientationPairs[20].x=17; +orientationPairs[21].w=12; orientationPairs[21].x=14; orientationPairs[22].w=13; orientationPairs[22].x=15; orientationPairs[23].w=14; orientationPairs[23].x=16; +orientationPairs[24].w=15; orientationPairs[24].x=17; orientationPairs[25].w=16; orientationPairs[25].x=12; orientationPairs[26].w=17; orientationPairs[26].x=13; + +orientationPairs[27].w=18; orientationPairs[27].x=21; orientationPairs[28].w=19; orientationPairs[28].x=22; orientationPairs[29].w=20; orientationPairs[29].x=23; +orientationPairs[30].w=18; orientationPairs[30].x=20; orientationPairs[31].w=19; orientationPairs[31].x=21; orientationPairs[32].w=20; orientationPairs[32].x=22; +orientationPairs[33].w=21; orientationPairs[33].x=23; orientationPairs[34].w=22; orientationPairs[34].x=18; orientationPairs[35].w=23; orientationPairs[35].x=19; + +orientationPairs[36].w=24; orientationPairs[36].x=27; orientationPairs[37].w=25; orientationPairs[37].x=28; orientationPairs[38].w=26; orientationPairs[38].x=29; +orientationPairs[39].w=30; orientationPairs[39].x=33; orientationPairs[40].w=31; orientationPairs[40].x=34; orientationPairs[41].w=32; orientationPairs[41].x=35; +orientationPairs[42].w=36; orientationPairs[42].x=39; orientationPairs[43].w=37; orientationPairs[43].x=40; orientationPairs[44].w=38; orientationPairs[44].x=41; + +for( unsigned m = NB_ORIENPAIRS; m--; ) +{ +float dx = patternLookup[orientationPairs[m].w].x - patternLookup[orientationPairs[m].x].x; +float dy = patternLookup[orientationPairs[m].w].y - patternLookup[orientationPairs[m].x].y; +float norm_sq = (dx * dx + dy * dy); +orientationPairs[m].y = round((dx / (norm_sq)) * 4096.0); //weight_dx +orientationPairs[m].z = round((dy / (norm_sq)) * 4096.0); //weight_dy +} + +// build the list of description pairs +uchar2 allPairs[(int)((FREAK_NB_POINTS * (FREAK_NB_POINTS + 1)) / 2)]; +for( int i = 1, idx = 0; i < FREAK_NB_POINTS; ++i ) +{ +// (generate all the pairs) +for( int j = 0; j < i; ++j ) +{ +allPairs[idx++] = (uchar2){(uchar)i, (uchar)j}; +} +} +for( int i = 0; i < NB_PAIRS; ++i ) +descriptionPairs[i] = allPairs[FREAK_DEF_PAIRS[i]]; + +int kpScaleIdx[keypoints.size()]; + +// kernel running with parameter : +// __kernel void freak( +// __read_only image2d_t image, // grayescale image - height X width +// __read_only image2d_t imgIntegral, // (height+1) X (width+1) with zero values +// __global float3* keypoints, // ptx, pty, angle +// __global uchar* descriptors, // kp_size * (64 = NB_PAIRS/8) - CV_8U with zero values +// __global int* patternSizes, // array size : NB_SCALES = 64 +// __global int4* orientationPairs, // array size : FREAK_NB_ORIENTATION = 256 +// __global float3* patternLookup, // array size : NB_SCALES(64) * FREAK_NB_ORIENTATION(256) * FREAK_NB_POINTS(43) +// __global uchar2* descriptionPairs, // array size : NB_PAIRS = 512 +// __global int* nOctaves, +// __global int* kpScaleIdx //array size = kp_size - used to save pattern scale index corresponding to each keypoints +// ) +// FREAK_LOG2 = 0.693147180559945; +// FREAK_NB_ORIENTATION = 256; +// FREAK_NB_POINTS = 43; +// FREAK_SMALLEST_KP_SIZE = 7; +// NB_PAIRS = 512; +// NB_SCALES = 64; \ No newline at end of file diff --git a/kernel/compute-residual.cl b/kernel/compute-residual.cl new file mode 100644 index 0000000..5afa6a7 --- /dev/null +++ b/kernel/compute-residual.cl @@ -0,0 +1,165 @@ +// Copyright (C) 2021 Majid Geravand +// Copyright (C) 2021 Gfuse + +// Enable OpenCL 32-bit integer atomic functions. +#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable + +float2 world2cam(float3 feature) +{ + float r = sqrt(pow(feature.x/feature.z, 2) + pow(feature.y/feature.z, 2)); + float factor = 1.0; + if((float)S != 0 || r > 0.001) + factor = (atan(r * 2.0 * tan(0.5 * (float)S)) / (r * (float)S)); + return (float2)((float)C_X + (float)F_X * factor * feature.x/feature.z, (float)C_Y + (float)F_Y * factor * feature.y/feature.z); +} + +float3 xyz_cur(float3 cur, float3 ref, float3 ref_feature) +{ + if(ref.z < 0.0) + ref.z = 3.141592653589793238462643383279502884197169399375 - ref.z; + else + ref.z = ref.z - 3.1415926535897932384626433832795028841971693993; + float cc_ss = cos(cur.z) * cos(ref.z) - sin(cur.z) * sin(ref.z); + float sc_cs = cos(cur.z) * sin(ref.z) + cos(ref.z) * sin(cur.z); + return (float3)(cc_ss * ref_feature.x + sc_cs * ref_feature.z + cur.x - ref.x * cos(cur.z) - ref.z * sin(cur.z), + ref_feature.y, + -1.0 * sc_cs * ref_feature.x + cc_ss * ref_feature.z + cur.z + ref.x * sin(cur.z) - ref.z * cos(cur.z)); +} + +void jacobian_xyz2uv(float3 xyz_in_f, float* J) +{ + *(J + 0) = -(1. / xyz_in_f[2]); // -1/z + *(J + 1) = (xyz_in_f[0]) * ((1. / xyz_in_f[2]) * (1. / xyz_in_f[2])); // x/z^2 + *(J + 2) = -(1.0 + pow((xyz_in_f[0]),2) / ((1. / xyz_in_f[2]) * (1. / xyz_in_f[2]))); // -(1.0 + x^2/z^2) + *(J + 3) = 1e-19; // 0 + *(J + 4) = (xyz_in_f[1]) * ((1. / xyz_in_f[2]) * (1. / xyz_in_f[2])); // y/z^2 + *(J + 5) = -(xyz_in_f[0]) * (xyz_in_f[1]) / ((1. / xyz_in_f[2]) * (1. / xyz_in_f[2])); // -x*y/z^2 +} + +void jacobian_xyz2uv_2(float3 xyz_in_f, float3 ref_pose, float3 cur_pose, float* J) +{ float3 txtytetha = cur_pose - ref_pose; + float2 uv = world2cam(xyz_in_f); + *(J + 0) = 1.0; + *(J + 1) = 0.0; + *(J + 2) = ((-1 * sin(txtytetha[2]) * cos(ref_pose[2])) - (cos(txtytetha[2]) * sin(ref_pose[2]))) * uv[0] + ((cos(txtytetha[2]) * cos(ref_pose[2])) - (sin(txtytetha[2]) * sin(ref_pose[2]))) * uv[1]; + *(J + 3) = 0.0; + *(J + 4) = 1.0; + *(J + 5) = ((-1 * cos(txtytetha[2]) * cos(ref_pose[2])) + (sin(txtytetha[2]) * sin(ref_pose[2]))) * uv[0] - ((sin(txtytetha[2]) * cos(ref_pose[2])) + (cos(txtytetha[2]) * sin(ref_pose[2]))) * uv[1]; +} + +void compute_hessain(float3 j, __global float* H, float w) +{ + *(H + 0) += j[0] * j[0] * w; + *(H + 1) += j[0] * j[1] * w; + *(H + 2) += j[0] * j[2] * w; + *(H + 3) += j[1] * j[0] * w; + *(H + 4) += j[1] * j[1] * w; + *(H + 5) += j[1] * j[2] * w; + *(H + 6) += j[2] * j[0] * w; + *(H + 7) += j[2] * j[1] * w; + *(H + 8) += j[2] * j[2] * w; +} + +__kernel void compute_residual( + __read_only image2d_t image_cur, // current frame + __read_only image2d_t image_ref, // reference frame + __global float3 * cur_pose,//[reference frame pose{x,z,pitch}] + __global float3 * ref_pose,//[current frame pose{x,z,pitch}] + __global float3 * ref_feature, // feature on the reference frame, when we applied the distance calculation: xyz_ref((*it)->f*((*it)->point->pos_ - Eigen::Vector3d(ref_pos[0],0.0,ref_pos[1])).norm()); + __global float2 * featue_px, + int level, + __global float * errors, + __global float * Hessian, + __global float3 * Jacobian, + __global float * chi, + float scale_ +) +{ + float scale = pow(2.0, -level); + // Prepare a suitable OpenCL image sampler. + sampler_t const sampler = CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST; + // Use global work feature. + int f = get_global_id(0); + // check if reference with patch size is within image + float2 uv_ref = featue_px[f] * scale; + float2 uv_ref_i = floor(uv_ref); + if(uv_ref_i.x - (PATCH_HALFSIZE + 1) < 0 || uv_ref_i.y - (PATCH_HALFSIZE + 1) < 0 || uv_ref_i.x + (PATCH_HALFSIZE + 1) >= get_image_dim(image_ref)[0] || uv_ref_i.y + (PATCH_HALFSIZE + 1) >= get_image_dim(image_ref)[1])return; + // evaluate projection jacobian + float frame_jac[6]={0.0}; // 2X3 + jacobian_xyz2uv(sqrt(pow(ref_feature[f] - (float3)(ref_pose[0].x,0.0,ref_pose[0].y), 2.0)), &frame_jac); + //jacobian_xyz2uv_2(ref_feature[f], ref_pose[0], cur_pose[0], &frame_jac); + //printf("jacobian : %f %f %f %f %f %f\n", frame_jac[0], frame_jac[1], frame_jac[2], frame_jac[3], frame_jac[4], frame_jac[5]); + // compute bilateral interpolation weights for reference image + float2 subpix= uv_ref - uv_ref_i; + float w_ref_tl = (1.0 - subpix.x) * (1.0 - subpix.y); + float w_ref_tr = subpix.x * (1.0 - subpix.y); + float w_ref_bl = (1.0 - subpix.x) * subpix.y; + float w_ref_br = subpix.x * subpix.y; + + // compute bilateral interpolation weights for the current image + float2 uv_cur_pyr = world2cam(xyz_cur(cur_pose[0], ref_pose[0] ,ref_feature[f])) * scale; + float2 uv_cur_i = floor(uv_cur_pyr); + float2 subpix_uv_cur = uv_cur_pyr - uv_cur_i; + float w_cur_tl = (1.0 - subpix_uv_cur.x) * (1.0 - subpix_uv_cur.y); + float w_cur_tr = subpix_uv_cur.x * (1.0 - subpix_uv_cur.y); + float w_cur_bl = (1.0 - subpix_uv_cur.x) * subpix_uv_cur.y; + float w_cur_br = subpix_uv_cur.x * subpix_uv_cur.y; + float e = 0.0; + float chi_=0.0; + for(int y = 0; y < PATCH_SIZE; ++y) + { + int ref_element_addr = (int)(uv_ref_i.y + y - PATCH_HALFSIZE) * get_image_dim(image_ref)[0] + (uv_ref_i.x - PATCH_HALFSIZE); + int cur_element_addr = (int)(uv_cur_i.y + y - PATCH_HALFSIZE) * get_image_dim(image_cur)[0] + (uv_cur_i.x - PATCH_HALFSIZE); + + for(int x = 0; x < PATCH_SIZE; ++x, ++ref_element_addr, ++cur_element_addr) + { + // precompute interpolated reference patch color + int2 px_reftl = (int2)( ref_element_addr % get_image_dim(image_ref)[0], ref_element_addr / get_image_dim(image_ref)[0]); + int2 px_reftr = (int2)((ref_element_addr + 1) % get_image_dim(image_ref)[0], (ref_element_addr + 1) / get_image_dim(image_ref)[0]); + int2 px_refbl = (int2)((ref_element_addr + get_image_dim(image_ref)[0]) % get_image_dim(image_ref)[0], (ref_element_addr + get_image_dim(image_ref)[0]) / get_image_dim(image_ref)[0]); + int2 px_refbr = (int2)((ref_element_addr + get_image_dim(image_ref)[0] + 1) % get_image_dim(image_ref)[0], (ref_element_addr + get_image_dim(image_ref)[0] + 1) / get_image_dim(image_ref)[0]); + float value = w_ref_tl * read_imageui(image_ref, sampler, px_reftl).x + w_ref_tr * read_imageui(image_ref, sampler, px_reftr).x + + w_ref_bl * read_imageui(image_ref, sampler, px_refbl).x + w_ref_br * read_imageui(image_ref, sampler, px_refbr).x; + + float dx = 0.5f * ((w_ref_tl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + 1) % get_image_dim(image_ref)[0], ((ref_element_addr + 1) / get_image_dim(image_ref)[0]))).x + + w_ref_tr * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + 2) % get_image_dim(image_ref)[0], ((ref_element_addr + 2) / get_image_dim(image_ref)[0]))).x + + w_ref_bl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) + 1) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) + 1) / get_image_dim(image_ref)[0]))).x + + w_ref_br * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) + 2) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) + 2) / get_image_dim(image_ref)[0]))).x) + -(w_ref_tl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr - 1) % get_image_dim(image_ref)[0], ((ref_element_addr - 1) / get_image_dim(image_ref)[0]))).x + + w_ref_tr * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + 0) % get_image_dim(image_ref)[0], ((ref_element_addr + 0) / get_image_dim(image_ref)[0]))).x + + w_ref_bl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) - 1) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) - 1) / get_image_dim(image_ref)[0]))).x + + w_ref_br * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0])) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0])) / get_image_dim(image_ref)[0]))).x)); + + float dy = 0.5f * ((w_ref_tl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0])) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0])) / get_image_dim(image_ref)[0]))).x + + w_ref_tr * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) + 1) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) + 1) / get_image_dim(image_ref)[0]))).x + + w_ref_bl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) * 2) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) * 2) / get_image_dim(image_ref)[0]))).x + + w_ref_br * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (get_image_dim(image_ref)[0]) * 2 + 1) % get_image_dim(image_ref)[0], ((ref_element_addr + (get_image_dim(image_ref)[0]) * 2 + 1) / get_image_dim(image_ref)[0]))).x) + -(w_ref_tl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (-get_image_dim(image_ref)[0])) % get_image_dim(image_ref)[0], ((ref_element_addr + (-get_image_dim(image_ref)[0])) / get_image_dim(image_ref)[0]))).x + + w_ref_tr * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + (1 - get_image_dim(image_ref)[0])) % get_image_dim(image_ref)[0], ((ref_element_addr + (1 - get_image_dim(image_ref)[0])) / get_image_dim(image_ref)[0]))).x + + w_ref_bl * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + 0) % get_image_dim(image_ref)[0], ((ref_element_addr + 0) / get_image_dim(image_ref)[0]))).x + + w_ref_br * read_imageui(image_ref, sampler, (int2) ((ref_element_addr + 1) % get_image_dim(image_ref)[0], ((ref_element_addr + 1) / get_image_dim(image_ref)[0]))).x)); + + // compute residual + int2 px_curtl = (int2)( cur_element_addr % get_image_dim(image_cur)[0], cur_element_addr / get_image_dim(image_cur)[0]); + int2 px_curtr = (int2)((cur_element_addr + 1) % get_image_dim(image_cur)[0], (cur_element_addr + 1) / get_image_dim(image_cur)[0]); + int2 px_curbl = (int2)((cur_element_addr + (get_image_dim(image_cur)[0])) % get_image_dim(image_cur)[0], (cur_element_addr + (get_image_dim(image_cur)[0])) / get_image_dim(image_cur)[0]); + int2 px_curbr = (int2)((cur_element_addr + (get_image_dim(image_cur)[0]) + 1) % get_image_dim(image_cur)[0], (cur_element_addr + (get_image_dim(image_cur)[0]) + 1) / get_image_dim(image_cur)[0]); + + float res = value - w_cur_tl * read_imageui(image_cur, sampler, px_curtl).x + w_cur_tr * read_imageui(image_cur, sampler, px_curtr).x + + w_cur_bl * read_imageui(image_cur, sampler, px_curbl).x + w_cur_br * read_imageui(image_cur, sampler, px_curbr).x; + // used to compute scale for robust cost + e += fabs(res); + // robustification + float weight = res/scale_; //1.48f * vk::getMedian(errors) + chi_ += pow(res,2) * weight; + float3 j_row0 = (float3)((dx * frame_jac[0]), (dx * frame_jac[1]), (dx * frame_jac[2])); + float3 j_row1 = (float3)((dy * frame_jac[3]), (dy * frame_jac[4]), (dy * frame_jac[5])); + float3 J = (j_row0 + j_row1) * ((float)F_X / scale); + compute_hessain(J, &Hessian[f*9], weight); + Jacobian[f] -= J * res * weight; + +} +} +errors[f] = e / pow(PATCH_SIZE,2.0); +chi[f]=chi_; +} diff --git a/kernel/freak.cl b/kernel/freak.cl new file mode 100644 index 0000000..498e29f --- /dev/null +++ b/kernel/freak.cl @@ -0,0 +1,129 @@ +void meanIntensity( image2d_t _image, image2d_t _integral, float kp_x, float kp_y, + int scale, int rot, int* point, float3* patternLookupPtr, uchar* output) +{ + // Prepare a suitable OpenCL image sampler. + sampler_t const sampler = CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST; + // get point position in image + float3* FreakPoint = patternLookupPtr + (scale * FREAK_NB_ORIENTATION * FREAK_NB_POINTS + rot * FREAK_NB_POINTS + (*point)); + float xf = FreakPoint->x + kp_x; + float yf = FreakPoint->y + kp_y; + int x = (int)xf; + int y = (int)yf; + + // get the sigma: + float radius = FreakPoint->z;//sigma + + // calculate output: + if( radius < 0.5 ) + { + // interpolation multipliers: + const int r_x = (int)((xf - x) * 1024); + const int r_y = (int)((yf - y) * 1024); + const int r_x_1 = (1024 - r_x); + const int r_y_1 = (1024 - r_y); + uint ret_val; + // linear interpolation: + ret_val = (r_x_1 * r_y_1 * (int)(read_imageui(_image, sampler, (int2)(y , x ))).x) + + (r_x * r_y_1 * (int)(read_imageui(_image, sampler, (int2)(y , x+1))).x) + + (r_x_1 * r_y * (int)(read_imageui(_image, sampler, (int2)(y+1, x ))).x) + + (r_x * r_y * (int)(read_imageui(_image, sampler, (int2)(y+1, x+1))).x); + // return the rounded mean + ret_val += 2 * 1024 * 1024; + output[*point] = (uchar)(ret_val / (4 * 1024 * 1024)); + } + + // calculate borders + const int x_left = round(xf - radius); + const int y_top = round(yf - radius); + const int x_right = round(xf + radius + 1); // integral image is 1px wider + const int y_bottom = round(yf + radius + 1); // integral image is 1px higher + int ret_val; + + ret_val = read_imageui(_integral, sampler, (int2)(y_bottom, x_right)).x; // bottom right corner + ret_val -= read_imageui(_integral, sampler, (int2)(y_bottom, x_left)).x; // bottom left corner + ret_val += read_imageui(_integral, sampler, (int2)(y_top, x_left)).x; // top left corner + ret_val -= read_imageui(_integral, sampler, (int2)(y_top, x_right)).x; // top right corner + const int area = (x_right - x_left) * (y_bottom - y_top); + ret_val = (ret_val + area / 2) / area; + output[*point] = (uchar)(ret_val); +} +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +__kernel void freak( + __read_only image2d_t image, // grayescale image + __read_only image2d_t imgIntegral, + __global float3* keypoints, // ptx, pty, angle + __global uchar* descriptors, // kp_size * (64 = NB_PAIRS/8) - CV_8U with zero values + __global int* patternSizes, // array size : NB_SCALES = 64 + __global int4* orientationPairs, // array size : FREAK_NB_ORIENTATION = 256 + __global float3* patternLookup, // array size : NB_SCALES(64) * FREAK_NB_ORIENTATION(256) * FREAK_NB_POINTS(43) + __global uchar2* descriptionPairs, // array size : NB_PAIRS = 512 + __global int* nOctaves, + __global int* kpScaleIdx //array size = kp_size - used to save pattern scale index corresponding to each keypoints + ) +{ + const float sizeCst = (float)(NB_SCALES / (FREAK_LOG2 * *nOctaves)); + uchar pointsValue[FREAK_NB_POINTS]; + int thetaIdx = 0; + int direction0; + int direction1; + + int k = get_global_id(0); + + kpScaleIdx[k] = max( (int)(log(7.0 / FREAK_SMALLEST_KP_SIZE) * sizeCst + 0.5) ,0); + if( kpScaleIdx[k] >= NB_SCALES ) + kpScaleIdx[k] = NB_SCALES - 1; + + if( keypoints[k].x <= patternSizes[kpScaleIdx[k]] || // check if the description at this specific position and scale fits inside the image + keypoints[k].y <= patternSizes[kpScaleIdx[k]] || + keypoints[k].x >= get_image_dim(image).y - patternSizes[kpScaleIdx[k]] || + keypoints[k].y >= get_image_dim(image).x - patternSizes[kpScaleIdx[k]]) + return; + + // get the points intensity value in the un-rotated pattern + for( int i = FREAK_NB_POINTS; i--; ) + { + meanIntensity(image, imgIntegral, keypoints[k].x, keypoints[k].y, + *(kpScaleIdx + k), 0, &i, patternLookup, pointsValue); + } + direction0 = 0; + direction1 = 0; + for( int m = 45; m--; ) + { + // iterate through the orientation pairs + const int delta = (pointsValue[ orientationPairs[m].w ] - pointsValue[ orientationPairs[m].x ]); + direction0 += delta * (orientationPairs[m].y) / 2048; // weight_dx + direction1 += delta * (orientationPairs[m].z) / 2048; // weight_dy + } + + thetaIdx = round(FREAK_NB_ORIENTATION * + (float)(atan2((float)direction1,(float)direction0) * (180.0 / 3.141592653589793238462643383279502884197169399375)) * + (1 / 360.0)); + + if( thetaIdx < 0 ) + thetaIdx += FREAK_NB_ORIENTATION; + + if( thetaIdx >= FREAK_NB_ORIENTATION ) + thetaIdx -= FREAK_NB_ORIENTATION; + + // extract descriptor at the computed orientation + for( int i = FREAK_NB_POINTS; i--; ) + { + meanIntensity(image, imgIntegral, keypoints[k].x, keypoints[k].y, + *(kpScaleIdx + k), thetaIdx, &i, patternLookup, pointsValue); + } + + // Extract descriptor + int cnt = 0; + for( int n = 0; n<4; n++ ) + { + for (int m = 8; m >= 1; m--) + { + for(int kk = (n*16)+15; kk >= (n*16); --kk, ++cnt) + { + descriptors[(k * 64) + kk] *= 2; + if (pointsValue[(int)descriptionPairs[cnt].x] >= pointsValue[(int)descriptionPairs[cnt].y]) + descriptors[(k * 64) + kk] += 1; + } + } + } +} \ No newline at end of file diff --git a/kernel/integral_image.cl b/kernel/integral_image.cl new file mode 100644 index 0000000..da53953 --- /dev/null +++ b/kernel/integral_image.cl @@ -0,0 +1,13 @@ +__kernel void integral_image( + __read_only image2d_t int_img, // grayescale image - height X width + __write_only image2d_t out_img // (height+1) X (width+1) with zero values + ) +{ + sampler_t const sampler = CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST; + int2 coord = (int2)(get_global_id(0)+1, get_global_id(1)+1); + int res = 0; + for (int i = 0; i < coord.x; i++) + for (int j = 0; j < coord.y; j++) + res += read_imageui(int_img, sampler, (int2)(i, j)); // bottom right corner + write_imageui(out_img, coord, res); +} \ No newline at end of file diff --git a/main2.cpp b/main2.cpp new file mode 100644 index 0000000..23bd20e --- /dev/null +++ b/main2.cpp @@ -0,0 +1,42 @@ +// +// Created by root on 8/5/21. +// + +#include +#include "cl_class.h" +#include +#include +#include +#include +// Maximum number of corners. +#define FAST_COUNT (1 << 18) + +int main() { + opencl gpu; + gpu.make_kernel("compute_residual"); + cv::Mat img=cv::Mat(cv::Size(700, 500),CV_8UC1); + gpu.write_buf(0,0,img); + gpu.write_buf(0,1,img); + cl_float3 pose[1]={0.0}; + gpu.write_buf(0,2,1,pose); + gpu.write_buf(0,3,1,pose); + cl_float3 f[300]={0}; + gpu.write_buf(0,4,300,f); + cl_float2 px[300]={0}; + gpu.write_buf(0,5,300,px); + float e[300]={0}; + gpu.write_buf(0,7,300,e); + float H[300*9]={0}; + gpu.write_buf(0,8,9*300,H); + cl_float3 J[300]; + gpu.write_buf(0,9,300,J); + float chi2[300]={0.01}; + gpu.write_buf(0,10,300,chi2); + for(int i=0;i<10;++i){ + vio::SparseImgAlignGpu img_align(4, 2,30, vio::SparseImgAlignGpu::GaussNewton, true,&gpu); + img_align.run(); + } + gpu.clear_buf(); + std::cerr<<"finished\n"; + return 0; +} \ No newline at end of file diff --git a/src/math_utils.cpp b/src/math_utils.cpp new file mode 100644 index 0000000..d09d3ba --- /dev/null +++ b/src/math_utils.cpp @@ -0,0 +1,202 @@ +/* + * math_utils.cpp + * + * Created on: Jul 20, 2012 + * Author: cforster + */ + +#include + +namespace vk { + +using namespace Eigen; + +Vector3d +triangulateFeatureNonLin(const Matrix3d& R, const Vector3d& t, + const Vector3d& feature1, const Vector3d& feature2 ) +{ + Vector3d f2 = R * feature2; + Vector2d b; + b[0] = t.dot(feature1); + b[1] = t.dot(f2); + Matrix2d A; + A(0,0) = feature1.dot(feature1); + A(1,0) = feature1.dot(f2); + A(0,1) = -A(1,0); + A(1,1) = -f2.dot(f2); + Vector2d lambda = A.inverse() * b; + Vector3d xm = lambda[0] * feature1; + Vector3d xn = t + lambda[1] * f2; + return ( xm + xn )/2; +} + +bool +depthFromTriangulationExact( + const Matrix3d& R_r_c, + const Vector3d& t_r_c, + const Vector3d& f_r, + const Vector3d& f_c, + double& depth_in_r, + double& depth_in_c) +{ + // bearing vectors (f_r, f_c) do not need to be unit length + const Vector3d f_c_in_r(R_r_c*f_c); + const double a = f_c_in_r.dot(f_r) / t_r_c.dot(f_r); + const double b = f_c_in_r.dot(t_r_c); + const double denom = (a*b - f_c_in_r.dot(f_c_in_r)); + + if(abs(denom) < 0.000001) + return false; + + depth_in_c = (b-a*t_r_c.dot(t_r_c)) / denom; + depth_in_r = (t_r_c + f_c_in_r*depth_in_c).norm(); + return true; +} + +double +reprojError(const Vector3d& f1, + const Vector3d& f2, + double error_multiplier2) +{ + Vector2d e = project2d(f1) - project2d(f2); + return error_multiplier2 * e.norm(); +} + +double +computeInliers(const vector& features1, // c1 + const vector& features2, // c2 + const Matrix3d& R, // R_c1_c2 + const Vector3d& t, // c1_t + const double reproj_thresh, + double error_multiplier2, + vector& xyz_vec, // in frame c1 + vector& inliers, + vector& outliers) +{ + inliers.clear(); inliers.reserve(features1.size()); + outliers.clear(); outliers.reserve(features1.size()); + xyz_vec.clear(); xyz_vec.reserve(features1.size()); + double tot_error = 0; + //triangulate all features and compute reprojection errors and inliers + for(size_t j=0; j reproj_thresh || e2 > reproj_thresh) + outliers.push_back(j); + else + { + inliers.push_back(j); + tot_error += e1+e2; + } + } + return tot_error; +} + +void +computeInliersOneView(const vector & feature_sphere_vec, + const vector & xyz_vec, + const Matrix3d &R, + const Vector3d &t, + const double reproj_thresh, + const double error_multiplier2, + vector& inliers, + vector& outliers) +{ + inliers.clear(); inliers.reserve(xyz_vec.size()); + outliers.clear(); outliers.reserve(xyz_vec.size()); + for(size_t j = 0; j < xyz_vec.size(); j++ ) + { + double e = reprojError(feature_sphere_vec[j], + R.transpose() * ( xyz_vec[j] - t ), + error_multiplier2); + if(e < reproj_thresh) + inliers.push_back(j); + else + outliers.push_back(j); + } +} + +Vector3d +dcm2rpy(const Matrix3d &R) +{ + Vector3d rpy; + rpy[1] = atan2( -R(2,0), sqrt( pow( R(0,0), 2 ) + pow( R(1,0), 2 ) ) ); + if( fabs( rpy[1] - M_PI/2 ) < 0.00001 ) + { + rpy[2] = 0; + rpy[0] = -atan2( R(0,1), R(1,1) ); + } + else + { + if( fabs( rpy[1] + M_PI/2 ) < 0.00001 ) + { + rpy[2] = 0; + rpy[0] = -atan2( R(0,1), R(1,1) ); + } + else + { + rpy[2] = atan2( R(1,0)/cos(rpy[1]), R(0,0)/cos(rpy[1]) ); + rpy[0] = atan2( R(2,1)/cos(rpy[1]), R(2,2)/cos(rpy[1]) ); + } + } + return rpy; +} + +Matrix3d +rpy2dcm(const Vector3d &rpy) +{ + Matrix3d R1; + R1(0,0) = 1.0; R1(0,1) = 0.0; R1(0,2) = 0.0; + R1(1,0) = 0.0; R1(1,1) = cos(rpy[0]); R1(1,2) = -sin(rpy[0]); + R1(2,0) = 0.0; R1(2,1) = -R1(1,2); R1(2,2) = R1(1,1); + + Matrix3d R2; + R2(0,0) = cos(rpy[1]); R2(0,1) = 0.0; R2(0,2) = sin(rpy[1]); + R2(1,0) = 0.0; R2(1,1) = 1.0; R2(1,2) = 0.0; + R2(2,0) = -R2(0,2); R2(2,1) = 0.0; R2(2,2) = R2(0,0); + + Matrix3d R3; + R3(0,0) = cos(rpy[2]); R3(0,1) = -sin(rpy[2]); R3(0,2) = 0.0; + R3(1,0) = -R3(0,1); R3(1,1) = R3(0,0); R3(1,2) = 0.0; + R3(2,0) = 0.0; R3(2,1) = 0.0; R3(2,2) = 1.0; + + return R3 * R2 * R1; +} + +Quaterniond +angax2quat(const Vector3d& n, const double& angle) +{ + // n must be normalized! + double s(sin(angle/2)); + return Quaterniond( cos(angle/2), n[0]*s, n[1]*s, n[2]*s ); +} + + +Matrix3d +angax2dcm(const Vector3d& n, const double& angle) +{ + // n must be normalized + Matrix3d sqewn(sqew(n)); + return Matrix3d(Matrix3d::Identity() + sqewn*sin(angle) + sqewn*sqewn*(1-cos(angle))); +} + +double +sampsonusError(const Vector2d &v2Dash, const Matrix3d& Essential, const Vector2d& v2) +{ + Vector3d v3Dash = unproject2d(v2Dash); + Vector3d v3 = unproject2d(v2); + + double dError = v3Dash.transpose() * Essential * v3; + + Vector3d fv3 = Essential * v3; + Vector3d fTv3Dash = Essential.transpose() * v3Dash; + + Vector2d fv3Slice = fv3.head<2>(); + Vector2d fTv3DashSlice = fTv3Dash.head<2>(); + + return (dError * dError / (fv3Slice.dot(fv3Slice) + fTv3DashSlice.dot(fTv3DashSlice))); +} + +} // end namespace vk diff --git a/src/robust_cost.cpp b/src/robust_cost.cpp new file mode 100644 index 0000000..62cda4c --- /dev/null +++ b/src/robust_cost.cpp @@ -0,0 +1,166 @@ +/** +* This file is part of dvo. +* +* Copyright 2012 Christian Kerl (Technical University of Munich) +* For more information see . +* +* dvo is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* dvo is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with dvo. If not, see . +*/ + +#include +#include +#include +#include +#include + +namespace vk { +namespace robust_cost { + +const float TDistributionScaleEstimator::INITIAL_SIGMA = 5.0f; +const float TDistributionScaleEstimator::DEFAULT_DOF = 5.0f; + +TDistributionScaleEstimator:: +TDistributionScaleEstimator(const float dof) : + dof_(dof), + initial_sigma_(INITIAL_SIGMA) +{} + +float TDistributionScaleEstimator:: +compute(std::vector& errors) const +{ + std::cerr<<"42\n"; + float initial_lamda = 1.0f / (initial_sigma_ * initial_sigma_); + int num = 0; + float lambda = initial_lamda; + int iterations = 0; + do + { + ++iterations; + initial_lamda = lambda; + num = 0; + lambda = 0.0f; + + for(std::vector::iterator it=errors.begin(); it!=errors.end(); ++it) + { + if(std::isfinite(*it)) + { + ++num; + const float error2 = (*it)*(*it); + lambda += error2 * ( (dof_ + 1.0f) / (dof_ + initial_lamda * error2) ); + } + } + lambda = float(num) / lambda; + } while(std::abs(lambda - initial_lamda) > 1e-3); + + return std::sqrt(1.0f / lambda); +} + +const float MADScaleEstimator::NORMALIZER = 1.48f; // 1 / 0.6745 + +float MADScaleEstimator:: +compute(std::vector& errors) const +{ + std::cerr<<"74\n"; + // error must be in absolute values! + return NORMALIZER * vk::getMedian(errors); +} + +float NormalDistributionScaleEstimator:: +compute(std::vector& errors) const +{ + std::cerr<<"82\n"; + const float mean = std::accumulate(errors.begin(), errors.end(), 0)/errors.size(); + float var = 0.0; + std::for_each(errors.begin(), errors.end(), [&](const float d) { + var += (d - mean) * (d - mean); + }); + return std::sqrt(var); // return standard deviation +} + +const float TukeyWeightFunction::DEFAULT_B = 4.6851f; + +TukeyWeightFunction::TukeyWeightFunction(const float b) +{ + configure(b); +} + +float TukeyWeightFunction::value(const float& x) const +{ + const float x_square = x * x; + if(x_square <= b_square) + { + const float tmp = 1.0f - x_square / b_square; + return tmp * tmp; + } + else + { + return 0.0f; + } +} + +void TukeyWeightFunction:: +configure(const float& param) +{ + b_square = param * param; +} + +const float TDistributionWeightFunction::DEFAULT_DOF = 5.0f; + +TDistributionWeightFunction:: +TDistributionWeightFunction(const float dof) +{ + configure(dof); +} + +float TDistributionWeightFunction:: +value(const float & x) const +{ + return ((dof_ + 1.0f) / (dof_ + (x * x))); +} + +void TDistributionWeightFunction:: +configure(const float& param) +{ + dof_ = param; + normalizer_ = dof_ / (dof_ + 1.0f); +} + +const float HuberWeightFunction::DEFAULT_K = 1.345f; + +HuberWeightFunction:: +HuberWeightFunction(const float k) +{ + configure(k); +} + +void HuberWeightFunction:: +configure(const float& param) +{ + k = param; +} + +float HuberWeightFunction:: +value(const float& t) const +{ + const float t_abs = std::abs(t); + if(t_abs < k) + return 1.0f; + else + return k / t_abs; +} + +} // namespace robust_cost +} // namespace vk + + diff --git a/src/sparse_img_align_gpu.cpp b/src/sparse_img_align_gpu.cpp new file mode 100644 index 0000000..61a9be7 --- /dev/null +++ b/src/sparse_img_align_gpu.cpp @@ -0,0 +1,268 @@ +// This file is part of SVO - Semi-direct Visual Odometry. +// +// Copyright (C) 2014 Christian Forster +// (Robotics and Perception Group, University of Zurich, Switzerland). +// +// SVO is free software: you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the Free Software +// Foundation, either version 3 of the License, or any later version. +// +// SVO is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include + +namespace vio { + +SparseImgAlignGpu::SparseImgAlignGpu( + int max_level, int min_level, int n_iter, + Method method, bool verbose,opencl* residual) : + max_level_(max_level), + min_level_(min_level), + residual_(residual) +{ + n_iter_ = n_iter; + n_iter_init_ = n_iter_; + method_ = method; + verbose_ = verbose; + eps_ = 1e-10; +// data = fopen((std::string(getenv("HOME"))+"/Project/data.txt").c_str(), "w+"); +} +int SparseImgAlignGpu::feature_counter(std::string filename) { + int counter = 0; + std::string line; + std::ifstream myfile (filename); + if (myfile.is_open()) { + getline(myfile, line); + while(line.find("features") == std::string::npos) + getline(myfile, line); + while (!myfile.eof()) { + getline(myfile, line); + counter ++; + } + myfile.close(); + } + else + std::cout << "Unable to open file"; + return counter; +} +void SparseImgAlignGpu::data_reader(std::string filename, float *rp, float *cp, float *c, float *fts, float *fts_px) { + std::string line; + std::ifstream myfile (filename); + if (myfile.is_open()) { + while (true) { + getline(myfile, line); + if (line.find("ref_frame") != std::string::npos) { + getline(myfile, line); + std::string substring; + std::stringstream ss(line); + getline(ss, substring, ','); + *(rp) = atof(substring.c_str()); + getline(ss, substring, ','); + *(rp + 1) = atof(substring.c_str()); + getline(ss, substring, ','); + *(rp + 2) = atof(substring.c_str()); + } else if (line.find("cur_frame") != std::string::npos) { + getline(myfile, line); + std::string substring; + std::stringstream ss(line); + getline(ss, substring, ','); + *(cp) = atof(substring.c_str()); + getline(ss, substring, ','); + *(cp + 1) = atof(substring.c_str()); + getline(ss, substring, ','); + *(cp + 2) = atof(substring.c_str()); + } else if (line.find("camera") != std::string::npos) { + getline(myfile, line); + std::string substring; + std::stringstream ss(line); + getline(ss, substring, ','); + *(c) = atof(substring.c_str()); + getline(ss, substring, ','); + *(c + 1) = atof(substring.c_str()); + getline(ss, substring, ','); + *(c + 2) = atof(substring.c_str()); + getline(ss, substring, ','); + *(c + 3) = atof(substring.c_str()); + getline(ss, substring, ','); + *(c + 4) = atof(substring.c_str()); + } + else{ + break; + } + } + if (line.find("features") != std::string::npos) { + int fts_i = 0; + int fts_px_i = 0; + while (!myfile.eof()) { + getline(myfile, line); + std::string substring; + std::stringstream ss(line); + getline(ss, substring, ','); + *(fts + (fts_i)) = atof(substring.c_str()); + getline(ss, substring, ','); + *(fts + (fts_i + 1)) = atof(substring.c_str()); + getline(ss, substring, ','); + *(fts + (fts_i + 2)) = atof(substring.c_str()); + fts_i += 3; + getline(ss, substring, ','); + *(fts_px + (fts_px_i)) = atof(substring.c_str()); + getline(ss, substring, ','); + *(fts_px + (fts_px_i + 1)) = atof(substring.c_str()); + fts_px_i += 2; + } + } + myfile.close(); + } + else + std::cout << "Unable to open file"; + return; +} +/*void draw(double* points, int f) { + for (int level = 2; level <= 4; level++) { + double scale = pow(2.0, -level); + cv::Mat ref_img = cv::imread(std::string(TEST_DATA_DIR)+"/fer"+ std::to_string(level)+".png"); + for (int i = 0; i < f; i++) { + cv::Point p; + p.x = points[2*i] * scale; + p.y = points[2*i+1] * scale; + cv::circle(ref_img, p, 1, (0, 0, 255)); + } + cv::imwrite("/root/Projects/p_25_vio_opencl/Vio_OpenCL/test/res/ref"+ std::to_string(level)+".png",ref_img); + } +}*/ +size_t SparseImgAlignGpu::run() +{ + std::string datafilename = std::string(TEST_DATA_DIR)+"/data.txt"; + int fts_size = feature_counter(datafilename); + float* fts = new float[3 * fts_size]; + float* fts_px = new float[2 * fts_size]; + reset(); + float camera[5]; + float ref_pos[3]; + float cur_pos[3]; + data_reader(datafilename, ref_pos, cur_pos, camera, fts, fts_px); + cl_float3 ref_[1],cur_[1]; + ref_[0].x=ref_pos[0]; + ref_[0].y=ref_pos[1]; + ref_[0].z=ref_pos[2]; + cur_[0].x=cur_pos[0]; + cur_[0].y=cur_pos[1]; + cur_[0].z=cur_pos[2]; + residual_->reload_buf(0,2,cur_); + residual_->reload_buf(0,3,ref_); + cl_float3 features[fts_size]; + cl_float2 featue_px[fts_size]; + + for (int i = 0; i < fts_size; ++i) { + features[i].x = fts[3*i]; + features[i].y = fts[3*i+1]; + features[i].z = fts[3*i+2]; + } + for (int i = 0; i < fts_size; ++i) { + featue_px[i].x = fts_px[2*i]; + featue_px[i].y = fts_px[2*i+1]; + } + + feature_counter_ = fts_size; // is used to compute the index of the cached jacobian + level_=4; + residual_->reload_buf(0,4,features); + residual_->reload_buf(0,5,featue_px); + Sophus::SE2 T_cur(cur_pos[2],Eigen::Vector2d(cur_pos[0],cur_pos[1]));///TODO temporary, we can remove it + for(level_ = max_level_; level_ >= min_level_; --level_) + { + cv::Mat cur_img = cv::imread(std::string(TEST_DATA_DIR)+"/cur"+ std::to_string(level_)+".png"); + cv::Mat ref_img = cv::imread(std::string(TEST_DATA_DIR)+"/fer"+ std::to_string(level_)+".png"); + residual_->reload_buf(0,0,cur_img); + residual_->reload_buf(0,1,ref_img); + residual_->write_buf(0,6,level_); + mu_ = 1.0; + optimize(T_cur); + } + cl_float3 pos[1]={0}; + residual_->read(0,2,pos); + std::cerr<<"pos : "<write_buf(0,11,scale_); + residual_->reload_buf(0,10,chi2_); + residual_->reload_buf(0,8,H); + residual_->reload_buf(0,9,J); + /// TODO GPU compute based on the feature + residual_->run(0,feature_counter_); + float error[300]={0.0}; + float chi[300]={0.0}; + residual_->read(0,10,feature_counter_,chi); + residual_->read(0,7,feature_counter_,error); + for(int i = 1; i < feature_counter_; ++i){ + error[0] += error[i]; + chi[0] += chi[i]; + } + scale_ =error[0]; + return chi[0]; +} + +int SparseImgAlignGpu::solve() +{ + float H[300*9]={0.0}; + cl_float3 J[300]={0.0}; + residual_->read(0,8,feature_counter_*9,H); + residual_->read(0,9,feature_counter_,J); + for(int i = 1; i < feature_counter_; ++i){ + H[0] += H[i*9]; + H[1] += H[i*9+1]; + H[2] += H[i*9+2]; + H[3] += H[i*9+3]; + H[4] += H[i*9+4]; + H[5] += H[i*9+5]; + H[6] += H[i*9+6]; + H[7] += H[i*9+7]; + H[8] += H[i*9+8]; + J[0].x -= J[i].x; + J[0].y -= J[i].y; + J[0].z -= J[i].z; + } + double Hd[9]={(double)H[0],(double)H[1],(double)H[2], + (double)H[3],(double)H[4],(double)H[5], + (double)H[6],(double)H[7],(double)H[8]}; + double Jd[3]={(double)J[0].x,(double)J[0].y,(double)J[0].z}; + x_ = Eigen::Matrix(Hd).ldlt().solve(Eigen::Vector3d(Jd[0],Jd[1],Jd[2])); + if((bool) std::isnan((double) x_[0])) + return 0; + return 1; +} +void SparseImgAlignGpu::update() +{ +/// TODO the update situation may have a smarter solution +/// TODO the update situation may have a smarter solution + cl_float3 pos[1]={0.0,0.0,0.0}; + residual_->read(0,2,pos); + Sophus::SE2 update = Sophus::SE2(pos[0].z,Eigen::Vector2d(pos[0].x,pos[0].y)) * Sophus::SE2::exp(-1.0*x_); + pos[0].x=(float)update.translation()(0); + pos[0].y=(float)update.translation()(1); + pos[0].z=(float)atan(update.so2().unit_complex().imag()/update.so2().unit_complex().real()); + residual_->reload_buf(0,2,pos); +} + +void SparseImgAlignGpu::startIteration() +{} + +void SparseImgAlignGpu::finishIteration() +{ +} + +} // namespace vio + diff --git a/test/data/cur2.png b/test/data/cur2.png new file mode 100644 index 0000000000000000000000000000000000000000..0cbae83fde60fd4292233d083d6861d602b61684 GIT binary patch literal 11799 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 KMNUMnLSTa9_~bnR literal 0 HcmV?d00001 diff --git a/test/data/cur4.png b/test/data/cur4.png new file mode 100644 index 0000000000000000000000000000000000000000..2aadbfb24f670ae9ea5dae819104f348cd7e6ab9 GIT binary patch literal 1084 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 Tvg4>I00000NkvXXu0mjfPgEVN literal 0 HcmV?d00001 diff --git a/test/data/fer4.png b/test/data/fer4.png new file mode 100644 index 0000000000000000000000000000000000000000..a5a047bb8c94cf24e14f396afdf59e0c93c9bf3b GIT binary patch literal 1081 zcmV-91jhS`P)7-Hnn z=z|F%0TC}j2v}MR1zBO)ZM&DVJ9FmDMZOO{r7{Q~Pc5uB=?qf^0J8x{%6JgBck=`N zM!lnQsT6!v@dkgJ=G=Aj*)fXXO(;YVmrCWQ>-I=|?cqR4mFKWJA2*U4dl1l>*2%jFtZ)Eg?IM!{ZfL^w0N)|;4Xe&)X4T%9MsKl(5gOfa}yV8`Vx<_fJ~JZ&OP z_N}{9JEiySzcDg$Ssq_vFBF%eLszrfle8~$3A6j|j{c8ssjMZuqcYuKm+*@1MQ>Lv`UarO5nucYLOn>ou?R02akY z!BWgCq`IW`Hq6lMm3xz`M;IW*8&@`!eba`aEHu3C{wBnP?4{??a&YvItO~7LlV_&^ z2&L-6ZSNM+_PA6A-Xb>%HNxxC=rOLQ3_jcFPJIv)0vy@pt0*VuH)oaB@J{iI0SE~3 zqhk{zm1f@DO6SfpBuEIkbkoxE8*4LpuHj^>wc}~%IGdQQwN2nQnj=S7IC_BGe|xvD z__^Er3t7O4ZLjM{ZIDhtgCcsH?KyFbq9<1Buj<;;cOTcR)Ns7%X8LOtlaMf7;{#w+ zBrC5`1g};0%~R$0sqKUe3@ksl5r1;H*D>*Ut1B|X<8<|9iq2@=y}llHk(l zopL=`@YzVe3#GE8j^}B`#1U;R#+a7UA&SK2GH-4DsdBm)Hd!Ns!<|l4l;Q!1IAra) z*e63H6%NG6toLl~fpGbJ`Ie;|-lM(F6B_T9Xc(qDsUxLowG80&px4d1U7hPG%sg`V zgjynf(DSNM$yv3~;qZh(aAqK%_LZe9Dlx?=!WRT6GVj4TWJXwrJn4koIb-?=-q<4Y zIcfu6GK!P|5>F8=2hS*H1c~>~6jEF7m@B-}aGnW{6cGV{c!30|;7Euw)@rSt^=J#L z`*5C%kT3>-h=ed83>Zi6y)&-R+F6H%H8O+GBhF~RDM5-rC?Eo5gm~|)wYsp@LSYJ- z!N(C7timWFMM3}&067rioU>LLXPqyM?q~l4U27?4`F@Xp00000NkvXXu0mjfpFs&I literal 0 HcmV?d00001 diff --git a/test/data0/test1.png b/test/data0/test1.png new file mode 100644 index 0000000000000000000000000000000000000000..df6935b78aa5b9147e9209959ea67b773db5f98d GIT binary patch literal 362086 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 Z{co2qi00&<|Fi${pZ=@=;=lQq|3Al#zS#f( literal 0 HcmV?d00001 diff --git a/test/res/ref2.png b/test/res/ref2.png new file mode 100644 index 0000000000000000000000000000000000000000..d2fca19061eb0419a73042ad7c6b9f1e52df3c9e GIT binary patch literal 32844 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 XeprHhny3fA2|;KF&9FSG)3yHs^T2bZ literal 0 HcmV?d00001 diff --git a/test/res/ref4.png b/test/res/ref4.png new file mode 100644 index 0000000000000000000000000000000000000000..b15bda9ba99d35235167fcfd5a9140ef184c28b9 GIT binary patch literal 2887 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 literal 0 HcmV?d00001