engeom 0.2.7__tar.gz → 0.2.8__tar.gz

{engeom-0.2.7 → 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.7"
+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.7 → engeom-0.2.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "py-engeom"
-version = "0.2.7"
+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.7 → engeom-0.2.8}/PKG-INFO

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

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

@@ -9,6 +9,7 @@ mod mesh;
 mod metrology;
 mod raster;
 mod svd_basis;
+mod ray_casting;
 
 use pyo3::prelude::*;
 
@@ -54,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)
 }
 

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))
+    }
+}