Added template parameter for indices type in Correspondence; minor ch…

…anges
mcx · Feb 17, 2020 · 28cdc32 · 28cdc32
1 parent 64444c5
commit 28cdc32
Show file tree

Hide file tree

Showing 4 changed files with 31 additions and 29 deletions.
diff --git a/include/cilantro/core/correspondence.hpp b/include/cilantro/core/correspondence.hpp
@@ -5,19 +5,19 @@
 namespace cilantro {
     enum struct CorrespondenceSearchDirection {FIRST_TO_SECOND, SECOND_TO_FIRST, BOTH};
 
-    template <typename ScalarT>
+    template <typename ScalarT, typename IndexT = size_t>
     struct Correspondence {
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
         typedef ScalarT Scalar;
 
-        size_t indexInFirst;
-        size_t indexInSecond;
+        IndexT indexInFirst;
+        IndexT indexInSecond;
         ScalarT value;
 
         Correspondence() {}
 
-        Correspondence(size_t i, size_t j, ScalarT val) : indexInFirst(i), indexInSecond(j), value(val) {}
+        Correspondence(IndexT i, IndexT j, ScalarT val) : indexInFirst(i), indexInSecond(j), value(val) {}
 
         struct ValueLessComparator {
             inline bool operator()(const Correspondence &c1, const Correspondence &c2) const {

diff --git a/include/cilantro/core/data_containers.hpp b/include/cilantro/core/data_containers.hpp
@@ -9,49 +9,51 @@ namespace cilantro {
     public:
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
+        typedef Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> Base;
+
         typedef ScalarT Scalar;
 
         enum { Dimension = EigenDim };
 
         DataMatrixMap(Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic> &data)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data.data(), data.rows(), data.cols())
+                : Base(data.data(), data.rows(), data.cols())
         {}
 
         DataMatrixMap(Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> data)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data.data(), data.rows(), data.cols())
+                : Base(data.data(), data.rows(), data.cols())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         DataMatrixMap(std::vector<ScalarT> &data)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((ScalarT *)data.data(), EigenDim, data.size()/EigenDim)
+                : Base((ScalarT *)data.data(), EigenDim, data.size()/EigenDim)
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim == Eigen::Dynamic>::type>
         DataMatrixMap(std::vector<ScalarT> &data, size_t dim)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((ScalarT *)data.data(), dim, data.size()/dim)
+                : Base((ScalarT *)data.data(), dim, data.size()/dim)
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic && sizeof(Eigen::Matrix<ScalarT,Dim,1>) % 16 != 0>::type>
         DataMatrixMap(std::vector<Eigen::Matrix<ScalarT,EigenDim,1>> &data)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((ScalarT *)data.data(), EigenDim, data.size())
+                : Base((ScalarT *)data.data(), EigenDim, data.size())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         DataMatrixMap(std::vector<Eigen::Matrix<ScalarT,EigenDim,1>,Eigen::aligned_allocator<Eigen::Matrix<ScalarT,EigenDim,1>>> &data)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((ScalarT *)data.data(), EigenDim, data.size())
+                : Base((ScalarT *)data.data(), EigenDim, data.size())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         DataMatrixMap(ScalarT * data, size_t num_points = 0)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data, EigenDim, num_points)
+                : Base(data, EigenDim, num_points)
         {}
 
         DataMatrixMap(ScalarT * data, size_t dim, size_t num_points)
-                : Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data, dim, num_points)
+                : Base(data, dim, num_points)
         {}
 
-        inline Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>& base() {
-            return (*static_cast<Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> *>(this));
+        inline Base& base() {
+            return *static_cast<Base *>(this);
         }
     };
 
@@ -88,53 +90,55 @@ namespace cilantro {
     public:
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
+        typedef Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> Base;
+
         typedef ScalarT Scalar;
 
         enum { Dimension = EigenDim };
 
         ConstDataMatrixMap(const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic> &data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data.data(), data.rows(), data.cols())
+                : Base(data.data(), data.rows(), data.cols())
         {}
 
         ConstDataMatrixMap(Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data.data(), data.rows(), data.cols())
+                : Base(data.data(), data.rows(), data.cols())
         {}
 
         ConstDataMatrixMap(Eigen::Map<Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data.data(), data.rows(), data.cols())
+                : Base(data.data(), data.rows(), data.cols())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         ConstDataMatrixMap(const std::vector<ScalarT> &data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((const ScalarT *)data.data(), EigenDim, data.size()/EigenDim)
+                : Base((const ScalarT *)data.data(), EigenDim, data.size()/EigenDim)
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim == Eigen::Dynamic>::type>
         ConstDataMatrixMap(const std::vector<ScalarT> &data, size_t dim)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((const ScalarT *)data.data(), dim, data.size()/dim)
+                : Base((const ScalarT *)data.data(), dim, data.size()/dim)
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic && sizeof(Eigen::Matrix<ScalarT,Dim,1>) % 16 != 0>::type>
         ConstDataMatrixMap(const std::vector<Eigen::Matrix<ScalarT,EigenDim,1>,Eigen::aligned_allocator<Eigen::Matrix<ScalarT,EigenDim,1>>> &data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((const ScalarT *)data.data(), EigenDim, data.size())
+                : Base((const ScalarT *)data.data(), EigenDim, data.size())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         ConstDataMatrixMap(const std::vector<Eigen::Matrix<ScalarT,EigenDim,1>> &data)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>((const ScalarT *)data.data(), EigenDim, data.size())
+                : Base((const ScalarT *)data.data(), EigenDim, data.size())
         {}
 
         template <ptrdiff_t Dim = EigenDim, class = typename std::enable_if<Dim != Eigen::Dynamic>::type>
         ConstDataMatrixMap(const ScalarT * data, size_t num_points = 0)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data, EigenDim, num_points)
+                : Base(data, EigenDim, num_points)
         {}
 
         ConstDataMatrixMap(const ScalarT * data, size_t dim, size_t num_points)
-                : Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>(data, dim, num_points)
+                : Base(data, dim, num_points)
         {}
 
-        inline const Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>>& base() {
-            return (*static_cast<Eigen::Map<const Eigen::Matrix<ScalarT,EigenDim,Eigen::Dynamic>> *>(this));
+        inline const Base& base() {
+            return *static_cast<Base *>(this);
         }
     };
 

diff --git a/include/cilantro/correspondence_search/correspondence_search_oracle.hpp b/include/cilantro/correspondence_search/correspondence_search_oracle.hpp
@@ -17,7 +17,7 @@ namespace cilantro {
 
         typedef CorrespondenceSet<ScalarT> OracleCorrespondences;
 
-        CorrespondenceSearchOracle(const CorrespondenceSet<ScalarT> &correspondences,
+        CorrespondenceSearchOracle(const OracleCorrespondences &correspondences,
                                    EvaluationFeatureAdaptorT &src_eval_features,
                                    EvaluatorT &evaluator)
                 : oracle_correspondences_(correspondences),
@@ -75,7 +75,7 @@ namespace cilantro {
         }
 
     private:
-        const CorrespondenceSet<ScalarT>& oracle_correspondences_;
+        const OracleCorrespondences& oracle_correspondences_;
 
         EvaluationFeatureAdaptorT& src_evaluation_features_adaptor_;
         Evaluator& evaluator_;

diff --git a/include/cilantro/registration/warp_field_estimation.hpp b/include/cilantro/registration/warp_field_estimation.hpp
@@ -2,8 +2,6 @@
 
 #include <Eigen/Sparse>
 #include <cilantro/core/space_transformations.hpp>
-// #include <cilantro/core/nearest_neighbors.hpp>
-// #include <cilantro/core/correspondence.hpp>
 #include <cilantro/core/common_pair_evaluators.hpp>
 
 namespace cilantro {