Frontend segmentation components

.gitignore

@@ -243,4 +243,7 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+# egg-info
+*.egg-info/

.gitmodules

@@ -17,3 +17,6 @@
 [submodule "deps/pybind11"]
 	path = deps/pybind11
 	url = https://github.com/pybind/pybind11.git
+[submodule "deps/submodule-cilantro"]
+	path = deps/submodule-cilantro
+	url = https://github.com/diffCheckOrg/submodule-cilantro.git

.vscode/settings.json

@@ -104,6 +104,7 @@
         "cwctype": "cpp",
         "memory_resource": "cpp",
         "scoped_allocator": "cpp",
-        "strstream": "cpp"
+        "strstream": "cpp",
+        "core": "cpp"
     }
 }

CMakeLists.txt

@@ -94,11 +94,15 @@ endif()
 
 # Boost (header only) -----------------------------------------------------
 download_submodule_project(boost)
-target_link_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85)
+target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/boost/win/1_89/include/boost-1_85)
 
 # CGAL (header-only) ------------------------------------------------------
 target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/cgal/include)
 
+# Cilantro (header-only) --------------------------------------------------
+download_submodule_project(cilantro)
+target_include_directories(${SHARED_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/deps/submodule-cilantro/include)
+
 # loguru (header-only) ----------------------------------------------------
 download_submodule_project(loguru)
 add_subdirectory(deps/loguru)

ScreenCamera_2024-06-30-00-00-53.json

@@ -0,0 +1,41 @@
+{
+	"class_name" : "PinholeCameraParameters",
+	"extrinsic" : 
+	[
+		0.78518600604290978,
+		-0.4688467948733368,
+		0.4045560762754441,
+		0.0,
+		-0.61432912235314374,
+		-0.67201447960085037,
+		0.41351695084435719,
+		0.0,
+		0.077991444038432445,
+		-0.57321830234544802,
+		-0.81568260525341763,
+		0.0,
+		1416.8243739322577,
+		908.62300697364822,
+		1063.1264987715035,
+		1.0
+	],
+	"intrinsic" : 
+	{
+		"height" : 800,
+		"intrinsic_matrix" : 
+		[
+			692.82032302755101,
+			0.0,
+			0.0,
+			0.0,
+			692.82032302755101,
+			0.0,
+			499.5,
+			399.5,
+			1.0
+		],
+		"width" : 1000
+	},
+	"version_major" : 1,
+	"version_minor" : 0
+}

ScreenCamera_2024-06-30-11-58-46.json

@@ -0,0 +1,41 @@
+{
+	"class_name" : "PinholeCameraParameters",
+	"extrinsic" : 
+	[
+		0.76239913059926834,
+		-0.422274821893041,
+		0.49033818988192268,
+		0.0,
+		-0.54132130094127906,
+		-0.00099240450767756894,
+		0.8408152378974435,
+		0.0,
+		-0.35456849099817256,
+		-0.90646731321570218,
+		-0.22934296427574399,
+		0.0,
+		1550.6223360557265,
+		197.24908733414611,
+		336.92784140962624,
+		1.0
+	],
+	"intrinsic" : 
+	{
+		"height" : 800,
+		"intrinsic_matrix" : 
+		[
+			692.82032302755101,
+			0.0,
+			0.0,
+			0.0,
+			692.82032302755101,
+			0.0,
+			499.5,
+			399.5,
+			1.0
+		],
+		"width" : 1000
+	},
+	"version_major" : 1,
+	"version_minor" : 0
+}

cmake/build_run.bat

@@ -0,0 +1 @@
+.\cmake\build.bat ; if ($?) { .\build\bin\Release\diffCheckApp.exe }

src/diffCheck.hh

@@ -3,6 +3,8 @@
 #include <open3d/Open3D.h>
 #include <loguru.hpp>
 
+#include <cilantro/cilantro.hpp>
+
 // diffCheck includes
 #include "diffCheck/log.hh"
 const diffCheck::Log LOG = diffCheck::Log();
@@ -14,3 +16,4 @@ const diffCheck::Log LOG = diffCheck::Log();
 #include "diffCheck/transformation/DFTransformation.hh"
 #include "diffCheck/registrations/DFGlobalRegistrations.hh"
 #include "diffCheck/registrations/DFRefinedRegistration.hh"
+#include "diffCheck/segmentation/DFSegmentation.hh"

src/diffCheck/geometry/DFMesh.cc

@@ -79,6 +79,62 @@ namespace diffCheck::geometry
         return bboxPts;
     }
 
+    Eigen::Vector3d DFMesh::GetFirstNormal()
+    {
+        if (this->NormalsFace.size() == 0)
+        {
+            std::shared_ptr<open3d::geometry::TriangleMesh> O3DTriangleMesh = this->Cvt2O3DTriangleMesh();
+            O3DTriangleMesh->ComputeTriangleNormals();
+            this->NormalsFace.resize(O3DTriangleMesh->triangle_normals_.size());
+            for (size_t i = 0; i < O3DTriangleMesh->triangle_normals_.size(); i++)
+            {
+                this->NormalsFace[i] = O3DTriangleMesh->triangle_normals_[i];
+            }
+
+        }
+        return this->NormalsFace[0];
+    }
+
+    bool DFMesh::IsPointOnFace(Eigen::Vector3d point, double associationThreshold)
+    {
+        /*
+        To check if the point is in the face, we take into account all the triangles forming the face.
+        We calculate the area of each triangle, then check if the sum of the areas of the tree triangles 
+        formed by two of the points of the referencr triangle and our point is equal to the reference triangle area 
+        (within a user-defined margin). If it is the case, the triangle is in the face.
+        */
+        std::vector<Eigen::Vector3i> faceTriangles = this->Faces;
+        for (Eigen::Vector3i triangle : faceTriangles)
+        {
+            Eigen::Vector3d v0 = this->Vertices[triangle[0]];
+            Eigen::Vector3d v1 = this->Vertices[triangle[1]];
+            Eigen::Vector3d v2 = this->Vertices[triangle[2]];
+            Eigen::Vector3d n = (v1 - v0).cross(v2 - v0);
+            double normOfNormal = n.norm();
+            n.normalize();
+
+            Eigen::Vector3d projectedPoint = point - n * (n.dot(point - v0)) ;
+
+            double referenceTriangleArea = normOfNormal*0.5;
+            Eigen::Vector3d n1 = (v1 - v0).cross(projectedPoint - v0);
+            double area1 = n1.norm()*0.5;
+            Eigen::Vector3d n2 = (v2 - v1).cross(projectedPoint - v1);
+            double area2 = n2.norm()*0.5;
+            Eigen::Vector3d n3 = (v0 - v2).cross(projectedPoint - v2);
+            double area3 = n3.norm()*0.5;
+            double res = (area1 + area2 + area3 - referenceTriangleArea) / referenceTriangleArea;
+
+            // arbitrary value to avoid false positives (points that, when projected on the triangle, are in it, but that are actually located too far from the mesh to actually belong to it)
+            double maxProjectionDistance = std::min({(v1 - v0).norm(), (v2 - v1).norm(), (v0 - v2).norm()});
+
+            if (std::abs(res) < associationThreshold && (projectedPoint - point).norm() < maxProjectionDistance)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
     void DFMesh::LoadFromPLY(const std::string &path)
     {
         std::shared_ptr<diffCheck::geometry::DFMesh> tempMesh_ptr = diffCheck::io::ReadPLYMeshFromFile(path);

src/diffCheck/geometry/DFMesh.hh

@@ -71,6 +71,21 @@ namespace diffCheck::geometry
          */
         std::vector<Eigen::Vector3d> GetTightBoundingBox();
 
+        /**
+         * @brief Get the first normal of the mesh. Meant for planar meshes
+         * 
+         * @return Eigen::Vector3d the normal
+         */
+        Eigen::Vector3d GetFirstNormal();
+
+        /**
+         * @brief Check if a point is on a face of the mesh
+         * 
+         * @param point the point to check
+         * @param associationThreshold the threshold to consider the point associable to the mesh. It is the ratio between the surface of the closest mesh triangle of the mesh face, and the sum of the areas of the three triangles described by the point projected on the mesh face and two of the mesh triangle vertices. The lower the number, the more strict the association will be and some poinnts on the mesh face might be wrongfully excluded. In theory, in a perfect case, a value of 0 could be used, but in practice, values of 0.05-0.2 are more realistic, depending on the application.
+         */
+        bool IsPointOnFace(Eigen::Vector3d point, double associationThreshold = 0.1);
+
     public:  ///< I/O loader
         /**
          * @brief Read a mesh from a file