REFACTOR project method.

Author: petrasvestartas

docs/examples/example_meshing.py

@@ -2,7 +2,7 @@
 from compas.datastructures import Mesh
 from compas_viewer import Viewer
 
-from compas_cgal.meshing import mesh_remesh
+from compas_cgal.meshing import trimesh_remesh
 
 
 input_file = Path(__file__).parent.parent.parent / "data" / "rhinovault_mesh_0.ply"
@@ -13,7 +13,7 @@
 iterations = 10
 
 # Remesh
-V1, F1 = mesh_remesh(mesh.to_vertices_and_faces(), edge_length, iterations)
+V1, F1 = trimesh_remesh(mesh.to_vertices_and_faces(), edge_length, iterations)
 remeshed = Mesh.from_vertices_and_faces(V1, F1)
 
 

docs/examples/example_meshing_dual.py

@@ -3,7 +3,7 @@
 from compas.datastructures import Mesh
 from compas_viewer import Viewer
 
-from compas_cgal.meshing import remesh_dual
+from compas_cgal.meshing import trimesh_dual
 
 
 input_file = Path(__file__).parent.parent.parent / "data" / "rhinovault_mesh_0.ply"
@@ -17,10 +17,9 @@
         fixed_vertices.append(v)
 
 # Remesh and Dual
-V2, F2, V3, F3 = remesh_dual(mesh.to_vertices_and_faces(), length_factor=1.0, number_of_iterations=100, angle_radians=0.9, fixed_vertices=[])
+V2, F2, V3, F3 = trimesh_dual(mesh.to_vertices_and_faces(), length_factor=1.0, number_of_iterations=100, angle_radians=0.9, fixed_vertices=[])
 remeshed, dual = Mesh.from_vertices_and_faces(V2, F2), Mesh.from_vertices_and_faces(V3, F3)
 
-
 # ==============================================================================
 # Visualize
 # ==============================================================================

docs/examples/example_projection.py

@@ -4,7 +4,7 @@
 from compas.datastructures import Mesh
 from compas_viewer import Viewer
 
-from compas_cgal.meshing import project_mesh_on_mesh, project_points_on_mesh
+from compas_cgal.meshing import project_mesh_on_mesh, project_points_on_mesh, pull_mesh_on_mesh, pull_points_on_mesh
 
 
 # Mesh to project
@@ -15,14 +15,17 @@
 input_file_1 = Path(__file__).parent.parent.parent / "data" / "rhinovault_mesh_1.ply"
 mesh_1 = Mesh.from_ply(input_file_1)
 
-mesh_result = project_mesh_on_mesh(mesh_0, mesh_1, use_normals=False)
+mesh_result_project = project_mesh_on_mesh(mesh_0, mesh_1)
 
 # Points with normals to project
 v, f = mesh_0.to_vertices_and_faces()
 normals = []
 for i in range(len(v)):
     normals.append(mesh_0.vertex_normal(i))
-points_result = project_points_on_mesh(v, mesh_1, normals)
+points_result_project = project_points_on_mesh(v, mesh_1)
+
+mesh_result_pull = pull_mesh_on_mesh(mesh_0, mesh_1)
+points_result_pull = pull_points_on_mesh(v, normals, mesh_1)
 
 # ==============================================================================
 # Visualize
@@ -34,8 +37,15 @@
 
 viewer.scene.add(mesh_0, name="source mesh_0", show_faces=False)
 viewer.scene.add(mesh_1, name="target mesh_1", show_faces=False)
-viewer.scene.add(mesh_result, name="projected mesh_result", color=[255, 0, 0])
-for i, point in enumerate(points_result):
-    viewer.scene.add(Point(*point), name=f"point_{i}", color=[0, 255, 0])
+viewer.scene.add(mesh_result_project, name="projected mesh", color=[255, 0, 0])
+viewer.scene.add(mesh_result_pull, name="pulled mesh", color=[0, 255, 0])
+
+group_projected = viewer.scene.add_group("projected points")
+for i, point in enumerate(points_result_project):
+    group_projected.add(Point(*point), name=f"point_{i}", color=[0, 0, 0])
+
+group_pulled = viewer.scene.add_group("pulled points")
+for i, point in enumerate(points_result_pull):
+    group_pulled.add(Point(*point), name=f"point_{i}", color=[0, 0, 0])
 
 viewer.show()

src/compas_cgal/meshing.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 from compas.datastructures import Mesh
 from compas.plugins import plugin
@@ -12,7 +10,7 @@
 
 
 @plugin(category="trimesh", pluggable_name="trimesh_remesh")
-def mesh_remesh(
+def trimesh_remesh(
     mesh: VerticesFaces,
     target_edge_length: float,
     number_of_iterations: int = 10,
@@ -55,24 +53,71 @@ def mesh_remesh(
     V, F = mesh
     V = np.asarray(V, dtype=np.float64, order="C")
     F = np.asarray(F, dtype=np.int32, order="C")
-    return _meshing.remesh(V, F, target_edge_length, number_of_iterations, do_project)
+    return _meshing.pmp_trimesh_remesh(V, F, target_edge_length, number_of_iterations, do_project)
+
+
+def trimesh_dual(
+    mesh: VerticesFaces,
+    length_factor: float = 1.0,
+    number_of_iterations: int = 10,
+    angle_radians: float = 0.9,
+    scale_factor: float = 1.0,
+    fixed_vertices: list[int] = [],
+) -> tuple[np.ndarray, list[list[int]]]:
+    """Create a dual mesh from a triangular mesh with variable-length faces.
+
+    Parameters
+    ----------
+    mesh : :attr:`compas_cgal.types.VerticesFaces`
+        The mesh to create a dual from.
+    angle_radians : double, optional
+        Angle limit in radians for boundary vertices to remove.
+    length_factor : double, optional
+        Length factor for remeshing.
+    number_of_iterations : int, optional
+        Number of remeshing iterations.
+    scale_factor : double, optional
+        Scale factor for inner vertices.
+    fixed_vertices : list[int], optional
+        List of vertex indices to keep fixed during remeshing.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+
+        - Remeshed mesh vertices as an Nx3 numpy array.
+        - Remeshed mesh faces as an Mx3 numpy array.
+        - Dual mesh vertices as an Nx3 numpy array.
+        - Variable-length faces as a list of lists of vertex indices.
+
+    Notes
+    -----
+    This dual mesh implementation includes proper boundary handling by:
+    1. Creating vertices at face centroids of the primal mesh
+    2. Creating additional vertices at boundary edge midpoints
+    3. Creating proper connections for boundary edges
+
+    """
+    V, F = mesh
+    V = np.asarray(V, dtype=np.float64, order="C")
+    F = np.asarray(F, dtype=np.int32, order="C")
+    fixed_vertices = np.asarray(fixed_vertices, dtype=np.int32, order="C")
+    return _meshing.pmp_trimesh_remesh_dual(V, F, fixed_vertices, length_factor, number_of_iterations, angle_radians, scale_factor)
 
 
 def project_mesh_on_mesh(
     mesh_source: VerticesFaces,
     mesh_target: VerticesFaces,
-    use_normals: bool = True,
 ) -> VerticesFaces:
-    """Project mesh_target vertices onto mesh_source surface.
+    """Project mesh_source vertices onto mesh_target surface.
 
     Parameters
     ----------
     mesh_source : :attr:`compas_cgal.types.VerticesFaces`
-        The mesh to project onto (target surface).
+        Mesh that is projected onto the target mesh.
     mesh_target : :attr:`compas_cgal.types.VerticesFaces`
-        The mesh whose vertices will be projected (source points).
-    use_normals : bool, optional
-        Whether to use normals for ray-based projection. If False, closest point projection is used.
+        Mesh that is projected onto.
 
     Returns
     -------
@@ -81,130 +126,89 @@ def project_mesh_on_mesh(
 
     """
     V_source, F_source = mesh_source.to_vertices_and_faces()
-    V_target, F_target = mesh_target.to_vertices_and_faces(triangulated=True)
+    V_source = project_points_on_mesh(V_source, mesh_target)
+    return Mesh.from_vertices_and_faces(V_source, F_source)
 
-    # Convert inputs to numpy arrays
-    numpy_V_source = np.asarray(V_source, dtype=np.float64, order="C")
 
-    numpy_V_target = np.asarray(V_target, dtype=np.float64, order="C")
-    numpy_F_target = np.asarray(F_target, dtype=np.int32, order="C")
+def pull_mesh_on_mesh(
+    mesh_source: VerticesFaces,
+    mesh_target: VerticesFaces,
+) -> VerticesFaces:
+    """Pull mesh_source vertices onto mesh_target surface using mesh_source normals.
 
-    # Handle normals calculation
-    if use_normals:
-        # Pre-allocate numpy array for normals with correct size
-        numpy_N_source = np.zeros((mesh_source.number_of_vertices(), 3), dtype=np.float64)
+    Parameters
+    ----------
+    mesh_source : :attr:`compas_cgal.types.VerticesFaces`
+        Mesh that is projected onto the target mesh.
+    mesh_target : :attr:`compas_cgal.types.VerticesFaces`
+        Mesh that is projected onto.
 
-        # Fill the array with vertex normals
-        for i, vertex_key in enumerate(mesh_source.vertices()):
-            normal = -mesh_source.vertex_normal(vertex_key)
-            numpy_N_source[i, 0] = normal.x
-            numpy_N_source[i, 1] = normal.y
-            numpy_N_source[i, 2] = normal.z
-    else:
-        # Don't use normals - create empty array
-        numpy_N_source = np.zeros((0, 0), dtype=np.float64)
+    Returns
+    -------
+    :attr:`compas_cgal.types.VerticesFaces`
+        The projected mesh (vertices on mesh_source surface, original faces).
 
-    # Call the C++ function
-    _meshing.project(numpy_V_target, numpy_F_target, numpy_V_source, numpy_N_source)
+    """
+    V_source, F_source = mesh_source.to_vertices_and_faces()
+    N_source = []
+    for v in mesh_source.vertices():
+        N_source.append(mesh_source.vertex_normal(v))
 
-    return Mesh.from_vertices_and_faces(numpy_V_source, F_source)
+    V_source = pull_points_on_mesh(V_source, N_source, mesh_target)
+    return Mesh.from_vertices_and_faces(V_source, F_source)
 
 
 def project_points_on_mesh(
     points: list[list[float]],
-    mesh_target: VerticesFaces,
-    normals: Optional[list[list[float]]] = None,
+    mesh: VerticesFaces,
 ) -> list[list[float]]:
-    """Project points onto mesh_target surface.
+    """Project points onto a mesh by closest perpendicular distance.
 
     Parameters
     ----------
     points : list[list[float]]
         The points to project.
-    mesh_target : :attr:`compas_cgal.types.VerticesFaces`
-        The mesh whose vertices will be projected (source points).
-    normals : list[list[float]], optional
-        The normals of the points to project.
+    mesh : :attr:`compas_cgal.types.VerticesFaces`
+        Mesh that the points are projected onto.
 
     Returns
     -------
     list[list[float]]
-        The projected points (vertices on mesh_target surface).
+        The projected points (vertices on the mesh surface).
 
     """
-    V_target, F_target = mesh_target.to_vertices_and_faces(triangulated=True)
-
-    # Convert inputs to numpy arrays
+    V_target, F_target = mesh.to_vertices_and_faces(triangulated=True)
     numpy_V_source = np.asarray(points, dtype=np.float64, order="C")
-
     numpy_V_target = np.asarray(V_target, dtype=np.float64, order="C")
     numpy_F_target = np.asarray(F_target, dtype=np.int32, order="C")
-
-    # Handle normals calculation
-    if normals:
-        # Pre-allocate numpy array for normals with correct size
-        numpy_N_source = np.zeros((len(points), 3), dtype=np.float64)
-
-        # Fill the array with vertex normals
-        for i, normal in enumerate(normals):
-            numpy_N_source[i, 0] = normal[0]
-            numpy_N_source[i, 1] = normal[1]
-            numpy_N_source[i, 2] = normal[2]
-    else:
-        # Don't use normals - create empty array
-        numpy_N_source = np.zeros((0, 0), dtype=np.float64)
-
-    # Call the C++ function
-    _meshing.project(numpy_V_target, numpy_F_target, numpy_V_source, numpy_N_source)
+    _meshing.pmp_project(numpy_V_target, numpy_F_target, numpy_V_source)
 
     return numpy_V_source
 
 
-def remesh_dual(
-    mesh: VerticesFaces,
-    length_factor: float = 1.0,
-    number_of_iterations: int = 10,
-    angle_radians: float = 0.9,
-    scale_factor: float = 1.0,
-    fixed_vertices: list[int] = [],
-) -> tuple[np.ndarray, list[list[int]]]:
-    """Create a dual mesh from a triangular mesh with variable-length faces.
+def pull_points_on_mesh(points: list[list[float]], normals: list[list[float]], mesh: VerticesFaces) -> list[list[float]]:
+    """Pull points onto a mesh surface using ray-mesh intersection along normal vectors.
 
     Parameters
     ----------
+    points : list[list[float]]
+        The points to pull.
+    normals : list[list[float]]
+        The normal vectors used for directing the projection.
     mesh : :attr:`compas_cgal.types.VerticesFaces`
-        The mesh to create a dual from.
-    angle_radians : double, optional
-        Angle limit in radians for boundary vertices to remove.
-    length_factor : double, optional
-        Length factor for remeshing.
-    number_of_iterations : int, optional
-        Number of remeshing iterations.
-    scale_factor : double, optional
-        Scale factor for inner vertices.
-    fixed_vertices : list[int], optional
-        List of vertex indices to keep fixed during remeshing.
+        Mesh that the points are pulled onto.
 
     Returns
     -------
-    tuple
-        A tuple containing:
-
-        - Remeshed mesh vertices as an Nx3 numpy array.
-        - Remeshed mesh faces as an Mx3 numpy array.
-        - Dual mesh vertices as an Nx3 numpy array.
-        - Variable-length faces as a list of lists of vertex indices.
-
-    Notes
-    -----
-    This dual mesh implementation includes proper boundary handling by:
-    1. Creating vertices at face centroids of the primal mesh
-    2. Creating additional vertices at boundary edge midpoints
-    3. Creating proper connections for boundary edges
+    list[list[float]]
+        The pulled points (vertices on the mesh surface).
 
     """
-    V, F = mesh
-    V = np.asarray(V, dtype=np.float64, order="C")
-    F = np.asarray(F, dtype=np.int32, order="C")
-    fixed_vertices = np.asarray(fixed_vertices, dtype=np.int32, order="C")
-    return _meshing.remesh_dual(V, F, fixed_vertices, length_factor, number_of_iterations, angle_radians, scale_factor)
+
+    V_target, F_target = mesh.to_vertices_and_faces(triangulated=True)
+    numpy_V_source = np.asarray(points, dtype=np.float64, order="C")
+    numpy_N_source = np.asarray(normals, dtype=np.float64, order="C")
+    numpy_V_target = np.asarray(V_target, dtype=np.float64, order="C")
+    numpy_F_target = np.asarray(F_target, dtype=np.int32, order="C")
+    _meshing.pmp_pull(numpy_V_target, numpy_F_target, numpy_V_source, numpy_N_source)
+    return numpy_V_source