CAP: AssociateClusters function implemented in the back-end

Author: DamienGilliard

src/diffCheck/geometry/DFPointCloud.hh

@@ -81,7 +81,7 @@ namespace diffCheck::geometry
          */
         void EstimateNormals(
             bool useCilantroEvaluator = false,
-            std::optional<int> knn = 100,
+            std::optional<int> knn = 50,
             std::optional<double> searchRadius = std::nullopt);
 
         /**

src/diffCheck/segmentation/DFSegmentation.cc

@@ -94,16 +94,16 @@ namespace diffCheck::segmentation
         return segments;
     }
 
-    std::tuple<std::shared_ptr<geometry::DFPointCloud>, std::vector<std::shared_ptr<geometry::DFPointCloud>>> DFSegmentation::AssociateSegments(
-        std::vector<std::shared_ptr<geometry::DFMesh>> meshFaces,
-        std::vector<std::shared_ptr<geometry::DFPointCloud>> segments,
+    std::shared_ptr<geometry::DFPointCloud> DFSegmentation::AssociateClusters(
+        std::vector<std::shared_ptr<geometry::DFMesh>> referenceMesh,
+        std::vector<std::shared_ptr<geometry::DFPointCloud>> &clusters,
         double associationThreshold)
     {
         std::shared_ptr<geometry::DFPointCloud> unifiedPointCloud = std::make_shared<geometry::DFPointCloud>();
         std::vector<std::shared_ptr<geometry::DFPointCloud>> segmentsRemainder;
 
         // iterate through the mesh faces given as function argument
-        for (std::shared_ptr<diffCheck::geometry::DFMesh> face : meshFaces)
+        for (std::shared_ptr<diffCheck::geometry::DFMesh> face : referenceMesh)
         {
             std::shared_ptr<geometry::DFPointCloud> correspondingSegment;
             std::shared_ptr<open3d::geometry::TriangleMesh> o3dFace;
@@ -131,7 +131,7 @@ namespace diffCheck::segmentation
             Eigen::Vector3d segmentCenter;
             Eigen::Vector3d segmentNormal;
             double faceDistance = std::numeric_limits<double>::max();
-            for (auto segment : segments)
+            for (auto segment : clusters)
             {
                 for (auto point : segment->Points)
                 {
@@ -154,7 +154,7 @@ namespace diffCheck::segmentation
                 }
             }
 
-            // get the triangles of the face. This is to check if the point is in the face
+            // get the triangles of the face.
             std::vector<Eigen::Vector3i> faceTriangles = o3dFace->triangles_;
 
             for (Eigen::Vector3d point : correspondingSegment->Points)
@@ -197,15 +197,36 @@ namespace diffCheck::segmentation
                 if (pointInFace)
                 {
                     unifiedPointCloud->Points.push_back(point);
+                    unifiedPointCloud->Normals.push_back(
+                        correspondingSegment->Normals[std::distance(
+                            correspondingSegment->Points.begin(), 
+                            std::find(correspondingSegment->Points.begin(), 
+                            correspondingSegment->Points.end(), 
+                            point))]
+                        );
                 }
             }
             // removing points from the segment that are in the face
             for(Eigen::Vector3d point : unifiedPointCloud->Points)
             {
-                correspondingSegment->Points.erase(std::remove(correspondingSegment->Points.begin(), correspondingSegment->Points.end(), point), correspondingSegment->Points.end());
+                correspondingSegment->Points.erase(
+                    std::remove(
+                        correspondingSegment->Points.begin(), 
+                        correspondingSegment->Points.end(), 
+                        point), 
+                    correspondingSegment->Points.end());
+            }
+            if (correspondingSegment->GetNumPoints() == 0)
+            {
+                clusters.erase(
+                    std::remove(
+                        clusters.begin(), 
+                        clusters.end(), 
+                        correspondingSegment), 
+                    clusters.end());
             }
         }
-        return std::make_tuple(unifiedPointCloud, segments);
+        return unifiedPointCloud;
     }
 
 } // namespace diffCheck::segmentation

src/diffCheck/segmentation/DFSegmentation.hh

@@ -24,5 +24,16 @@ namespace diffCheck::segmentation
             int knnNeighborhoodSize = 10,
             float radiusNeighborhoodSize = 10.f,
             bool colorClusters = false);
+
+        /** @brief Associates point cloud segments to mesh faces. It uses the center of mass of the segments and the mesh faces to find correspondances. For each mesh face it then iteratively associate the points of the segment that are actually on the mesh face.
+         * @param referenceMesh the vector of mesh faces to associate with the segments
+         * @param clusters the vector of clusters from cilantro to associate with the mesh faces of the reference mesh
+         * @param associationThreshold the threshold to consider the points of a segment and a mesh face as associable. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded.
+         * @return std::shared_ptr<geometry::DFPointCloud> The unified segments
+         */
+        static std::shared_ptr<geometry::DFPointCloud> DFSegmentation::AssociateClusters(
+            std::vector<std::shared_ptr<geometry::DFMesh>> referenceMesh,
+            std::vector<std::shared_ptr<geometry::DFPointCloud>> &clusters,
+            double associationThreshold);
     };
 } // namespace diffCheck::segmentation

src/diffCheckApp.cc

@@ -33,62 +33,43 @@ int main()
   pcdSrc->EstimateNormals();
   segments = diffCheck::segmentation::DFSegmentation::NormalBasedSegmentation(
     pcdSrc,
-    20.f,
-    10,
+    2.0f,
+    100,
     true,
-    50,
+    30,
     0.5f,
-    true);
+    false);
   std::cout << "number of segments:" << segments.size()<< std::endl;
 
-  std::tuple<std::shared_ptr<diffCheck::geometry::DFPointCloud>, std::vector<std::shared_ptr<diffCheck::geometry::DFPointCloud>>> unifiedSegments = 
-    diffCheck::segmentation::DFSegmentation::AssociateSegments(meshSrc, segments, 0.15);
+  std::shared_ptr<diffCheck::geometry::DFPointCloud> unifiedSegments = 
+    diffCheck::segmentation::DFSegmentation::AssociateSegments(meshSrc, segments, .1);
 
   diffCheck::visualizer::Visualizer vis;
-  for (auto segment : std::get<1>(unifiedSegments))
+  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;
 
+    segment->Colors.clear();
     for (int i = 0; i < segment->Points.size(); i++)
     {
       segment->Colors.push_back(Eigen::Vector3d(r, g, b));
     }
-    vis.AddPointCloud(segment);
-
-    // // 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 < std::get<0>(unifiedSegments)->Points.size(); i++)
-    // {
-    //   std::get<0>(unifiedSegments)->Colors.push_back(Eigen::Vector3d(r, g, b));
-    // }
-    // vis.AddPointCloud(std::get<0>(unifiedSegments));
-
-    // for (auto segemt : std::get<1>(unifiedSegments))
-    // {
-    //   for (int i = 0; i < segemt->Points.size(); i++)
-    //   {
-    //     segemt->Colors.push_back(Eigen::Vector3d(0, 0, 1));
-    //   }
-    //   vis.AddPointCloud(segemt);
-    // }
+    // vis.AddPointCloud(segment);
 
   }
   for(auto mesh : meshSrc)
   {
     vis.AddMesh(mesh);
   }
 
-  auto unified = std::get<0>(unifiedSegments);
-  for (int i = 0; i < unified->Points.size(); i++)
+  for (int i = 0; i < unifiedSegments->Points.size(); i++)
   {
-    unified->Colors.push_back(Eigen::Vector3d(0, 0, 0));
+    unifiedSegments->Colors.push_back(Eigen::Vector3d(0, 0, 0));
   }
-  vis.AddPointCloud(unified);
+  vis.AddPointCloud(unifiedSegments);
 
   auto endTime = std::chrono::high_resolution_clock::now();
   auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - initTime);