Moves UniformSampling to filters, it's not a Keypoint

apps/3d_rec_framework/include/pcl/apps/3d_rec_framework/feature_wrapper/local/local_estimator.h

@@ -9,7 +9,7 @@
 #define REC_FRAMEWORK_LOCAL_ESTIMATOR_H_
 
 #include <pcl/apps/3d_rec_framework/feature_wrapper/normal_estimator.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 #include <pcl/surface/mls.h>
 #include <pcl/keypoints/harris_3d.h>
 #include <pcl/keypoints/sift_keypoint.h>
@@ -85,7 +85,7 @@ namespace pcl
         boost::shared_ptr<std::vector<std::vector<float> > > neighborhood_dist_;
 
         void
-        filterPlanar (PointInTPtr & input, pcl::PointCloud<int> & keypoints_cloud)
+        filterPlanar (PointInTPtr & input, PointInTPtr & keypoints_cloud)
         {
           pcl::PointCloud<int> filtered_keypoints;
           //create a search object
@@ -97,17 +97,17 @@ namespace pcl
           tree->setInputCloud (input);
 
           neighborhood_indices_.reset (new std::vector<std::vector<int> >);
-          neighborhood_indices_->resize (keypoints_cloud.points.size ());
+          neighborhood_indices_->resize (keypoints_cloud->points.size ());
           neighborhood_dist_.reset (new std::vector<std::vector<float> >);
-          neighborhood_dist_->resize (keypoints_cloud.points.size ());
+          neighborhood_dist_->resize (keypoints_cloud->points.size ());
 
-          filtered_keypoints.points.resize (keypoints_cloud.points.size ());
+          filtered_keypoints.points.resize (keypoints_cloud->points.size ());
           int good = 0;
 
-          for (size_t i = 0; i < keypoints_cloud.points.size (); i++)
+          for (size_t i = 0; i < keypoints_cloud->points.size (); i++)
           {
 
-            if (tree->radiusSearch (keypoints_cloud[i], radius_, (*neighborhood_indices_)[good], (*neighborhood_dist_)[good]))
+            if (tree->radiusSearch (keypoints_cloud->points[i], radius_, (*neighborhood_indices_)[good], (*neighborhood_dist_)[good]))
             {
 
               EIGEN_ALIGN16 Eigen::Matrix3f covariance_matrix;
@@ -128,15 +128,15 @@ namespace pcl
               if ((fabs (eigenValues[0] - eigenValues[1]) < 1.5e-4) || (eigsum != 0 && fabs (eigenValues[0] / eigsum) > 1.e-2))
               {
                 //region is not planar, add to filtered keypoint
-                keypoints_cloud.points[good] = keypoints_cloud.points[i];
+                keypoints_cloud->points[good] = keypoints_cloud->points[i];
                 good++;
               }
             }
           }
 
           neighborhood_indices_->resize (good);
           neighborhood_dist_->resize (good);
-          keypoints_cloud.points.resize (good);
+          keypoints_cloud->points.resize (good);
 
           neighborhood_indices_->clear ();
           neighborhood_dist_->clear ();
@@ -166,18 +166,10 @@ namespace pcl
           keypoint_extractor.setRadiusSearch (sampling_density_);
           keypoint_extractor.setInputCloud (input_);
 
-          pcl::PointCloud<int> keypoints_idxes;
-          keypoint_extractor.compute (keypoints_idxes);
+          keypoint_extractor.filter (*keypoints);
 
           if (filter_planar_)
-            filterPlanar (input_, keypoints_idxes);
-
-          std::vector<int> indices;
-          indices.resize (keypoints_idxes.points.size ());
-          for (size_t i = 0; i < indices.size (); i++)
-            indices[i] = keypoints_idxes.points[i];
-
-          pcl::copyPointCloud (*input_, indices, *keypoints);
+            filterPlanar (input_, keypoints);
         }
       };
 

apps/3d_rec_framework/tools/apps/src/local_recognition_mian_dataset.cpp

@@ -12,7 +12,6 @@
 #include <pcl/apps/3d_rec_framework/feature_wrapper/local/shot_local_estimator.h>
 #include <pcl/apps/3d_rec_framework/feature_wrapper/local/shot_local_estimator_omp.h>
 #include <pcl/apps/3d_rec_framework/feature_wrapper/local/fpfh_local_estimator.h>
-#include <pcl/keypoints/uniform_sampling.h>
 #include <pcl/visualization/pcl_visualizer.h>
 #include <pcl/recognition/cg/correspondence_grouping.h>
 #include <pcl/recognition/cg/geometric_consistency.h>

apps/src/openni_uniform_sampling.cpp

@@ -38,7 +38,7 @@
 #include <pcl/io/openni_grabber.h>
 #include <pcl/visualization/cloud_viewer.h>
 #include <pcl/io/openni_camera/openni_driver.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 #include <pcl/console/parse.h>
 #include <pcl/common/time.h>
 
@@ -80,14 +80,14 @@ class OpenNIUniformSampling
       FPS_CALC ("computation");
 
       cloud_.reset (new Cloud);
-      indices_.reset (new pcl::PointCloud<int>);
       keypoints_.reset (new pcl::PointCloud<pcl::PointXYZ>);
       // Computation goes here
       pass_.setInputCloud (cloud);
-      pass_.compute (*indices_);
+      pcl::PointCloud<pcl::PointXYZRGBA> sampled;
+      pass_.filter (sampled);
       *cloud_  = *cloud;
 
-      pcl::copyPointCloud<pcl::PointXYZRGBA, pcl::PointXYZ> (*cloud, indices_->points, *keypoints_);
+      pcl::copyPointCloud<pcl::PointXYZRGBA, pcl::PointXYZ> (sampled, *keypoints_);
     }
 
     void
@@ -138,7 +138,6 @@ class OpenNIUniformSampling
     boost::mutex mtx_;
     CloudPtr cloud_;
     pcl::PointCloud<pcl::PointXYZ>::Ptr keypoints_;
-    pcl::PointCloud<int>::Ptr indices_;
 };
 
 void

doc/tutorials/content/sources/correspondence_grouping/correspondence_grouping.cpp

@@ -4,7 +4,7 @@
 #include <pcl/features/normal_3d_omp.h>
 #include <pcl/features/shot_omp.h>
 #include <pcl/features/board.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 #include <pcl/recognition/cg/hough_3d.h>
 #include <pcl/recognition/cg/geometric_consistency.h>
 #include <pcl/visualization/pcl_visualizer.h>
@@ -221,19 +221,16 @@ main (int argc, char *argv[])
   //
   //  Downsample Clouds to Extract keypoints
   //
-  pcl::PointCloud<int> sampled_indices;
 
   pcl::UniformSampling<PointType> uniform_sampling;
   uniform_sampling.setInputCloud (model);
   uniform_sampling.setRadiusSearch (model_ss_);
-  uniform_sampling.compute (sampled_indices);
-  pcl::copyPointCloud (*model, sampled_indices.points, *model_keypoints);
+  uniform_sampling.filter (*model_keypoints);
   std::cout << "Model total points: " << model->size () << "; Selected Keypoints: " << model_keypoints->size () << std::endl;
 
   uniform_sampling.setInputCloud (scene);
   uniform_sampling.setRadiusSearch (scene_ss_);
-  uniform_sampling.compute (sampled_indices);
-  pcl::copyPointCloud (*scene, sampled_indices.points, *scene_keypoints);
+  uniform_sampling.filter (*scene_keypoints);
   std::cout << "Scene total points: " << scene->size () << "; Selected Keypoints: " << scene_keypoints->size () << std::endl;
 
 

doc/tutorials/content/sources/global_hypothesis_verification/global_hypothesis_verification.cpp

@@ -41,7 +41,7 @@
 #include <pcl/features/normal_3d_omp.h>
 #include <pcl/features/shot_omp.h>
 #include <pcl/features/board.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 #include <pcl/recognition/cg/hough_3d.h>
 #include <pcl/recognition/cg/geometric_consistency.h>
 #include <pcl/recognition/hv/hv_go.h>
@@ -256,19 +256,15 @@ main (int argc,
   /**
    *  Downsample Clouds to Extract keypoints
    */
-  pcl::PointCloud<int> sampled_indices;
-
   pcl::UniformSampling<PointType> uniform_sampling;
   uniform_sampling.setInputCloud (model);
   uniform_sampling.setRadiusSearch (model_ss_);
-  uniform_sampling.compute (sampled_indices);
-  pcl::copyPointCloud (*model, sampled_indices.points, *model_keypoints);
+  uniform_sampling.filter (*model_keypoints);
   std::cout << "Model total points: " << model->size () << "; Selected Keypoints: " << model_keypoints->size () << std::endl;
 
   uniform_sampling.setInputCloud (scene);
   uniform_sampling.setRadiusSearch (scene_ss_);
-  uniform_sampling.compute (sampled_indices);
-  pcl::copyPointCloud (*scene, sampled_indices.points, *scene_keypoints);
+  uniform_sampling.filter (*scene_keypoints);
   std::cout << "Scene total points: " << scene->size () << "; Selected Keypoints: " << scene_keypoints->size () << std::endl;
 
   /**

doc/tutorials/content/sources/registration_api/example1.cpp

@@ -7,7 +7,6 @@
 
 #include <pcl/io/pcd_io.h>
 #include <pcl/console/time.h>
-#include <pcl/keypoints/uniform_sampling.h>
 #include <pcl/features/normal_3d.h>
 #include <pcl/features/fpfh.h>
 #include <pcl/registration/correspondence_estimation.h>

doc/tutorials/content/sources/registration_api/example2.cpp

@@ -5,7 +5,7 @@
 
 #include <pcl/io/pcd_io.h>
 #include <pcl/conversions.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 #include <pcl/features/normal_3d.h>
 #include <pcl/features/fpfh.h>
 #include <pcl/registration/correspondence_estimation.h>
@@ -26,18 +26,15 @@ estimateKeypoints (const PointCloud<PointXYZ>::Ptr &src,
                    PointCloud<PointXYZ> &keypoints_src,
                    PointCloud<PointXYZ> &keypoints_tgt)
 {
-  PointCloud<int> keypoints_src_idx, keypoints_tgt_idx;
   // Get an uniform grid of keypoints
   UniformSampling<PointXYZ> uniform;
   uniform.setRadiusSearch (1);  // 1m
 
   uniform.setInputCloud (src);
-  uniform.compute (keypoints_src_idx);
-  copyPointCloud<PointXYZ, PointXYZ> (*src, keypoints_src_idx.points, keypoints_src);
+  uniform.filter (keypoints_src);
 
   uniform.setInputCloud (tgt);
-  uniform.compute (keypoints_tgt_idx);
-  copyPointCloud<PointXYZ, PointXYZ> (*tgt, keypoints_tgt_idx.points, keypoints_tgt);
+  uniform.filter (keypoints_tgt);
 
   // For debugging purposes only: uncomment the lines below and use pcl_viewer to view the results, i.e.:
   // pcl_viewer source_pcd keypoints_src.pcd -ps 1 -ps 10

filters/CMakeLists.txt

@@ -34,6 +34,7 @@ if(build)
         src/frustum_culling.cpp
         src/covariance_sampling.cpp
         src/median_filter.cpp
+        src/uniform_sampling.cpp
 	src/voxel_grid_occlusion_estimation.cpp
 	    src/normal_refinement.cpp
         src/grid_minimum.cpp
@@ -74,6 +75,7 @@ if(build)
         "include/pcl/${SUBSYS_NAME}/frustum_culling.h"
         "include/pcl/${SUBSYS_NAME}/covariance_sampling.h"
         "include/pcl/${SUBSYS_NAME}/median_filter.h"
+        "include/pcl/${SUBSYS_NAME}/uniform_sampling.h"
         "include/pcl/${SUBSYS_NAME}/normal_refinement.h"
         "include/pcl/${SUBSYS_NAME}/grid_minimum.h"
         "include/pcl/${SUBSYS_NAME}/morphological_filter.h"
@@ -110,6 +112,7 @@ if(build)
         "include/pcl/${SUBSYS_NAME}/impl/frustum_culling.hpp"
         "include/pcl/${SUBSYS_NAME}/impl/covariance_sampling.hpp"
         "include/pcl/${SUBSYS_NAME}/impl/median_filter.hpp"
+        "include/pcl/${SUBSYS_NAME}/impl/uniform_sampling.hpp"
         "include/pcl/${SUBSYS_NAME}/impl/normal_refinement.hpp"
         "include/pcl/${SUBSYS_NAME}/impl/grid_minimum.hpp"
         "include/pcl/${SUBSYS_NAME}/impl/morphological_filter.hpp"

keypoints/include/pcl/keypoints/impl/uniform_sampling.hpp → filters/include/pcl/filters/impl/uniform_sampling.hpp

@@ -35,15 +35,15 @@
  *
  */
 
-#ifndef PCL_KEYPOINTS_UNIFORM_SAMPLING_IMPL_H_
-#define PCL_KEYPOINTS_UNIFORM_SAMPLING_IMPL_H_
+#ifndef PCL_FILTERS_UNIFORM_SAMPLING_IMPL_H_
+#define PCL_FILTERS_UNIFORM_SAMPLING_IMPL_H_
 
 #include <pcl/common/common.h>
-#include <pcl/keypoints/uniform_sampling.h>
+#include <pcl/filters/uniform_sampling.h>
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename PointInT> void
-pcl::UniformSampling<PointInT>::detectKeypoints (PointCloudOut &output)
+template <typename PointT> void
+pcl::UniformSampling<PointT>::applyFilter (PointCloud &output)
 {
   // Has the input dataset been set already?
   if (!input_)
@@ -59,7 +59,7 @@ pcl::UniformSampling<PointInT>::detectKeypoints (PointCloudOut &output)
 
   Eigen::Vector4f min_p, max_p;
   // Get the minimum and maximum dimensions
-  pcl::getMinMax3D<PointInT>(*input_, min_p, max_p);
+  pcl::getMinMax3D<PointT>(*input_, min_p, max_p);
 
   // Compute the minimum and maximum bounding box values
   min_b_[0] = static_cast<int> (floor (min_p[0] * inverse_leaf_size_[0]));
@@ -118,11 +118,11 @@ pcl::UniformSampling<PointInT>::detectKeypoints (PointCloudOut &output)
   int cp = 0;
 
   for (typename boost::unordered_map<size_t, Leaf>::const_iterator it = leaves_.begin (); it != leaves_.end (); ++it)
-    output.points[cp++] = it->second.idx;
+    output.points[cp++] = input_->points[it->second.idx];
   output.width = static_cast<uint32_t> (output.points.size ());
 }
 
 #define PCL_INSTANTIATE_UniformSampling(T) template class PCL_EXPORTS pcl::UniformSampling<T>;
 
-#endif    // PCL_KEYPOINTS_UNIFORM_SAMPLING_IMPL_H_
+#endif    // PCL_FILTERS_UNIFORM_SAMPLING_IMPL_H_