engeom 0.2.11__tar.gz → 0.2.12__tar.gz

{engeom-0.2.11 → engeom-0.2.12}/Cargo.lock

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

{engeom-0.2.11 → engeom-0.2.12}/Cargo.toml

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

{engeom-0.2.11 → engeom-0.2.12}/PKG-INFO

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

{engeom-0.2.11 → engeom-0.2.12}/python/engeom/geom2.pyi

@@ -138,6 +138,22 @@ class Vector2(Iterable[float]):
         """
         ...
 
+    def with_x(self, x: float) -> Vector2:
+        """
+        Return a new vector with the same y component as this vector, but with the x component set to the given value.
+        :param x: the new x component of the vector.
+        :return: a new vector with the same y component as this vector, but with the x component set to the given value.
+        """
+        ...
+
+    def with_y(self, y: float) -> Vector2:
+        """
+        Return a new vector with the same x component as this vector, but with the y component set to the given value.
+        :param y: the new y component of the vector.
+        :return: a new vector with the same x component as this vector, but with the y component set to the given value.
+        """
+        ...
+
 
 class Point2(Iterable[float]):
     """
@@ -243,6 +259,22 @@ class Point2(Iterable[float]):
         """
         ...
 
+    def with_x(self, x: float) -> Point2:
+        """
+        Return a new point with the same y component as this point, but with the x component set to the given value.
+        :param x: the new x component of the point.
+        :return: a new point with the same y component as this point, but with the x component set to the given value.
+        """
+        ...
+
+    def with_y(self, y: float) -> Point2:
+        """
+        Return a new point with the same x component as this point, but with the y component set to the given value.
+        :param y: the new y component of the point.
+        :return: a new point with the same x component as this point, but with the y component set to the given value.
+        """
+        ...
+
 
 class SurfacePoint2:
     """
@@ -950,6 +982,43 @@ class Circle2:
         """
         ...
 
+    @staticmethod
+    def fitting(points: NDArray[float], guess: Circle2 | None = None, sigma: float | None = None) -> Circle2:
+        """
+        Fit a circle to a set of points using an unconstrained Levenberg-Marquardt minimization of the sum of
+        squared errors between the points and the boundary of the circle.
+
+        The initial guess is used to provide a starting point for the optimization. If no guess is provided, the
+        unit circle will be used.
+
+        The sigma parameter is used to weight the points in the optimization. If no sigma is provided, all points
+        will be weighted equally, otherwise points beyond `sigma` standard deviations from the mean will be
+        assigned a weight of 0.0.
+        :param points: the points to fit the circle to.
+        :param guess: an optional initial guess for the circle. If None, the unit circle will be used.
+        :param sigma: an optional standard deviation to use for weighting the points. If None, all points will be
+        weighted equally.
+        :return: a new `Circle2` object representing the fitted circle.
+        """
+        ...
+
+    @staticmethod
+    def ransac(points: NDArray[float], tol: float, iterations: int | None = None, min_r: float | None = None,
+               max_r: float | None = None) -> Circle2:
+        """
+        Fit a circle to a set of points using the RANSAC algorithm. The algorithm will randomly sample points from the
+        input set and fit a circle to them, then check how many points are within the given tolerance of the fitted
+        circle. The best fitting circle will be returned.
+
+        :param points: the points to fit the circle to.
+        :param tol: the tolerance for the RANSAC algorithm.
+        :param iterations: the number of iterations to run. If None, a default value of 500 will be used.
+        :param min_r: the minimum radius of the circle. If None, no minimum will be enforced.
+        :param max_r: the maximum radius of the circle. If None, no maximum will be enforced.
+        :return: a new `Circle2` object representing the fitted circle.
+        """
+        ...
+
 
 class Arc2:
     """
@@ -1148,3 +1217,11 @@ class Aabb2:
         :return: a new AABB object with the shrunk bounds.
         """
         ...
+
+    def merged(self, other: Aabb2) -> Aabb2:
+        """
+        Merge this AABB with another AABB and return a new AABB.
+        :param other: the other AABB to merge with.
+        :return: a new AABB object that is the result of merging this AABB with the other AABB.
+        """
+        ...

{engeom-0.2.11 → engeom-0.2.12}/python/engeom/geom3.pyi

@@ -150,6 +150,33 @@ class Vector3(Iterable[float]):
         """
         ...
 
+    def with_x(self, x: float) -> Vector3:
+        """
+        Return a new vector with the same y and z components as this vector, but with the x component set to the
+        specified value.
+        :param x: the new x component of the vector.
+        :return: a new vector with the specified x component.
+        """
+        ...
+
+    def with_y(self, y: float) -> Vector3:
+        """
+        Return a new vector with the same x and z components as this vector, but with the y component set to the
+        specified value.
+        :param y: the new y component of the vector.
+        :return: a new vector with the specified y component.
+        """
+        ...
+
+    def with_z(self, z: float) -> Vector3:
+        """
+        Return a new vector with the same x and y components as this vector, but with the z component set to the
+        specified value.
+        :param z: the new z component of the vector.
+        :return: a new vector with the specified z component.
+        """
+        ...
+
 
 class Point3(Iterable[float]):
     """
@@ -267,6 +294,33 @@ class Point3(Iterable[float]):
         """
         ...
 
+    def with_x(self, x: float) -> Point3:
+        """
+        Return a new point with the same y and z coordinates as this point, but with the x coordinate set to the
+        specified value.
+        :param x: the new x coordinate of the point.
+        :return: a new point with the specified x coordinate.
+        """
+        ...
+
+    def with_y(self, y: float) -> Point3:
+        """
+        Return a new point with the same x and z coordinates as this point, but with the y coordinate set to the
+        specified value.
+        :param y: the new y coordinate of the point.
+        :return: a new point with the specified y coordinate.
+        """
+        ...
+
+    def with_z(self, z: float) -> Point3:
+        """
+        Return a new point with the same x and y coordinates as this point, but with the z coordinate set to the
+        specified value.
+        :param z: the new z coordinate of the point.
+        :return: a new point with the specified z coordinate.
+        """
+        ...
+
 
 class SurfacePoint3:
     """
@@ -1273,7 +1327,8 @@ class Mesh:
         ...
 
     @staticmethod
-    def create_rect_beam_between(p0: Point3, p1: Point3, width: float, height: float, up: Vector3 | None = None) -> Mesh:
+    def create_rect_beam_between(p0: Point3, p1: Point3, width: float, height: float,
+                                 up: Vector3 | None = None) -> Mesh:
         """
         Create a rectangular cross-sectioned prism between two points with a specified width and height. The prism will
         be centered between the two points and oriented along the line connecting them. The up vector's projection onto
@@ -1687,6 +1742,15 @@ class Aabb3:
         """
         ...
 
+    def merged(self, other: Aabb3) -> Aabb3:
+        """
+        Merge this AABB with another AABB. The resulting AABB will be the smallest AABB that contains both AABBs.
+
+        :param other: the other AABB to merge with.
+        :return: a new AABB object representing the merged bounds.
+        """
+        ...
+
 
 class RayBundle3:
     """

{engeom-0.2.11 → engeom-0.2.12}/src/bounding.rs

@@ -114,6 +114,12 @@ impl Aabb2 {
         use parry2d_f64::bounding_volume::BoundingVolume;
         Aabb2::from_inner(self.inner.tightened(d))
     }
+
+    fn merged(&self, other: &Self) -> Self {
+        use parry2d_f64::bounding_volume::BoundingVolume;
+        let merged = self.get_inner().merged(other.get_inner());
+        Aabb2::from_inner(merged)
+    }
 }
 
 // ================================================================================================
@@ -238,4 +244,10 @@ impl Aabb3 {
         use parry3d_f64::bounding_volume::BoundingVolume;
         Aabb3::from_inner(self.inner.tightened(d))
     }
+
+    fn merged(&self, other: &Self) -> Self {
+        use parry3d_f64::bounding_volume::BoundingVolume;
+        let merged = self.get_inner().merged(other.get_inner());
+        Aabb3::from_inner(merged)
+    }
 }

{engeom-0.2.11 → engeom-0.2.12}/src/conversions.rs

@@ -1,7 +1,7 @@
 //! This module has conversion helpers for numpy arrays and other engeom types
 
 use engeom::{Point2, Point3, Vector2, Vector3};
-use numpy::ndarray::{ArrayD, ArrayViewD};
+use numpy::ndarray::{ArrayD, ArrayView2, ArrayViewD};
 use pyo3::exceptions::PyValueError;
 use pyo3::PyResult;
 
@@ -83,6 +83,19 @@ pub fn array_to_vectors3(array: &ArrayViewD<'_, f64>) -> PyResult<Vec<Vector3>>
         .collect())
 }
 
+pub fn array2_to_points2(array: &ArrayView2<'_, f64>) -> PyResult<Vec<Point2>> {
+    let shape = array.shape();
+    if shape.len() != 2 || shape[1] != 2 {
+        return Err(PyValueError::new_err("Expected Nx2 array of points"));
+    }
+
+    Ok(array
+        .rows()
+        .into_iter()
+        .map(|row| Point2::new(row[0], row[1]))
+        .collect())
+}
+
 pub fn array_to_points2(array: &ArrayViewD<'_, f64>) -> PyResult<Vec<Point2>> {
     let shape = array.shape();
     if shape.len() != 2 || shape[1] != 2 {

{engeom-0.2.11 → engeom-0.2.12}/src/geom2.rs

@@ -1,11 +1,14 @@
 use crate::bounding::Aabb2;
 use crate::common::Resample;
-use crate::conversions::{array_to_points2, array_to_vectors2, points_to_array2};
+use crate::conversions::{
+    array2_to_points2, array_to_points2, array_to_vectors2, points_to_array2,
+};
 use crate::geom3::Point3;
 use engeom::geom2::{HasBounds2, Line2};
-use engeom::To3D;
+use engeom::{BestFit, To3D};
+use engeom::airfoil::OpenEdge;
 use numpy::ndarray::{Array1, ArrayD};
-use numpy::{IntoPyArray, PyArray1, PyArrayDyn, PyReadonlyArrayDyn};
+use numpy::{IntoPyArray, PyArray1, PyArrayDyn, PyReadonlyArray2, PyReadonlyArrayDyn};
 use pyo3::exceptions::PyValueError;
 use pyo3::types::PyIterator;
 use pyo3::{
@@ -136,6 +139,18 @@ impl Vector2 {
     fn angle_to(&self, other: Vector2) -> f64 {
         self.inner.angle(&other.inner)
     }
+
+    fn with_x(&self, x: f64) -> Self {
+        Self {
+            inner: engeom::Vector2::new(x, self.inner.y),
+        }
+    }
+
+    fn with_y(&self, y: f64) -> Self {
+        Self {
+            inner: engeom::Vector2::new(self.inner.x, y),
+        }
+    }
 }
 
 // ================================================================================================
@@ -246,6 +261,18 @@ impl Point2 {
             b.get_inner(),
         ))
     }
+
+    fn with_x(&self, x: f64) -> Self {
+        Self {
+            inner: engeom::Point2::new(x, self.inner.y),
+        }
+    }
+
+    fn with_y(&self, y: f64) -> Self {
+        Self {
+            inner: engeom::Point2::new(self.inner.x, y),
+        }
+    }
 }
 
 // ================================================================================================
@@ -426,6 +453,52 @@ impl Circle2 {
     fn point_at_angle(&self, angle: f64) -> Point2 {
         Point2::from_inner(self.inner.point_at_angle(angle))
     }
+
+    #[staticmethod]
+    #[pyo3(signature=(points, guess=None, sigma=None))]
+    fn fitting<'py>(
+        points: PyReadonlyArray2<'py, f64>,
+        guess: Option<Circle2>,
+        sigma: Option<f64>,
+    ) -> PyResult<Self> {
+        let points = array2_to_points2(&points.as_array())?;
+        let guess = if let Some(c) = guess {
+            c.get_inner().clone()
+        } else {
+            engeom::Circle2::new(0.0, 0.0, 1.0)
+        };
+
+        let mode = if let Some(s) = sigma {
+            BestFit::Gaussian(s)
+        } else {
+            BestFit::All
+        };
+
+        let circle = engeom::Circle2::fitting_circle(&points, &guess, mode)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self::from_inner(circle))
+    }
+
+    #[staticmethod]
+    #[pyo3(signature=(points, tol, iterations=None, min_r=None, max_r=None))]
+    fn ransac<'py>(
+        points: PyReadonlyArray2<'py, f64>,
+        tol: f64,
+        iterations: Option<usize>,
+        min_r: Option<f64>,
+        max_r: Option<f64>,
+    ) -> PyResult<Self> {
+        let points = array2_to_points2(&points.as_array())?;
+        let result = engeom::Circle2::ransac(
+            &points,
+            tol,
+            iterations,
+            min_r,
+            max_r,
+        )
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self::from_inner(result))
+    }
 }
 
 // ================================================================================================

{engeom-0.2.11 → engeom-0.2.12}/src/geom3.rs

@@ -139,6 +139,24 @@ impl Vector3 {
     fn angle_to(&self, other: Vector3) -> f64 {
         self.inner.angle(&other.inner)
     }
+
+    fn with_z(&self, z: f64) -> Self {
+        Self {
+            inner: engeom::Vector3::new(self.inner.x, self.inner.y, z),
+        }
+    }
+
+    fn with_x(&self, x: f64) -> Self {
+        Self {
+            inner: engeom::Vector3::new(x, self.inner.y, self.inner.z),
+        }
+    }
+
+    fn with_y(&self, y: f64) -> Self {
+        Self {
+            inner: engeom::Vector3::new(self.inner.x, y, self.inner.z),
+        }
+    }
 }
 
 // ================================================================================================
@@ -256,6 +274,24 @@ impl Point3 {
             b.get_inner(),
         ))
     }
+
+    fn with_x(&self, x: f64) -> Self {
+        Self {
+            inner: engeom::Point3::new(x, self.inner.y, self.inner.z),
+        }
+    }
+
+    fn with_y(&self, y: f64) -> Self {
+        Self {
+            inner: engeom::Point3::new(self.inner.x, y, self.inner.z),
+        }
+    }
+
+    fn with_z(&self, z: f64) -> Self {
+        Self {
+            inner: engeom::Point3::new(self.inner.x, self.inner.y, z),
+        }
+    }
 }
 
 // ================================================================================================
@@ -630,58 +666,6 @@ impl XyzWpr {
     }
 }
 
-// #[pymethods]
-// impl XyzWpr {
-//     #[new]
-//     fn new(x: f64, y: f64, z: f64, w: f64, p: f64, r: f64) -> Self {
-//         Self {
-//             inner: engeom::geom3::XyzWpr::new(x, y, z, w, p, r),
-//         }
-//     }
-//
-//     #[getter]
-//     fn values(&self) -> Vec<f64> {
-//         vec![
-//             self.inner.x,
-//             self.inner.y,
-//             self.inner.z,
-//             self.inner.w,
-//             self.inner.p,
-//             self.inner.r,
-//         ]
-//     }
-//
-//     #[getter]
-//     fn x(&self) -> f64 {
-//         self.inner.x
-//     }
-//
-//     #[getter]
-//     fn y(&self) -> f64 {
-//         self.inner.y
-//     }
-//
-//     #[getter]
-//     fn z(&self) -> f64 {
-//         self.inner.z
-//     }
-//
-//     #[getter]
-//     fn w(&self) -> f64 {
-//         self.inner.w
-//     }
-//
-//     #[getter]
-//     fn p(&self) -> f64 {
-//         self.inner.p
-//     }
-//
-//     #[getter]
-//     fn r(&self) -> f64 {
-//         self.inner.r
-//     }
-// }
-
 #[derive(FromPyObject)]
 enum Transformable3 {
     Iso(Iso3),