engeom 0.2.6__tar.gz → 0.2.8__tar.gz

{engeom-0.2.6 → engeom-0.2.8}/Cargo.lock

@@ -831,9 +831,9 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.23.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78"
+checksum = "a7cfbf3f0feededcaa4d289fe3079b03659e85c5b5a177f4ba6fb01ab4fb3e39"
 dependencies = [
  "libc",
  "ndarray",
@@ -841,6 +841,7 @@ dependencies = [
  "num-integer",
  "num-traits",
  "pyo3",
+ "pyo3-build-config",
  "rustc-hash",
 ]
 
@@ -1024,7 +1025,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
  "engeom",
  "numpy",
@@ -1049,9 +1050,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
+checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -1067,9 +1068,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
+checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -1077,9 +1078,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
+checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1087,9 +1088,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
+checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1099,9 +1100,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
+checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1446,9 +1447,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "thiserror"

{engeom-0.2.6 → engeom-0.2.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "py-engeom"
-version = "0.2.6"
+version = "0.2.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,10 +9,10 @@ name = "engeom"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version= "0.23.3" , features=["abi3-py38", "extension-module"]}
+pyo3 = { version= "0.24.1", features=["abi3-py38", "extension-module"]}
 engeom = { path = "./engeom", features = ["stl"]}
 parry3d-f64 = {version= "0.18.0", features=["serde-serialize"]}
 parry2d-f64 = {version= "0.18.0", features=["serde-serialize"]}
-numpy = "0.23.0"
+numpy = "0.24.0"
 rand = "0.9.0"
 

{engeom-0.2.6 → engeom-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engeom
-Version: 0.2.6
+Version: 0.2.8
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{engeom-0.2.6 → engeom-0.2.8}/engeom/src/lib.rs

@@ -10,6 +10,7 @@ pub mod io;
 pub mod metrology;
 pub mod stats;
 pub mod utility;
+pub mod raster3;
 
 pub type Result<T> = std::result::Result<T, Box<dyn Error>>;
 

engeom-0.2.8/engeom/src/raster3.rs

@@ -0,0 +1,60 @@
+//! This module contains tools for working with 3D voxel grids.
+
+
+use std::collections::HashSet;
+
+
+/// This function takes a set of coordinates in a 3D grid and returns a list of clusters of
+/// connected voxel coordinates.
+///
+/// # Arguments
+///
+/// * `indices`:
+///
+/// returns: Vec<Vec<(u32, u32, u32), Global>, Global>
+///
+/// # Examples
+///
+/// ```
+///
+/// ```
+pub fn clusters_from_sparse(mut indices: HashSet<(i32, i32, i32)>) -> Vec<Vec<(i32, i32, i32)>> {
+    let mut results = Vec::new();
+
+    while !indices.is_empty() {
+        let mut working = Vec::new();
+        let mut to_visit = Vec::new();
+
+        to_visit.push(pop_index(&mut indices));
+
+        while !to_visit.is_empty() {
+            let current = to_visit.pop().unwrap();
+            working.push(current);
+
+            for x in -1..=1 {
+                for y in -1..=1 {
+                    for z in -1..=1 {
+                        if x == 0 && y == 0 && z == 0 {
+                            continue;
+                        }
+
+                        let neighbor = (current.0 + x, current.1 + y, current.2 + z);
+                        if indices.remove(&neighbor) {
+                            to_visit.push(neighbor);
+                        }
+                    }
+                }
+            }
+        }
+
+        results.push(working.into_iter().collect());
+    }
+
+    results
+}
+
+fn pop_index(indices: &mut HashSet<(i32, i32, i32)>) -> (i32, i32, i32) {
+    let result = indices.iter().next().unwrap().clone();
+    indices.remove(&result);
+    result
+}

{engeom-0.2.6 → engeom-0.2.8}/python/engeom/_plot/pyvista.py

@@ -176,19 +176,48 @@ else:
                 bold=False,
             )
 
-        def coordinate_frame(self, iso: Iso3, size: float = 1.0):
+        def coordinate_frame(self, iso, size: float = 1.0, line_width=3.0, label: str | None = None,
+                             label_size: int = 12):
             """
             Add a coordinate frame to the plotter.  This will appear as three lines, with X in red, Y in green,
             and Z in blue.  The length of each line is determined by the `size` parameter.
-            :param iso: The isometry to use as the origin and orientation of the coordinate frame.
+            :param iso: The isometry to use as the origin and orientation of the coordinate frame. May be an `Iso3`, a
+            4x4 `numpy.ndarray` that validly converts into an `Iso3`, or anything with an `as_numpy` method that
+            returns a valid 4x4 `numpy.ndarray`.
             :param size: The length of each line in the coordinate frame.
+            :param line_width: The width of the lines in the coordinate frame.
+            :param label: An optional label to display at the origin of the coordinate frame.
+            :param label_size: The size of the label text.
             """
+            if not isinstance(iso, Iso3):
+                if hasattr(iso, "as_numpy"):
+                    iso = iso.as_numpy()
+
+                if isinstance(iso, numpy.ndarray):
+                    if iso.shape == (4, 4):
+                        iso = Iso3(iso)
+                    else:
+                        raise ValueError("Invalid shape for iso: expected (4, 4), got {iso.shape}")
+                else:
+                    raise TypeError("Invalid type for iso: expected Iso3 or numpy.ndarray, got {type(iso)}")
+
             points = numpy.array([[0, 0, 0], [size, 0, 0], [0, size, 0], [0, 0, size]], dtype=numpy.float64)
             points = iso.transform_points(points)
 
-            self.plotter.add_lines(points[[0, 1]], color="red", width=5.0)
-            self.plotter.add_lines(points[[0, 2]], color="green", width=5.0)
-            self.plotter.add_lines(points[[0, 3]], color="blue", width=5.0)
+            self.plotter.add_lines(points[[0, 1]], color="red", width=line_width)
+            self.plotter.add_lines(points[[0, 2]], color="green", width=line_width)
+            self.plotter.add_lines(points[[0, 3]], color="blue", width=line_width)
+
+            if label:
+                self.plotter.add_point_labels(
+                    [points[0]],
+                    [label],
+                    show_points=False,
+                    background_color="white",
+                    font_family="courier",
+                    font_size=label_size,
+                    bold=False,
+                )
 
         def label(self, point: PlotCoords, text: str, **kwargs):
             """

{engeom-0.2.6 → engeom-0.2.8}/python/engeom/geom3.pyi

@@ -1282,3 +1282,29 @@ class Aabb3:
         :return: a new AABB object with the shrunk bounds.
         """
         ...
+
+
+class RayBundle3:
+    """
+    A class representing a bundle of rays in 3D space. The rays are represented by a set of origins and directions,
+    which are used to define the rays.
+
+    This class is used for ray tracing operations, such as intersection tests with meshes or other geometric objects.
+    """
+
+    def __init__(self, array: NDArray[float]):
+        """
+        Create a ray bundle from a numpy array of shape (n, 6) containing the origins and directions of the rays.
+        :param array: a numpy array of shape (n, 6) containing the origins and directions of the rays.
+        """
+        ...
+
+    def intersect_mesh(self, mesh: Mesh, iso: Iso3 | None = None, angle: float | None = None) -> NDArray[float]:
+        """
+
+        :param angle:
+        :param mesh:
+        :param iso:
+        :return:
+        """
+        ...

engeom-0.2.8/python/engeom/raster3/__init__.py

@@ -0,0 +1,9 @@
+"""
+This module provides a number of classes and functions for working with 3D raster (voxel) data.
+"""
+
+from ..engeom import _raster3
+
+# Global import of all functions
+for name in [n for n in dir(_raster3) if not n.startswith("_")]:
+    globals()[name] = getattr(_raster3, name)

engeom-0.2.8/python/engeom/raster3.pyi

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import List
+
+from numpy.typing import NDArray
+
+def clusters_from_sparse(indices: NDArray[int]) -> List[NDArray[int]]:
+    """
+    Find clusters of connected voxel indices from a sparse array of voxel coordinates. The input array should be a Nx3
+    array of integer voxel indices. The output is a list of arrays, where each array contains the indices of a single
+    cluster of connected voxels.
+
+    The connectivity is defined as 26-connectivity, i.e. each voxel is connected to all neighbors with which it shares
+    at least one corner.
+
+    :param indices: Nx3 array of voxel indices
+    :return: List of arrays, each containing a Mx3 numpy array of the indices of a single cluster of connected voxels
+    """
+    ...

{engeom-0.2.6 → engeom-0.2.8}/src/lib.rs

@@ -7,7 +7,9 @@ mod geom2;
 mod geom3;
 mod mesh;
 mod metrology;
+mod raster;
 mod svd_basis;
+mod ray_casting;
 
 use pyo3::prelude::*;
 
@@ -53,6 +55,9 @@ fn register_geom3(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
     child.add_class::<bounding::Aabb3>()?;
     child.add_class::<svd_basis::SvdBasis3>()?;
 
+    // Intersection and ray casting
+    child.add_class::<ray_casting::RayBundle3>()?;
+
     parent_module.add_submodule(&child)
 }
 
@@ -89,6 +94,14 @@ fn register_metrology_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()
     parent_module.add_submodule(&child)
 }
 
+fn register_raster3_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let child = PyModule::new(parent_module.py(), "_raster3")?;
+
+    child.add_function(wrap_pyfunction!(raster::clusters_from_sparse, &child)?)?;
+
+    parent_module.add_submodule(&child)
+}
+
 /// Engeom is a library for geometric operations in 2D and 3D space.
 #[pymodule(name = "engeom")]
 fn py_engeom(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -98,6 +111,9 @@ fn py_engeom(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // 3D geometry submodule
     register_geom3(m)?;
 
+    // 3D raster module
+    register_raster3_module(m)?;
+
     // Alignment submodule
     register_align_module(m)?;
 

{engeom-0.2.6 → engeom-0.2.8}/src/mesh.rs

@@ -161,12 +161,21 @@ impl Mesh {
         Ok(result.into_pyarray(py))
     }
 
-    fn measure_point_deviation(&self, x: f64, y: f64, z: f64, dist_mode: DeviationMode) -> Distance3 {
+    fn measure_point_deviation(
+        &self,
+        x: f64,
+        y: f64,
+        z: f64,
+        dist_mode: DeviationMode,
+    ) -> Distance3 {
         let point = engeom::Point3::new(x, y, z);
         Distance3::from_inner(self.inner.measure_point_deviation(&point, dist_mode.into()))
     }
 
-    fn boundary_first_flatten<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyArrayDyn<f64>>> {
+    fn boundary_first_flatten<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> PyResult<Bound<'py, PyArrayDyn<f64>>> {
         let edges = self
             .inner
             .calc_edges()

engeom-0.2.8/src/raster.rs

@@ -0,0 +1,40 @@
+use numpy::ndarray::{Array1, ArrayD};
+use numpy::{IntoPyArray, PyArray1, PyArrayDyn, PyReadonlyArrayDyn, PyUntypedArrayMethods};
+use pyo3::exceptions::PyValueError;
+use pyo3::types::PyIterator;
+use pyo3::{
+    pyclass, pyfunction, Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyResult,
+    Python,
+};
+use std::collections::HashSet;
+
+#[pyfunction]
+pub fn clusters_from_sparse<'py>(
+    indices: PyReadonlyArrayDyn<'py, i32>,
+) -> PyResult<Vec<Bound<'py, PyArrayDyn<i32>>>> {
+    let shape = indices.shape();
+    if shape.len() != 2 || shape[1] != 3 {
+        return Err(PyValueError::new_err("Expected Nx3 array of indices"));
+    }
+
+    let mut working = HashSet::new();
+    for r in indices.as_array().rows().into_iter() {
+        let idx = (r[0], r[1], r[2]);
+        working.insert(idx);
+    }
+
+    let mut results = engeom::raster3::clusters_from_sparse(working);
+    let mut combined = Vec::new();
+
+    for result in results.drain(..) {
+        let mut array = ArrayD::zeros(vec![result.len(), 3]);
+        for (i, idx) in result.iter().enumerate() {
+            array[[i, 0]] = idx.0;
+            array[[i, 1]] = idx.1;
+            array[[i, 2]] = idx.2;
+        }
+        combined.push(array.into_pyarray(indices.py()));
+    }
+
+    Ok(combined)
+}

engeom-0.2.8/src/ray_casting.rs

@@ -0,0 +1,113 @@
+use crate::geom3::Iso3;
+use crate::mesh::Mesh;
+use numpy::ndarray::{Array1, ArrayD};
+use numpy::{IntoPyArray, PyArray1, PyArrayDyn, PyReadonlyArrayDyn, PyUntypedArrayMethods};
+use parry3d_f64::query::{Ray as PRay3, RayCast};
+use pyo3::exceptions::PyValueError;
+use pyo3::types::PyIterator;
+use pyo3::{
+    pyclass, pymethods, Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyResult,
+    Python,
+};
+
+#[pyclass]
+#[derive(Clone)]
+pub struct RayBundle3 {
+    inner: Vec<PRay3>,
+}
+
+impl RayBundle3 {
+    pub fn from_inner(inner: Vec<PRay3>) -> Self {
+        Self { inner }
+    }
+
+    pub fn get_inner(&self) -> &Vec<PRay3> {
+        &self.inner
+    }
+}
+
+#[pymethods]
+impl RayBundle3 {
+    #[new]
+    fn new<'py>(array: PyReadonlyArrayDyn<'py, f64>) -> PyResult<Self> {
+        let array = array.as_array();
+        let shape = array.shape();
+        if shape.len() != 2 || shape[1] != 6 {
+            return Err(PyValueError::new_err("Expected Nx6 array of points"));
+        }
+
+        let mut rays = Vec::with_capacity(shape[0]);
+
+        for row in array.rows().into_iter() {
+            let ray = PRay3::new(
+                engeom::Point3::new(row[0], row[1], row[2]),
+                engeom::Vector3::new(row[3], row[4], row[5]),
+            );
+            rays.push(ray);
+        }
+
+        Ok(Self::from_inner(rays))
+    }
+
+    fn __len__(&self) -> usize {
+        self.inner.len()
+    }
+
+    fn __repr__(&self) -> String {
+        format!("<RayBundle3 n={}>", self.inner.len())
+    }
+
+    #[pyo3(signature=(mesh, mesh_iso = None, angle = None))]
+    fn intersect_mesh<'py>(
+        &self,
+        py: Python<'py>,
+        mesh: &Mesh,
+        mesh_iso: Option<&Iso3>,
+        angle: Option<f64>,
+    ) -> PyResult<Bound<'py, PyArrayDyn<f64>>> {
+        let mut result = Vec::new();
+        let iso = if let Some(mesh_iso) = mesh_iso {
+            mesh_iso.get_inner()
+        } else {
+            &engeom::Iso3::identity()
+        };
+
+        if let Some(angle_limit) = angle {
+            for ray in self.inner.iter() {
+                if let Some(ri) =
+                    mesh.get_inner()
+                        .tri_mesh()
+                        .cast_ray_and_get_normal(iso, ray, f64::MAX, false)
+                {
+                    let n = ri.normal * -1.0;
+                    if ray.dir.angle(&n) < angle_limit {
+                        let t = ri.time_of_impact;
+                        result.push(ray.point_at(t))
+                    }
+                }
+            }
+        } else {
+            for ray in self.inner.iter() {
+                if let Some(t) = mesh
+                    .get_inner()
+                    .tri_mesh()
+                    .cast_ray(iso, ray, f64::MAX, false)
+                {
+                    result.push(ray.point_at(t))
+                }
+            }
+        }
+
+        // let result = ArrayD::from_shape_vec((result.len(), 3), result.into_iter().flat_map(|p| p.to_array()).collect())
+        //     .map_err(|_| PyValueError::new_err("Failed to create array"))?;
+
+        let mut result_array = ArrayD::zeros(vec![result.len(), 3]);
+        for (i, point) in result.iter().enumerate() {
+            result_array[[i, 0]] = point.x;
+            result_array[[i, 1]] = point.y;
+            result_array[[i, 2]] = point.z;
+        }
+
+        Ok(result_array.into_pyarray(py))
+    }
+}

{engeom-0.2.6 → engeom-0.2.8}/src/svd_basis.rs

@@ -1,9 +1,9 @@
 use crate::conversions::{array_to_points2, array_to_points3};
+use crate::geom2::{Iso2, Vector2};
 use crate::geom3::{Iso3, Vector3};
 use numpy::ndarray::Array1;
 use numpy::{IntoPyArray, PyArray1, PyReadonlyArray1, PyReadonlyArrayDyn};
 use pyo3::prelude::*;
-use crate::geom2::{Iso2, Vector2};
 
 #[pyclass]
 pub struct SvdBasis2 {