Update validation routines

python/ncollpyde/__init__.py

@@ -11,12 +11,12 @@
 from .main import INDEX  # noqa: F401
 from .main import N_CPUS  # noqa: F401
 from .main import PRECISION  # noqa: F401
-from .main import Volume  # noqa: F401
+from .main import Volume, Validation
 from .main import configure_threadpool  # noqa: F401
 from ._ncollpyde import n_threads  # noqa: F401
 from ._ncollpyde import _version
 
 __version__ = _version()
 __version_info__ = tuple(int(n) for n in __version__.split("-")[0].split("."))
 
-__all__ = ["Volume"]
+__all__ = ["Volume", "Validation"]

python/ncollpyde/_ncollpyde.pyi

@@ -14,7 +14,12 @@ Indices = npt.NDArray[np.uint32]
 
 class TriMeshWrapper:
     def __init__(
-        self, points: Points, indices: Indices, n_rays: int, ray_seed: int
+        self,
+        points: Points,
+        indices: Indices,
+        n_rays: int,
+        ray_seed: int,
+        validate: int,
     ): ...
     def contains(
         self, points: Points, n_rays: int, consensus: int, parallel: bool

python/ncollpyde/main.py

@@ -3,6 +3,7 @@
 import warnings
 from multiprocessing import cpu_count
 from typing import TYPE_CHECKING, Optional, Tuple, Union, List
+from enum import IntFlag, auto
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -29,6 +30,41 @@
 INDEX = np.dtype(_index())
 
 
+class Validation(IntFlag):
+    """Enum representing the different validations which can be applied.
+
+    Combine with `|`.
+    Must contain ORIENTED (see `Validation.minimum()`).
+    """
+    HALF_EDGE_TOPOLOGY = 1
+    CONNECTED_COMPONENTS = 2
+    DELETE_BAD_TOPOLOGY_TRIANGLES = 4
+    ORIENTED = 8
+    MERGE_DUPLICATE_VERTICES = 16
+    MERGE_DEGENERATE_TRIANGLES = 32
+    MERGE_DUPLICATE_TRIANGLES = 64
+
+    @classmethod
+    def minimum(cls):
+        return cls.ORIENTED
+
+    @classmethod
+    def default(cls):
+        return cls.all()
+
+    @classmethod
+    def all(cls):
+        return (
+            cls.HALF_EDGE_TOPOLOGY
+            | cls.CONNECTED_COMPONENTS
+            | cls.DELETE_BAD_TOPOLOGY_TRIANGLES
+            | cls.ORIENTED
+            | cls.MERGE_DUPLICATE_VERTICES
+            | cls.MERGE_DEGENERATE_TRIANGLES
+            | cls.MERGE_DUPLICATE_TRIANGLES
+        )
+
+
 def configure_threadpool(n_threads: Optional[int], name_prefix: Optional[str]):
     """Configure the thread pool used for parallelisation.
 
@@ -85,7 +121,7 @@ def __init__(
         self,
         vertices: ArrayLike,
         triangles: ArrayLike,
-        validate=False,
+        validate: Validation = Validation.default(),
         threads: Optional[bool] = None,
         n_rays=DEFAULT_RAYS,
         ray_seed=DEFAULT_SEED,
@@ -114,10 +150,24 @@ def __init__(
         """
         vert = np.asarray(vertices, self.dtype)
         if len(vert) > np.iinfo(INDEX).max:
-            raise ValueError(f"Cannot represent {len(vert)} vertices with {INDEX}")
+            raise ValueError(
+                f"Cannot represent {len(vert)} vertices with {INDEX}"
+            )
         tri = np.asarray(triangles, INDEX)
-        if validate:
-            vert, tri = self._validate(vert, tri)
+        if isinstance(validate, bool):
+            warnings.warn(
+                "`validate: bool` should be replaced by a Validation enum "
+                "controlling validation by this library. "
+                "The previous behaviour of validating using the "
+                "external trimesh library may be removed in future.",
+                DeprecationWarning,
+            )
+            if validate:
+                vert, tri = self._validate(vert, tri)
+                validate = Validation.all()
+            else:
+                validate = Validation.minimum()
+
         self.threads = self._interpret_threads(threads)
         if ray_seed is None:
             logger.warning(
@@ -129,7 +179,7 @@ def __init__(
         self.n_rays = int(n_rays)
         inner_rays = 0 if self.n_rays < 0 else self.n_rays
 
-        self._impl = TriMeshWrapper(vert, tri, inner_rays, ray_seed)
+        self._impl = TriMeshWrapper(vert, tri, inner_rays, ray_seed, validate)
 
     def _validate(
         self, vertices: np.ndarray, triangles: np.ndarray
@@ -358,7 +408,7 @@ def intersections(
     def from_meshio(
         cls,
         mesh: "meshio.Mesh",
-        validate=False,
+        validate: Validation = Validation.default(),
         threads=None,
         n_rays=DEFAULT_RAYS,
         ray_seed=DEFAULT_SEED,
@@ -367,7 +417,7 @@ def from_meshio(
         Convenience function for instantiating a Volume from a meshio Mesh.
 
         :param mesh: meshio Mesh whose only cells are triangles.
-        :param validate: as passed to ``__init__``, defaults to False
+        :param validate: as passed to ``__init__``, defaults to Validation.default()
         :param threads: as passed to ``__init__``, defaults to None
         :param n_rays: as passed to ``__init__``, defaults to 3
         :param ray_seed: as passed to ``__init__``, defaults to None (random)

src/interface.rs

@@ -4,7 +4,7 @@ use ndarray::{Array2, ArrayView1};
 use numpy::ndarray::{Array, Zip};
 use numpy::{IntoPyArray, PyArray1, PyArray2, PyReadonlyArray2};
 use parry3d_f64::math::{Point, Vector};
-use parry3d_f64::shape::TriMesh;
+use parry3d_f64::shape::{TriMesh, TriMeshFlags};
 use pyo3::exceptions::{PyRuntimeError, PyValueError};
 use pyo3::prelude::*;
 use rand::SeedableRng;
@@ -13,7 +13,7 @@ use rayon::{prelude::*, ThreadPoolBuilder};
 
 use crate::utils::{
     aabb_diag, dist_from_mesh, mesh_contains_point, mesh_contains_point_oriented,
-    points_cross_mesh, random_dir, sdf_inner, Precision, FLAGS,
+    points_cross_mesh, random_dir, sdf_inner, Precision,
 };
 
 // fn vec_to_point<T: 'static + Debug + PartialEq + Copy>(v: Vec<T>) -> Point<T> {
@@ -38,6 +38,7 @@ impl TriMeshWrapper {
         indices: PyReadonlyArray2<u32>,
         n_rays: usize,
         ray_seed: u64,
+        validate: u8,
     ) -> PyResult<Self> {
         let points2 = points
             .as_array()
@@ -53,7 +54,14 @@ impl TriMeshWrapper {
             .collect();
         let mut mesh = TriMesh::new(points2, indices2);
 
-        mesh.set_flags(FLAGS)
+        let flags = TriMeshFlags::from_bits(validate)
+            .ok_or(PyValueError::new_err("Invalid `validate` enum"))?;
+        if !flags.contains(TriMeshFlags::ORIENTED) {
+            return Err(PyValueError::new_err(
+                "`validate` enum must contain ORIENTED",
+            ));
+        }
+        mesh.set_flags(flags)
             .map_err(|e| PyValueError::new_err(format!("Invalid mesh topology: {e}")))?;
 
         if n_rays > 0 {

tests/conftest.py

@@ -3,7 +3,7 @@
 import meshio
 import pytest
 
-from ncollpyde import Volume
+from ncollpyde import Volume, Validation
 
 test_dir = Path(__file__).resolve().parent
 project_dir = test_dir.parent
@@ -17,7 +17,7 @@ def mesh():
 
 @pytest.fixture
 def volume(mesh):
-    return Volume.from_meshio(mesh, validate=True)
+    return Volume.from_meshio(mesh, validate=Validation.all())
 
 
 @pytest.fixture
@@ -27,11 +27,11 @@ def simple_mesh():
 
 @pytest.fixture
 def simple_volume(simple_mesh):
-    return Volume.from_meshio(simple_mesh, validate=True)
+    return Volume.from_meshio(simple_mesh, validate=Validation.all())
 
 
 @pytest.fixture
 def sez_right():
     return Volume.from_meshio(
-        meshio.read(str(mesh_dir / "SEZ_right.stl")), validate=True
+        meshio.read(str(mesh_dir / "SEZ_right.stl")), validate=Validation.all()
     )

tests/test_ncollpyde.py

@@ -57,44 +57,44 @@ def test_contains_results(volume: Volume):
     assert np.allclose(ray, psnorms)
 
 
-def test_no_validation(mesh):
-    triangles = mesh.cells_dict["triangle"]
-    Volume(mesh.points, triangles, True)
+# def test_no_validation(mesh):
+#     triangles = mesh.cells_dict["triangle"]
+#     Volume(mesh.points, triangles, True)
 
 
-@pytest.mark.skipif(not trimesh, reason="Requires trimesh")
-def test_can_repair_hole(mesh):
-    triangles = mesh.cells_dict["triangle"]
-    triangles = triangles[:-1]
-    Volume(mesh.points, triangles, True)
+# @pytest.mark.skipif(not trimesh, reason="Requires trimesh")
+# def test_can_repair_hole(mesh):
+#     triangles = mesh.cells_dict["triangle"]
+#     triangles = triangles[:-1]
+#     Volume(mesh.points, triangles, True)
 
 
-@pytest.mark.skipif(not trimesh, reason="Requires trimesh")
-def test_can_repair_inversion(mesh):
-    triangles = mesh.cells_dict["triangle"]
-    triangles[-1] = triangles[-1, ::-1]
-    Volume(mesh.points, triangles, True)
+# @pytest.mark.skipif(not trimesh, reason="Requires trimesh")
+# def test_can_repair_inversion(mesh):
+#     triangles = mesh.cells_dict["triangle"]
+#     triangles[-1] = triangles[-1, ::-1]
+#     Volume(mesh.points, triangles, True)
 
 
-@pytest.mark.skipif(not trimesh, reason="Requires trimesh")
-def test_can_repair_inversions(mesh):
-    triangles = mesh.cells_dict["triangle"]
-    triangles = triangles[:, ::-1]
-    Volume(mesh.points, triangles, True)
+# @pytest.mark.skipif(not trimesh, reason="Requires trimesh")
+# def test_can_repair_inversions(mesh):
+#     triangles = mesh.cells_dict["triangle"]
+#     triangles = triangles[:, ::-1]
+#     Volume(mesh.points, triangles, True)
 
 
-@pytest.mark.skipif(not trimesh, reason="Requires trimesh")
-def test_inversions_repaired(simple_mesh):
-    center = [0.5, 0.5, 0.5]
+# @pytest.mark.skipif(not trimesh, reason="Requires trimesh")
+# def test_inversions_repaired(simple_mesh):
+#     center = [0.5, 0.5, 0.5]
 
-    orig_points = simple_mesh.points
-    orig_triangles = simple_mesh.cells_dict["triangle"]
-    assert center in Volume(orig_points, orig_triangles)
+#     orig_points = simple_mesh.points
+#     orig_triangles = simple_mesh.cells_dict["triangle"]
+#     assert center in Volume(orig_points, orig_triangles)
 
-    inv_triangles = orig_triangles[:, ::-1]
-    assert center not in Volume(orig_points, inv_triangles)
+#     inv_triangles = orig_triangles[:, ::-1]
+#     assert center not in Volume(orig_points, inv_triangles)
 
-    assert center in Volume(orig_points, inv_triangles, validate=True)
+#     assert center in Volume(orig_points, inv_triangles, validate=True)
 
 
 def test_points(mesh):