engeom 0.2.5__tar.gz → 0.2.7__tar.gz

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

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

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

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

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

engeom-0.2.7/docs/api/airfoil.md

@@ -0,0 +1,3 @@
+# Airfoil Module
+
+::: engeom.airfoil 

engeom-0.2.7/docs/api/engeom.md

@@ -0,0 +1,5 @@
+# Engeom
+
+The `engeom` main module has a handful of common entities shared across other parts of the library.
+
+::: engeom

engeom-0.2.7/docs/api/geom2.md

@@ -0,0 +1,3 @@
+# Geom2 Module
+
+::: engeom.geom2 

engeom-0.2.7/docs/api/geom3.md

@@ -0,0 +1,4 @@
+# Geom3 Module
+
+::: engeom.geom3
+

engeom-0.2.7/docs/api/metrology.md

@@ -0,0 +1,9 @@
+# Metrology Module
+
+!!! warning
+    The metrology feature set is still experimental and is under heavy development in the Rust `engeom` library.
+    Expect significant changes to the API in the future.
+
+::: engeom.metrology
+    options:
+        show_source: false

engeom-0.2.7/docs/api/plot.md

@@ -0,0 +1,15 @@
+# Plot Module
+
+!!! warning
+    This module's API is still under development and will likely change in the future.
+
+::: engeom.plot
+    options:
+        show_source: false
+        members:
+            - LabelPlace  
+            - PyvistaPlotterHelper
+            - GOM_CMAP 
+            - GomColorMap 
+            - MatplotlibAxesHelper
+

{engeom-0.2.5 → engeom-0.2.7}/docs/metrology.md

@@ -9,4 +9,3 @@
 The metrology features of the `engeom` library are designed to provide a common set of tools for actual measurements,
 separate from the geometry tools. For example, measurements like scalar distances, areas, GD&T form and position 
 measurements, and more, will be consolidated as entities and operations in the metrology features.
-

{engeom-0.2.5 → engeom-0.2.7}/engeom/src/airfoil/camber.rs

@@ -5,39 +5,48 @@ use super::helpers::{
 };
 use crate::airfoil::inscribed_circle::InscribedCircle;
 use crate::common::points::{dist, mid_point};
-use crate::common::BestFit;
 use crate::common::Resample::ByCount;
 use crate::geom2::hull::farthest_pair_indices;
 use crate::geom2::polyline2::SpanningRay;
-use crate::geom2::{rot90, Line2};
+use crate::geom2::{rot90, Line2, Segment2};
 use crate::AngleDir::{Ccw, Cw};
+use crate::{Curve2, UnitVec2};
 use crate::Result;
-use crate::{Circle2, Curve2, UnitVec2};
 use parry2d_f64::query::Ray;
 use parry2d_f64::shape::ConvexPolygon;
 
 /// Given a curve representing a camber line, attempt to detect the direction of the upper
-/// (suction, convex) side of the airfoil section. To do so, we will resample the curve to a
-/// finite number of points and then best-fit a circle to the points. The circle center should be
-/// on the concave (lower, pressure) side of the camber curve, so the direction from the circle
-/// center to the center of the camber curve will be the direction of the upper airfoil side.
-///
+/// (suction, convex) side of the airfoil section.
 /// # Arguments
 ///
 /// * `camber_line`: the curve representing the camber line of the airfoil section
 ///
 /// 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 mid_point = camber_line.at_fraction(0.5).unwrap().point();
+    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))?;
-    let guess = Circle2::from_3_points(
-        camber_line.at_front().point(),
-        mid_point,
-        camber_line.at_back().point(),
-    )?;
-    let circle = Circle2::fitting_circle(resampled.points(), &guess, BestFit::All)?;
-
-    Ok(UnitVec2::new_normalize(mid_point - circle.center))
+
+    let mut best = 0.0;
+    let mut best_point = None;
+
+    for p in resampled.points() {
+        let cp = check.projected_point(p);
+        let d = dist(p, &cp);
+        if d > best {
+            best = d;
+            best_point = Some(p);
+        }
+    }
+
+    if let Some(point) = best_point {
+        let cp = check.projected_point(point);
+        let dir = point - cp;
+        Ok(UnitVec2::new_normalize(dir))
+    } else {
+        Err("Failed to find point on camber line for face orientation detection".into())
+    }
 }
 
 /// Attempts to calculate and extract the mean camber line from an airfoil section curve and its

{engeom-0.2.5 → engeom-0.2.7}/engeom/src/airfoil.rs

@@ -14,7 +14,7 @@ use crate::airfoil::camber::camber_detect_upper_dir;
 use crate::common::points::dist;
 use crate::common::Intersection;
 use crate::geom2::hull::convex_hull_2d;
-use crate::metrology::Length2;
+use crate::metrology::Distance2;
 use crate::stats::compute_mean;
 pub use camber::extract_camber_line;
 pub use edges::{
@@ -358,14 +358,14 @@ impl AirfoilGeometry {
     ///
     /// * `gage`:
     ///
-    /// returns: Result<Length2, Box<dyn Error, Global>>
+    /// returns: Result<Distance2, Box<dyn Error, Global>>
     ///
     /// # Examples
     ///
     /// ```
     ///
     /// ```
-    pub fn get_thickness(&self, gage: AfGage) -> Result<Length2> {
+    pub fn get_thickness(&self, gage: AfGage) -> Result<Distance2> {
         let (upper, lower) = match gage {
             AfGage::OnCamber(x) => {
                 let l = if x < 0.0 { self.camber.length() + x } else { x };
@@ -463,13 +463,13 @@ impl AirfoilGeometry {
             }
         };
 
-        Ok(Length2::new(upper, lower, None))
+        Ok(Distance2::new(lower, upper, None))
     }
 
-    pub fn get_thickness_max(&self) -> Result<Length2> {
+    pub fn get_thickness_max(&self) -> Result<Distance2> {
         let tmax = self.find_tmax();
         let (upper, lower) = self.order_points(&tmax.contact_neg, &tmax.contact_pos)?;
-        Ok(Length2::new(upper, lower, None))
+        Ok(Distance2::new(lower, upper, None))
     }
 
     /// Order the points so that the first point returned is on the upper surface and the second
@@ -525,7 +525,7 @@ fn order_faces(
     // We should have intersections with both curves. If the outline is clean, we will have exactly
     // one intersection with each, but if not we might have more than one at a similar distance.
     if a_t.is_empty() || b_t.is_empty() {
-        Err("Failed to find intersections with the test point".into())
+        Err("Failed to find intersections with the test point while ordering faces".into())
     } else {
         let a_m = compute_mean(&a_t)?;
         let b_m = compute_mean(&b_t)?;

{engeom-0.2.5 → engeom-0.2.7}/engeom/src/func1/series1.rs

@@ -640,7 +640,7 @@ impl Series1 {
             clusters.push(current);
         }
 
-        // Now go through each cluster and if it is large enough, add all of the indices to the
+        // Now go through each cluster and if it is large enough, add all the indices to the
         // result vector
         let mut results = Vec::new();
         for cluster in clusters {

{engeom-0.2.5 → engeom-0.2.7}/engeom/src/geom3/mesh/measurement.rs

@@ -1,7 +1,7 @@
 //! This module contains features for taking measurements on meshes
 
 use crate::common::DistMode;
-use crate::metrology::Length3;
+use crate::metrology::Distance3;
 use crate::{Mesh, Point3, UnitVec3};
 
 impl Mesh {
@@ -33,7 +33,7 @@ impl Mesh {
     /// ```
     ///
     /// ```
-    pub fn measure_point_deviation(&self, point: &Point3, dist_mode: DistMode) -> Length3 {
+    pub fn measure_point_deviation(&self, point: &Point3, dist_mode: DistMode) -> Distance3 {
         let closest = self.surf_closest_to(point);
 
         // In both cases, the measurement point `b` will remain the test point and `a` will be the
@@ -53,6 +53,6 @@ impl Mesh {
             DistMode::ToPlane => closest.normal,
         };
 
-        Length3::new(closest.point, *point, Some(d))
+        Distance3::new(closest.point, *point, Some(d))
     }
 }

{engeom-0.2.5 → 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/metrology/dimension.rs

@@ -0,0 +1,97 @@
+//! This module has representations of different types of dimensions
+
+use crate::common::surface_point::SurfacePoint;
+use parry3d_f64::na::{Point, SVector, Unit};
+use crate::common::points::mid_point;
+
+pub trait Measurement {
+    fn value(&self) -> f64;
+}
+
+/// Represents a signed distance between two points in space along a specific direction. The value
+/// of the measurement will be the vector from `a` to `b` projected onto the direction vector,
+/// meaning that the value will be positive if `b` is in the direction of the vector and negative
+/// if `b` is in the opposite direction.
+pub struct Distance<const D: usize> {
+    /// The starting point of the distance measurement
+    pub a: Point<f64, D>,
+
+    /// The ending point of the distance measurement
+    pub b: Point<f64, D>,
+
+    /// The direction of the distance measurement
+    pub direction: Unit<SVector<f64, D>>,
+}
+
+impl<const D: usize> Distance<D> {
+    /// Create a new signed distance measurement between two points in space along a specific
+    /// direction. The value of the measurement will be the vector from `a` to `b` projected onto
+    /// the direction vector, meaning that the value will be positive if `b - a` is in the
+    /// direction of the vector and negative if not.
+    ///
+    /// # Arguments
+    ///
+    /// * `a`: The start point of the distance measurement
+    /// * `b`: The end point of the distance measurement
+    /// * `direction`: A unit vector representing the direction of the distance measurement. The
+    ///   default value is `None`, in which case the direction will be calculated as the normalized
+    ///   vector from `a` to `b`, resulting in a positive value with the full magnitude of the
+    ///   distance between the two points.
+    ///
+    /// returns: Distance<{ D }>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use engeom::{Point2, UnitVec2, Vector2};
+    /// use engeom::metrology::{Distance2, Measurement};
+    /// use approx::assert_relative_eq;
+    ///
+    /// let a = Point2::new(0.0, 0.0);
+    /// let b = Point2::new(1.0, 1.0);
+    ///
+    /// let d1 = Distance2::new(a, b, None);
+    /// let d2 = Distance2::new(b, a, None);
+    ///
+    /// assert_relative_eq!(d1.value(), 2_f64.sqrt());
+    /// assert_relative_eq!(d2.value(), 2_f64.sqrt());
+    ///
+    /// let dir = UnitVec2::new_unchecked(Vector2::x());
+    /// let d3 = Distance2::new(a, b, Some(dir));
+    /// let d4 = Distance2::new(b, a, Some(dir));
+    ///
+    /// assert_relative_eq!(d3.value(), 1.0);
+    /// assert_relative_eq!(d4.value(), -1.0);
+    /// ```
+    pub fn new(
+        a: Point<f64, D>,
+        b: Point<f64, D>,
+        direction: Option<Unit<SVector<f64, D>>>,
+    ) -> Self {
+        let direction = direction.unwrap_or(Unit::new_normalize(b - a));
+        Self { a, b, direction }
+    }
+
+    /// Reverse the distance measurement by swapping start and end points and flipping the direction
+    /// of measurement. The value and sign of the measurement will be the same after the operation,
+    /// but the points will have been swapped.
+    pub fn reversed(&self) -> Self {
+        Self {
+            a: self.b,
+            b: self.a,
+            direction: -self.direction,
+        }
+    }
+
+    /// Compute a SurfacePoint that is located halfway between point `a` and `b` and whose normal
+    /// vector is the direction of the distance measurement.
+    pub fn center(&self) -> SurfacePoint<D> {
+        SurfacePoint::new(mid_point(&self.a, &self.b), self.direction)
+    }
+}
+
+impl<const D: usize> Measurement for Distance<D> {
+    fn value(&self) -> f64 {
+        self.direction.dot(&(self.b - self.a))
+    }
+}

engeom-0.2.7/engeom/src/metrology.rs

@@ -0,0 +1,58 @@
+mod dimension;
+pub mod line_profiles;
+mod surface_deviation;
+mod tolerance;
+mod tolerance_map;
+
+pub use tolerance::Tolerance;
+pub use tolerance_map::{ConstantTolMap, DiscreteDomainTolMap, ToleranceMap};
+
+pub use dimension::Measurement;
+use crate::{Iso3, To2D, To3D};
+
+pub type SurfaceDeviation2 = surface_deviation::SurfaceDeviation<2>;
+pub type SurfaceDeviationSet2 = surface_deviation::SurfaceDeviationSet<2>;
+pub type SurfaceDeviation3 = surface_deviation::SurfaceDeviation<3>;
+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
+    /// is converted to 3D by adding a zero z-component, and then it is transformed by the provided
+    /// isometry to move it to some other location in 3D space.
+    ///
+    /// # Arguments
+    ///
+    /// * `iso`: The isometry transformation to apply to the 2D distance
+    ///
+    /// returns: Distance<3>
+    pub fn to_3d(&self, iso: &Iso3) -> Distance3 {
+        let a = iso * self.a.to_3d();
+        let b = iso * self.b.to_3d();
+        let direction = iso * self.direction.to_3d();
+        Distance3::new(a, b, Some(direction))
+    }
+}
+
+impl Distance3 {
+    /// Convert a 3D distance to a 2D distance using an isometry transformation. The 3D distance
+    /// is first transformed by the provided isometry, and then it is converted to 2D by dropping
+    /// the z-component.
+    ///
+    /// # Arguments
+    ///
+    /// * `iso`: The isometry transformation to apply to the 3D distance before dropping the
+    ///   z-component
+    ///
+    /// returns: Distance<2>
+    pub fn to_2d(&self, iso: &Iso3) -> Distance2 {
+        let a = (iso * self.a).to_2d();
+        let b = (iso * self.b).to_2d();
+        let direction = (iso * self.direction).to_2d();
+        Distance2::new(a, b, Some(direction))
+    }
+}

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.5 → engeom-0.2.7}/mkdocs.yml

@@ -17,6 +17,13 @@ nav:
   - Airfoils:
       - Introduction: airfoils/intro.md
   - Metrology: metrology.md
+  - API Reference:
+      - Common: api/engeom.md
+      - Geom2: api/geom2.md
+      - Geom3: api/geom3.md
+      - Metrology: api/metrology.md
+      - Airfoil: api/airfoil.md
+      - Plot: api/plot.md
 
 markdown_extensions:
   - pymdownx.arithmatex:
@@ -34,6 +41,14 @@ markdown_extensions:
   - pymdownx.superfences
   - admonition
 
+plugins:
+  - mkdocstrings:
+      handlers:
+        python:
+          options:
+            docstring_style: sphinx
+          paths: [python]
+
 extra_javascript:
   - javascripts/mathjax.js
   - https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js

engeom-0.2.7/python/engeom/_plot/__init__.py

@@ -0,0 +1 @@
+from .common import LabelPlace

engeom-0.2.7/python/engeom/_plot/common.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+class LabelPlace(Enum):
+    """
+    Represents the different locations where a label can be placed between its anchor points.
+    """
+
+    Outside = 1
+    """ The label is placed outside the anchor points, on the side of the second point in the measurement. """
+
+    Inside = 2
+    """ The label is placed between the two anchor points. """
+
+    OutsideRev = 3
+    """ The label is placed outside the two anchor points, on the side of the first point in the measurement. """
+
+