ADD mapping fixed points option.

Author: petrasvestartas

CHANGELOG.md

@@ -18,9 +18,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Added simplified borders to map_mesh function.
+- Added fixed points to map_mesh function.
+
 ### Changed
 
 - Fixed point welding bug in map_mesh function.
+- Changed example_isolines to work with the new compas_viewer.
 
 ### Removed
 

CMakeLists.txt

@@ -152,13 +152,13 @@ endfunction()
 # === Add your modules ===
 add_nanobind_module(_nanobind src/nanobind.cpp)
 add_nanobind_module(_types_std src/types_std.cpp)
-# add_nanobind_module(_boundaries src/boundaries.cpp)
-# add_nanobind_module(_curvature src/curvature.cpp)
-# add_nanobind_module(_geodistance src/geodistance.cpp)
-# add_nanobind_module(_intersections src/intersections.cpp)
-# add_nanobind_module(_isolines src/isolines.cpp)
-# add_nanobind_module(_massmatrix src/massmatrix.cpp)
-# add_nanobind_module(_meshing src/meshing.cpp)
-# add_nanobind_module(_parametrisation src/parametrisation.cpp)
-# add_nanobind_module(_planarize src/planarize.cpp)
+add_nanobind_module(_boundaries src/boundaries.cpp)
+add_nanobind_module(_curvature src/curvature.cpp)
+add_nanobind_module(_geodistance src/geodistance.cpp)
+add_nanobind_module(_intersections src/intersections.cpp)
+add_nanobind_module(_isolines src/isolines.cpp)
+add_nanobind_module(_massmatrix src/massmatrix.cpp)
+add_nanobind_module(_meshing src/meshing.cpp)
+add_nanobind_module(_parametrisation src/parametrisation.cpp)
+add_nanobind_module(_planarize src/planarize.cpp)
 add_nanobind_module(_mapping src/mapping.cpp)

docs/examples/example_isolines.py

@@ -53,6 +53,7 @@
 
 for i, isolines in enumerate(isolines):
     color = cmap(values[i], minval, maxval)
-    viewer.scene.add(isolines, linecolor=color, linewidth=3)
+    for isoline in isolines:
+        viewer.scene.add(isoline, linecolor=color, linewidth=3)
 
 viewer.show()

docs/examples/example_mapping_patterns.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
 from compas.colors import Color
+from compas.geometry import Point
 from compas.datastructures import Mesh
 from compas_viewer import Viewer
 from compas_viewer.config import Config
@@ -15,15 +16,30 @@
 
 mesh = Mesh.from_obj(Path(__file__).parent.parent.parent / "data" / "minimal_surface.obj")
 
+
+
 for vertex in mesh.vertices():
     x, y, z = mesh.vertex_attributes(vertex, "xyz")  # type: ignore
     mesh.vertex_attributes(vertex, "xyz", [x, -z, y])
 
+# ==============================================================================
+# Get Lowest and Highest points
+# ==============================================================================
+
+aabb = mesh.aabb()
+fixed_points = []
+
+
+for vertex in mesh.vertices():
+    x, y, z = mesh.vertex_attributes(vertex, "xyz")  # type: ignore
+    if abs(z-aabb.zmin) < 1e-3 or abs(z-aabb.zmax) < 1e-3:
+        fixed_points.append(vertex)
+
 # ==============================================================================
 # Mapping: 3D Mesh, 2D Pattern, UV
 # ==============================================================================
 
-mesh_mapped0 = map_pattern_to_mesh("ZigZag", mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=True)
+mesh_mapped0 = map_pattern_to_mesh("ZigZag", mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=True, fixed_points=fixed_points)
 mesh_mapped1 = map_pattern_to_mesh("ZigZag", mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=False)
 # ==============================================================================
 # Viewer
@@ -35,9 +51,11 @@
 
 viewer = Viewer(config=config)
 
-# viewer.scene.add(mesh, name="mesh", show_faces=False, linecolor=Color.grey(), opacity=0.2)
+viewer.scene.add(mesh, name="mesh", show_faces=False, linecolor=Color.grey(), opacity=0.2)
 viewer.scene.add(mesh_mapped0, name="mesh_mapped0", facecolor=Color.red(), show_points=True)
-viewer.scene.add(mesh_mapped1, name="mesh_mapped1", facecolor=Color.blue(), show_points=True, show_faces=False)
+# viewer.scene.add(mesh_mapped1, name="mesh_mapped1", facecolor=Color.blue(), show_points=True, show_faces=False)
 
+for p in fixed_points:
+    viewer.scene.add(mesh.vertex_point(p), pointcolor=Color.red(), pointsize=10)
 
 viewer.show()

mesh_flattened.json

@@ -75,7 +75,7 @@ CMAKE_POLICY_DEFAULT_CMP0135 = "NEW"
 
 [tool.cibuildwheel]
 build-verbosity = 3
-test-requires = ["numpy", "compas", "pytest", "build"]
+test-requires = ["numpy", "compas", "pytest", "build", "tessagon"]
 test-command = "pip install numpy compas && pip list && pytest {project}/tests"
 build-frontend = "pip"
 manylinux-x86_64-image = "manylinux2014"

pyproject.toml

@@ -26,7 +26,7 @@
 from compas_libigl._types_std import VectorVectorInt  # noqa: F401
 
 
-def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=True, tolerance=1e-6):
+def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=True, fixed_points=None, tolerance=1e-6):
     """
     Map a 2D pattern mesh onto a 3D target.
 
@@ -40,6 +40,8 @@ def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=T
         Whether to clip the pattern mesh to the boundaries of the target mesh.
     simplify_borders : bool
         Whether to simplify the border of the pattern mesh.
+    fixed_points : list[list[float]]
+        A list of fixed points on the target mesh.
     tolerance : float
         The tolerance for point comparison, to remove duplicates.
 
@@ -63,16 +65,30 @@ def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=T
     f_numpy = np.array(f, dtype=np.int32)
     pattern_v_numpy = np.array(pv, dtype=np.float64)
 
+    # Handle fixed_points - provide empty array if None
+
+    fixed_points_vectorint = VectorInt()
+    if fixed_points is None:
+        fixed_points_vectorint = VectorInt()
+    else:
+        fixed_points_vectorint = VectorInt(fixed_points)
+
+    # Convert pattern_f from Python list to VectorVectorInt which is expected by C++ code
+
+    pattern_f_vec = VectorVectorInt()
+    for face in pf:
+        pattern_f_vec.append(face)
+
     # Perform the mapping
     pv_numpy_copy, pf_numpy_cleaned, p_normals, pattern_is_boundary, pattern_groups = _mapping.map_mesh_with_automatic_parameterization(
-        v_numpy, f_numpy, pattern_v_numpy, pf, clip_boundaries, simplify_borders, tolerance
+        v_numpy, f_numpy, pattern_v_numpy, pattern_f_vec, clip_boundaries, simplify_borders, fixed_points_vectorint, tolerance
     )
 
     # Return the result as a tuple
     return pv_numpy_copy, pf_numpy_cleaned, p_normals, pattern_is_boundary, pattern_groups
 
 
-def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=True):
+def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=True, fixed_points=None):
     """
     Map a 2D pattern mesh onto a 3D target.
 
@@ -112,6 +128,8 @@ def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, patter
         The number of pattern vertices in the v direction.
     simplify_borders : bool
         Whether to simplify the border of the pattern mesh.
+    fixed_points : list[list[float]]
+        A list of fixed points on the target mesh.
 
     Returns
     -------
@@ -169,6 +187,8 @@ def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, patter
     pf = tessagon_mesh["face_list"]
 
     v, f = mesh.to_vertices_and_faces()
-    mapped_vertices, mapped_faces, mapped_normals, mapped_is_boundary, mapped_groups = map_mesh((v, f), (pv, pf), clip_boundaries=clip_boundaries, simplify_borders=simplify_borders, tolerance=tolerance)
+    mapped_vertices, mapped_faces, mapped_normals, mapped_is_boundary, mapped_groups = map_mesh(
+        (v, f), (pv, pf), clip_boundaries=clip_boundaries, simplify_borders=simplify_borders, fixed_points=fixed_points, tolerance=tolerance
+    )
 
     return Mesh.from_vertices_and_faces(mapped_vertices, mapped_faces)

src/compas_libigl/mapping.py

@@ -1,9 +1,4 @@
 #include "mapping.hpp"
-#include <algorithm>
-#include <iostream>
-#include <iomanip>
-#include <cmath>
-#include <unordered_set>
 
 // Custom hash function for tuple
 struct TupleHash {
@@ -99,7 +94,7 @@ std::vector<std::vector<int>> map_mesh_cropped(
         }
 
         // Update pattern vertex position through barycentric interpolation, comment this out if you keep 2D pattern
-        // pattern_v.row(id) = A * L(0, 0) + B * L(0, 1) + C * L(0, 2);
+        pattern_v.row(id) = A * L(0, 0) + B * L(0, 1) + C * L(0, 2);
 
         // If normals are requested, interpolate them using the same barycentric coordinates
         if (compute_normals) {
@@ -177,9 +172,18 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, std::vector<bool>
     const std::vector<std::vector<int>>& pattern_f,
     bool clip_boundaries,
     bool simplify_borders,
+    std::vector<int>& fixed_points,
     double tolerance
 )   
 {
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // Fixed points
+    ////////////////////////////////////////////////////////////////////////////////////////
+    Clipper2Lib::PathD fixed;
+    for (const auto &point_id : fixed_points){
+        fixed.emplace_back(Clipper2Lib::PointD(flattned_target_uv(point_id, 0), flattned_target_uv(point_id, 1)));
+    }
 
     ////////////////////////////////////////////////////////////////////////////////////////
     // Get Boundary polygon of a Mesh as Clipper Path.
@@ -302,6 +306,7 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, std::vector<bool>
             simplified_paths[0].reserve(subject[0].size());
 
             for (const auto &p : solution[0]){ // iterate the points of the intersection polygon
+                
                 // First check if point is close to any vertex (corner)
                 bool point_added = false;
                 for(size_t i = 0; i < subject[0].size(); i++){
@@ -313,6 +318,19 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, std::vector<bool>
                         break;
                     }
                 }
+
+                // Check if point is close to any fixed point
+                for(size_t i = 0; i < fixed.size(); i++){
+                    double fx = fixed[i].x;
+                    double fy = fixed[i].y;
+                    double dx = p.x - fx;
+                    double dy = p.y - fy;
+                    if (dx*dx + dy*dy < tolerance*tolerance){
+                        simplified_paths[0].push_back(p);
+                        point_added = true;
+                        break;
+                    }
+                }
 
                 // If not close to a vertex, check if close to any edge
                 if (!point_added) {
@@ -431,46 +449,20 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, compas::RowMatrix
     const std::vector<std::vector<int>>& pattern_f,
     bool clip_boundaries,
     bool simplify_borders,
+    std::vector<int>& fixed_points,
     double tolerance)
 {
 
 
+
+
     // Compute target mesh UV parameterization using LSCM
     Eigen::MatrixXd target_uv;
 
     // Find the open boundary
     Eigen::VectorXi B;
     igl::boundary_loop(target_f, B);
 
-    // Get Boundary vertices
-    std::vector<Eigen::Vector3d> corner_vertex_coords;
-    
-    std::vector<std::vector<int>> VV;
-    igl::adjacency_list(target_f, VV);
-    
-    // Create a set of boundary vertices for faster lookup
-    std::unordered_set<int> boundary_set;
-    for (int i = 0; i < B.size(); i++) {
-        boundary_set.insert(B(i));
-    }
-    
-    for (int i = 0; i < B.size(); i++) {
-        int v = B(i);
-        int boundary_valence = 0;
-        for (int neighbor : VV[v])
-            if (boundary_set.count(neighbor) > 0)
-                boundary_valence++;
-        
-        if (boundary_valence < 2) {
-            Eigen::Vector3d vertex_pos(target_v(v, 0), target_v(v, 1), target_v(v, 2));
-            corner_vertex_coords.push_back(vertex_pos);
-            std::cout << "Corner vertex " << v << " at position (" 
-                      << target_v(v, 0) << ", " 
-                      << target_v(v, 1) << ", " 
-                      << target_v(v, 2) << ")" << std::endl;
-        }
-    }
-
     // Fix two points on the boundary
     Eigen::VectorXi fixed(2, 1);
     fixed(0) = B(0);
@@ -494,7 +486,7 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, compas::RowMatrix
 
 
     // Clip the pattern
-    auto [clipped_pattern_v, clipped_pattern_f, clipped_pattern_is_boundary, clipped_pattern_groups] = eigen_to_clipper(target_uv, target_f, pattern_v, pattern_f, clip_boundaries, simplify_borders, tolerance);
+    auto [clipped_pattern_v, clipped_pattern_f, clipped_pattern_is_boundary, clipped_pattern_groups] = eigen_to_clipper(target_uv, target_f, pattern_v, pattern_f, clip_boundaries, simplify_borders, fixed_points, tolerance);
 
     Eigen::MatrixXd clipped_pattern_uv;
     clipped_pattern_uv.setZero();
@@ -531,6 +523,7 @@ NB_MODULE(_mapping, m)
         "pattern_f"_a,
         "clip_boundaries"_a,
         "simplify_borders"_a,
+        "fixed_points"_a,
         "tolerance"_a
     );
 }

src/mapping.cpp

@@ -74,6 +74,7 @@ bool paths_intersect(const Clipper2Lib::PathsD& paths1, const Clipper2Lib::Paths
  * @param pattern_f The pattern mesh face indices.
  * @param clip_boundaries Whether to clip the pattern mesh to the boundaries of the target mesh.
  * @param simplify_borders Whether to simplify the border of the pattern mesh.
+ * @param fixed_points fixed points on the target mesh
  * @param tolerance The tolerance for point comparison, to remove duplicates.
  * @return A tuple of the clipped pattern mesh vertex coordinates and face indices.
  */
@@ -85,6 +86,7 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, std::vector<bool>
     const std::vector<std::vector<int>>& pattern_f,
     bool clip_boundaries,
     bool simplify_borders,
+    std::vector<int>& fixed_points,
     double tolerance = 1e-6
 )  ;    
 
@@ -99,6 +101,7 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, std::vector<bool>
  * @param pattern_f vector of vectors of int of pattern mesh triangle indices
  * @param clip_boundaries whether to clip the pattern mesh to the boundaries of the target mesh
  * @param simplify_borders whether to simplify the border of the pattern mesh
+ * @param fixed_points fixed points on the target mesh
  * @param tolerance tolerance for point comparison, to remove duplicates
  * @return A tuple containing the mapped pattern vertices, faces, and vertex normal vectors.
  */
@@ -109,5 +112,6 @@ std::tuple<compas::RowMatrixXd, std::vector<std::vector<int>>, compas::RowMatrix
     const std::vector<std::vector<int>>& pattern_f,
     bool clip_boundaries,
     bool simplify_borders,
+    std::vector<int>& fixed_points,
     double tolerance = 1e-6
 );