TODO: <Modify index type for pointCloud>

2d/include/pcl/2d/impl/edge.hpp

@@ -69,7 +69,7 @@ Edge<PointInT, PointOutT>::detectEdgeSobel(pcl::PointCloud<PointOutT>& output)
   output.height = height;
   output.width = width;
 
-  for (std::size_t i = 0; i < output.size(); ++i) {
+  for (index_t i = 0; i < output.size(); ++i) {
     output[i].magnitude_x = (*magnitude_x)[i].intensity;
     output[i].magnitude_y = (*magnitude_y)[i].intensity;
     output[i].magnitude =
@@ -110,7 +110,7 @@ Edge<PointInT, PointOutT>::sobelMagnitudeDirection(
   output.height = height;
   output.width = width;
 
-  for (std::size_t i = 0; i < output.size(); ++i) {
+  for (index_t i = 0; i < output.size(); ++i) {
     output[i].magnitude_x = (*magnitude_x)[i].intensity;
     output[i].magnitude_y = (*magnitude_y)[i].intensity;
     output[i].magnitude =
@@ -148,7 +148,7 @@ Edge<PointInT, PointOutT>::detectEdgePrewitt(pcl::PointCloud<PointOutT>& output)
   output.height = height;
   output.width = width;
 
-  for (std::size_t i = 0; i < output.size(); ++i) {
+  for (index_t i = 0; i < output.size(); ++i) {
     output[i].magnitude_x = (*magnitude_x)[i].intensity;
     output[i].magnitude_y = (*magnitude_y)[i].intensity;
     output[i].magnitude =
@@ -363,7 +363,7 @@ Edge<PointInT, PointOutT>::detectEdgeCanny(pcl::PointCloud<PointOutT>& output)
   }
 
   // Final thresholding
-  for (std::size_t i = 0; i < input_->size(); ++i) {
+  for (index_t i = 0; i < input_->size(); ++i) {
     if ((*maxima)[i].intensity == std::numeric_limits<float>::max())
       output[i].magnitude = 255;
     else

2d/include/pcl/2d/impl/kernel.hpp

@@ -113,8 +113,8 @@ kernel<PointT>::gaussianKernel(pcl::PointCloud<PointT>& kernel)
   }
 
   // Normalizing the kernel
-  for (std::size_t i = 0; i < kernel.size(); ++i)
-    kernel[i].intensity /= sum;
+  for (auto& k : kernel)
+    k.intensity /= sum;
 }
 
 template <typename PointT>
@@ -139,8 +139,8 @@ kernel<PointT>::loGKernel(pcl::PointCloud<PointT>& kernel)
   }
 
   // Normalizing the kernel
-  for (std::size_t i = 0; i < kernel.size(); ++i)
-    kernel[i].intensity /= sum;
+  for (auto& k : kernel)
+    k.intensity /= sum;
 }
 
 template <typename PointT>

2d/include/pcl/2d/impl/morphology.hpp

@@ -353,8 +353,8 @@ Morphology<PointT>::structuringElementRectangle(pcl::PointCloud<PointT>& kernel,
   kernel.height = height;
   kernel.width = width;
   kernel.resize(height * width);
-  for (std::size_t i = 0; i < kernel.size(); ++i)
-    kernel[i].intensity = 1;
+  for(auto& k : kernel)
+    k.intensity = 1;
 }
 
 template <typename PointT>

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

@@ -75,8 +75,8 @@ class FPFHLocalEstimation : public LocalEstimator<PointInT, FeatureT> {
     fpfh_estimate.setRadiusSearch(support_radius_);
     fpfh_estimate.compute(*fpfhs);
 
-    signatures->resize(fpfhs->points.size());
-    signatures->width = static_cast<int>(fpfhs->points.size());
+    signatures->resize(fpfhs->size());
+    signatures->width = fpfhs->size();
     signatures->height = 1;
 
     int size_feat = 33;

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

@@ -107,8 +107,8 @@ class SHOTLocalEstimation : public LocalEstimator<PointInT, FeatureT> {
     shot_estimate.setInputNormals(normals);
     shot_estimate.setRadiusSearch(support_radius_);
     shot_estimate.compute(*shots);
-    signatures->resize(shots->points.size());
-    signatures->width = static_cast<int>(shots->points.size());
+    signatures->resize(shots->size());
+    signatures->width = shots->size();
     signatures->height = 1;
 
     int size_feat = sizeof(signatures->points[0].histogram) / sizeof(float);

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

@@ -112,8 +112,8 @@ class SHOTLocalEstimationOMP : public LocalEstimator<PointInT, FeatureT> {
       shot_estimate.compute(*shots);
     }
 
-    signatures->resize(shots->points.size());
-    signatures->width = static_cast<int>(shots->points.size());
+    signatures->resize(shots->size());
+    signatures->width = shots->size();
     signatures->height = 1;
 
     int size_feat = sizeof(signatures->points[0].histogram) / sizeof(float);

apps/3d_rec_framework/include/pcl/apps/3d_rec_framework/pipeline/impl/local_recognizer.hpp

@@ -208,7 +208,7 @@ pcl::rec_3d_framework::LocalRecognitionPipeline<Distance, PointInT, FeatureT>::
   PointInTPtr keypoints_pointcloud;
 
   if (signatures_ != nullptr && processed_ != nullptr &&
-      (signatures_->size() == keypoints_pointcloud->points.size())) {
+      (signatures_->size() == keypoints_pointcloud->size())) {
     keypoints_pointcloud = keypoints_input_;
     signatures = signatures_;
     processed = processed_;

apps/in_hand_scanner/src/icp.cpp

@@ -160,9 +160,9 @@ pcl::ihs::ICP::findTransformation (const MeshConstPtr&              mesh_model,
 {
   // Check the input
   // TODO: Double check the minimum number of points necessary for icp
-  const std::size_t n_min = 4;
+  const index_t n_min = 4;
 
-  if(mesh_model->sizeVertices () < n_min || cloud_data->size () < n_min)
+  if(static_cast<index_t>(mesh_model->sizeVertices ()) < n_min || cloud_data->size () < n_min)
   {
     std::cerr << "ERROR in icp.cpp: Not enough input points!\n";
     return (false);
@@ -193,8 +193,8 @@ pcl::ihs::ICP::findTransformation (const MeshConstPtr&              mesh_model,
   const CloudNormalConstPtr cloud_data_selected  = this->selectDataPoints (cloud_data);
   t_select = sw.getTime ();
 
-  const std::size_t n_model = cloud_model_selected->size ();
-  const std::size_t n_data  = cloud_data_selected->size ();
+  const index_t n_model = cloud_model_selected->size ();
+  const index_t n_data  = cloud_data_selected->size ();
   if(n_model < n_min) {std::cerr << "ERROR in icp.cpp: Not enough model points after selection!\n"; return (false);}
   if(n_data < n_min)  {std::cerr << "ERROR in icp.cpp: Not enough data points after selection!\n"; return (false);}
 
@@ -203,7 +203,7 @@ pcl::ihs::ICP::findTransformation (const MeshConstPtr&              mesh_model,
   kd_tree_->setInputCloud (cloud_model_selected);
   t_build = sw.getTime ();
 
-  std::vector <int>   index (1);
+  Indices index (1);
   std::vector <float> squared_distance (1);
 
   // Clouds with one to one correspondences
@@ -243,7 +243,7 @@ pcl::ihs::ICP::findTransformation (const MeshConstPtr&              mesh_model,
       // Check the distance threshold
       if (squared_distance [0] < squared_distance_threshold)
       {
-        if ((std::size_t) index [0] >= cloud_model_selected->size ())
+        if (index [0] >= cloud_model_selected->size ())
         {
           std::cerr << "ERROR in icp.cpp: Segfault!\n";
           std::cerr << "  Trying to access index " << index [0] << " >= " << cloud_model_selected->size () << std::endl;
@@ -371,7 +371,7 @@ pcl::ihs::ICP::selectModelPoints (const MeshConstPtr&    mesh_model,
                                   const Eigen::Matrix4f& T_inv) const
 {
   const CloudNormalPtr cloud_model_out (new CloudNormal ());
-  cloud_model_out->reserve (mesh_model->sizeVertices ());
+  cloud_model_out->reserve (static_cast<index_t>(mesh_model->sizeVertices ()));
 
   const Mesh::VertexDataCloud& cloud = mesh_model->getVertexDataCloud ();
 
@@ -424,7 +424,7 @@ pcl::ihs::ICP::minimizePointPlane (const CloudNormal& cloud_source,
 {
   // Check the input
   // n < n_min already checked in the icp main loop
-  const std::size_t n = cloud_source.size ();
+  const index_t n = cloud_source.size ();
   if (cloud_target.size () != n)
   {
     std::cerr << "ERROR in icp.cpp: Input must have the same size!\n";

apps/in_hand_scanner/src/integration.cpp

@@ -212,10 +212,9 @@ pcl::ihs::Integration::merge (const CloudXYZRGBNormalConstPtr& cloud_data,
 
   // Nearest neighbor search
   CloudXYZPtr xyz_model (new CloudXYZ ());
-  xyz_model->reserve (mesh_model->sizeVertices ());
-  for (std::size_t i=0; i<mesh_model->sizeVertices (); ++i)
+  xyz_model->reserve (static_cast<index_t>(mesh_model->sizeVertices ()));
+  for (const auto& pt : mesh_model->getVertexDataCloud ())
   {
-    const PointIHS& pt = mesh_model->getVertexDataCloud () [i];
     xyz_model->push_back (PointXYZ (pt.x, pt.y, pt.z));
   }
   kd_tree_->setInputCloud (xyz_model);
@@ -390,7 +389,7 @@ pcl::ihs::Integration::merge (const CloudXYZRGBNormalConstPtr& cloud_data,
 void
 pcl::ihs::Integration::age (const MeshPtr& mesh, const bool cleanup) const
 {
-  for (std::size_t i=0; i<mesh->sizeVertices (); ++i)
+  for (index_t i=0; i < static_cast<index_t>(mesh->sizeVertices ()); ++i)
   {
     PointIHS& pt = mesh->getVertexDataCloud () [i];
     if (pt.age < max_age_)
@@ -424,7 +423,7 @@ pcl::ihs::Integration::age (const MeshPtr& mesh, const bool cleanup) const
 void
 pcl::ihs::Integration::removeUnfitVertices (const MeshPtr& mesh, const bool cleanup) const
 {
-  for (std::size_t i=0; i<mesh->sizeVertices (); ++i)
+  for (index_t i=0; i < static_cast<index_t>(mesh->sizeVertices ()); ++i)
   {
     if (pcl::ihs::countDirections (mesh->getVertexDataCloud () [i].directions) < min_directions_)
     {

apps/in_hand_scanner/src/opengl_viewer.cpp

@@ -926,7 +926,7 @@ pcl::ihs::OpenGLViewer::drawMeshes ()
         }
         case COL_VISCONF:
         {
-          for (std::size_t i=0; i<mesh.vertices.size (); ++i)
+          for (index_t i=0; i<mesh.vertices.size (); ++i)
           {
             const unsigned int n = pcl::ihs::countDirections (mesh.vertices [i].directions);
             const unsigned int index = static_cast <unsigned int> (

apps/point_cloud_editor/src/cloud.cpp

@@ -45,6 +45,8 @@
 #include <pcl/apps/point_cloud_editor/common.h>
 #include <pcl/apps/point_cloud_editor/copyBuffer.h>
 
+using pcl::index_t;
+
 const float Cloud::DEFAULT_POINT_DISPLAY_SIZE_ = 2.0f;
 const float Cloud::DEFAULT_POINT_HIGHLIGHT_SIZE_ = 4.0f;
 
@@ -416,7 +418,7 @@ Cloud::getDisplaySpacePoint (unsigned int index) const
 void
 Cloud::getDisplaySpacePoints (Point3DVector& pts) const
 {
-  for(std::size_t i = 0; i < cloud_.size(); ++i)
+  for(index_t i = 0; i < cloud_.size(); ++i)
     pts.push_back(getDisplaySpacePoint(i));
 }
 
@@ -462,12 +464,12 @@ Cloud::updateCloudMembers ()
   float *pt = &(cloud_.points[0].data[X]);
   std::copy(pt, pt+XYZ_SIZE, max_xyz_);
   std::copy(max_xyz_, max_xyz_+XYZ_SIZE, min_xyz_);
-  for (std::size_t i = 1; i < cloud_.size(); ++i)
+  for (const auto& pt : cloud_)
   {
     for (unsigned int j = 0; j < XYZ_SIZE; ++j)
     {
-      min_xyz_[j] = std::min(min_xyz_[j], cloud_.points[i].data[j]);
-      max_xyz_[j] = std::max(max_xyz_[j], cloud_.points[i].data[j]);
+      min_xyz_[j] = std::min(min_xyz_[j], pt.data[j]);
+      max_xyz_[j] = std::max(max_xyz_[j], pt.data[j]);
     }
   }
   float range = 0.0f;

apps/src/grabcut_2d.cpp

@@ -531,11 +531,11 @@ main(int argc, char** argv)
       new pcl::PointCloud<pcl::PointXYZRGB>(scene->width, scene->height));
 
   if (scene->isOrganized()) {
-    std::uint32_t height_1 = scene->height - 1;
-    for (std::size_t i = 0; i < scene->height; ++i) {
-      for (std::size_t j = 0; j < scene->width; ++j) {
+    pcl::index_t height_1 = scene->height - 1;
+    for (pcl::index_t i = 0; i < scene->height; ++i) {
+      for (pcl::index_t j = 0; j < scene->width; ++j) {
         const pcl::PointXYZRGB& p = (*scene)(j, i);
-        std::size_t reverse_index = (height_1 - i) * scene->width + j;
+        pcl::index_t reverse_index = (height_1 - i) * scene->width + j;
         display_image->points[reverse_index].r = static_cast<float>(p.r) / 255.0;
         display_image->points[reverse_index].g = static_cast<float>(p.g) / 255.0;
         display_image->points[reverse_index].b = static_cast<float>(p.b) / 255.0;

apps/src/ni_agast.cpp

@@ -227,17 +227,16 @@ class AGASTDemo {
     keypoints3d.height = keypoints->height;
     keypoints3d.is_dense = true;
 
-    std::size_t j = 0;
-    for (std::size_t i = 0; i < keypoints->size(); ++i) {
+    index_t j = 0;
+    for (const auto& point : *keypoints) {
       const PointT& pt =
-          (*cloud)(static_cast<long unsigned int>(keypoints->points[i].u),
-                   static_cast<long unsigned int>(keypoints->points[i].v));
+          (*cloud)(point.u, point.v);
       if (!std::isfinite(pt.x) || !std::isfinite(pt.y) || !std::isfinite(pt.z))
         continue;
 
-      keypoints3d.points[j].x = pt.x;
-      keypoints3d.points[j].y = pt.y;
-      keypoints3d.points[j].z = pt.z;
+      keypoints3d[j].x = pt.x;
+      keypoints3d[j].y = pt.y;
+      keypoints3d[j].z = pt.z;
       ++j;
     }
 
@@ -297,11 +296,9 @@ class AGASTDemo {
 
         if (keypoints && !keypoints->empty()) {
           image_viewer_.removeLayer(getStrBool(keypts));
-          for (std::size_t i = 0; i < keypoints->size(); ++i) {
-            int u = int(keypoints->points[i].u);
-            int v = int(keypoints->points[i].v);
-            image_viewer_.markPoint(u,
-                                    v,
+          for (const auto& pt : *keypoints) {
+            image_viewer_.markPoint(static_cast<int>(pt.u),
+                                    static_cast<int>(pt.v),
                                     visualization::red_color,
                                     visualization::blue_color,
                                     10,

apps/src/ni_brisk.cpp

@@ -180,10 +180,10 @@ class BRISKDemo {
     keypoints3d.height = keypoints->height;
     keypoints3d.is_dense = true;
 
-    std::size_t j = 0;
-    for (std::size_t i = 0; i < keypoints->size(); ++i) {
+    index_t j = 0;
+    for (const auto& point : keypoints->points) {
       PointT pt =
-          bilinearInterpolation(cloud, keypoints->points[i].x, keypoints->points[i].y);
+          bilinearInterpolation(cloud, point.x, point.y);
 
       keypoints3d.points[j].x = pt.x;
       keypoints3d.points[j].y = pt.y;
@@ -244,11 +244,9 @@ class BRISKDemo {
         image_viewer_.showRGBImage<PointT>(cloud);
 
         image_viewer_.removeLayer(getStrBool(keypts));
-        for (std::size_t i = 0; i < keypoints->size(); ++i) {
-          int u = int(keypoints->points[i].x);
-          int v = int(keypoints->points[i].y);
-          image_viewer_.markPoint(u,
-                                  v,
+        for(const auto& pt : keypoints->points) {
+          image_viewer_.markPoint(int(pt.x),
+                                  int(pt.y),
                                   visualization::red_color,
                                   visualization::blue_color,
                                   10,

apps/src/ni_susan.cpp

@@ -151,7 +151,7 @@ class SUSANDemo {
 
         if (keypoints && !keypoints->empty()) {
           image_viewer_.removeLayer(getStrBool(keypts));
-          for (std::size_t i = 0; i < keypoints->size(); ++i) {
+          for (index_t i = 0; i < keypoints->size(); ++i) {
             int u = int(keypoints->points[i].label % cloud->width);
             int v = cloud->height - int(keypoints->points[i].label / cloud->width);
             image_viewer_.markPoint(u,

apps/src/openni_klt.cpp

@@ -257,7 +257,7 @@ class OpenNIViewer {
 
         std::vector<float> markers;
         markers.reserve(keypoints_->size() * 2);
-        for (std::size_t i = 0; i < keypoints_->size(); ++i) {
+        for (pcl::index_t i = 0; i < keypoints_->size(); ++i) {
           if (points_status_->indices[i] < 0)
             continue;
           const pcl::PointUV& uv = keypoints_->points[i];

apps/src/pcd_select_object_plane.cpp

@@ -574,7 +574,7 @@ class ObjectSelection {
         int poff = fields[rgba_index].offset;
         // BGR to RGB
         rgb_data_ = new unsigned char[cloud_->width * cloud_->height * 3];
-        for (std::uint32_t i = 0; i < cloud_->width * cloud_->height; ++i) {
+        for (index_t i = 0; i < cloud_->width * cloud_->height; ++i) {
           RGB rgb;
           memcpy(&rgb,
                  reinterpret_cast<unsigned char*>(&cloud_->points[i]) + poff,

apps/src/test_search.cpp

@@ -45,10 +45,10 @@ main(int argc, char** argv)
     pcl::io::loadPCDFile(pcd_path, *cloud);
   else {
     cloud->resize(1000000);
-    for (std::size_t idx = 0; idx < cloud->size(); ++idx) {
-      (*cloud)[idx].x = static_cast<float>(rand() / RAND_MAX);
-      (*cloud)[idx].y = static_cast<float>(rand() / RAND_MAX);
-      (*cloud)[idx].z = static_cast<float>(rand() / RAND_MAX);
+    for (auto& pt : *cloud) {
+      pt.x = static_cast<float>(rand() / RAND_MAX);
+      pt.y = static_cast<float>(rand() / RAND_MAX);
+      pt.z = static_cast<float>(rand() / RAND_MAX);
     }
   }
 

common/include/pcl/common/impl/centroid.hpp

@@ -691,10 +691,10 @@ demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
     cloud_out.width    = static_cast<std::uint32_t> (indices.size ());
     cloud_out.height   = 1;
   }
-  cloud_out.resize (indices.size ());
+  cloud_out.resize (static_cast<index_t>(indices.size ()));
 
   // Subtract the centroid from cloud_in
-  for (std::size_t i = 0; i < indices.size (); ++i)
+  for (index_t i = 0; i < static_cast<index_t>(indices.size ()); ++i)
   {
     cloud_out[i].x = static_cast<float> (cloud_in[indices[i]].x - centroid[0]);
     cloud_out[i].y = static_cast<float> (cloud_in[indices[i]].y - centroid[1]);
@@ -749,11 +749,11 @@ demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out)
 {
-  std::size_t npts = cloud_in.size ();
+  const auto npts = cloud_in.size ();
 
   cloud_out = Eigen::Matrix<Scalar, 4, Eigen::Dynamic>::Zero (4, npts);        // keep the data aligned
 
-  for (std::size_t i = 0; i < npts; ++i)
+  for (index_t i = 0; i < npts; ++i)
   {
     cloud_out (0, i) = cloud_in[i].x - centroid[0];
     cloud_out (1, i) = cloud_in[i].y - centroid[1];