CHANGE aliases and unify_cycles.

Author: petrasvestartas

CHANGELOG.md

@@ -27,8 +27,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+* Added meshpatter unify_cycles from COMPAS, LIBIGL has only triangle BFS.
+
 ### Changed
 
+* Remove C++ aliases to minimum.
+
 ### Removed
 
 * Removed all the types_std imports from the code. Instead type casters are used: https://nanobind.readthedocs.io/en/latest/exchanging.html .

mesh_flattened.json

@@ -1,7 +1,7 @@
 #include "boundaries.hpp"
 
-compas::VectorVectorInt trimesh_boundaries( Eigen::Ref<const compas::RowMatrixXi> F) {
-    compas::VectorVectorInt L;
+std::vector<std::vector<int>> trimesh_boundaries(Eigen::Ref<const compas::RowMatrixXi> F) {
+    std::vector<std::vector<int>> L;
     igl::boundary_loop(F, L);
     return L;
 }

src/boundaries.cpp

@@ -11,4 +11,4 @@
  *
  * @note The input mesh should be manifold for correct results.
  */
- compas::VectorVectorInt trimesh_boundaries(Eigen::Ref<const compas::RowMatrixXi> F);
+ std::vector<std::vector<int>> trimesh_boundaries(Eigen::Ref<const compas::RowMatrixXi> F);

src/boundaries.hpp

@@ -15,42 +15,25 @@
 #include <tuple>
 #include <iomanip>
 
-// Nanobind includes
+// Nanobind type casters: https://nanobind.readthedocs.io/en/latest/exchanging.html
+// If you want to bind a vector on your own, do not include compas.h, it will conflict with nanobind stl bindings.
 #include <nanobind/nanobind.h>
 #include <nanobind/eigen/dense.h>
 #include <nanobind/eigen/sparse.h>
 #include <nanobind/stl/tuple.h>
 #include <nanobind/stl/vector.h>
 #include <nanobind/stl/string.h>
-
+ 
+// Avoid any alias via using, unless really needed:
 namespace nb = nanobind;
-
 using namespace nb::literals;
 
-// Nanobind type casters: https://nanobind.readthedocs.io/en/latest/exchanging.html
-
 namespace compas {
-    // Basic Eigen types with clear naming
+    // Row-major matrix types for better interoperability with Python numpy arrays
     using RowMatrixXd = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
     using RowMatrixXi = Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-    using VectorXi = Eigen::VectorXi;
-    using VectorXd = Eigen::VectorXd;
-    
-    // STL containers with descriptive names
-    using VectorInt = std::vector<int>;
-    using VectorFloat = std::vector<float>;
-    using VectorBool = std::vector<bool>;
-    using VectorVectorInt = std::vector<VectorInt>;
-    
-    // Complex types with descriptive names
-    using TupleIntFloatFloatFloat = std::tuple<int, float, float, float>;  // face_id, u, v, t
-    using VectorTupleIntFloatFloatFloat = std::vector<TupleIntFloatFloatFloat>;
-    using VectorVectorTupleIntFloatFloatFloat = std::vector<VectorTupleIntFloatFloatFloat>;
 
-    // Tuple types with descriptive names
-    using IsolinesResult = std::tuple<RowMatrixXd, RowMatrixXi, RowMatrixXi>;  // vertices, edges, indices
-    using RemeshIsolineResult = std::tuple<RowMatrixXd, RowMatrixXi, VectorXi>;  // vertices, faces, labels
-    using RemeshIsolinesResult = std::tuple<RowMatrixXd, RowMatrixXi, VectorXd, VectorXi>;  // vertices, faces, scalar_values, face_groups
-    using PrincipalCurvatureResult = std::tuple<RowMatrixXd, RowMatrixXd, VectorXd, VectorXd>;  // PD1, PD2, PV1, PV2
-    using MeshMapResult = std::tuple<RowMatrixXd, VectorVectorInt, RowMatrixXd, VectorBool, VectorInt>;  // pattern_vertices, pattern_faces, pattern_normals, is_boundary, groups
+    // Vector types that maintain row-major storage for consistency
+    using RowVectorXd = Eigen::Matrix<double, 1, Eigen::Dynamic, Eigen::RowMajor>;
+    using RowVectorXi = Eigen::Matrix<int, 1, Eigen::Dynamic, Eigen::RowMajor>;
 }

src/compas.hpp

@@ -2,4 +2,4 @@
 __copyright__ = "Block Research Group - ETH Zurich"
 __license__ = "Mozilla Public License Version 2.0"
 __email__ = "[email protected], [email protected]"
-__version__ = "0.7.3"
+__version__ = "0.7.2"

src/compas_libigl/__init__.py

@@ -44,7 +44,7 @@
 }
 
 
-def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=True, fixed_vertices=None, tolerance=1e-6):
+def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=True, fixed_vertices=None, tolerance=1e-6, unify_cycles=True):
     """
     Map a 2D pattern mesh onto a 3D target.
 
@@ -66,17 +66,20 @@ def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=T
     tolerance : float, optional
         The tolerance for point comparison, to remove duplicates.
         Default is 1e-6.
+    unify_cycles : bool, optional
+        Whether to unify cycles of the pattern mesh.
+        Default is True.
 
     Returns
     -------
-    tuple[ndarray, VectorVectorInt, ndarray, VectorBool, VectorInt]
+    tuple[np.array, list[list[int]], np.array, list[bool], list[int]]
         A tuple containing:
 
-        * vertices: ndarray - The 3D coordinates of the mapped mesh vertices
-        * faces: VectorVectorInt - The faces of the mapped mesh
-        * normals: ndarray - The normal vectors at each vertex
-        * boundary_flags: VectorBool - Boolean flags indicating if vertices are on the boundary
-        * polygon_groups: VectorInt - Grouping indices for polygons (to form holes)
+        * vertices: np.array - The 3D coordinates of the mapped mesh vertices
+        * faces: list[list[int]] - The faces of the mapped mesh
+        * normals: np.array - The normal vectors at each vertex
+        * boundary_flags: list[bool] - Boolean flags indicating if vertices are on the boundary
+        * polygon_groups: list[int] - Grouping indices for polygons (to form holes)
     """
     # Unpack mesh tuples
     v, f = target_mesh
@@ -106,11 +109,17 @@ def map_mesh(target_mesh, pattern_mesh, clip_boundaries=True, simplify_borders=T
         v_numpy, f_numpy, pattern_v_numpy, pattern_f_vec, clip_boundaries, simplify_borders, fixed_vertices_vectorint, tolerance
     )
 
+    # LIBIGL has no BFS orienting for polygons, only triangles, so we copy here data several times:
+    if unify_cycles:
+        mesh = Mesh.from_vertices_and_faces(pv_numpy_copy, pf_numpy_cleaned)
+        mesh.unify_cycles()
+        pv_numpy_copy, pf_numpy_cleaned = mesh.to_vertices_and_faces()
+
     # 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, fixed_vertices=None):
+def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, pattern_u=16, pattern_v=16, simplify_borders=True, fixed_vertices=None, unify_cycles=True):
     """
     Map a 2D pattern mesh onto a 3D target.
 
@@ -158,7 +167,9 @@ def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, patter
     fixed_vertices : list[list[float]], optional
         A list of fixed points on the target mesh.
         Default is None.
-
+    unify_cycles : bool, optional
+        Whether to unify cycles of the pattern mesh.
+        Default is True.
     Returns
     -------
     compas.datastructures.Mesh
@@ -195,7 +206,7 @@ def map_pattern_to_mesh(name, mesh, clip_boundaries=True, tolerance=1e-6, patter
 
     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, fixed_vertices=fixed_vertices, tolerance=tolerance
+        (v, f), (pv, pf), clip_boundaries=clip_boundaries, simplify_borders=simplify_borders, fixed_vertices=fixed_vertices, tolerance=tolerance, unify_cycles=unify_cycles
     )
 
     return Mesh.from_vertices_and_faces(mapped_vertices, mapped_faces)

src/compas_libigl/mapping.py

@@ -1,24 +1,27 @@
 #include "curvature.hpp"
 
 
-compas::PrincipalCurvatureResult
+std::tuple<compas::RowMatrixXd, 
+         compas::RowMatrixXd, 
+         Eigen::VectorXd, 
+         Eigen::VectorXd>
 trimesh_principal_curvature(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F,
     int radius
 ) {
     compas::RowMatrixXd PD1, PD2;
-    compas::VectorXd PV1, PV2;
+    Eigen::VectorXd PV1, PV2;
     igl::principal_curvature(V, F, PD1, PD2, PV1, PV2, radius);
     return std::make_tuple(PD1, PD2, PV1, PV2);
 }
 
-compas::VectorXd
+Eigen::VectorXd
 trimesh_gaussian_curvature(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F
 ) {
-    compas::VectorXd K;
+    Eigen::VectorXd K;
     igl::gaussian_curvature(V, F, K);
     return K;
 }

src/curvature.cpp

@@ -12,7 +12,7 @@
  * @param F The face matrix of the triangle mesh (m x 3).
  * @return A vector of gaussian curvature values per vertex.
  */
-compas::VectorXd trimesh_gaussian_curvature(
+Eigen::VectorXd trimesh_gaussian_curvature(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F
 );
@@ -29,7 +29,10 @@ compas::VectorXd trimesh_gaussian_curvature(
  *         - PV1: principal curvature 1 per vertex (n x 1)
  *         - PV2: principal curvature 2 per vertex (n x 1)
  */
-compas::PrincipalCurvatureResult
+std::tuple<compas::RowMatrixXd, 
+         compas::RowMatrixXd, 
+         Eigen::VectorXd, 
+         Eigen::VectorXd>
 trimesh_principal_curvature(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F,

src/curvature.hpp

@@ -1,13 +1,13 @@
 #include "geodistance.hpp"
 
 // Main entry points
-compas::VectorXd trimesh_geodistance(
+Eigen::VectorXd trimesh_geodistance(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F,
     int source,
     const std::string& method
 ) {
-    compas::VectorXi sources(1);
+    Eigen::VectorXi sources(1);
     sources << source;
 
     if (method == "exact") {
@@ -19,10 +19,10 @@ compas::VectorXd trimesh_geodistance(
     throw std::runtime_error("Unknown method: " + method);
 }
 
-compas::VectorXd trimesh_geodistance_multiple(
+Eigen::VectorXd trimesh_geodistance_multiple(
     Eigen::Ref<const compas::RowMatrixXd> V,
     Eigen::Ref<const compas::RowMatrixXi> F,
-    Eigen::Ref<const compas::VectorXi> sources,
+    Eigen::Ref<const Eigen::VectorXi> sources,
     const std::string& method
 ) {
     if (sources.size() == 0) {
@@ -57,13 +57,13 @@ compas::VectorXd trimesh_geodistance_multiple(
 }
 
 // Implementation details
-compas::VectorXd trimesh_geodistance_exact(
+Eigen::VectorXd trimesh_geodistance_exact(
     const compas::RowMatrixXd& V,
     const compas::RowMatrixXi& F,
     int vid)
 {
-    compas::VectorXd D;
-    compas::VectorXi VS, FS, VT, FT;
+    Eigen::VectorXd D;
+    Eigen::VectorXi VS, FS, VT, FT;
 
     VS.resize(1);
     VS << vid;
@@ -75,12 +75,12 @@ compas::VectorXd trimesh_geodistance_exact(
     return D;
 }
 
-compas::VectorXd trimesh_geodistance_heat(
+Eigen::VectorXd trimesh_geodistance_heat(
     const compas::RowMatrixXd& V,
     const compas::RowMatrixXi& F,
     int vid)
 {
-    compas::VectorXi gamma;
+    Eigen::VectorXi gamma;
     gamma.resize(1);
     gamma << vid;