feat(meshing): trimesh_remesh — protect_boundary + protect_sharp_edges_angle_deg

Expose CGAL's edge_is_constrained_map + protect_constraints for
isotropic_remeshing. Two new optional kwargs (both default-disabled,
backward-compatible):

- protect_boundary=True  → all boundary edges constrained; preserves
  boundary curves verbatim including sharp corners that the default
  smoothing pass otherwise rounds.
- protect_sharp_edges_angle_deg=>0  → also constrain interior edges
  with dihedral angle >= threshold (via PMP::detect_sharp_edges).

Pattern matches existing edge_is_constrained_map usage in
src/{isolines,geodesics,booleans}.cpp.

Author: jf---

src/compas_cgal/meshing.py

@@ -14,6 +14,8 @@ def trimesh_remesh(
     target_edge_length: float,
     number_of_iterations: int = 10,
     do_project: bool = True,
+    protect_boundary: bool = False,
+    protect_sharp_edges_angle_deg: float = 0.0,
 ) -> VerticesFacesNumpy:
     """Remeshing of a triangle mesh.
 
@@ -27,15 +29,26 @@ def trimesh_remesh(
         Number of remeshing iterations.
     do_project : bool, optional
         If True, reproject vertices onto the input surface when they are created or displaced.
+    protect_boundary : bool, optional
+        If True, constrain all boundary edges so they are NOT split, collapsed,
+        or flipped during remeshing. Use this to preserve the input mesh's
+        boundary curve verbatim — including sharp corners that the default
+        smoothing pass would otherwise round.
+    protect_sharp_edges_angle_deg : float, optional
+        Dihedral threshold in degrees for interior feature detection. Edges
+        whose adjacent faces form a dihedral angle ≥ this value are marked
+        constrained and preserved. ``0.0`` disables interior-feature
+        detection (default).
 
     Returns
     -------
     VerticesFacesNumpy
 
     Notes
     -----
-    This remeshing function only constrains the edges on the boundary of the mesh.
-    Protecting specific features or edges is not implemented yet.
+    Without ``protect_boundary`` or ``protect_sharp_edges_angle_deg`` set,
+    boundary edges follow CGAL's default remeshing behaviour: re-sampled
+    to ``target_edge_length`` (visible corner rounding is the cost).
 
     Examples
     --------
@@ -52,7 +65,15 @@ def trimesh_remesh(
     V, F = mesh
     V = np.asarray(V, dtype=np.float64, order="C")
     F = np.asarray(F, dtype=np.int32, order="C")
-    return _meshing.pmp_trimesh_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,
+        protect_boundary,
+        protect_sharp_edges_angle_deg,
+    )
 
 
 def trimesh_dual(

src/meshing.cpp

@@ -5,6 +5,7 @@
 #include <CGAL/boost/graph/Dual.h>
 #include <CGAL/boost/graph/helpers.h>
 #include <CGAL/Polygon_mesh_processing/compute_normal.h>
+#include <CGAL/Polygon_mesh_processing/detect_features.h>
 
 #include <iostream>
 #include <fstream>
@@ -43,21 +44,52 @@ pmp_trimesh_remesh(
     Eigen::Ref<const compas::RowMatrixXi> faces_a,
     double target_edge_length,
     unsigned int number_of_iterations,
-    bool do_project)
+    bool do_project,
+    bool protect_boundary,
+    double protect_sharp_edges_angle_deg)
 {
     // Convert input matrices to CGAL mesh and keep a copy for projection
     compas::Mesh original_mesh = compas::mesh_from_vertices_and_faces(vertices_a, faces_a);
     compas::Mesh mesh_a = compas::mesh_from_vertices_and_faces(vertices_a, faces_a);
 
+    // Build an edge-is-constrained property map. Edges marked True are
+    // not split / collapsed / flipped during isotropic_remeshing — this
+    // is how features are preserved.
+    auto ecm = mesh_a.add_property_map<
+        boost::graph_traits<compas::Mesh>::edge_descriptor, bool>(
+        "e:is_constrained", false).first;
+
+    // Constrain all boundary edges when requested. CGAL's
+    // isotropic_remeshing otherwise re-samples boundary edges per
+    // target_edge_length, which rounds visible corners.
+    if (protect_boundary) {
+        for (auto e : edges(mesh_a)) {
+            auto h = halfedge(e, mesh_a);
+            if (is_border(h, mesh_a) || is_border(opposite(h, mesh_a), mesh_a)) {
+                put(ecm, e, true);
+            }
+        }
+    }
+
+    // Detect sharp interior edges (dihedral > threshold) and constrain
+    // them too. 0.0 disables (default).
+    if (protect_sharp_edges_angle_deg > 0.0) {
+        CGAL::Polygon_mesh_processing::detect_sharp_edges(
+            mesh_a, protect_sharp_edges_angle_deg, ecm);
+    }
+
     // Perform isotropic remeshing
     CGAL::Polygon_mesh_processing::isotropic_remeshing(
         faces(mesh_a),
         target_edge_length,
         mesh_a,
         CGAL::Polygon_mesh_processing::parameters::number_of_iterations(number_of_iterations)
-                       .do_project(do_project));
+                       .do_project(do_project)
+                       .edge_is_constrained_map(ecm)
+                       .protect_constraints(protect_boundary
+                                            || protect_sharp_edges_angle_deg > 0.0));
+
 
-                       
     // Clean up the mesh
     mesh_a.collect_garbage();
 
@@ -888,7 +920,9 @@ NB_MODULE(_meshing, m) {
         "faces_a"_a,
         "target_edge_length"_a,
         "number_of_iterations"_a = 10,
-        "do_project"_a = true
+        "do_project"_a = true,
+        "protect_boundary"_a = false,
+        "protect_sharp_edges_angle_deg"_a = 0.0
     );
 
     m.def(

src/meshing.h

@@ -63,7 +63,9 @@ pmp_trimesh_remesh(
     Eigen::Ref<const compas::RowMatrixXi> faces_a,
     double target_edge_length,
     unsigned int number_of_iterations = 10,
-    bool do_project = true);
+    bool do_project = true,
+    bool protect_boundary = false,
+    double protect_sharp_edges_angle_deg = 0.0);
 
 
 /**