Merge pull request PointCloudLibrary#4665 from mvieth/indices_5

Use more pcl::Indices

Author: mvieth

.ci/azure-pipelines/build/ubuntu_indices.yaml

@@ -10,12 +10,6 @@ steps:
       -DPCL_ONLY_CORE_POINT_TYPES=ON \
       -DPCL_INDEX_SIGNED=$INDEX_SIGNED \
       -DPCL_INDEX_SIZE=$INDEX_SIZE \
-      -DBUILD_geometry=OFF \
-      -DBUILD_io=OFF \
-      -DBUILD_tools=OFF \
-      -DBUILD_kdtree=OFF \
-      -DBUILD_ml=OFF \
-      -DBUILD_stereo=OFF \
       -DBUILD_global_tests=ON 
       # Temporary fix to ensure no tests are skipped
       cmake $(Build.SourcesDirectory)

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

@@ -77,7 +77,7 @@ class UniformSamplingExtractor : public KeypointExtractor<PointInT> {
   using KeypointExtractor<PointInT>::input_;
   using KeypointExtractor<PointInT>::radius_;
   float sampling_density_;
-  std::shared_ptr<std::vector<std::vector<int>>> neighborhood_indices_;
+  std::shared_ptr<std::vector<pcl::Indices>> neighborhood_indices_;
   std::shared_ptr<std::vector<std::vector<float>>> neighborhood_dist_;
 
   void
@@ -92,7 +92,7 @@ class UniformSamplingExtractor : public KeypointExtractor<PointInT> {
       tree.reset(new pcl::search::KdTree<PointInT>(false));
     tree->setInputCloud(input);
 
-    neighborhood_indices_.reset(new std::vector<std::vector<int>>);
+    neighborhood_indices_.reset(new std::vector<pcl::Indices>);
     neighborhood_indices_->resize(keypoints_cloud->size());
     neighborhood_dist_.reset(new std::vector<std::vector<float>>);
     neighborhood_dist_->resize(keypoints_cloud->size());

apps/src/ni_linemod.cpp

@@ -208,7 +208,7 @@ class NILinemod {
    * \param[out] object the segmented resultant object
    */
   void
-  segmentObject(int picked_idx,
+  segmentObject(pcl::index_t picked_idx,
                 const CloudConstPtr& cloud,
                 const PointIndices::Ptr& plane_indices,
                 const PointIndices::Ptr& plane_boundary_indices,
@@ -293,7 +293,7 @@ class NILinemod {
   /////////////////////////////////////////////////////////////////////////
   void
   segment(const PointT& picked_point,
-          int picked_idx,
+          pcl::index_t picked_idx,
           PlanarRegion<PointT>& region,
           PointIndices&,
           CloudPtr& object)

filters/src/passthrough.cpp

@@ -297,8 +297,11 @@ pcl::PassThrough<pcl::PCLPointCloud2>::applyFilter (Indices &indices)
   indices.resize (indices_->size ());
   removed_indices_->resize (indices_->size ());
   int oii = 0, rii = 0;  // oii = output indices iterator, rii = removed indices iterator
-  const std::uint32_t xyz_offset[3] = {input_->fields[x_idx_].offset, input_->fields[y_idx_].offset, input_->fields[z_idx_].offset};
-  PCL_DEBUG ("[pcl::%s<pcl::PCLPointCloud2>::applyFilter] Field offsets: x: %u, y: %u, z: %u.\n", filter_name_.c_str (), xyz_offset[0], xyz_offset[1], xyz_offset[2]);
+  const auto x_offset = input_->fields[x_idx_].offset,
+             y_offset = input_->fields[y_idx_].offset,
+             z_offset = input_->fields[z_idx_].offset;
+  PCL_DEBUG ("[pcl::%s<pcl::PCLPointCloud2>::applyFilter] Field offsets: x: %zu, y: %zu, z: %zu.\n", filter_name_.c_str (),
+             static_cast<std::size_t>(x_offset), static_cast<std::size_t>(y_offset), static_cast<std::size_t>(z_offset));
 
   // Has a field name been specified?
   if (filter_field_name_.empty ())
@@ -307,9 +310,9 @@ pcl::PassThrough<pcl::PCLPointCloud2>::applyFilter (Indices &indices)
     for (const auto ii : indices)  // ii = input index
     {
       float pt[3];
-      memcpy (&pt[0], &input_->data[ii * input_->point_step + xyz_offset[0]], sizeof(float));
-      memcpy (&pt[1], &input_->data[ii * input_->point_step + xyz_offset[1]], sizeof(float));
-      memcpy (&pt[2], &input_->data[ii * input_->point_step + xyz_offset[2]], sizeof(float));
+      memcpy (&pt[0], &input_->data[ii * input_->point_step + x_offset], sizeof(float));
+      memcpy (&pt[1], &input_->data[ii * input_->point_step + y_offset], sizeof(float));
+      memcpy (&pt[2], &input_->data[ii * input_->point_step + z_offset], sizeof(float));
       // Non-finite entries are always passed to removed indices
       if (!std::isfinite (pt[0]) ||
           !std::isfinite (pt[1]) ||
@@ -338,9 +341,9 @@ pcl::PassThrough<pcl::PCLPointCloud2>::applyFilter (Indices &indices)
     for (const auto ii : indices)  // ii = input index
     {
       float pt[3];
-      memcpy (&pt[0], &input_->data[ii * input_->point_step + xyz_offset[0]], sizeof(float));
-      memcpy (&pt[1], &input_->data[ii * input_->point_step + xyz_offset[1]], sizeof(float));
-      memcpy (&pt[2], &input_->data[ii * input_->point_step + xyz_offset[2]], sizeof(float));
+      memcpy (&pt[0], &input_->data[ii * input_->point_step + x_offset], sizeof(float));
+      memcpy (&pt[1], &input_->data[ii * input_->point_step + y_offset], sizeof(float));
+      memcpy (&pt[2], &input_->data[ii * input_->point_step + z_offset], sizeof(float));
       // Non-finite entries are always passed to removed indices
       if (!std::isfinite (pt[0]) ||
           !std::isfinite (pt[1]) ||

recognition/include/pcl/recognition/impl/hv/hv_go.hpp

@@ -65,7 +65,7 @@ inline void extractEuclideanClustersSmooth(const typename pcl::PointCloud<PointT
   // Create a bool vector of processed point indices, and initialize it to false
   std::vector<bool> processed (cloud.size (), false);
 
-  std::vector<int> nn_indices;
+  pcl::Indices nn_indices;
   std::vector<float> nn_distances;
   // Process all points in the indices vector
   int size = static_cast<int> (cloud.size ());

registration/include/pcl/registration/correspondence_rejection_poly.h

@@ -240,8 +240,8 @@ class PCL_EXPORTS CorrespondenceRejectorPoly : public CorrespondenceRejector {
    * all edge length ratios are larger than or equal to \ref similarity_threshold_
    */
   inline bool
-  thresholdPolygon(const std::vector<int>& source_indices,
-                   const std::vector<int>& target_indices)
+  thresholdPolygon(const pcl::Indices& source_indices,
+                   const pcl::Indices& target_indices)
   {
     // Convert indices to correspondences and an index vector pointing to each element
     pcl::Correspondences corr(cardinality_);

registration/include/pcl/registration/correspondence_types.h

@@ -61,15 +61,15 @@ getCorDistMeanStd(const pcl::Correspondences& correspondences,
  * \note order of indices corresponds to input list of descriptor correspondences
  */
 inline void
-getQueryIndices(const pcl::Correspondences& correspondences, std::vector<int>& indices);
+getQueryIndices(const pcl::Correspondences& correspondences, pcl::Indices& indices);
 
 /** \brief extracts the match indices
  * \param[in] correspondences list of correspondences
  * \param[out] indices array of extracted indices.
  * \note order of indices corresponds to input list of descriptor correspondences
  */
 inline void
-getMatchIndices(const pcl::Correspondences& correspondences, std::vector<int>& indices);
+getMatchIndices(const pcl::Correspondences& correspondences, pcl::Indices& indices);
 
 } // namespace registration
 } // namespace pcl

registration/include/pcl/registration/ia_fpcs.h

@@ -64,7 +64,7 @@ getMeanPointDensity(const typename pcl::PointCloud<PointT>::ConstPtr& cloud,
 template <typename PointT>
 inline float
 getMeanPointDensity(const typename pcl::PointCloud<PointT>::ConstPtr& cloud,
-                    const std::vector<int>& indices,
+                    const pcl::Indices& indices,
                     float max_dist,
                     int nr_threads = 1);
 
@@ -318,7 +318,7 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * * = 0 a set of four congruent points was selected
    */
   int
-  selectBase(std::vector<int>& base_indices, float (&ratio)[2]);
+  selectBase(pcl::Indices& base_indices, float (&ratio)[2]);
 
   /** \brief Select randomly a triplet of points with large point-to-point distances.
    * The minimum point sampling distance is calculated based on the estimated point
@@ -330,7 +330,7 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * * = 0 base triangle succesully selected
    */
   int
-  selectBaseTriangle(std::vector<int>& base_indices);
+  selectBaseTriangle(pcl::Indices& base_indices);
 
   /** \brief Setup the base (four coplanar points) by ordering the points and computing
    * intersection ratios and segment to segment distances of base diagonal.
@@ -339,14 +339,14 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * \param[out] ratio diagonal intersection ratios of base points
    */
   void
-  setupBase(std::vector<int>& base_indices, float (&ratio)[2]);
+  setupBase(pcl::Indices& base_indices, float (&ratio)[2]);
 
   /** \brief Calculate intersection ratios and segment to segment distances of base
    * diagonals. \param[in] base_indices indices of base B \param[out] ratio diagonal
    * intersection ratios of base points \return quality value of diagonal intersection
    */
   float
-  segmentToSegmentDist(const std::vector<int>& base_indices, float (&ratio)[2]);
+  segmentToSegmentDist(const pcl::Indices& base_indices, float (&ratio)[2]);
 
   /** \brief Search for corresponding point pairs given the distance between two base
    * points.
@@ -375,8 +375,8 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * * = 0 at least one base match was found
    */
   virtual int
-  determineBaseMatches(const std::vector<int>& base_indices,
-                       std::vector<std::vector<int>>& matches,
+  determineBaseMatches(const pcl::Indices& base_indices,
+                       std::vector<pcl::Indices>& matches,
                        const pcl::Correspondences& pairs_a,
                        const pcl::Correspondences& pairs_b,
                        const float (&ratio)[2]);
@@ -391,7 +391,7 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * * = 0 edges of match M fits to the ones of base B
    */
   int
-  checkBaseMatch(const std::vector<int>& match_indices, const float (&ds)[4]);
+  checkBaseMatch(const pcl::Indices& match_indices, const float (&ds)[4]);
 
   /** \brief Method to handle current candidate matches. Here we validate and evaluate
    * the matches w.r.t the base and store the best fitting match (together with its
@@ -404,8 +404,8 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * contains the candidates matches M
    */
   virtual void
-  handleMatches(const std::vector<int>& base_indices,
-                std::vector<std::vector<int>>& matches,
+  handleMatches(const pcl::Indices& base_indices,
+                std::vector<pcl::Indices>& matches,
                 MatchingCandidates& candidates);
 
   /** \brief Sets the correspondences between the base B and the match M by using the
@@ -416,8 +416,8 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * \param[out] correspondences resulting correspondences
    */
   virtual void
-  linkMatchWithBase(const std::vector<int>& base_indices,
-                    std::vector<int>& match_indices,
+  linkMatchWithBase(const pcl::Indices& base_indices,
+                    pcl::Indices& match_indices,
                     pcl::Correspondences& correspondences);
 
   /** \brief Validate the matching by computing the transformation between the source
@@ -434,8 +434,8 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
    * * = 0 MSE smaller than max_mse_
    */
   virtual int
-  validateMatch(const std::vector<int>& base_indices,
-                const std::vector<int>& match_indices,
+  validateMatch(const pcl::Indices& base_indices,
+                const pcl::Indices& match_indices,
                 const pcl::Correspondences& correspondences,
                 Eigen::Matrix4f& transformation);
 

registration/include/pcl/registration/ia_kfpcs.h

@@ -205,8 +205,8 @@ class KFPCSInitialAlignment
    * contains the candidates matches M
    */
   void
-  handleMatches(const std::vector<int>& base_indices,
-                std::vector<std::vector<int>>& matches,
+  handleMatches(const pcl::Indices& base_indices,
+                std::vector<pcl::Indices>& matches,
                 MatchingCandidates& candidates) override;
 
   /** \brief Validate the transformation by calculating the score value after

registration/include/pcl/registration/ia_ransac.h

@@ -261,10 +261,10 @@ class SampleConsensusInitialAlignment : public Registration<PointSource, PointTa
   /** \brief Choose a random index between 0 and n-1
    * \param n the number of possible indices to choose from
    */
-  inline int
+  inline pcl::index_t
   getRandomIndex(int n)
   {
-    return (static_cast<int>(n * (rand() / (RAND_MAX + 1.0))));
+    return (static_cast<pcl::index_t>(n * (rand() / (RAND_MAX + 1.0))));
   };
 
   /** \brief Select \a nr_samples sample points from cloud while making sure that their
@@ -275,9 +275,9 @@ class SampleConsensusInitialAlignment : public Registration<PointSource, PointTa
    */
   void
   selectSamples(const PointCloudSource& cloud,
-                int nr_samples,
+                unsigned int nr_samples,
                 float min_sample_distance,
-                std::vector<int>& sample_indices);
+                pcl::Indices& sample_indices);
 
   /** \brief For each of the sample points, find a list of points in the target cloud
    * whose features are similar to the sample points' features. From these, select one
@@ -288,8 +288,8 @@ class SampleConsensusInitialAlignment : public Registration<PointSource, PointTa
    */
   void
   findSimilarFeatures(const FeatureCloud& input_features,
-                      const std::vector<int>& sample_indices,
-                      std::vector<int>& corresponding_indices);
+                      const pcl::Indices& sample_indices,
+                      pcl::Indices& corresponding_indices);
 
   /** \brief An error metric for that computes the quality of the alignment between the
    * given cloud and the target. \param cloud the input cloud \param threshold distances

registration/include/pcl/registration/impl/correspondence_estimation_normal_shooting.hpp

@@ -73,7 +73,7 @@ CorrespondenceEstimationNormalShooting<PointSource, PointTarget, NormalT, Scalar
 
   correspondences.resize(indices_->size());
 
-  std::vector<int> nn_indices(k_);
+  pcl::Indices nn_indices(k_);
   std::vector<float> nn_dists(k_);
 
   int min_index = 0;
@@ -188,9 +188,9 @@ CorrespondenceEstimationNormalShooting<PointSource, PointTarget, NormalT, Scalar
 
   correspondences.resize(indices_->size());
 
-  std::vector<int> nn_indices(k_);
+  pcl::Indices nn_indices(k_);
   std::vector<float> nn_dists(k_);
-  std::vector<int> index_reciprocal(1);
+  pcl::Indices index_reciprocal(1);
   std::vector<float> distance_reciprocal(1);
 
   int min_index = 0;

registration/include/pcl/registration/impl/correspondence_types.hpp

@@ -68,15 +68,15 @@ getCorDistMeanStd(const pcl::Correspondences& correspondences,
 }
 
 inline void
-getQueryIndices(const pcl::Correspondences& correspondences, std::vector<int>& indices)
+getQueryIndices(const pcl::Correspondences& correspondences, pcl::Indices& indices)
 {
   indices.resize(correspondences.size());
   for (std::size_t i = 0; i < correspondences.size(); ++i)
     indices[i] = correspondences[i].index_query;
 }
 
 inline void
-getMatchIndices(const pcl::Correspondences& correspondences, std::vector<int>& indices)
+getMatchIndices(const pcl::Correspondences& correspondences, pcl::Indices& indices)
 {
   indices.resize(correspondences.size());
   for (std::size_t i = 0; i < correspondences.size(); ++i)