CHANGE parametrization is hidden from user, only pattern and target mesh required.

Author: pv

docs/examples/example_mapping.py

@@ -39,45 +39,21 @@
 pv = tessagon_mesh["vert_list"]
 pf = tessagon_mesh["face_list"]
 
-
 # ==============================================================================
-# Place the pattern mesh at the center of the 3D mesh
+# Place the pattern mesh at the bottom left corner of the mesh
 # ==============================================================================
+
 pattern2d = Mesh.from_vertices_and_faces(pv, pf)
 c = pattern2d.aabb().corner(0)
 pattern2d.translate([-c[0], -c[1], -c[2]])
 pv, pf = pattern2d.to_vertices_and_faces()
 
-
-# ==============================================================================
-# Parametrization
-# ==============================================================================
-
-uv = igl.trimesh_lscm((v, f))
-
-mesh_flattened = mesh.copy()
-mesh_flattened.vertices_attribute("z", 0)
-
-for i in range(mesh.number_of_vertices()):
-    mesh_flattened.vertex_attributes(i, "xy", uv[i])
-
-# ==============================================================================
-# Rescale the flattened uv mesh to 1x1 scale
-# ==============================================================================
-box = mesh_flattened.aabb()
-c = box.corner(0)
-mesh_flattened.translate([-c[0], -c[1], -c[2]])
-mesh_flattened.scale(1.0 / box.xsize, 1.0 / box.ysize, 1)
-
-for i in range(mesh.number_of_vertices()):
-    uv[i] = mesh_flattened.vertex_attributes(i, "xy")
-
 # ==============================================================================
 # Mapping: 3D Mesh, 2D Pattern, UV
 # ==============================================================================
 
-p_uv = igl.trimesh_simple((pv, pf))
-mesh_mapped = igl.map_mesh(v, f, uv, pv, pf, p_uv)
+mv, mf = igl.map_mesh((v, f), (pv, pf))
+mesh_mapped = Mesh.from_vertices_and_faces(mv, mf)
 
 # ==============================================================================
 # Viewer
@@ -86,6 +62,13 @@
 viewer = Viewer()
 viewer.scene.add(mesh, name="mesh", show_faces=False, linecolor=Color.grey(), opacity=0.2)
 viewer.scene.add(pattern2d, name="pattern2d")
-viewer.scene.add(mesh_flattened, name="mesh_flattened")
 viewer.scene.add(mesh_mapped, name="mesh_mapped", facecolor=Color.red())
+
+# To see where the pattern is mapped:
+uv = igl.trimesh_lscm((v, f))
+mesh_flattened = mesh.copy()
+for i in range(mesh.number_of_vertices()):
+    mesh_flattened.vertex_attributes(i, "xyz", [uv[i][0], uv[i][1], 0])
+
+viewer.scene.add(mesh_flattened, name="mesh_flattened")
 viewer.show()

docs/examples/example_parametrisation.py

@@ -31,8 +31,6 @@
 for index, key in enumerate(mesh.vertices()):
     mesh_lscm.vertex_attributes(key, "xy", lscm_uv[index])
 
-mesh_lscm.transform(Scale.from_factors([3, 3, 3]))
-
 # ==============================================================================
 # Visualization
 # ==============================================================================

src/compas_libigl/mapping.py

@@ -1,42 +1,43 @@
 import numpy as np
-from compas.datastructures import Mesh
 
 from compas_libigl import _mapping
 
 
-def map_mesh(v, f, uv, pv, pf, p_uv):
-    """Map a 2D pattern mesh onto a 3D target mesh using simple UV parameterization.
+def map_mesh(target_mesh, pattern_mesh):
+    """Map a 2D pattern mesh onto a 3D target.
 
     Parameters
     ----------
-    v : list[list[float]]
-        The vertices of the target mesh.
-    f : list[list[int]]
-        The faces of the target mesh.
-    uv : list[list[float]]
-        The UV coordinates of the target mesh.
-    pv : list[list[float]]
-        The vertices of the pattern mesh.
-    pf : list[list[int]]
-        The faces of the pattern mesh.
-    p_uv : list[list[float]]
-        The UV coordinates of the pattern mesh.
+    target_mesh : tuple
+        A tuple of (vertices, faces) representing the target mesh.
+        vertices : list[list[float]]
+            The vertices of the target mesh.
+        faces : list[list[int]]
+            The triangle faces of the target mesh.
+    pattern_mesh : tuple
+        A tuple of (vertices, faces) representing the pattern mesh.
+        vertices : list[list[float]]
+            The vertices of the pattern mesh.
+        faces : list[list[int]]
+            The polygonal faces of the pattern mesh.
 
     Returns
     -------
-    pattern_mapped_cleaned : compas.datastructures.Mesh
-        The mapped pattern mesh.
+    tuple
+        A tuple containing (vertices, faces) of the mapped pattern mesh.
     """
+    # Unpack mesh tuples
+    v, f = target_mesh
+    pv, pf = pattern_mesh
 
+    # Convert to numpy arrays
     v_numpy = np.array(v, dtype=np.float64)
     f_numpy = np.array(f, dtype=np.int32)
-    uv_numpy = np.array(uv, dtype=np.float64)
     pattern_v_numpy = np.array(pv, dtype=np.float64)
     pattern_f_numpy = np.array(pf, dtype=np.int32)
-    p_uv_numpy = np.array(p_uv, dtype=np.float64)
 
-    # Call the mapping function with the new signature (returns a tuple)
-    pattern_f_numpy_cleaned = _mapping.map_mesh(v_numpy, f_numpy, uv_numpy, pattern_v_numpy, pattern_f_numpy, p_uv_numpy)
+    # Perform the mapping
+    pattern_f_numpy_cleaned = _mapping.map_mesh_with_automatic_parameterization(v_numpy, f_numpy, pattern_v_numpy, pattern_f_numpy)
 
-    pattern_mapped_cleaned = Mesh.from_vertices_and_faces(pattern_v_numpy, pattern_f_numpy_cleaned)
-    return pattern_mapped_cleaned
+    # Return the result as a tuple
+    return pattern_v_numpy, pattern_f_numpy_cleaned

src/mapping.cpp

@@ -160,21 +160,84 @@ std::vector<std::vector<int>> map_mesh(
     return pattern_polygonal_faces;
 }
 
-// Create the nanobind module
-NB_MODULE(_mapping, m) {
-    // Bind std::vector<std::vector<int>> type for Python interoperability
-    nb::bind_vector<std::vector<int>>(m, "VectorInt");
-    nb::bind_vector<std::vector<std::vector<int>>>(m, "VectorVectorInt");
+std::vector<std::vector<int>> map_mesh_with_automatic_parameterization(
+    Eigen::Ref<const compas::RowMatrixXd> target_v, 
+    Eigen::Ref<const compas::RowMatrixXi> target_f, 
+    Eigen::Ref<compas::RowMatrixXd> pattern_v, 
+    Eigen::Ref<const compas::RowMatrixXi> pattern_f)
+{
+    // Compute target mesh UV parameterization using LSCM
+    Eigen::MatrixXd target_uv;
+    
+    // Find the open boundary
+    Eigen::VectorXi B;
+    igl::boundary_loop(target_f, B);
+
+    // Fix two points on the boundary
+    Eigen::VectorXi fixed(2, 1);
+    fixed(0) = B(0);
+    fixed(1) = B(B.size() / 2);
+
+    Eigen::MatrixXd fixed_uv(2, 2);
+    fixed_uv << 0, 0, 1, 0;
+
+    // LSCM parametrization
+    igl::lscm(target_v, target_f, fixed, fixed_uv, target_uv);
+    
+    // Rescale target UV coordinates
+    // Find min and max values for normalization
+    Eigen::Vector2d min_coeff = target_uv.colwise().minCoeff();
+    Eigen::Vector2d max_coeff = target_uv.colwise().maxCoeff();
+    
+    // Compute the size of the bounding box
+    Eigen::Vector2d size = max_coeff - min_coeff;
+    
+    // Translate UV coordinates so minimum is at the origin
+    target_uv.col(0) = target_uv.col(0).array() - min_coeff(0);
+    target_uv.col(1) = target_uv.col(1).array() - min_coeff(1);
+    
+    // Scale to fit in a 0-1 box while maintaining aspect ratio
+    double scale_factor = 1.0 / std::max(size(0), size(1));
+    target_uv *= scale_factor;
+    
+    // Compute pattern mesh UV parameterization using simple method
+    Eigen::MatrixXd pattern_uv = pattern_v.leftCols(2);  // Use the first two columns (X and Y coordinates)
 
+    // Rescale pattern UV coordinates
+    min_coeff = pattern_uv.colwise().minCoeff();
+    max_coeff = pattern_uv.colwise().maxCoeff();
+    
+    size = max_coeff - min_coeff;
+    
+    pattern_uv.col(0) = pattern_uv.col(0).array() - min_coeff(0);
+    pattern_uv.col(1) = pattern_uv.col(1).array() - min_coeff(1);
+    
+    scale_factor = 1.0 / std::max(size(0), size(1));
+    pattern_uv *= scale_factor;
+    
+    // Now perform the mapping using the computed UV parameterizations
+    return map_mesh(target_v, target_f, target_uv, pattern_v, pattern_f, pattern_uv);
+}
+
+NB_MODULE(_mapping, m)
+{
     m.def(
         "map_mesh",
         &map_mesh,
-        "Map a 2D pattern mesh onto a 3D target mesh using simple UV parameterization",
-        "v"_a,
-        "f"_a,
-        "uv"_a,
+        "Map a 2D pattern mesh onto a 3D target mesh.",
+        "target_v"_a,
+        "target_f"_a,
+        "target_uv"_a,
         "pattern_v"_a,
         "pattern_f"_a,
-        "pattern_uv"_a
-    );
-}
+        "pattern_uv"_a);
+        
+    m.def(
+        "map_mesh_with_automatic_parameterization",
+        &map_mesh_with_automatic_parameterization,
+        "Map a 2D pattern mesh onto a 3D target mesh with automatic parameterization.",
+        "target_v"_a,
+        "target_f"_a,
+        "pattern_v"_a,
+        "pattern_f"_a);
+}

src/mapping.hpp

@@ -65,4 +65,22 @@ std::vector<std::vector<int>> map_mesh(
     Eigen::Ref<const compas::RowMatrixXd> uv,
     Eigen::Ref<compas::RowMatrixXd> pattern_v, 
     Eigen::Ref<const compas::RowMatrixXi> pattern_f, 
-    Eigen::Ref<const compas::RowMatrixXd> pattern_uv);
+    Eigen::Ref<const compas::RowMatrixXd> pattern_uv);
+
+
+/**
+ * Map a 2D pattern mesh onto a 3D target mesh with automatic parameterization, mesh is always mapped to 1x1 unit.
+ * This function automatically computes the UV parameterization for both meshes
+ * and then performs mapping, eliminating the need for separate parameterization steps.
+ * 
+ * @param target_v #V x 3 matrix of target mesh vertex coordinates
+ * @param target_f #F x 3 matrix of target mesh triangle indices
+ * @param pattern_v #V x 3 matrix of pattern mesh vertex coordinates
+ * @param pattern_f #F x 3 matrix of pattern mesh triangle indices
+ * @return A vector of face indices representing polygons in the mapped mesh
+ */
+std::vector<std::vector<int>> map_mesh_with_automatic_parameterization(
+    Eigen::Ref<const compas::RowMatrixXd> target_v, 
+    Eigen::Ref<const compas::RowMatrixXi> target_f, 
+    Eigen::Ref<compas::RowMatrixXd> pattern_v, 
+    Eigen::Ref<const compas::RowMatrixXi> pattern_f);

src/parametrisation.cpp

@@ -5,6 +5,24 @@
 #include <igl/map_vertices_to_circle.h>
 #include <Eigen/Core>
 
+void rescale(Eigen::MatrixXd &V_uv)
+{
+    // Find min and max values for normalization
+    Eigen::Vector2d min_coeff = V_uv.colwise().minCoeff();
+    Eigen::Vector2d max_coeff = V_uv.colwise().maxCoeff();
+    
+    // Compute the size of the bounding box
+    Eigen::Vector2d size = max_coeff - min_coeff;
+    
+    // Translate UV coordinates so minimum is at the origin
+    V_uv.col(0) = V_uv.col(0).array() - min_coeff(0);
+    V_uv.col(1) = V_uv.col(1).array() - min_coeff(1);
+    
+    // Scale to fit in a 0-1 box while maintaining aspect ratio
+    double scale_factor = 1.0 / std::max(size(0), size(1));
+    V_uv *= scale_factor;
+}
+
 Eigen::MatrixXd
 harmonic(
     Eigen::Ref<const compas::RowMatrixXd> V,
@@ -23,6 +41,8 @@ harmonic(
     // Harmonic parametrization for the internal vertices
     igl::harmonic(V, F, B, B_uv, 1, V_uv);
 
+    rescale(V_uv);
+
     return V_uv;
 }
 
@@ -47,6 +67,8 @@ lscm(
 
     // LSCM parametrization
     igl::lscm(V, F, fixed, fixed_uv, V_uv);
+    
+    rescale(V_uv);
 
     return V_uv;
 }
@@ -59,17 +81,8 @@ simple(
     // Create UV coordinates matrix from XY coordinates
     Eigen::MatrixXd V_uv = V.leftCols(2);  // Use the first two columns (X and Y coordinates)
 
-    // Find min and max values for normalization
-    Eigen::Vector2d min_coeff = V_uv.colwise().minCoeff();
-    Eigen::Vector2d max_coeff = V_uv.colwise().maxCoeff();
-    
-    // Normalize to range [0,1]
-    for(int id = 0; id < V_uv.rows(); id++)
-    {
-        V_uv(id, 0) = (V_uv(id, 0) - min_coeff(0)) / (max_coeff(0) - min_coeff(0));
-        V_uv(id, 1) = (V_uv(id, 1) - min_coeff(1)) / (max_coeff(1) - min_coeff(1));
-    }
-    
+    rescale(V_uv);
+
     return V_uv;
 }
 

src/parametrisation.hpp

@@ -3,6 +3,13 @@
 #include "compas.hpp"
 #include <Eigen/Core>
 
+/**
+ * Rescale UV coordinates to fit in a 0-1 box while maintaining aspect ratio.
+ * 
+ * @param V_uv #V x 2 matrix of UV coordinates
+ */
+void rescale(Eigen::MatrixXd &V_uv);
+
 /**
  * Compute the harmonic parametrization of a triangle mesh.
  *

tests/test_mapping.py

@@ -27,12 +27,9 @@ def test_map_mesh():
     pv = tessagon_mesh["vert_list"]
     pf = tessagon_mesh["face_list"]
 
-    # Create UV parameterization
-    uv = igl.trimesh_lscm((v, f))
-    p_uv = igl.trimesh_simple((pv, pf))
-
     # Map pattern onto target mesh
-    mesh_mapped = igl.map_mesh(v, f, uv, pv, pf, p_uv)
+    mv, mf = igl.map_mesh((v, f), (pv, pf))
+    mesh_mapped = Mesh.from_vertices_and_faces(mv, mf)
 
     # Verify the result is a valid mesh
     assert mesh_mapped is not None