engeom 0.1.1__tar.gz → 0.1.2__tar.gz

{engeom-0.1.1 → engeom-0.1.2}/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ahash"
@@ -149,7 +149,7 @@ dependencies = [
 
 [[package]]
 name = "engeom"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "itertools 0.14.0",
  "kiddo",
@@ -613,7 +613,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "engeom",
  "numpy",

{engeom-0.1.1 → engeom-0.1.2}/Cargo.toml

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

{engeom-0.1.1 → engeom-0.1.2}/PKG-INFO

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

{engeom-0.1.1 → engeom-0.1.2}/engeom/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ahash"
@@ -276,7 +276,7 @@ dependencies = [
 
 [[package]]
 name = "engeom"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "approx",
  "criterion",

{engeom-0.1.1 → engeom-0.1.2}/engeom/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "engeom"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 readme = "README.md"
 

engeom-0.1.2/engeom/src/common/indices.rs

@@ -0,0 +1,130 @@
+//! This module should have tools for working with indices
+
+use std::collections::HashSet;
+
+pub fn index_vec(indices: Option<&[usize]>, len: usize) -> Vec<usize> {
+    if let Some(items) = indices {
+        items.to_vec()
+    } else {
+        (0..len).collect::<Vec<_>>()
+    }
+}
+
+/// Identify chains of indices. Starting from a set of index pairs, assemble consecutive pairs into
+/// chains of contiguous indices while preserving the order of each pair.  The input is a slice of
+/// u32 pairs, and the output is a vector of vectors of u32. Each inner vector represents a chain
+/// of contiguous indices.
+///
+/// # Arguments
+///
+/// * `indices`: original pairs of indices
+///
+/// returns: Vec<Vec<u32, Global>, Global>
+///
+/// # Examples
+///
+/// ```
+///
+/// ```
+pub fn chained_indices(indices: &[[u32; 2]]) -> Vec<Vec<u32>> {
+    let mut pairs = index_vec(None, indices.len());
+
+    let mut chains: Vec<Vec<u32>> = Vec::new();
+    let mut working = Vec::new();
+    let mut forward = true;
+
+    while !pairs.is_empty() {
+        // If working is empty, start a new chain with the first pair
+        if working.is_empty() {
+            let i = pairs.pop().unwrap();
+            working.push(indices[i][0]);
+            working.push(indices[i][1]);
+            forward = true;
+        }
+
+        if forward {
+            let last = *working.last().unwrap();
+            if let Some((k, i)) = chain_candidates(&pairs, indices, last, true) {
+                working.push(indices[i][1]);
+                pairs.swap_remove(k);
+            } else {
+                forward = false;
+            }
+        } else {
+            let first = *working.first().unwrap();
+            if let Some((k, i)) = chain_candidates(&pairs, indices, first, false) {
+                working.insert(0, indices[i][0]);
+                pairs.swap_remove(k);
+            } else {
+                chains.push(working.clone());
+                working.clear();
+            }
+        }
+    }
+
+    if !working.is_empty() {
+        chains.push(working);
+    }
+
+    chains
+}
+
+fn chain_candidates(
+    pairs: &[usize],
+    indices: &[[u32; 2]],
+    last: u32,
+    forward: bool,
+) -> Option<(usize, usize)> {
+    let mut candidates = Vec::new();
+    let j = if forward { 0 } else { 1 };
+
+    for (k, &i) in pairs.iter().enumerate() {
+        if indices[i][j] == last {
+            candidates.push((k, i));
+        }
+    }
+
+    if candidates.len() == 1 {
+        Some(candidates[0])
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn chain_candidates_forward() {
+        let indices = [[0, 1], [1, 2], [2, 3]];
+        let pairs = [1, 2];
+
+        let result = chain_candidates(&pairs, &indices, 1, true);
+
+        assert_eq!(result, Some((0, 1)));
+    }
+
+    #[test]
+    fn chain_candidates_backwards() {
+        let indices = [[0, 1], [1, 2], [2, 3]];
+        let pairs = [0, 1];
+
+        let result = chain_candidates(&pairs, &indices, 2, false);
+
+        assert_eq!(result, Some((1, 1)));
+    }
+
+    #[test]
+    fn test_chained_indices() {
+        let indices = [[0, 1], [1, 2], [2, 3], [4, 5], [5, 6], [7, 8]];
+
+        let mut chains = chained_indices(&indices);
+        chains.sort_by(|a, b| a[0].cmp(&b[0]));
+
+        assert_eq!(chains.len(), 3);
+        assert_eq!(chains[0], vec![0, 1, 2, 3]);
+        assert_eq!(chains[1], vec![4, 5, 6]);
+        assert_eq!(chains[2], vec![7, 8]);
+    }
+}

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/geom2/curve2.rs

@@ -695,7 +695,7 @@ impl Curve2 {
     /// ```
     ///
     /// ```
-    pub fn transformed(&self, transform: &Iso2) -> Self {
+    pub fn transformed_by(&self, transform: &Iso2) -> Self {
         let points = transform_points(self.line.vertices(), transform);
         Curve2::from_points(&points, self.tol, self.is_closed).unwrap()
     }

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/geom3/curve3.rs

@@ -101,6 +101,16 @@ impl Curve3 {
         self.line.vertices()
     }
 
+    pub fn transformed_by(&self, iso: &Iso3) -> Self {
+        let points = self
+            .line
+            .vertices()
+            .iter()
+            .map(|p| iso * p)
+            .collect::<Vec<_>>();
+        Self::from_points(&points, self.tol).unwrap()
+    }
+
     pub fn from_points(points: &[Point3], tol: f64) -> Result<Self> {
         let mut points = points.to_vec();
         points.dedup_by(|a, b| dist(a, b) <= tol);

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/geom3/mesh.rs

@@ -6,16 +6,16 @@ mod patches;
 mod serialization;
 mod uv_mapping;
 
-use crate::{Iso3, Plane3, Point2, Point3, SurfacePoint3, Result};
+use crate::{Curve3, Iso3, Plane3, Point2, Point3, Result, SurfacePoint3};
 use std::f64::consts::PI;
 
 pub use self::serialization::{MeshData, MeshFlatData};
 pub use self::uv_mapping::UvMapping;
-use crate::common::indices::index_vec;
+use crate::common::indices::{chained_indices, index_vec};
 use crate::common::SurfacePointCollection;
 use crate::geom3::points::points_sample_poisson_disk;
-use parry3d_f64::query::{PointProjection, PointQueryWithLocation, SplitResult};
-use parry3d_f64::shape::{TriMesh, TrianglePointLocation};
+use parry3d_f64::query::{IntersectResult, PointProjection, PointQueryWithLocation, SplitResult};
+use parry3d_f64::shape::{TriMesh, TriMeshFlags, TrianglePointLocation};
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
 
@@ -27,6 +27,51 @@ pub struct Mesh {
 }
 
 impl Mesh {
+    /// Create a new mesh from a list of vertices and a list of triangles.  Additional options can
+    /// be set to merge duplicate vertices and delete degenerate triangles.
+    ///
+    /// # Arguments
+    ///
+    /// * `vertices`:
+    /// * `triangles`:
+    /// * `is_solid`:
+    /// * `merge_duplicates`:
+    /// * `delete_degenerate`:
+    /// * `uv`:
+    ///
+    /// returns: Result<Mesh, Box<dyn Error, Global>>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///
+    /// ```
+    pub fn new_with_options(
+        vertices: Vec<Point3>,
+        triangles: Vec<[u32; 3]>,
+        is_solid: bool,
+        merge_duplicates: bool,
+        delete_degenerate: bool,
+        uv: Option<UvMapping>,
+    ) -> Result<Self> {
+        let mut flags = TriMeshFlags::empty();
+        if merge_duplicates {
+            flags |= TriMeshFlags::MERGE_DUPLICATE_VERTICES;
+            flags |= TriMeshFlags::DELETE_DUPLICATE_TRIANGLES;
+        }
+        if delete_degenerate {
+            flags |= TriMeshFlags::DELETE_BAD_TOPOLOGY_TRIANGLES;
+            flags |= TriMeshFlags::DELETE_DEGENERATE_TRIANGLES;
+        }
+
+        let shape = TriMesh::with_flags(vertices, triangles, flags)?;
+        Ok(Self {
+            shape,
+            is_solid,
+            uv,
+        })
+    }
+
     pub fn new(vertices: Vec<Point3>, triangles: Vec<[u32; 3]>, is_solid: bool) -> Self {
         let shape = TriMesh::new(vertices, triangles).expect("Failed to create TriMesh");
         Self {
@@ -361,6 +406,44 @@ impl Mesh {
             SplitResult::Positive => SplitResult::Positive,
         }
     }
+
+    /// Perform a section of the mesh with a plane, returning a list of `Curve3` objects that
+    /// trace the intersection of the mesh with the plane.
+    ///
+    /// # Arguments
+    ///
+    /// * `plane`:
+    /// * `tol`:
+    ///
+    /// returns: Result<Vec<Curve3, Global>, Box<dyn Error, Global>>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///
+    /// ```
+    pub fn section(&self, plane: &Plane3, tol: Option<f64>) -> Result<Vec<Curve3>> {
+        let tol = tol.unwrap_or(1.0e-6);
+        let mut collected = Vec::new();
+        let result = self
+            .shape
+            .intersection_with_local_plane(&plane.normal, plane.d, 1.0e-6);
+
+        if let IntersectResult::Intersect(pline) = result {
+            let chains = chained_indices(pline.indices());
+            for chain in chains.iter() {
+                let points = chain
+                    .iter()
+                    .map(|&i| pline.vertices()[i as usize])
+                    .collect::<Vec<_>>();
+                if let Ok(curve) = Curve3::from_points(&points, tol) {
+                    collected.push(curve);
+                }
+            }
+        }
+
+        Ok(collected)
+    }
 }
 
 fn box_geom(width: f64, height: f64, depth: f64) -> (Vec<Point3>, Vec<[u32; 3]>) {

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/geom3/plane3.rs

@@ -37,7 +37,6 @@ impl Plane3 {
         self.normal.dot(&point.coords) - self.d
     }
 
-
     /// Measure and return the distance from the plane to a point in 3D space. The distance is
     /// always positive, and indicates the shortest distance from the point to the plane. If you
     /// need to know whether the point is above or below the plane, use `signed_distance_to_point`.

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/io.rs

@@ -12,7 +12,7 @@ use stl_io;
 use crate::geom3::Mesh;
 
 #[cfg(feature = "stl")]
-pub fn read_mesh_stl(path: &Path) -> Result<Mesh> {
+pub fn read_mesh_stl(path: &Path, merge_duplicates: bool, delete_degenerate: bool) -> Result<Mesh> {
     let mut file = OpenOptions::new().read(true).open(path)?;
     let mesh = stl_io::read_stl(&mut file)?;
 
@@ -34,7 +34,14 @@ pub fn read_mesh_stl(path: &Path) -> Result<Mesh> {
         })
         .collect::<Vec<_>>();
 
-    Ok(Mesh::new(vertices, triangles, false))
+    Mesh::new_with_options(
+        vertices,
+        triangles,
+        false,
+        merge_duplicates,
+        delete_degenerate,
+        None,
+    )
 }
 
 #[cfg(feature = "stl")]

{engeom-0.1.1 → engeom-0.1.2}/engeom/src/lib.rs

@@ -26,7 +26,7 @@ pub use geom2::{
 
 // Extremely common 3D types
 pub use geom3::{
-    Curve3, CurveStation3, Iso3, Mesh, Plane3, Point3, SurfacePoint3, UnitVec3, Vector3, SvdBasis3,
+    Curve3, CurveStation3, Iso3, Mesh, Plane3, Point3, SurfacePoint3, SvdBasis3, UnitVec3, Vector3,
 };
 
 // Extremely common conversion tools

{engeom-0.1.1 → engeom-0.1.2}/python/engeom/engeom.pyi

@@ -1,14 +1,8 @@
 from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, List, Tuple, Union
 from enum import Enum
 
-import numpy
-
+type Resample = Resample_ByCount | Resample_BySpacing | Resample_ByMaxSpacing
 
 class DeviationMode(Enum):
     Absolute = 0
     Normal = 1
-
-