CAP: segmentation function well implemented and documented

Author: DamienGilliard

src/diffCheck/segmentation/DFSegmentation.cc

@@ -10,7 +10,10 @@ namespace diffCheck::segmentation
         geometry::DFPointCloud &pointCloud,
         float voxelSize,
         float normalThresholdDegree,
-        int minClusterSize)
+        int minClusterSize,
+        bool useKnnNeighborhood,
+        int radiusNeighborhoodSize,
+        int knnNeighborhoodSize)
     {
         std::vector<std::shared_ptr<geometry::DFPointCloud>> segments;
         cilantro::PointCloud3f cilantroPointCloud;
@@ -20,41 +23,78 @@ namespace diffCheck::segmentation
         {
             cilantroPointCloud.points.conservativeResize(3, cilantroPointCloud.points.cols() + 1);
             cilantroPointCloud.points.rightCols(1) = pointCloud.Points[i].cast<float>();
-            cilantroPointCloud.normals.conservativeResize(3, cilantroPointCloud.normals.cols() + 1);
-            cilantroPointCloud.normals.rightCols(1) = pointCloud.Normals[i].cast<float>();
-
         }
 
-        // Compute normals
-        // cilantroPointCloud.estimateNormals(radiusNormal);
+        // segment the point cloud using knn or radius neighborhood
+        if (useKnnNeighborhood)
+        {
+            cilantro::KNNNeighborhoodSpecification<int> neighborhood(knnNeighborhoodSize);
 
-        // Neighborhood definition
-        cilantro::RadiusNeighborhoodSpecification<float> neighborhood(voxelSize * 2);
+            // conpute the normals and downsample
+            cilantroPointCloud.estimateNormals(neighborhood, false);
+            cilantroPointCloud.gridDownsample(voxelSize);
 
-        // Similarity evaluator
-        cilantro::NormalsProximityEvaluator<float, 3> similarityEvaluator(cilantroPointCloud.normals, normalThresholdDegree*M_PI/180.0f);
-       
+            // Similarity evaluator
+            cilantro::NormalsProximityEvaluator<float, 3> similarityEvaluator(
+            cilantroPointCloud.normals, 
+            normalThresholdDegree*M_PI/180.0f);
 
-        // Segment the point cloud
-        cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud.points);
-        segmenter.segment(neighborhood, similarityEvaluator, minClusterSize);
-        auto clusterToPointMap = segmenter.getClusterToPointIndicesMap();
-        int nSegments = segmenter.getNumberOfClusters();
+            // Segment the point cloud
+            cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud.points);
+            segmenter.segment(neighborhood, similarityEvaluator, minClusterSize);
+            auto clusterToPointMap = segmenter.getClusterToPointIndicesMap();
+            int nSegments = segmenter.getNumberOfClusters();
 
-        // Get the segments
-        std::cout<<"Number of segments: "<<nSegments<<std::endl;
-        for (int indice = 0; indice<nSegments; indice++)
+            // Get the segments
+            for (int indice = 0; indice<nSegments; indice++)
+            {
+                std::shared_ptr<geometry::DFPointCloud> segment = std::make_shared<geometry::DFPointCloud>();
+                for (auto pointIndice : clusterToPointMap[indice])
+                {
+                    Eigen::Vector3d point = cilantroPointCloud.points.col(pointIndice).cast<double>();
+                    Eigen::Vector3d normal = cilantroPointCloud.normals.col(pointIndice).cast<double>();
+                    segment->Points.push_back(point);
+                    segment->Normals.push_back(normal);
+                }
+                segments.push_back(segment);
+            }
+        }
+        else
         {
-            std::shared_ptr<geometry::DFPointCloud> segment = std::make_shared<geometry::DFPointCloud>();
-            for (auto pointIndice : clusterToPointMap[indice])
+            cilantro::RadiusNeighborhoodSpecification<float> neighborhood(radiusNeighborhoodSize);
+
+            // conpute the normals and downsample
+            cilantroPointCloud.estimateNormals(neighborhood, false);
+            cilantroPointCloud.gridDownsample(voxelSize);
+            
+            // Similarity evaluator
+            cilantro::NormalsProximityEvaluator<float, 3> similarityEvaluator(
+            cilantroPointCloud.normals, 
+            normalThresholdDegree*M_PI/180.0f);
+
+            // Segment the point cloud
+            cilantro::ConnectedComponentExtraction3f<> segmenter(cilantroPointCloud.points);
+            segmenter.segment(neighborhood, similarityEvaluator, minClusterSize);
+
+            auto clusterToPointMap = segmenter.getClusterToPointIndicesMap();
+            int nSegments = segmenter.getNumberOfClusters();
+
+            // Get the segments
+            for (int indice = 0; indice<nSegments; indice++)
             {
-                std::cout<<"Point indice: "<<pointIndice<<std::endl;
-                Eigen::Vector3d point = cilantroPointCloud.points.col(pointIndice).cast<double>();
-                segment->Points.push_back(point);
+                std::shared_ptr<geometry::DFPointCloud> segment = std::make_shared<geometry::DFPointCloud>();
+                for (auto pointIndice : clusterToPointMap[indice])
+                {
+                    Eigen::Vector3d point = cilantroPointCloud.points.col(pointIndice).cast<double>();
+                    Eigen::Vector3d normal = cilantroPointCloud.normals.col(pointIndice).cast<double>();
+                    segment->Points.push_back(point);
+                    segment->Normals.push_back(normal);
+                }
+                segments.push_back(segment);
             }
-            segments.push_back(segment);
         }
+        
 
         return segments;
     }
-}
+} // namespace diffCheck::segmentation

src/diffCheck/segmentation/DFSegmentation.hh

@@ -6,18 +6,23 @@ namespace diffCheck::segmentation
     class DFSegmentation
     {
         public:
-        /** @brief Segment the point cloud into planes
-         * Using Cilantro's ConnectedComponentExtraction3f method
+        /** @brief Downsamples and segments the point cloud using Cilantro's ConnectedComponentExtraction3f method
          * @param pointCloud the point cloud to segment
-         * @param voxelSize the voxel size for the search in the point cloud
-         * @param normalThresholdDegree the normal threshold in degrees do differentiate segments
-         * @param minClusterSize the minimum cluster size to consider a segment
+         * @param voxelSize the voxel size for the downsampling of the point cloud. The point cloud is downsampled after the normal calculation. A lower number will result in a denser point cloud
+         * @param normalThresholdDegree the normal threshold in degrees do differentiate segments. The higher the number, the more tolerent the segmentation will be to normal differences
+         * @param minClusterSize the minimum cluster size to consider a segment. A lower number will discard smaller segments
+         * @param useKnnNeighborhood if true, the neighborhood search will be done using the knnNeighborhoodSize, otherwise it will be done using radiusNeighborhoodSize
+         * @param knnNeighborhoodSize the k nearest neighbors size for the "neighborhood search". This is used when useKnnNeighborhood is true. a higher number will result in smoother segmentation, but at the cost of computation time
+         * @param radiusNeighborhoodSize the radius of the neighborhood size for the "radius search". This is used when useKnnNeighborhood is false. A higher number will result in smoother segmentation, but at the cost of computation time.
          * @return std::vector<geometry::DFPointCloud> the segmented point clouds
          */
         static std::vector<std::shared_ptr<geometry::DFPointCloud>> SegmentationPointCloud(
             geometry::DFPointCloud &pointCloud,
             float voxelSize = 0.2,
             float normalThresholdDegree = 20,
-            int minClusterSize = 10);    
+            int minClusterSize = 10,
+            bool useKnnNeighborhood = true,
+            int radiusNeighborhoodSize = 10,
+            int knnNeighborhoodSize = 10);
     };
 } // namespace diffCheck::segmentation

src/diffCheckApp.cc

@@ -7,15 +7,32 @@
 int main()
 {
   std::shared_ptr<diffCheck::geometry::DFPointCloud> pcdSrc = std::make_shared<diffCheck::geometry::DFPointCloud>();
-
-  std::string pathPcdSrc = R"(C:\Users\andre\Downloads\04_pt.ply)";
+  std::shared_ptr<diffCheck::geometry::DFMesh> meshSrc = std::make_shared<diffCheck::geometry::DFMesh>();
+  std::vector<std::shared_ptr<diffCheck::geometry::DFPointCloud>> segments;
+  std::string pathMeshSrc = R"(C:\Users\localuser\Downloads\02_mesh.ply)";
+  std::string pathPcdSrc = R"(C:\Users\localuser\Downloads\02_points_with_errors_1e6_pts.ply)";
 
   pcdSrc->LoadFromPLY(pathPcdSrc);
+  meshSrc->LoadFromPLY(pathMeshSrc);
+
+  segments = diffCheck::segmentation::DFSegmentation::SegmentationPointCloud(*pcdSrc, 0.01, 1, 30, true, 50, 30);
+  std::cout << "number of segments:" << segments.size()<< std::endl;
 
-  pcdSrc->DownsampleBySize(100);
+  diffCheck::visualizer::Visualizer vis;
+  vis.AddMesh(meshSrc);
+  for (auto segment : segments)
+  {
+    // colorize the segments with random colors
+    double r = static_cast<double>(rand()) / RAND_MAX;
+    double g = static_cast<double>(rand()) / RAND_MAX;
+    double b = static_cast<double>(rand()) / RAND_MAX;    
+    for (int i = 0; i < segment->Points.size(); i++)
+    {
+      segment->Colors.push_back(Eigen::Vector3d(r, g, b));
+    }
+    vis.AddPointCloud(segment);
 
-  std::shared_ptr<diffCheck::visualizer::Visualizer> vis = std::make_shared<diffCheck::visualizer::Visualizer>();
-  vis->AddPointCloud(pcdSrc);
-  vis->Run();
+  }
+  vis.Run();
   return 0;
 }

src/diffCheckBindings.cc

@@ -163,5 +163,8 @@ PYBIND11_MODULE(diffcheck_bindings, m) {
             py::arg("point_cloud"),
             py::arg("voxel_size") = 1,
             py::arg("normal_threshold_degree") = 20,
-            py::arg("min_cluster_size") = 10);
+            py::arg("min_cluster_size") = 10,
+            py::arg("use_knn_neighborhood") = false,
+            py::arg("radius_neighborhood_size") = 10,
+            py::arg("knn_neighborhood_size") = 10);
 }