engeom 0.2.8__tar.gz → 0.2.9__tar.gz

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

@@ -1025,7 +1025,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.2.8"
+version = "0.2.9"
 dependencies = [
  "engeom",
  "numpy",

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

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

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

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

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/airfoil/camber.rs

@@ -10,8 +10,8 @@ use crate::geom2::hull::farthest_pair_indices;
 use crate::geom2::polyline2::SpanningRay;
 use crate::geom2::{rot90, Line2, Segment2};
 use crate::AngleDir::{Ccw, Cw};
-use crate::{Curve2, UnitVec2};
 use crate::Result;
+use crate::{Curve2, UnitVec2};
 use parry2d_f64::query::Ray;
 use parry2d_f64::shape::ConvexPolygon;
 
@@ -23,8 +23,11 @@ use parry2d_f64::shape::ConvexPolygon;
 ///
 /// returns: Result<Unit<Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>>, Box<dyn Error, Global>>
 pub fn camber_detect_upper_dir(camber_line: &Curve2) -> Result<UnitVec2> {
-    let check = Segment2::try_new(camber_line.at_front().point(), camber_line.at_back().point())
-        .map_err(|_| "Failed to create segment from camber line while detecting face orientation")?;
+    let check = Segment2::try_new(
+        camber_line.at_front().point(),
+        camber_line.at_back().point(),
+    )
+    .map_err(|_| "Failed to create segment from camber line while detecting face orientation")?;
 
     let resampled = camber_line.resample(ByCount(50))?;
 

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/geom3/mesh/edges.rs

@@ -100,7 +100,7 @@ impl<'a> MeshEdges<'a> {
 
 /// Given an edge, return a key that can be used to identify the vertices that are connected by the
 /// edge without regard to the order of the vertices.
-fn edge_key(edge: &[u32; 2]) -> [u32; 2] {
+pub fn edge_key(edge: &[u32; 2]) -> [u32; 2] {
     let x = edge[0].min(edge[1]);
     let y = edge[0].max(edge[1]);
     [x, y]
@@ -110,7 +110,7 @@ fn edge_key(edge: &[u32; 2]) -> [u32; 2] {
 /// the faces are presented. The edges are not deduplicated nor their direction normalized. The
 /// resulting list will be 3x the length of the original faces. Elements 0-2 will be from face 0,
 /// elements 3-5 will be from face 1, and so on.
-fn naive_edges(faces: &[[u32; 3]]) -> Vec<[u32; 2]> {
+pub fn naive_edges(faces: &[[u32; 3]]) -> Vec<[u32; 2]> {
     let mut edges = Vec::new();
     for face in faces {
         edges.push([face[1], face[2]]);
@@ -122,7 +122,7 @@ fn naive_edges(faces: &[[u32; 3]]) -> Vec<[u32; 2]> {
 
 /// Given a reference list of all edges, return a sorted list of unique edges and the number of
 /// times each edge appeared in the original list.
-fn unique_edges(all_edges: &[[u32; 2]]) -> Vec<([u32; 2], usize)> {
+pub fn unique_edges(all_edges: &[[u32; 2]]) -> Vec<([u32; 2], usize)> {
     let mut unique = HashMap::new();
     for edge in all_edges {
         let key = edge_key(edge);

engeom-0.2.9/engeom/src/geom3/mesh/outline.rs

@@ -0,0 +1,281 @@
+//! This module exists to help generate a visual outline of a mesh
+
+use super::Mesh;
+use crate::common::points::{fill_gaps, mid_point};
+use crate::geom3::mesh::edges::{edge_key, naive_edges, unique_edges};
+use crate::{Point3, UnitVec3};
+use parry3d_f64::query::{Ray, RayCast};
+use std::collections::{HashMap, HashSet};
+use std::f64::consts::PI;
+
+// struct KeyChainer {
+//     forward: HashMap<u32, HashSet<u32>>,
+//     reverse: HashMap<u32, HashSet<u32>>,
+// }
+//
+// fn first_single(map: &mut HashMap<u32, HashSet<u32>>) -> Option<(u32, u32)> {
+//     for (k, v) in map.iter_mut() {
+//         if v.len() == 1 {
+//             let k0 = *k;
+//             let k1 = *v.iter().next().unwrap();
+//             return Some((k0, k1));
+//         }
+//     }
+//     None
+// }
+//
+// impl KeyChainer {
+//     pub fn new() -> Self {
+//         KeyChainer {
+//             forward: HashMap::new(),
+//             reverse: HashMap::new(),
+//         }
+//     }
+//
+//     pub fn push(&mut self, key: &[u32; 2]) {
+//         let k_min = key[0].min(key[1]);
+//         let k_max = key[0].max(key[1]);
+//         self.forward.entry(k_min).or_default().insert(k_max);
+//         self.reverse.entry(k_max).or_default().insert(k_min);
+//     }
+//
+//     pub fn remove_pair(&mut self, k0: u32, k1: u32) {
+//         let k_min = k0.min(k1);
+//         let k_max = k0.max(k1);
+//
+//         if let Some(v) = self.forward.get_mut(&k_min) {
+//             v.remove(&k_max);
+//             if v.is_empty() {
+//                 self.forward.remove(&k_min);
+//             }
+//         }
+//
+//         if let Some(v) = self.reverse.get_mut(&k_max) {
+//             v.remove(&k_min);
+//             if v.is_empty() {
+//                 self.reverse.remove(&k_max);
+//             }
+//         }
+//     }
+//
+//     pub fn pop_new(&mut self) -> Option<(u32, u32)> {
+//         if let Some((k0, k1)) = first_single(&mut self.forward) {
+//             self.remove_pair(k0, k1);
+//             Some((k0, k1))
+//         } else if let Some((k0, k1)) = first_single(&mut self.reverse) {
+//             self.remove_pair(k0, k1);
+//             Some((k0, k1))
+//         } else {
+//             // Find the lowest count from forward
+//             if let Some(n) = self
+//                 .forward
+//                 .iter()
+//                 .min_by(|a, b| a.1.len().cmp(&b.1.len()))
+//                 .clone()
+//             {
+//                 let k0 = *n.0;
+//                 let k1 = *n.1.iter().next().unwrap();
+//                 self.remove_pair(k0, k1);
+//                 Some((k0, k1))
+//             } else {
+//                 None
+//             }
+//         }
+//     }
+//
+//     pub fn find_next(&mut self, k0: u32) -> Option<u32> {
+//         if let Some(v) = self.forward.get_mut(&k0) {
+//             if v.len() == 1 {
+//                 let k1 = *v.iter().next().unwrap();
+//                 self.remove_pair(k0, k1);
+//                 return Some(k1);
+//             }
+//         }
+//         if let Some(v) = self.reverse.get_mut(&k0) {
+//             if v.len() == 1 {
+//                 let k1 = *v.iter().next().unwrap();
+//                 self.remove_pair(k0, k1);
+//                 return Some(k1);
+//             }
+//         }
+//         None
+//     }
+//
+//     pub fn sequences(&mut self) -> Vec<Vec<u32>> {
+//         let mut chains = Vec::new();
+//         let mut working = Vec::new();
+//
+//         // Find first
+//         while !self.forward.is_empty() {
+//             if working.is_empty() {
+//                 if let Some((k0, k1)) = self.pop_new() {
+//                     working.push(k0);
+//                     working.push(k1);
+//                 } else {
+//                     for (a, b) in self.forward.iter() {
+//                         println!("{} -> {:?}", a, b);
+//                     }
+//                     for (a, b) in self.reverse.iter() {
+//                         println!("{} <- {:?}", a, b);
+//                     }
+//                     panic!("This should not happen");
+//                 }
+//             }
+//
+//             // Now we have a working chain
+//             let last = *working.last().unwrap();
+//             if let Some(next) = self.find_next(last) {
+//                 self.remove_pair(last, next);
+//                 working.push(next);
+//             } else {
+//                 // We are done with this chain
+//                 chains.push(working.clone());
+//                 working.clear();
+//             }
+//         }
+//
+//         chains
+//     }
+// }
+
+impl Mesh {
+    pub fn visual_outline(
+        &self,
+        facing: UnitVec3,
+        max_edge_length: f64,
+        corner_angle: Option<f64>,
+    ) -> Vec<(Point3, Point3, u8)> {
+        let corner_angle = corner_angle.unwrap_or(PI / 4.0 - 1e-2);
+        let (boundaries, mut corners) = self.classified_edge_types();
+        // let mut working = KeyChainer::new();
+        let mut working = Vec::new();
+
+        for (i, indices) in self.shape.indices().iter().enumerate() {
+            for (i0, i1) in [(0, 1), (1, 2), (2, 0)] {
+                let k = edge_key(&[indices[i0], indices[i1]]);
+
+                if boundaries.contains(&k) {
+                    working.push(k);
+                } else if let Some(corner) = corners.get_mut(&k) {
+                    if corner[0] == u32::MAX {
+                        corner[0] = i as u32;
+                    } else {
+                        corner[1] = i as u32;
+                    }
+                }
+            }
+        }
+
+        // At this point, working contains boundary edges and corners contains corner face pairs
+        // Now we need to process the corners
+        for (key, corner) in corners.iter() {
+            if corner[0] == u32::MAX || corner[1] == u32::MAX {
+                continue;
+            }
+
+            let n0u = self.shape.triangle(corner[0]).normal();
+            let n1u = self.shape.triangle(corner[1]).normal();
+
+            if let (Some(n0), Some(n1)) = (n0u, n1u) {
+                if n0.angle(&n1) > corner_angle {
+                    // Is this a corner?
+                    working.push(*key);
+                } else {
+                    let f0 = facing.dot(&n0);
+                    let f1 = facing.dot(&n1);
+                    let f_max = f0.max(f1);
+                    let f_min = f0.min(f1);
+
+                    if f_max >= 0.0 && f_min < 0.0 {
+                        // Is this a silhouette?
+                        working.push(*key);
+                    }
+                }
+            }
+        }
+
+        let vert_normals = self.get_vertex_normals();
+        let mut edges = Vec::new();
+        for k in working {
+            let k0 = k[0];
+            let k1 = k[1];
+
+            let p0: Point3 =
+                self.shape.vertices()[k0 as usize].clone() + vert_normals[k0 as usize] * 1e-2;
+            let p1: Point3 =
+                self.shape.vertices()[k1 as usize].clone() + vert_normals[k1 as usize] * 1e-2;
+
+            let points = fill_gaps(&[p0, p1], max_edge_length);
+
+            for (p0, p1) in points.iter().zip(points.iter().skip(1)) {
+                let p = mid_point(p0, p1) + facing.into_inner() * 1e-2;
+
+                let ray = Ray::new(p, facing.into_inner());
+
+                if self.shape.intersects_local_ray(&ray, f64::MAX) {
+                    edges.push((*p0, *p1, 1))
+                } else {
+                    edges.push((*p0, *p1, 0))
+                }
+            }
+        }
+
+        // // We want to chain vertices together
+        // let sequences = working
+        //     .sequences()
+        //     .into_iter()
+        //     .map(|indices| {
+        //         indices
+        //             .iter()
+        //             .map(|i| self.shape.vertices()[*i as usize])
+        //             .collect::<Vec<_>>()
+        //     })
+        //     .collect::<Vec<_>>();
+        //
+        // let mut edges = Vec::new();
+        // let shift = -facing.into_inner();
+        // for c in sequences.iter() {
+        //     if let Ok(chain) = Curve3::from_points(c, 1e-3) {
+        //         if chain.count() < 3 || chain.length() < max_edge_length * 2.0  {
+        //             continue;
+        //         }
+        //
+        //         // println!("before l={} n={}", chain.length(), chain.count());
+        //         let chain = chain.resample(Resample::ByMaxSpacing(max_edge_length));
+        //         // println!("after");
+        //
+        //         for (p0, p1) in chain.points().iter().zip(chain.points().iter().skip(1)) {
+        //             let p = mid_point(p0, p1) + shift * 1e-2;
+        //
+        //             let ray = Ray::new(p, shift);
+        //
+        //             if self.shape.intersects_local_ray(&ray, f64::MAX) {
+        //                 edges.push((*p0, *p1, 1))
+        //             } else {
+        //                 edges.push((*p0, *p1, 0))
+        //             }
+        //         }
+        //     }
+        // }
+
+        edges
+    }
+
+    fn classified_edge_types(&self) -> (HashSet<[u32; 2]>, HashMap<[u32; 2], [u32; 2]>) {
+        let naive = naive_edges(&self.shape.indices());
+        let unique = unique_edges(&naive);
+
+        let mut boundaries = HashSet::new();
+        let mut corners = HashMap::new();
+
+        for (key, count) in unique {
+            if count == 1 {
+                boundaries.insert(key);
+            } else if count == 2 {
+                corners.insert(key, [u32::MAX, u32::MAX]);
+            }
+        }
+
+        (boundaries, corners)
+    }
+}

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/geom3/mesh/patches.rs

@@ -1,5 +1,5 @@
 use crate::geom3::Mesh;
-use crate::Point3;
+use crate::{Point3, Result};
 use std::collections::{HashMap, HashSet};
 
 fn edge_key(i: usize, f: &[u32; 3]) -> (u32, u32) {
@@ -50,7 +50,7 @@ fn take_one_boundary(order: &mut HashMap<u32, u32>) -> Option<Vec<u32>> {
     Some(sequence)
 }
 
-pub fn compute_boundary_points(mesh: &Mesh, patch: &[usize]) -> Vec<Vec<Point3>> {
+pub fn compute_boundary_points(mesh: &Mesh, patch: &[usize]) -> Result<Vec<Vec<Point3>>> {
     let mut order = HashMap::new();
     let mut remaining = HashSet::new();
     let edges = compute_boundary_edges(mesh, patch);
@@ -58,7 +58,7 @@ pub fn compute_boundary_points(mesh: &Mesh, patch: &[usize]) -> Vec<Vec<Point3>>
         if let std::collections::hash_map::Entry::Vacant(e) = order.entry(v0) {
             e.insert(v1);
         } else {
-            panic!("Duplicate boundary point found!");
+            return Err("Duplicate boundary point found!".into());
         }
         remaining.insert(v0);
     }
@@ -68,14 +68,14 @@ pub fn compute_boundary_points(mesh: &Mesh, patch: &[usize]) -> Vec<Vec<Point3>>
         sequences.push(sequence);
     }
 
-    sequences
+    Ok(sequences
         .into_iter()
         .map(|seq| {
             seq.into_iter()
                 .map(|v| mesh.vertices()[v as usize])
                 .collect()
         })
-        .collect()
+        .collect())
 }
 
 /// Uses the adjacency information of the mesh to compute a list of patches of connected faces. This

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/geom3/mesh.rs

@@ -7,6 +7,7 @@ mod edges;
 mod faces;
 pub mod filtering;
 mod measurement;
+mod outline;
 mod patches;
 mod queries;
 mod sampling;
@@ -14,7 +15,7 @@ mod uv_mapping;
 
 pub use self::uv_mapping::UvMapping;
 use crate::geom3::Aabb3;
-use crate::{Iso3, Point2, Point3, Result, SurfacePoint3};
+use crate::{Iso3, Point2, Point3, Result, SurfacePoint3, UnitVec3, Vector3};
 pub use edges::MeshEdges;
 use parry3d_f64::shape::{TriMesh, TriMeshFlags};
 
@@ -207,13 +208,52 @@ impl Mesh {
     /// lists of points, where each list of points is the boundary of a patch.  Note that this
     /// function will not work on non-manifold meshes.
     ///
-    /// returns: Vec<Vec<usize, Global>, Global>
-    pub fn get_patch_boundary_points(&self) -> Vec<Vec<Point3>> {
+    /// returns: Result<Vec<Vec<usize, Global>, Global>>
+    pub fn get_patch_boundary_points(&self) -> Result<Vec<Vec<Point3>>> {
         let patches = self.get_patches();
-        patches
-            .iter()
-            .flat_map(|patch| patches::compute_boundary_points(self, patch))
-            .collect()
+        let mut result = Vec::new();
+        for patch in patches.iter() {
+            result.extend(patches::compute_boundary_points(self, patch)?);
+        }
+
+        Ok(result)
+    }
+
+    pub fn get_face_normals(&self) -> Result<Vec<UnitVec3>> {
+        let mut result = Vec::new();
+        for t in self.shape.triangles() {
+            if let Some(n) = t.normal() {
+                result.push(n.clone());
+            } else {
+                return Err("Failed to get normal".into());
+            }
+        }
+
+        Ok(result)
+    }
+
+    pub fn get_vertex_normals(&self) -> Vec<Vector3> {
+        let mut sums: Vec<Vector3> = vec![Vector3::new(0.0, 0.0, 0.0); self.shape.vertices().len()];
+        let mut counts = vec![0; self.shape.vertices().len()];
+
+        for (indices, tri) in self.shape.indices().iter().zip(self.shape.triangles()) {
+            if let Some(n) = tri.normal() {
+                for i in indices {
+                    sums[*i as usize] += n.into_inner();
+                    counts[*i as usize] += 1;
+                }
+            }
+        }
+
+        // Normalize the normals
+        for i in 0..sums.len() {
+            if counts[i] > 0 {
+                let v = sums[i] / counts[i] as f64;
+                sums[i] = v.normalize();
+            }
+        }
+
+        sums
     }
 }
 

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/metrology.rs

@@ -7,8 +7,8 @@ mod tolerance_map;
 pub use tolerance::Tolerance;
 pub use tolerance_map::{ConstantTolMap, DiscreteDomainTolMap, ToleranceMap};
 
-pub use dimension::Measurement;
 use crate::{Iso3, To2D, To3D};
+pub use dimension::Measurement;
 
 pub type SurfaceDeviation2 = surface_deviation::SurfaceDeviation<2>;
 pub type SurfaceDeviationSet2 = surface_deviation::SurfaceDeviationSet<2>;
@@ -18,7 +18,6 @@ pub type SurfaceDeviationSet3 = surface_deviation::SurfaceDeviationSet<3>;
 pub type Distance2 = dimension::Distance<2>;
 pub type Distance3 = dimension::Distance<3>;
 
-
 // Conversions between 2D and 3D distances
 impl Distance2 {
     /// Convert a 2D distance to a 3D distance using an isometry transformation. The 2D distance
@@ -55,4 +54,4 @@ impl Distance3 {
         let direction = (iso * self.direction).to_2d();
         Distance2::new(a, b, Some(direction))
     }
-}
+}

{engeom-0.2.8 → engeom-0.2.9}/engeom/src/raster3.rs

@@ -1,60 +1,58 @@
-//! 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
-}
+//! 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
+}