engeom 0.2.6__tar.gz → 0.2.7__tar.gz

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

@@ -1024,7 +1024,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.2.6"
+version = "0.2.7"
 dependencies = [
  "engeom",
  "numpy",

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

@@ -1,6 +1,6 @@
 [package]
 name = "py-engeom"
-version = "0.2.6"
+version = "0.2.7"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

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

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

{engeom-0.2.6 → engeom-0.2.7}/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.7/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.7/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.7/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.7}/src/lib.rs

@@ -7,6 +7,7 @@ mod geom2;
 mod geom3;
 mod mesh;
 mod metrology;
+mod raster;
 mod svd_basis;
 
 use pyo3::prelude::*;
@@ -89,6 +90,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 +107,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.7}/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.7/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.6 → engeom-0.2.7}/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 {