ADD documentation, test.

Author: pv

CMakeLists.txt

@@ -172,5 +172,4 @@ 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(_patternmap src/patternmap.cpp)
 add_nanobind_module(_mapping src/mapping.cpp)

docs/_images/example_mapping.png

@@ -1,27 +1,24 @@
 from compas.datastructures import Mesh
-from tessagon.types.hex_tessagon import HexTessagon
-from tessagon.adaptors.list_adaptor import ListAdaptor
 from compas_viewer import Viewer
-import compas_libigl as igl
-from compas_libigl import _mapping
-import numpy as np
+from tessagon.adaptors.list_adaptor import ListAdaptor
+from tessagon.types.hex_tessagon import HexTessagon
+from compas.colors import Color
 
-viewer = Viewer()
+import compas_libigl as igl
 
 # ==============================================================================
 # Input geometry: 3D Mesh
 # ==============================================================================
 
-# Load the mesh
 mesh = Mesh.from_obj("data/minimal_surface.obj")
 for key, attr in mesh.vertices(True):
     y = attr["y"]
     attr["y"] = -attr["z"]
     attr["z"] = y
+mesh.translate([2, 2, 0.5])
 
 v, f = mesh.to_vertices_and_faces()
 
-viewer.scene.add(mesh, name="mesh")
 
 # ==============================================================================
 # Input geometry: 2D Pattern creation using Tessagon library, can be other mesh.
@@ -44,57 +41,51 @@
 
 
 # ==============================================================================
-# Parametrization: choose between simple, lcsm and harmonic methods.
+# Place the pattern mesh at the center of the 3D 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_simple((v, f))
-# uv = igl.trimesh_lscm((v, f))
-# uv = igl.trimesh_harmonic((v, f))
+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])
 
-viewer.scene.add(mesh_flattened, name="mesh_flattened")
-
 # ==============================================================================
-# Mapping: 3D Mesh, 2D Pattern, UV
-# Eigen::Ref<const compas::RowMatrixXd> v, 
-# Eigen::Ref<const compas::RowMatrixXi> f, 
-# 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, 
-# std::vector<std::vector<int>>& pattern_polygonal_faces
+# 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)
 
-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)
-pattern_uv = igl.trimesh_simple((pv, pf))
-pattern_uv_numpy = np.array(pattern_uv, dtype=np.float64)
-pattern_polygonal_faces = pf
-
-print("Before mapping")
-print(pattern_v_numpy[0])
-_mapping.mapMesh3D_AABB(v_numpy, f_numpy, uv_numpy, pattern_v_numpy, pattern_f_numpy, pattern_uv_numpy, pattern_polygonal_faces)
-print("After mapping")
-
-for i in range(100):
-    print(pattern_v_numpy[i])
-
-mapped_mesh = Mesh.from_vertices_and_faces(pattern_v_numpy, pattern_f_numpy)
-viewer.scene.add(mapped_mesh, name="mapped_mesh")
+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)
 
 # ==============================================================================
 # Viewer
 # ==============================================================================
 
-
-viewer.show()
+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())
+viewer.show()

docs/examples/example_patternmap.py renamed to docs/examples/example_mapping.py

@@ -0,0 +1,10 @@
+********************************************************************************
+Mapping
+********************************************************************************
+
+.. figure:: /_images/example_mapping.png
+    :figclass: figure
+    :class: figure-img img-fluid
+
+.. literalinclude:: example_mapping.py
+    :language: python

docs/examples/example_mapping.rst

@@ -13,4 +13,5 @@ scikit-build-core[pyproject] >=0.10
 twine
 wheel
 setuptools
-cibuildwheel==2.23.1
+cibuildwheel==2.23.1
+tessagon

requirements-dev.txt

@@ -1 +1,2 @@
 compas >=2.0.0
+tessagon

requirements.txt

@@ -8,9 +8,9 @@
 from .isolines import trimesh_isolines, groupsort_isolines
 from .massmatrix import trimesh_massmatrix
 from .parametrisation import trimesh_harmonic, trimesh_lscm, trimesh_simple
-from .mapping import trimesh_map_simple, trimesh_map_aabb
 from .planarize import quadmesh_planarize
 from .meshing import trimesh_remesh_along_isoline, trimesh_remesh_along_isolines
+from .mapping import map_mesh
 
 
 __author__ = ["tom van mele", "petras vestartas"]
@@ -123,4 +123,5 @@ def get_armadillo():
     "quadmesh_planarize",
     "trimesh_remesh_along_isoline",
     "trimesh_remesh_along_isolines",
+    "map_mesh",
 ]

src/compas_libigl/__init__.py

@@ -1,71 +1,42 @@
 import numpy as np
+from compas.datastructures import Mesh
 
 from compas_libigl import _mapping
 
 
-def trimesh_map_simple(M_target, M_pattern, UV_target):
+def map_mesh(v, f, uv, pv, pf, p_uv):
     """Map a 2D pattern mesh onto a 3D target mesh using simple UV parameterization.
 
     Parameters
     ----------
-    M_target : tuple[list[list[float]], list[list[int]]]
-        A target mesh represented by a tuple of (vertices, faces)
-        where vertices are 3D points and faces are triangles
-    M_pattern : tuple[list[list[float]], list[list[int]]]
-        A pattern mesh represented by a tuple of (vertices, faces)
-        where vertices are 2D or 3D points and faces are triangles
-    UV_target : list[list[float]]
-        UV coordinates for the target mesh vertices
+    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.
 
     Returns
     -------
-    tuple[list[list[float]], list[list[int]]]
-        The mapped pattern mesh as a tuple of (vertices, faces)
+    pattern_mapped_cleaned : compas.datastructures.Mesh
+        The mapped pattern mesh.
     """
-    V_target, F_target = M_target
-    V_pattern, F_pattern = M_pattern
-    
-    V_target = np.asarray(V_target, dtype=np.float64)
-    F_target = np.asarray(F_target, dtype=np.int32)
-    V_pattern = np.asarray(V_pattern, dtype=np.float64)
-    F_pattern = np.asarray(F_pattern, dtype=np.int32)
-    UV_target = np.asarray(UV_target, dtype=np.float64)
-    
-    V_result, F_result = _mapping.mapMesh3D_simple(
-        V_target, F_target, V_pattern, F_pattern, UV_target)
-    
-    return V_result.tolist(), F_result.tolist()
 
+    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)
 
-def trimesh_map_aabb(M_target, M_pattern, UV_target):
-    """Map a 2D pattern mesh onto a 3D target mesh using AABB tree for faster point lookup.
+    # 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)
 
-    Parameters
-    ----------
-    M_target : tuple[list[list[float]], list[list[int]]]
-        A target mesh represented by a tuple of (vertices, faces)
-        where vertices are 3D points and faces are triangles
-    M_pattern : tuple[list[list[float]], list[list[int]]]
-        A pattern mesh represented by a tuple of (vertices, faces)
-        where vertices are 2D or 3D points and faces are triangles
-    UV_target : list[list[float]]
-        UV coordinates for the target mesh vertices
-
-    Returns
-    -------
-    tuple[list[list[float]], list[list[int]]]
-        The mapped pattern mesh as a tuple of (vertices, faces)
-    """
-    V_target, F_target = M_target
-    V_pattern, F_pattern = M_pattern
-    
-    V_target = np.asarray(V_target, dtype=np.float64)
-    F_target = np.asarray(F_target, dtype=np.int32)
-    V_pattern = np.asarray(V_pattern, dtype=np.float64)
-    F_pattern = np.asarray(F_pattern, dtype=np.int32)
-    UV_target = np.asarray(UV_target, dtype=np.float64)
-    
-    V_result, F_result = _mapping.mapMesh3D_AABB(
-        V_target, F_target, V_pattern, F_pattern, UV_target)
-    
-    return V_result.tolist(), F_result.tolist()
+    pattern_mapped_cleaned = Mesh.from_vertices_and_faces(pattern_v_numpy, pattern_f_numpy_cleaned)
+    return pattern_mapped_cleaned

src/compas_libigl/mapping.py

@@ -25,6 +25,7 @@ def trimesh_harmonic(M):
     F = np.asarray(F, dtype=np.int32)
     return _parametrisation.harmonic(V, F)
 
+
 @plugin(category="trimesh")
 def trimesh_lscm(M):
     """Compute the least squares conformal map of a triangle mesh.
@@ -47,7 +48,6 @@ def trimesh_lscm(M):
     return _parametrisation.lscm(V, F)
 
 
-
 @plugin(category="trimesh")
 def trimesh_simple(M):
     """Compute the least squares conformal map of a triangle mesh.