Merge pull request #20 from Loop3D/fix/speed-up

fix: add direct calls to geometry attributes e.g. area, points

Author: lachlangrose

loop_cgal/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 from typing import Tuple
 
 import numpy as np
@@ -20,12 +21,20 @@ class TriMesh(_TriMesh):
     Inherits from the base TriMesh class and provides additional functionality.
     """
 
-    def __init__(self, surface: pv.PolyData):
+    def __init__(self, surface):
+        if isinstance(surface, _TriMesh):
+            # Copy-construct directly from another TriMesh at the C++ level.
+            # This is used by read_from_file and anywhere a TriMesh-to-TriMesh
+            # copy is needed without a pyvista round-trip.
+            super().__init__(surface)
+            return
+
         # Validate input surface
         validate_pyvista_polydata(surface, "input surface")
 
         # Triangulate to ensure we have triangular faces
-        surface = surface.triangulate()
+        if not surface.is_all_triangles:
+            surface = surface.triangulate()
 
         # Extract vertices and triangles
         verts = np.array(surface.points, dtype=np.float64).copy()
@@ -34,6 +43,7 @@ def __init__(self, surface: pv.PolyData):
             raise ValueError("Invalid surface geometry")
 
         super().__init__(verts, faces)
+
     @classmethod
     def from_vertices_and_triangles(
         cls, vertices: np.ndarray, triangles: np.ndarray
@@ -56,7 +66,10 @@ def from_vertices_and_triangles(
         # Create a temporary PyVista PolyData object for validation
         if not validate_vertices_and_faces(vertices, triangles):
             raise ValueError("Invalid vertices or triangles")
-        surface = pv.PolyData(vertices, np.hstack((np.full((triangles.shape[0], 1), 3), triangles)).flatten())
+        surface = pv.PolyData(
+            vertices,
+            np.hstack((np.full((triangles.shape[0], 1), 3), triangles)).flatten(),
+        )
         return cls(surface)
 
     def get_vertices_and_triangles(
@@ -107,13 +120,62 @@ def vtk(
         """
         return self.to_pyvista(area_threshold, duplicate_vertex_threshold)
 
-    def copy(self) -> TriMesh:
+    @property
+    def area(self) -> float:
+        """Surface area computed directly from the CGAL mesh (no pyvista conversion)."""
+        return self._cgal_area()
+
+    @property
+    def points(self) -> np.ndarray:
+        """Vertex coordinates as (n, 3) numpy array (no pyvista conversion)."""
+        return self._cgal_points()
+
+    @property
+    def n_cells(self) -> int:
+        """Number of faces in the CGAL mesh (no pyvista conversion)."""
+        return self._cgal_n_faces()
+
+    @property
+    def n_points(self) -> int:
+        """Number of vertices in the CGAL mesh (no pyvista conversion)."""
+        return self._cgal_n_vertices()
+
+    @classmethod
+    def read_from_file(cls, path: str) -> "TriMesh":
+        """Read a mesh from a binary file written by :meth:`write_to_file`.
+
+        Bypasses the pyvista/VTK stack entirely — much faster for temp files
+        passed between CGAL operations.
         """
-        Create a copy of the TriMesh.
+        return cls(_TriMesh._read_from_file(path))
+
+    def clone(self) -> TriMesh:
+        """
+        Return a deep copy of this TriMesh as a Python ``TriMesh`` instance.
+
+        Uses the C++ copy-constructor binding to clone the CGAL mesh directly,
+        with no numpy array roundtrip.
+        """
+        return TriMesh(self)
+
+    def copy(self, deep: bool = True) -> TriMesh:
+        """
+        Return a deep copy of this TriMesh.
+
+        Uses the C++-level ``clone()`` to copy the CGAL mesh directly without
+        a pyvista round-trip, preserving all vertices, faces, and fixed edges.
 
         Returns
         -------
         TriMesh
-            A copy of the TriMesh object.
+            A deep copy of this TriMesh.
         """
-        return TriMesh(self.to_pyvista())
+        return self.clone()
+
+    def __copy__(self) -> TriMesh:
+        return self.clone()
+
+    def __deepcopy__(self, memo: dict) -> TriMesh:
+        result = self.clone()
+        memo[id(self)] = result
+        return result

loop_cgal/bindings.cpp

@@ -22,6 +22,15 @@ PYBIND11_MODULE(_loop_cgal, m)
      py::class_<TriMesh>(m, "TriMesh")
          .def(py::init<const pybind11::array_t<double> &, const pybind11::array_t<int> &>(),
               py::arg("vertices"), py::arg("triangles"))
+         .def(py::init([](const TriMesh& other) { return other.clone(); }),
+              py::arg("other"),
+              "Copy-construct a TriMesh as a deep clone of another (no array roundtrip).")
+         .def("clip_with_plane", &TriMesh::clipWithPlane,
+              py::arg("a"), py::arg("b"), py::arg("c"), py::arg("d"),
+              py::arg("use_exact_kernel") = true,
+              "Clip the mesh with the halfspace ax+by+cz+d <= 0. "
+              "Uses PMP::clip(mesh, Plane_3) directly — no corefinement, no skirt construction. "
+              "Returns the number of faces removed (0 = no-op).")
          .def("cut_with_surface", &TriMesh::cutWithSurface, py::arg("surface"),
               py::arg("preserve_intersection") = false,
               py::arg("preserve_intersection_clipper") = false,
@@ -42,6 +51,21 @@ PYBIND11_MODULE(_loop_cgal, m)
               "Vertex index pairs defining edges to be fixed in mesh when remeshing.")
          .def("cut_with_implicit_function", &TriMesh::cut_with_implicit_function,
               py::arg("property"), py::arg("value"),py::arg("cutmode") = ImplicitCutMode::KEEP_POSITIVE_SIDE,
-              "Cut the mesh with an implicit function defined by vertex properties.");
+              "Cut the mesh with an implicit function defined by vertex properties.")
+         .def("_cgal_area", &TriMesh::area, "Surface area computed directly from CGAL mesh.")
+         .def("_cgal_n_faces", &TriMesh::n_faces, "Number of faces in the CGAL mesh.")
+         .def("_cgal_n_vertices", &TriMesh::n_vertices, "Number of vertices in the CGAL mesh.")
+         .def("_cgal_points", &TriMesh::get_points, "Vertex coordinates as (n, 3) numpy array.")
+         .def("overlaps", &TriMesh::overlaps, py::arg("other"), py::arg("bbox_tol") = 1e-6,
+              "Return True if this mesh intersects another TriMesh (AABB fast-reject + triangle-level check).")
+         .def("clone", &TriMesh::clone,
+              "Return a deep copy of this TriMesh at the C++ level (no pyvista round-trip). "
+              "Preserves the full fixed-edge set including any user-added edges.")
+         .def("write_to_file", &TriMesh::write_to_file, py::arg("path"),
+              "Write the mesh to a compact binary file (LCMESH format). "
+              "Much faster than converting to pyvista and saving as VTK.")
+         .def_static("_read_from_file", &TriMesh::read_from_file, py::arg("path"),
+              "Read a mesh from a binary file written by write_to_file. "
+              "Returns a _TriMesh — use TriMesh.read_from_file() from Python instead.");
 
 } // End of PYBIND11_MODULE

loop_cgal/utils.py

@@ -1,6 +1,8 @@
 import pyvista as pv
 import numpy as np
 import scipy.sparse as sp
+
+
 def validate_pyvista_polydata(
     surface: pv.PolyData, surface_name: str = "surface"
 ) -> None:
@@ -80,19 +82,10 @@ def validate_vertices_and_faces(verts, faces):
     # build a ntris x nverts matrix
     # populate with true for vertex in each triangle
     # sum rows and if not equal to 3 then it is degenerate
-    face_idx = np.arange(faces.shape[0])
-    face_idx = np.tile(face_idx, (3, 1)).T.flatten()
-    faces_flat = faces.flatten()
-    m = sp.coo_matrix(
-        (np.ones(faces_flat.shape[0]), (faces_flat, face_idx)),
-        shape=(verts.shape[0], faces.shape[0]),
-        dtype=bool,
-    )
-    # coo duplicates entries so just make sure its boolean
-    m = m > 0
-    if not np.all(m.sum(axis=0) == 3):
-        degen_idx = np.where(m.sum(axis=0) != 3)[1]
+    a, b, c = faces[:, 0], faces[:, 1], faces[:, 2]
+    if np.any((a == b) | (b == c) | (a == c)):
+        degen_idx = np.where((a == b) | (b == c) | (a == c))
         raise ValueError(
             f"Surface contains degenerate triangles: {degen_idx} (each triangle must have exactly 3 vertices)"
         )
-    return True
+    return True