Release/2.0.0

.pre-commit-config.yaml

@@ -34,6 +34,7 @@ repos:
       types-requests==2.31.0,
       numpy==2.0.1,
       pytest==8.3.1,
+      websockets>=10.4,
       types-setuptools>=71.1.0.20240818
       ]
     args: [--config=pyproject.toml]

README.md

@@ -64,24 +64,59 @@ gantt
     title       diffCheck - general overview
     excludes    weekends
 
-    section Publication
-    Abstract edition                    :active, absed, 2024-03-01, 2024-03-15
-    Submission abstract ICSA            :milestone, icsaabs, 2024-03-15, 0d
-    Paper edition                       :paperd, 2024-10-01, 2024-10-30
-    Submission paper ICSA               :milestone, icsapap, 2024-10-30, 0d
-
-    section Code development
-    Backend development                 :backenddev, after icsaabs, 6w
-    Rhino/Grasshopper integration       :rhghinteg, after backenddev, 6w
-    Documentation & Interface           :docuint, after fabar, 3w
+    section Workshop
+    Workshop dryrun                         :milestone, crit, dryrun, 2025-09-15, 1d
+    Workshop in Boston                      :workshop, 2025-11-16, 2d
+
+    section Component development
+    Pose estimation                         :CD1, 2025-05-15, 1w
+    Communication w/ hardware               :CD2, after CD1, 3w
+    Pose comparison                         :CD3, after CD1, 3w
+    General PC manipulation                 :CD4, after CD1, 6w
+    Data analysis component                 :CD5, after CD3, 3w
+
+    section Workshop preparation
+    Workshop scenario                       :doc1, 2025-08-01, 1w
+    New compilation documentation           :doc2, after mac, 2w
+    New components documentation            :doc2, 2025-08-01, 4w
+    Development of special pipeline for data:doc3, after doc1, 3w
+
+    section Cross-platform
+    adaptation of CMake for mac compilation :mac, 2025-07-01, 3w
 
     section Prototype testing
-    Fabrication of AR Prototype         :crit, fabar, 2024-07-01, 2024-08-30
-    Fabrication of CNC Prototype        :crit, fabcnc, 2024-07-01, 2024-08-30
-    Fabrication of Robot Prototype      :crit, fabrob, 2024-07-01, 2024-08-30
-    Data collection and evaluation      :dataeval, after fabrob, 4w
+    Fabrication of iterative prototype      :fab, 2025-08-01, 2w
 ```
 
+
+
 ## How to contribute
 
 If you want to contribute to the project, please refer to the [contribution guidelines]([./CONTRIBUTING.md](https://diffcheckorg.github.io/diffCheck/contribute.html)).
+
+## Logic
+The logic of the workflow is currently as follows:
+
+```mermaid
+stateDiagram-v2
+    state "[breps to assemble]" as s1
+    state "scan of latest element placed" as s2
+    state "get pose of i-th brep" as s3
+    state "get pose of i-1-th brep" as s4
+    state "compute pose of i-1-th element from scan" as s5
+    state "compute pose difference" as s6
+    state "compute pose correction" as s7
+    state "assemble i-th-element" as s8
+    state "i += 1" as s9
+    [*]-->s2
+    s1-->s3
+    s1-->s4
+    s2-->s5
+    s5-->s6
+    s4-->s6
+    s6-->s7
+    s3-->s7
+    s7-->s8
+    s8-->s9
+    s9-->[*]
+```

pyproject.toml

@@ -20,7 +20,8 @@ module = [
     "GH_IO.*",
     "clr.*",
     "diffcheck_bindings",
-    "diffCheck.diffcheck_bindings"
+    "diffCheck.diffcheck_bindings",
+    "ghpythonlib.*"
 ]
 ignore_missing_imports = true
 

src/diffCheck.hh

@@ -6,6 +6,9 @@
 #include <loguru.hpp>
 
 #include <cilantro/cilantro.hpp>
+#include <cilantro/clustering/kmeans.hpp>
+
+#include <Eigen/Dense>
 
 // diffCheck includes
 #include "diffCheck/log.hh"

src/diffCheck/IOManager.cc

@@ -68,4 +68,11 @@ namespace diffCheck::io
         std::filesystem::path pathCloud = pathTestData / "test_pc_for_SOR_101pts_with_1_outlier.ply";
         return pathCloud.string();
     }
+
+    std::string GetTwoConnectedPlanesPlyPath()
+    {
+        std::filesystem::path pathTestData = GetTestDataDir();
+        std::filesystem::path pathCloud = pathTestData / "two_connected_planes_with_normals.ply";
+        return pathCloud.string();
+    }
 } // namespace diffCheck::io

src/diffCheck/IOManager.hh

@@ -42,4 +42,6 @@ namespace diffCheck::io
     std::string GetRoofQuarterPlyPath();
     /// @brief Get the path to the plane point cloud with one outlier
     std::string GetPlanePCWithOneOutliers();
+    /// @brief Get the path to the two connected planes ply test file
+    std::string GetTwoConnectedPlanesPlyPath();
 } // namespace diffCheck::io

src/diffCheck/geometry/DFPointCloud.cc

@@ -216,6 +216,61 @@ namespace diffCheck::geometry
             this->Normals.push_back(normal);
     }
 
+    Eigen::Vector3d DFPointCloud::FitPlaneRANSAC(
+            double distanceThreshold,
+            int ransacN,
+            int numIterations)
+    {
+        if (this->Points.size() < ransacN)
+        {
+            DIFFCHECK_ERROR("Not enough points to fit a plane with RANSAC.");
+            return Eigen::Vector3d::Zero();
+        }
+
+        auto O3DPointCloud = this->Cvt2O3DPointCloud();
+        std::tuple< Eigen::Vector4d, std::vector<size_t>> planeModel = O3DPointCloud->SegmentPlane(distanceThreshold, ransacN, numIterations);
+        Eigen::Vector3d planeParameters = std::get<0>(planeModel).head<3>();
+        return planeParameters;
+    }
+
+    void DFPointCloud::Crop(const Eigen::Vector3d &minBound, const Eigen::Vector3d &maxBound)
+    {
+        auto O3DPointCloud = this->Cvt2O3DPointCloud();
+        auto O3DPointCloudCropped = O3DPointCloud->Crop(open3d::geometry::AxisAlignedBoundingBox(minBound, maxBound));
+        this->Points.clear();
+        for (auto &point : O3DPointCloudCropped->points_)
+            this->Points.push_back(point);
+        this->Colors.clear();
+        for (auto &color : O3DPointCloudCropped->colors_)
+            this->Colors.push_back(color);
+        this->Normals.clear();
+        for (auto &normal : O3DPointCloudCropped->normals_)
+            this->Normals.push_back(normal);
+    }
+
+    void DFPointCloud::Crop(const std::vector<Eigen::Vector3d> &corners)
+    {
+        if (corners.size() != 8)
+            throw std::invalid_argument("The corners vector must contain exactly 8 points.");
+        open3d::geometry::OrientedBoundingBox obb = open3d::geometry::OrientedBoundingBox::CreateFromPoints(corners);
+        auto O3DPointCloud = this->Cvt2O3DPointCloud();
+        auto O3DPointCloudCropped = O3DPointCloud->Crop(obb);
+        this->Points.clear();
+        for (auto &point : O3DPointCloudCropped->points_)
+            this->Points.push_back(point);
+        this->Colors.clear();
+        for (auto &color : O3DPointCloudCropped->colors_)
+            this->Colors.push_back(color);
+        this->Normals.clear();
+        for (auto &normal : O3DPointCloudCropped->normals_)
+            this->Normals.push_back(normal);
+    }
+
+    DFPointCloud DFPointCloud::Duplicate() const
+    {
+        return DFPointCloud(this->Points, this->Colors, this->Normals);
+    }
+
     void DFPointCloud::UniformDownsample(int everyKPoints)
     {
         auto O3DPointCloud = this->Cvt2O3DPointCloud();
@@ -258,6 +313,86 @@ namespace diffCheck::geometry
         return bboxPts;
     }
 
+    void DFPointCloud::SubtractPoints(const DFPointCloud &pointCloud, double distanceThreshold)
+    {
+        if (this->Points.size() == 0 || pointCloud.Points.size() == 0)
+            throw std::invalid_argument("One of the point clouds is empty.");
+
+        auto O3DSourcePointCloud = this->Cvt2O3DPointCloud();
+        auto O3DTargetPointCloud = std::make_shared<DFPointCloud>(pointCloud)->Cvt2O3DPointCloud();
+        auto O3DResultPointCloud = std::make_shared<open3d::geometry::PointCloud>();
+
+        open3d::geometry::KDTreeFlann threeDTree;
+        threeDTree.SetGeometry(*O3DTargetPointCloud);
+        std::vector<int> indices;
+        std::vector<double> distances;
+        for (const auto &point : O3DSourcePointCloud->points_)
+        {
+            threeDTree.SearchRadius(point, distanceThreshold, indices, distances);
+            if (indices.empty())
+            {
+                O3DResultPointCloud->points_.push_back(point);
+                if (O3DSourcePointCloud->HasColors())
+                {
+                    O3DResultPointCloud->colors_.push_back(O3DSourcePointCloud->colors_[&point - &O3DSourcePointCloud->points_[0]]);
+                }
+                if (O3DSourcePointCloud->HasNormals())
+                {
+                    O3DResultPointCloud->normals_.push_back(O3DSourcePointCloud->normals_[&point - &O3DSourcePointCloud->points_[0]]);
+                }
+            }
+        }
+        this->Points.clear();
+        for (auto &point : O3DResultPointCloud->points_)
+            this->Points.push_back(point);
+        if (O3DResultPointCloud->HasColors())
+        {
+            this->Colors.clear();
+            for (auto &color : O3DResultPointCloud->colors_){this->Colors.push_back(color);};
+        }
+        if (O3DResultPointCloud->HasNormals())
+        {
+            this->Normals.clear();
+            for (auto &normal : O3DResultPointCloud->normals_){this->Normals.push_back(normal);};
+        }
+    }
+
+    diffCheck::geometry::DFPointCloud DFPointCloud::Intersect(const DFPointCloud &pointCloud, double distanceThreshold)
+    {
+        if (this->Points.size() == 0 || pointCloud.Points.size() == 0)
+            throw std::invalid_argument("One of the point clouds is empty.");
+
+        auto O3DSourcePointCloud = this->Cvt2O3DPointCloud();
+        auto O3DTargetPointCloud = std::make_shared<DFPointCloud>(pointCloud)->Cvt2O3DPointCloud();
+        auto O3DResultPointCloud = std::make_shared<open3d::geometry::PointCloud>();
+
+        open3d::geometry::KDTreeFlann threeDTree;
+        threeDTree.SetGeometry(*O3DTargetPointCloud);
+        std::vector<int> indices;
+        std::vector<double> distances;
+        for (const auto &point : O3DSourcePointCloud->points_)
+        {
+            threeDTree.SearchRadius(point, distanceThreshold, indices, distances);
+            if (!indices.empty())
+            {
+                O3DResultPointCloud->points_.push_back(point);
+                if (O3DSourcePointCloud->HasColors())
+                {
+                    O3DResultPointCloud->colors_.push_back(O3DSourcePointCloud->colors_[&point - &O3DSourcePointCloud->points_[0]]);
+                }
+                if (O3DSourcePointCloud->HasNormals())
+                {
+                    O3DResultPointCloud->normals_.push_back(O3DSourcePointCloud->normals_[&point - &O3DSourcePointCloud->points_[0]]);
+                }
+            }
+        }
+        diffCheck::geometry::DFPointCloud result;
+        result.Points = O3DResultPointCloud->points_;
+        result.Colors = O3DResultPointCloud->colors_;
+        result.Normals = O3DResultPointCloud->normals_;
+        return result;
+    }
+
     void DFPointCloud::ApplyTransformation(const diffCheck::transformation::DFTransformation &transformation)
     {
         auto O3DPointCloud = this->Cvt2O3DPointCloud();

src/diffCheck/geometry/DFPointCloud.hh

@@ -8,6 +8,8 @@
 
 #include <cilantro/utilities/point_cloud.hpp>
 #include <cilantro/core/nearest_neighbors.hpp>
+#include <cilantro/clustering/kmeans.hpp>
+
 
 namespace diffCheck::geometry
 {
@@ -89,6 +91,40 @@ namespace diffCheck::geometry
          */
         void RemoveStatisticalOutliers(int nbNeighbors, double stdRatio);
 
+        /**
+         * @brief Fit a plane to the point cloud using RANSAC
+         * 
+         * @param distanceThreshold the distance threshold to consider a point as an inlier
+         * @param ransacN the number of points to sample for each RANSAC iteration
+         * @param numIterations the number of RANSAC iterations
+         * @return The Normal vector of the fitted plane as an Eigen::Vector3d
+         */
+        Eigen::Vector3d FitPlaneRANSAC(
+            double distanceThreshold = 0.01,
+            int ransacN = 3,
+            int numIterations = 100);
+
+        /**
+         *  @brief Crop the point cloud to a bounding box defined by the min and max bounds
+         * 
+         *  @param minBound the minimum bound of the bounding box as an Eigen::Vector3d
+         *  @param maxBound the maximum bound of the bounding box as an Eigen::Vector3d
+         */
+        void Crop(const Eigen::Vector3d &minBound, const Eigen::Vector3d &maxBound);
+
+        /**
+         * @brief Crop the point cloud to a bounding box defined by the 8 corners of the box
+         * @param corners the 8 corners of the bounding box as a vector of Eigen::Vector3d
+         */
+        void Crop(const std::vector<Eigen::Vector3d> &corners);
+
+        /**
+         * @brief Get the duplicate of the point cloud. This is mainly used in the python bindings
+         * 
+         * @return DFPointCloud a copy of the point cloud
+         */
+        diffCheck::geometry::DFPointCloud Duplicate() const;
+
     public:  ///< Downsamplers
         /**
          * @brief Downsample the point cloud with voxel grid
@@ -136,6 +172,24 @@ namespace diffCheck::geometry
          *  /// 
         */
         std::vector<Eigen::Vector3d> GetTightBoundingBox();
+
+    public:  ///< Point cloud subtraction and intersection
+        /**
+         * @brief Subtract the points, colors and normals from another point cloud when they are too close to the points of another point cloud.
+         * 
+         * @param pointCloud the other point cloud to subtract from this one
+         * @param distanceThreshold the distance threshold to consider a point as too close. Default is 0.01.
+         */
+        void SubtractPoints(const DFPointCloud &pointCloud, double distanceThreshold = 0.01);
+
+        /**
+         * @brief Intersect the points, colors and normals from another point cloud when they are close enough to the points of another point cloud. Is the point cloud interpretation of a boolean intersection.
+         * 
+         * @param pointCloud the other point cloud to intersect with this one
+         * @param distanceThreshold the distance threshold to consider a point as too close. Default is 0.01.
+         * @return diffCheck::geometry::DFPointCloud the intersected point cloud
+         */
+        diffCheck::geometry::DFPointCloud Intersect(const DFPointCloud &pointCloud, double distanceThreshold = 0.01);
 
     public:  ///< Transformers
         /**

src/diffCheck/segmentation/DFSegmentation.cc

@@ -330,7 +330,7 @@ namespace diffCheck::segmentation
     void DFSegmentation::CleanUnassociatedClusters(
         bool isCylinder,
         std::vector<std::shared_ptr<geometry::DFPointCloud>> &unassociatedClusters,
-        std::vector<std::shared_ptr<geometry::DFPointCloud>> &existingPointCloudSegments,
+        std::vector<std::vector<std::shared_ptr<geometry::DFPointCloud>>> &existingPointCloudSegments,
         std::vector<std::vector<std::shared_ptr<geometry::DFMesh>>> meshes,
         double angleThreshold,
         double associationThreshold)
@@ -459,12 +459,12 @@ namespace diffCheck::segmentation
                     DIFFCHECK_WARN("No mesh face found for the cluster. Skipping the cluster.");
                     continue;
                 }
-                if (goodMeshIndex >= existingPointCloudSegments.size())
+                if (goodMeshIndex >= existingPointCloudSegments.size() || goodFaceIndex >= existingPointCloudSegments[goodMeshIndex].size())
                 {
                     DIFFCHECK_WARN("No segment found for the face. Skipping the face.");
                     continue;
                 }
-                std::shared_ptr<geometry::DFPointCloud> completed_segment = existingPointCloudSegments[goodMeshIndex];
+                std::shared_ptr<geometry::DFPointCloud> completed_segment = existingPointCloudSegments[goodMeshIndex][goodFaceIndex];
 
                 for (Eigen::Vector3d point : cluster->Points)
                 {

src/diffCheck/segmentation/DFSegmentation.hh

@@ -44,15 +44,15 @@ namespace diffCheck::segmentation
         /** @brief Iterated through clusters and finds the corresponding mesh face. It then associates the points of the cluster that are on the mesh face to the segment already associated with the mesh face.
          * @param isCylinder a boolean to indicate if the model is a cylinder. If true, the method will use the GetCenterAndAxis method of the mesh to find the center and axis of the mesh. based on that, we only want points that have normals more or less perpendicular to the cylinder axis.
          * @param unassociatedClusters the clusters from the normal-based segmentatinon that haven't been associated yet.
-         * @param existingPointCloudSegments the already associated segments
+         * @param existingPointCloudSegments the already associated segments per mesh face.
          * @param meshes the mesh faces for all the model. This is used to associate the clusters to the mesh faces.
          * * @param angleThreshold the threshold to consider the a cluster as potential candidate for association. the value passed is the minimum sine of the angles. A value of 0 requires perfect alignment (angle = 0), while a value of 0.1 allows an angle of 5.7 degrees. 
          * @param associationThreshold the threshold to consider the points of a segment and a mesh face as associable. It is the ratio between the surface of the closest mesh triangle and the sum of the areas of the three triangles that form the rest of the pyramid described by the mesh triangle and the point we want to associate or not. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded.   
          */
         static void DFSegmentation::CleanUnassociatedClusters(
             bool isCylinder,
             std::vector<std::shared_ptr<geometry::DFPointCloud>> &unassociatedClusters,
-            std::vector<std::shared_ptr<geometry::DFPointCloud>> &existingPointCloudSegments,
+            std::vector<std::vector<std::shared_ptr<geometry::DFPointCloud>>> &existingPointCloudSegments,
             std::vector<std::vector<std::shared_ptr<geometry::DFMesh>>> meshes,
             double angleThreshold = 0.1,
             double associationThreshold = 0.1);