Move further towards KdTreeNanoflann (#6413)

mvieth · web-flow · commit 279d91f60794 · 2026-03-21T16:12:52.000+01:00
* More further towards KdTreeNanoflann
Extend `autoSelectMethod` to types that do not have xyz-coordinates (i.e. features types)

* Changes per review

* Add octree to autoSelectMethod
diff --git a/common/include/pcl/impl/point_types.hpp b/common/include/pcl/impl/point_types.hpp
@@ -173,6 +173,7 @@ namespace pcl
       template<> struct descriptorSize<GASDSignature7992> { static constexpr const int value = 7992; };
       template<> struct descriptorSize<GFPFHSignature16> { static constexpr const int value = 16; };
       template<> struct descriptorSize<Narf36> { static constexpr const int value = 36; };
+      template<> struct descriptorSize<NormalBasedSignature12> { static constexpr const int value = 12; };
       template<int N> struct descriptorSize<Histogram<N>> { static constexpr const int value = N; };
 
 
diff --git a/common/include/pcl/point_representation.h b/common/include/pcl/point_representation.h
@@ -204,6 +204,8 @@ namespace pcl
       using Ptr = shared_ptr<DefaultPointRepresentation<PointDefault> >;
       using ConstPtr = shared_ptr<const DefaultPointRepresentation<PointDefault> >;
 
+      static constexpr const std::int32_t NR_DIMS = std::min<std::int32_t>(sizeof (PointDefault) / sizeof (float), 3);
+    
       DefaultPointRepresentation ()
       {
         // If point type is unknown, assume it's a struct/array of floats, and compute the number of dimensions
@@ -312,6 +314,8 @@ namespace pcl
       using ConstPtr = shared_ptr<const DefaultFeatureRepresentation<PointDefault>>;
       using FieldList = typename pcl::traits::fieldList<PointDefault>::type;
 
+      static constexpr const std::int32_t NR_DIMS = pcl::detail::traits::descriptorSize_v<PointDefault>;
+
       DefaultFeatureRepresentation ()
       {
         nr_dimensions_ = 0; // zero-out the nr_dimensions_ before it gets incremented
@@ -336,9 +340,11 @@ namespace pcl
   class DefaultPointRepresentation <PointXYZ> : public  PointRepresentation <PointXYZ>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 3;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 3;
+        nr_dimensions_ = NR_DIMS;
         trivial_ = true;
       }
 
@@ -356,9 +362,11 @@ namespace pcl
   class DefaultPointRepresentation <PointXYZI> : public  PointRepresentation <PointXYZI>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 3;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 3;
+        nr_dimensions_ = NR_DIMS;
         trivial_ = true;
       }
 
@@ -377,9 +385,11 @@ namespace pcl
   class DefaultPointRepresentation <PointNormal> : public  PointRepresentation <PointNormal>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 3;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 3;
+        nr_dimensions_ = NR_DIMS;
         trivial_ = true;
       }
 
@@ -404,12 +414,14 @@ namespace pcl
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   template <>
-  class DefaultPointRepresentation <PPFSignature> : public DefaultFeatureRepresentation <PPFSignature>
+  class DefaultPointRepresentation <PPFSignature> : public PointRepresentation <PPFSignature>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 4;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 4;
+        nr_dimensions_ = NR_DIMS;
         trivial_ = true;
       }
 
@@ -453,9 +465,11 @@ namespace pcl
   class DefaultPointRepresentation <Narf36> : public PointRepresentation <Narf36>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 36;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 36;
+        nr_dimensions_ = NR_DIMS;
         trivial_=false;
       }
 
@@ -476,9 +490,11 @@ namespace pcl
   class DefaultPointRepresentation<ShapeContext1980> : public PointRepresentation<ShapeContext1980>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 1980;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 1980;
+        nr_dimensions_ = NR_DIMS;
       }
 
       void
@@ -494,9 +510,11 @@ namespace pcl
   class DefaultPointRepresentation<UniqueShapeContext1960> : public PointRepresentation<UniqueShapeContext1960>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 1960;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 1960;
+        nr_dimensions_ = NR_DIMS;
       }
 
       void
@@ -512,9 +530,11 @@ namespace pcl
   class DefaultPointRepresentation<SHOT352> : public PointRepresentation<SHOT352>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 352;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 352;
+        nr_dimensions_ = NR_DIMS;
       }
 
       void
@@ -530,9 +550,11 @@ namespace pcl
   class DefaultPointRepresentation<SHOT1344> : public PointRepresentation<SHOT1344>
   {
     public:
+      static constexpr const std::int32_t NR_DIMS = 1344;
+    
       DefaultPointRepresentation ()
       {
-        nr_dimensions_ = 1344;
+        nr_dimensions_ = NR_DIMS;
       }
 
       void
diff --git a/people/include/pcl/people/impl/ground_based_people_detection_app.hpp b/people/include/pcl/people/impl/ground_based_people_detection_app.hpp
@@ -375,13 +375,10 @@ pcl::people::GroundBasedPeopleDetectionApp<PointT>::compute (std::vector<pcl::pe
 
   // Euclidean Clustering:
   std::vector<pcl::PointIndices> cluster_indices;
-  typename pcl::search::KdTree<PointT>::Ptr tree (new pcl::search::KdTree<PointT>);
-  tree->setInputCloud(no_ground_cloud_);
   pcl::EuclideanClusterExtraction<PointT> ec;
   ec.setClusterTolerance(2 * voxel_size_);
   ec.setMinClusterSize(min_points_);
   ec.setMaxClusterSize(max_points_);
-  ec.setSearchMethod(tree);
   ec.setInputCloud(no_ground_cloud_);
   ec.extract(cluster_indices);
 
diff --git a/registration/include/pcl/registration/ia_fpcs.h b/registration/include/pcl/registration/ia_fpcs.h
@@ -86,7 +86,7 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
   using ConstPtr =
       shared_ptr<const FPCSInitialAlignment<PointSource, PointTarget, NormalT, Scalar>>;
 
-  using KdTreeReciprocal = pcl::search::KdTree<PointSource>;
+  using KdTreeReciprocal = pcl::search::Search<PointSource>;
   using KdTreeReciprocalPtr = typename KdTreeReciprocal::Ptr;
 
   using PointCloudTarget = pcl::PointCloud<PointTarget>;
diff --git a/registration/include/pcl/registration/ia_ransac.h b/registration/include/pcl/registration/ia_ransac.h
@@ -137,13 +137,10 @@ class SampleConsensusInitialAlignment : public Registration<PointSource, PointTa
 
   using ErrorFunctorPtr = typename ErrorFunctor::Ptr;
 
-  using FeatureKdTreePtr = typename KdTreeFLANN<FeatureT>::Ptr;
+  using FeatureKdTreePtr = typename pcl::search::Search<FeatureT>::Ptr;
   /** \brief Constructor. */
   SampleConsensusInitialAlignment()
-  : input_features_()
-  , target_features_()
-  , feature_tree_(new pcl::KdTreeFLANN<FeatureT>)
-  , error_functor_()
+  : input_features_(), target_features_(), error_functor_()
   {
     reg_name_ = "SampleConsensusInitialAlignment";
     max_iterations_ = 1000;
diff --git a/registration/include/pcl/registration/impl/ia_fpcs.hpp b/registration/include/pcl/registration/impl/ia_fpcs.hpp
@@ -671,8 +671,11 @@ pcl::registration::FPCSInitialAlignment<PointSource, PointTarget, NormalT, Scala
   }
 
   // initialize new kd tree of intermediate points from first point pair correspondences
-  KdTreeReciprocalPtr tree_e(new KdTreeReciprocal);
-  tree_e->setInputCloud(cloud_e);
+  KdTreeReciprocalPtr tree_e(pcl::search::autoSelectMethod<PointSource>(
+      cloud_e,
+      true,
+      pcl::search::Purpose::radius_search)); // maybe check again if results do not have
+                                             // to be sorted
 
   pcl::Indices ids;
   std::vector<float> dists_sqr;
diff --git a/registration/include/pcl/registration/impl/ia_ransac.hpp b/registration/include/pcl/registration/impl/ia_ransac.hpp
@@ -42,6 +42,7 @@
 #define IA_RANSAC_HPP_
 
 #include <pcl/common/distances.h>
+#include <pcl/search/auto.h> // for autoSelectMethod
 
 namespace pcl {
 
@@ -71,7 +72,8 @@ SampleConsensusInitialAlignment<PointSource, PointTarget, FeatureT>::setTargetFe
     return;
   }
   target_features_ = features;
-  feature_tree_->setInputCloud(target_features_);
+  feature_tree_.reset(pcl::search::autoSelectMethod<FeatureT>(
+      target_features_, false, pcl::search::Purpose::many_knn_search));
 }
 
 template <typename PointSource, typename PointTarget, typename FeatureT>
diff --git a/registration/include/pcl/registration/impl/sample_consensus_prerejective.hpp b/registration/include/pcl/registration/impl/sample_consensus_prerejective.hpp
@@ -41,6 +41,8 @@
 #ifndef PCL_REGISTRATION_SAMPLE_CONSENSUS_PREREJECTIVE_HPP_
 #define PCL_REGISTRATION_SAMPLE_CONSENSUS_PREREJECTIVE_HPP_
 
+#include <pcl/search/auto.h> // for autoSelectMethod
+
 namespace pcl {
 
 template <typename PointSource, typename PointTarget, typename FeatureT>
@@ -69,7 +71,8 @@ SampleConsensusPrerejective<PointSource, PointTarget, FeatureT>::setTargetFeatur
     return;
   }
   target_features_ = features;
-  feature_tree_->setInputCloud(target_features_);
+  feature_tree_.reset(pcl::search::autoSelectMethod<FeatureT>(
+      target_features_, false, pcl::search::Purpose::many_knn_search));
 }
 
 template <typename PointSource, typename PointTarget, typename FeatureT>
diff --git a/registration/include/pcl/registration/sample_consensus_prerejective.h b/registration/include/pcl/registration/sample_consensus_prerejective.h
@@ -109,7 +109,7 @@ class SampleConsensusPrerejective : public Registration<PointSource, PointTarget
   using ConstPtr =
       shared_ptr<const SampleConsensusPrerejective<PointSource, PointTarget, FeatureT>>;
 
-  using FeatureKdTreePtr = typename KdTreeFLANN<FeatureT>::Ptr;
+  using FeatureKdTreePtr = typename pcl::search::Search<FeatureT>::Ptr;
 
   using CorrespondenceRejectorPoly =
       pcl::registration::CorrespondenceRejectorPoly<PointSource, PointTarget>;
@@ -121,7 +121,6 @@ class SampleConsensusPrerejective : public Registration<PointSource, PointTarget
   SampleConsensusPrerejective()
   : input_features_()
   , target_features_()
-  , feature_tree_(new pcl::KdTreeFLANN<FeatureT>)
   , correspondence_rejector_poly_(new CorrespondenceRejectorPoly)
   {
     reg_name_ = "SampleConsensusPrerejective";
diff --git a/search/include/pcl/search/impl/auto.hpp b/search/include/pcl/search/impl/auto.hpp
@@ -15,35 +15,58 @@
 #include <pcl/search/brute_force.h>
 #include <pcl/search/kdtree.h>
 #include <pcl/search/kdtree_nanoflann.h>
+#include <pcl/search/octree.h>
 #include <pcl/search/organized.h>
 
 template<typename PointT>
 pcl::search::Search<PointT> * pcl::search::autoSelectMethod(const typename pcl::PointCloud<PointT>::ConstPtr& cloud, const pcl::IndicesConstPtr& indices, bool sorted_results, pcl::search::Purpose purpose) {
   pcl::search::Search<PointT> * searcher = nullptr;
-  if (cloud->isOrganized ()) {
-    searcher = new pcl::search::OrganizedNeighbor<PointT> (sorted_results);
-    if(searcher->setInputCloud (cloud, indices)) { // may return false if OrganizedNeighbor cannot work with the cloud, then use another search method instead
-      return searcher;
+  if constexpr (pcl::traits::has_xyz_v<PointT>) {
+    if (cloud->isOrganized ()) {
+      searcher = new pcl::search::OrganizedNeighbor<PointT> (sorted_results);
+      if(searcher->setInputCloud (cloud, indices)) { // may return false if OrganizedNeighbor cannot work with the cloud, then use another search method instead
+        return searcher;
+      }
+      delete searcher;
     }
   }
+
 #if PCL_HAS_NANOFLANN
-  searcher = new pcl::search::KdTreeNanoflann<PointT> (sorted_results, (purpose == pcl::search::Purpose::one_knn_search ? 10 : 20));
+  // we get the number of search dimensions as a compile-time-constant via NR_DIMS. NR_DIMS may be -1 if it is not possible to determine the dimensions at compile-time (only at run-time), however then searching may be slower. If NR_DIMS is not -1, it must be the same as the return value of getNumberOfDimensions().
+  searcher = new pcl::search::KdTreeNanoflann<PointT, pcl::DefaultPointRepresentation<PointT>::NR_DIMS> (sorted_results, (purpose == pcl::search::Purpose::one_knn_search ? 10 : 20));
   if(searcher->setInputCloud (cloud, indices)) {
     return searcher;
   }
+  delete searcher;
 #else
   pcl::utils::ignore(purpose);
 #endif
+
 #if PCL_HAS_FLANN
   searcher = new pcl::search::KdTree<PointT> (sorted_results);
   if(searcher->setInputCloud (cloud, indices)) {
     return searcher;
   }
+  delete searcher;
 #endif
-  // If nothing else works, use brute force method
-  searcher = new pcl::search::BruteForce<PointT> (sorted_results);
-  searcher->setInputCloud (cloud, indices);
-  return searcher;
+
+  if constexpr (pcl::traits::has_xyz_v<PointT>) {
+    searcher = new pcl::search::Octree<PointT> (0.01); // TODO a better heuristic to choose octree resolution?
+    searcher->setSortedResults (sorted_results);
+    if(searcher->setInputCloud (cloud, indices)) {
+      return searcher;
+    }
+    delete searcher;
+  }
+
+  // If nothing else works, and the point type has xyz coordinates, use brute force method
+  if constexpr (pcl::traits::has_xyz_v<PointT>) {
+    searcher = new pcl::search::BruteForce<PointT> (sorted_results);
+    searcher->setInputCloud (cloud, indices);
+    return searcher;
+  }
+  PCL_ERROR("[pcl::search::autoSelectMethod] No suitable method found. Make sure you have nanoflann and/or FLANN installed.\n");
+  return nullptr;
 }
 
 #define PCL_INSTANTIATE_AutoSelectMethod(T) template PCL_EXPORTS pcl::search::Search<T> * pcl::search::autoSelectMethod<T>(const typename pcl::PointCloud<T>::ConstPtr& cloud, const pcl::IndicesConstPtr& indices, bool sorted_results, pcl::search::Purpose purpose);
diff --git a/search/src/auto.cpp b/search/src/auto.cpp
@@ -12,6 +12,6 @@
 #ifndef PCL_NO_PRECOMPILE
 #include <pcl/impl/instantiate.hpp>
 #include <pcl/point_types.h>
-PCL_INSTANTIATE(AutoSelectMethod, PCL_XYZ_POINT_TYPES)
+PCL_INSTANTIATE(AutoSelectMethod, PCL_POINT_TYPES)
 #endif    // PCL_NO_PRECOMPILE
 
diff --git a/test/common/test_common.cpp b/test/common/test_common.cpp
@@ -50,6 +50,7 @@
 #include <pcl/point_types.h>
 #include <pcl/point_cloud.h>
 #include <pcl/common/point_tests.h> // for isFinite
+#include <pcl/point_representation.h>
 
 using namespace pcl;
 
@@ -520,6 +521,15 @@ TEST (PCL, computeMedian)
   EXPECT_EQ(median5, 5.5);
 }
 
+template <typename T> class PointRepresentationTest : public ::testing::Test { };
+using PointRepresentationTestTypes = ::testing::Types<BOOST_PP_SEQ_ENUM(PCL_POINT_TYPES)>;
+TYPED_TEST_SUITE(PointRepresentationTest, PointRepresentationTestTypes);
+TYPED_TEST(PointRepresentationTest, GetNormalVectorXfMap)
+{
+  pcl::DefaultPointRepresentation<TypeParam> point_representation;
+  EXPECT_EQ (pcl::DefaultPointRepresentation<TypeParam>::NR_DIMS, point_representation.getNumberOfDimensions());
+}
+
 /* ---[ */
 int
 main (int argc, char** argv)
diff --git a/tools/boundary_estimation.cpp b/tools/boundary_estimation.cpp
@@ -107,7 +107,6 @@ compute (const pcl::PCLPointCloud2::ConstPtr &input, pcl::PCLPointCloud2 &output
   BoundaryEstimation<pcl::PointNormal, pcl::PointNormal, pcl::Boundary> ne;
   ne.setInputCloud (xyznormals);
   ne.setInputNormals (xyznormals);
-  //ne.setSearchMethod (pcl::KdTreeFLANN<pcl::PointNormal>::Ptr (new pcl::KdTreeFLANN<pcl::PointNormal>));
   ne.setKSearch (k);
   ne.setAngleThreshold (static_cast<float> (angle));
   ne.setRadiusSearch (radius);
diff --git a/tools/compute_hausdorff.cpp b/tools/compute_hausdorff.cpp
diff --git a/tools/pcd_viewer.cpp b/tools/pcd_viewer.cpp

Original file line number	Diff line number	Diff line change
`@@ -204,6 +204,8 @@ namespace pcl`
`204`	`204`	`using Ptr = shared_ptr<DefaultPointRepresentation<PointDefault> >;`
`205`	`205`	`using ConstPtr = shared_ptr<const DefaultPointRepresentation<PointDefault> >;`
`206`	`206`
	`207`	`+ static constexpr const std::int32_t NR_DIMS = std::min<std::int32_t>(sizeof (PointDefault) / sizeof (float), 3);`
	`208`	`+`
`207`	`209`	`DefaultPointRepresentation ()`
`208`	`210`	`{`
`209`	`211`	`// If point type is unknown, assume it's a struct/array of floats, and compute the number of dimensions`
`@@ -312,6 +314,8 @@ namespace pcl`
`312`	`314`	`using ConstPtr = shared_ptr<const DefaultFeatureRepresentation<PointDefault>>;`
`313`	`315`	`using FieldList = typename pcl::traits::fieldList<PointDefault>::type;`
`314`	`316`
	`317`	`+ static constexpr const std::int32_t NR_DIMS = pcl::detail::traits::descriptorSize_v<PointDefault>;`
	`318`	`+`
`315`	`319`	`DefaultFeatureRepresentation ()`
`316`	`320`	`{`
`317`	`321`	`nr_dimensions_ = 0; // zero-out the nr_dimensions_ before it gets incremented`
`@@ -336,9 +340,11 @@ namespace pcl`
`336`	`340`	`class DefaultPointRepresentation <PointXYZ> : public PointRepresentation <PointXYZ>`
`337`	`341`	`{`
`338`	`342`	`public:`
	`343`	`+ static constexpr const std::int32_t NR_DIMS = 3;`
	`344`	`+`
`339`	`345`	`DefaultPointRepresentation ()`
`340`	`346`	`{`
`341`		`- nr_dimensions_ = 3;`
	`347`	`+ nr_dimensions_ = NR_DIMS;`
`342`	`348`	`trivial_ = true;`
`343`	`349`	`}`
`344`	`350`
`@@ -356,9 +362,11 @@ namespace pcl`
`356`	`362`	`class DefaultPointRepresentation <PointXYZI> : public PointRepresentation <PointXYZI>`
`357`	`363`	`{`
`358`	`364`	`public:`
	`365`	`+ static constexpr const std::int32_t NR_DIMS = 3;`
	`366`	`+`
`359`	`367`	`DefaultPointRepresentation ()`
`360`	`368`	`{`
`361`		`- nr_dimensions_ = 3;`
	`369`	`+ nr_dimensions_ = NR_DIMS;`
`362`	`370`	`trivial_ = true;`
`363`	`371`	`}`
`364`	`372`
`@@ -377,9 +385,11 @@ namespace pcl`
`377`	`385`	`class DefaultPointRepresentation <PointNormal> : public PointRepresentation <PointNormal>`
`378`	`386`	`{`
`379`	`387`	`public:`
	`388`	`+ static constexpr const std::int32_t NR_DIMS = 3;`
	`389`	`+`
`380`	`390`	`DefaultPointRepresentation ()`
`381`	`391`	`{`
`382`		`- nr_dimensions_ = 3;`
	`392`	`+ nr_dimensions_ = NR_DIMS;`
`383`	`393`	`trivial_ = true;`
`384`	`394`	`}`
`385`	`395`
`@@ -404,12 +414,14 @@ namespace pcl`
`404`	`414`
`405`	`415`	`//////////////////////////////////////////////////////////////////////////////////////////////////////////////////`
`406`	`416`	`template <>`
`407`		`- class DefaultPointRepresentation <PPFSignature> : public DefaultFeatureRepresentation <PPFSignature>`
	`417`	`+ class DefaultPointRepresentation <PPFSignature> : public PointRepresentation <PPFSignature>`
`408`	`418`	`{`
`409`	`419`	`public:`
	`420`	`+ static constexpr const std::int32_t NR_DIMS = 4;`
	`421`	`+`
`410`	`422`	`DefaultPointRepresentation ()`
`411`	`423`	`{`
`412`		`- nr_dimensions_ = 4;`
	`424`	`+ nr_dimensions_ = NR_DIMS;`
`413`	`425`	`trivial_ = true;`
`414`	`426`	`}`
`415`	`427`
`@@ -453,9 +465,11 @@ namespace pcl`
`453`	`465`	`class DefaultPointRepresentation <Narf36> : public PointRepresentation <Narf36>`
`454`	`466`	`{`
`455`	`467`	`public:`
	`468`	`+ static constexpr const std::int32_t NR_DIMS = 36;`
	`469`	`+`
`456`	`470`	`DefaultPointRepresentation ()`
`457`	`471`	`{`
`458`		`- nr_dimensions_ = 36;`
	`472`	`+ nr_dimensions_ = NR_DIMS;`
`459`	`473`	`trivial_=false;`
`460`	`474`	`}`
`461`	`475`
`@@ -476,9 +490,11 @@ namespace pcl`
`476`	`490`	`class DefaultPointRepresentation<ShapeContext1980> : public PointRepresentation<ShapeContext1980>`
`477`	`491`	`{`
`478`	`492`	`public:`
	`493`	`+ static constexpr const std::int32_t NR_DIMS = 1980;`
	`494`	`+`
`479`	`495`	`DefaultPointRepresentation ()`
`480`	`496`	`{`
`481`		`- nr_dimensions_ = 1980;`
	`497`	`+ nr_dimensions_ = NR_DIMS;`
`482`	`498`	`}`
`483`	`499`
`484`	`500`	`void`
`@@ -494,9 +510,11 @@ namespace pcl`
`494`	`510`	`class DefaultPointRepresentation<UniqueShapeContext1960> : public PointRepresentation<UniqueShapeContext1960>`
`495`	`511`	`{`
`496`	`512`	`public:`
	`513`	`+ static constexpr const std::int32_t NR_DIMS = 1960;`
	`514`	`+`
`497`	`515`	`DefaultPointRepresentation ()`
`498`	`516`	`{`
`499`		`- nr_dimensions_ = 1960;`
	`517`	`+ nr_dimensions_ = NR_DIMS;`
`500`	`518`	`}`
`501`	`519`
`502`	`520`	`void`
`@@ -512,9 +530,11 @@ namespace pcl`
`512`	`530`	`class DefaultPointRepresentation<SHOT352> : public PointRepresentation<SHOT352>`
`513`	`531`	`{`
`514`	`532`	`public:`
	`533`	`+ static constexpr const std::int32_t NR_DIMS = 352;`
	`534`	`+`
`515`	`535`	`DefaultPointRepresentation ()`
`516`	`536`	`{`
`517`		`- nr_dimensions_ = 352;`
	`537`	`+ nr_dimensions_ = NR_DIMS;`
`518`	`538`	`}`
`519`	`539`
`520`	`540`	`void`
`@@ -530,9 +550,11 @@ namespace pcl`
`530`	`550`	`class DefaultPointRepresentation<SHOT1344> : public PointRepresentation<SHOT1344>`
`531`	`551`	`{`
`532`	`552`	`public:`
	`553`	`+ static constexpr const std::int32_t NR_DIMS = 1344;`
	`554`	`+`
`533`	`555`	`DefaultPointRepresentation ()`
`534`	`556`	`{`
`535`		`- nr_dimensions_ = 1344;`
	`557`	`+ nr_dimensions_ = NR_DIMS;`
`536`	`558`	`}`
`537`	`559`
`538`	`560`	`void`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@`
`42`	`42`	`#define IA_RANSAC_HPP_`
`43`	`43`
`44`	`44`	`#include <pcl/common/distances.h>`
	`45`	`+#include <pcl/search/auto.h> // for autoSelectMethod`
`45`	`46`
`46`	`47`	`namespace pcl {`
`47`	`48`
`@@ -71,7 +72,8 @@ SampleConsensusInitialAlignment<PointSource, PointTarget, FeatureT>::setTargetFe`
`71`	`72`	`return;`
`72`	`73`	`}`
`73`	`74`	`target_features_ = features;`
`74`		`- feature_tree_->setInputCloud(target_features_);`
	`75`	`+ feature_tree_.reset(pcl::search::autoSelectMethod<FeatureT>(`
	`76`	`+ target_features_, false, pcl::search::Purpose::many_knn_search));`
`75`	`77`	`}`
`76`	`78`
`77`	`79`	`template <typename PointSource, typename PointTarget, typename FeatureT>`