engeom 0.1.2__cp38-abi3-win32.whl → 0.2.1__cp38-abi3-win32.whl

engeom/airfoil/__init__.py

@@ -0,0 +1,5 @@
+from ..engeom import _airfoil
+
+# Global import of all functions
+for name in [n for n in dir(_airfoil) if not n.startswith("_")]:
+    globals()[name] = getattr(_airfoil, name)

engeom/airfoil.pyi

@@ -0,0 +1,334 @@
+from typing import List
+
+import numpy
+from enum import Enum
+
+from .geom2 import Circle2, Curve2, Point2, SurfacePoint2, Arc2
+from .metrology import Length2
+
+type MclOrientEnum = MclOrient.TmaxFwd | MclOrient.DirFwd
+type FaceOrientEnum = FaceOrient.Detect | FaceOrient.UpperDir
+type EdgeFindEnum = EdgeFind.Open | EdgeFind.OpenIntersect | EdgeFind.Intersect | EdgeFind.RansacRadius
+type EdgeTypeEnum = EdgeType | Arc2
+type AfGageEnum = AfGage.OnCamber | AfGage.Radius
+
+class EdgeType(Enum):
+    Open=0
+    Closed=1
+
+class AfGage:
+    """
+    A class representing a measurement for locating a position on an airfoil cross-section.
+    """
+    class OnCamber:
+        def __init__(self, d: float):
+            """
+            A gaging method that measures a distance along the mean camber line. A positive distance will be from the
+            leading edge towards the trailing edge, and a negative distance will be from the trailing edge towards the
+            leading edge.
+            :param d: the distance along the mean camber line to find the position
+            """
+            ...
+
+    class Radius:
+        def __init__(self, r: float):
+            """
+            A gaging method that measures by intersection with a circle of a given radius centered on either the
+            leading or trailing edge point.  A positive radius indicates that the circle is located on the leading edge
+            while a negative radius indicates that the circle is located on the trailing edge.
+            :param r: the radius of the circle to find the position
+            """
+            ...
+
+class FaceOrient:
+    """
+    An enumeration of the possible ways to orient the upper/lower (suction/pressure, convex/concave) faces of an
+    airfoil cross-section.
+    """
+
+    class Detect:
+        """
+        In an airfoil with an MCL that exhibits curvature, this will attempt to detect which direction the camber line
+        curves and thus identify convex/concave. This will fail if the MCL is straight.
+        """
+        ...
+
+    class UpperDir:
+        """
+        This method will orient the faces based on a vector direction provided by the user.
+        """
+
+        def __init__(self, x: float, y: float):
+            """
+            Create a new upper direction parameter. The x and y arguments are components of a direction vector which
+            should distinguish the upper (pressure side, convex) face of the airfoil. At the center of the mean camber
+            line, an intersection in this direction will be taken with each of the two faces. The intersection that
+            is further in the direction of this vector will be considered the upper face of the airfoil, and the other
+            will be considered the lower face.
+
+            :param x: the x component of the upper direction vector
+            :param y: the y component of the upper direction vector
+            """
+            ...
+
+
+class MclOrient:
+    """
+    An enumeration of the possible ways to orient (to identify which side is the leading edge and which side is the
+    trailing edge) the mean camber line of an airfoil.
+    """
+
+    class TmaxFwd:
+        """
+        This method will take advantage of the fact that for most typical subsonic airfoils the maximum thickness point
+        is closer to the leading edge than the trailing edge.
+        """
+        ...
+
+    class DirFwd:
+        """
+        This method will orient the airfoil based on a vector direction provided by the user.
+        """
+
+        def __init__(self, x: float, y: float):
+            """
+            Create a new forward direction parameter. The x and y arguments are components of a direction vector which
+            should distinguish the forward (leading edge) direction of the airfoil. The position of the first and last
+            inscribed circle will be projected onto this vector, and the larger result (the one that is more in the
+            direction of this vector) will be considered the leading edge of the airfoil.
+
+            For instance, if you know that the airfoil is oriented so that the leading edge will have a smaller x value
+            than the trailing edge, `DirFwd(-1, 0)` will correctly orient the airfoil.
+            :param x: the x component of the forward direction vector
+            :param y: the y component of the forward direction vector
+            """
+            ...
+
+
+class EdgeFind:
+    """
+    An enumeration of the possible techniques to find the leading and/or trailing edge geometry of an airfoil.
+    """
+
+    class Open:
+        """
+        This algorithm will not attempt to find edge geometry, and will simply leave the inscribed circles for the side
+        as they are. Use this if you know that the airfoil cross-section is open/incomplete on this side, and you don't
+        care to extend the MCL any further.
+        """
+        ...
+
+    class OpenIntersect:
+        def __init__(self, max_iter: int):
+            """
+            This algorithm will attempt to find the edge geometry by intersecting the end of the inscribed circles
+            camber curve with the open gap in the airfoil cross-section, then refining the end of the MCL with more
+            inscribed circles until the location of the end converges to within 1/100th of the general refinement
+            tolerance.
+
+            If the maximum number of iterations is reached before convergence, the method will throw an error instead.
+
+            :param max_iter: the maximum number of iterations to attempt to find the edge geometry
+            """
+            ...
+
+    class Intersect:
+        """
+        This algorithm will simply intersect the end of the inscribed circles camber curve with the airfoil
+        cross-section. This is the fastest method with the least amount of assumptions, and makes sense for airfoil
+        edges where you know the mean camber line has very low curvature in the vicinity of the edge.
+        """
+        ...
+
+    class RansacRadius:
+        def __init__(self, in_tol: float, n: int = 500):
+            """
+            This algorithm uses RANSAC (Random Sample Consensus) to find a constant radius leading edge circle that
+            fits the greatest number of points leftover at the edge within the tolerance `in_tol`.
+
+            The method will try `n` different combinations of three points picked at random from the remaining points
+            at the edge, construct a circle, and then count the number of points within `in_tol` distance of the circle
+            perimeter. The circle with the most points within tolerance will be considered the last inscribed circle.
+
+            The MCL will be extended to this final circle, and then intersected with the airfoil cross-section to find
+            the final edge point.
+
+            :param in_tol: the max distance from the circle perimeter for a point to be considered a RANSAC inlier
+            :param n: The number of RANSAC iterations to perform
+            """
+            ...
+
+
+class InscribedCircle:
+    @property
+    def circle(self) -> Circle2: ...
+
+    @property
+    def contact_a(self) -> Point2:
+        """
+        A contact point of the inscribed circle with one side of the airfoil cross-section. Inscribed circles computed
+        together will have a consistent meaning of `a` and `b` sides, but which is the upper or lower surface will
+        depend on the ordering of the circles and the coordinate system of the airfoil.
+        """
+        ...
+
+    @property
+    def contact_b(self) -> Point2:
+        """
+        The other contact point of the inscribed circle with the airfoil cross-section. Inscribed circles computed
+        together will have a consistent meaning of `a` and `b` sides, but which is the upper or lower surface will
+        depend on the ordering of the circles and the coordinate system of the airfoil.
+        """
+        ...
+
+
+class EdgeResult:
+    """
+    Represents the results of an edge detection algorithm
+    """
+
+    @property
+    def point(self) -> Point2:
+        """
+        The point on the airfoil cross-section that was detected as the edge.
+        """
+        ...
+
+    @property
+    def geometry(self):
+        ...
+
+
+class AirfoilGeometry:
+    """
+    The result of an airfoil geometry computation.
+    """
+
+    @staticmethod
+    def from_analyze(
+            section: Curve2,
+            refine_tol: float,
+            camber_orient: MclOrientEnum,
+            leading: EdgeFindEnum,
+            trailing: EdgeFindEnum,
+            face_orient: FaceOrientEnum,
+    ) -> AirfoilGeometry:
+        ...
+
+    @property
+    def leading(self) -> EdgeResult | None:
+        """
+        The result of the leading edge detection algorithm.
+        """
+        ...
+
+    @property
+    def trailing(self) -> EdgeResult | None:
+        """
+        The result of the trailing edge detection algorithm.
+        """
+        ...
+
+    @property
+    def camber(self) -> Curve2:
+        """
+        The mean camber line of the airfoil cross-section. The curve will be oriented so that the first point is at
+        the leading edge of the airfoil and the last point is at the trailing edge.
+        :return:
+        """
+        ...
+
+    @property
+    def upper(self) -> Curve2 | None:
+        """
+        The curve representing the upper (suction, convex) side of the airfoil cross-section. The curve will be oriented
+        in the same winding direction as the original section, so the first point may be at either the leading or
+        trailing edge based on the airfoil geometry and the coordinate system.
+
+        :return: A Curve2, or None if there was an issue detecting the leading or trailing edge.
+        """
+        ...
+
+    @property
+    def lower(self) -> Curve2 | None:
+        """
+        The curve representing the lower (pressure, concave) side of the airfoil cross-section. The curve will be
+        oriented in the same winding direction as the original section, so the first point may be at either the leading
+        or trailing edge based on the airfoil geometry and the coordinate system.
+
+        :return: A Curve2, or None if there was an issue detecting the leading or trailing edge.
+        """
+        ...
+
+    @property
+    def circle_array(self) -> numpy.ndarray[float]:
+        """
+        Returns the list of inscribed circles as a numpy array of shape (N, 3) where N is the number of inscribed
+        circles. The first two columns are the x and y coordinates of the circle center, and the third column is the
+        radius of the circle.
+        """
+        ...
+
+    def get_thickness(self, gage: AfGageEnum) -> Length2:
+        """
+        Get the thickness dimension of the airfoil cross-section.
+        :param gage: the gaging method to use
+        :return:
+        """
+        ...
+
+    def get_tmax(self) -> Length2:
+        """
+        Get the maximum thickness dimension of the airfoil cross-section.
+        :return:
+        """
+        ...
+
+    def get_tmax_circle(self) -> Circle2:
+        """
+        Get the circle representing the maximum thickness dimension of the airfoil cross-section.
+        :return:
+        """
+        ...
+
+
+def compute_inscribed_circles(section: Curve2, refine_tol: float) -> List[InscribedCircle]:
+    """
+    Compute the unambiguous inscribed circles of an airfoil cross-section.
+
+    The cross-section is represented by a curve in the x-y plane. The curve does not need to be closed, but the points
+    should be oriented in a counter-clockwise direction and should only contain data from the outer surface of the
+    airfoil (internal features/points should not be part of the data).
+
+    The method used to compute these circles is:
+
+    1. We calculate the convex hull of the points in the section and find the longest distance between any two points.
+    2. At the center of the longest distance line, we draw a perpendicular line and look for exactly two intersections
+       with the section. We assume that one of these is on the upper surface of the airfoil and the other is on the
+       lower, though it does not matter which is which.
+    3. We fit the maximum inscribed circle whose center is constrained to the line between these two points. The
+       location and radius of this circle is refined until it converges to within 1/100th of `refine_tol`.
+    4. The inscribed circle has two contact points with the section. The line between these contact points is a good
+       approximation of the direction orthogonal to the mean camber line near the circle.  We create a parallel line
+       to this one, advancing from the circle center by 1/4 of the circle radius, and looking for exactly two
+       intersections with the section.  If we fail, we try again with a slightly less aggressive advancement until we
+       either succeed or give up.
+    5. We fit the maximum inscribed circle whose center is constrained to the new line, and refine it as in step 3.
+    6. We recursively fit inscribed circles between this new circle and the previous one until the error between the
+       position and radius of any circle is less than `refine_tol` from the linear interpolation between its next and
+       previous neighbors.
+    7. We repeat the process from step 4 until the distance between the center of the most recent circle and the
+       farthest point in the direction of the next advancement is less than 1/4 of the radius of the most recent
+       circle. This terminates the process before we get too close to the leading or trailing edge of the airfoil.
+    8. We repeat the process from step 3, but this time in the opposite direction from the first circle. This will
+       give us the inscribed circles on the other side of the airfoil.
+
+    When finished, we have a list of inscribed circles from the unambiguous regions (not too close to the leading or
+    trailing edges) of the airfoil cross-section. The circles are ordered from one side of the airfoil to the other,
+    but the order may be *either* from the leading to the trailing edge *or* vice versa.
+
+    :param section: the curve representing the airfoil cross-section.
+    :param refine_tol: a tolerance used when refining the inscribed circles, see description for details.
+    :return: a list of inscribed circle objects whose order is contiguous but may be in either direction
+    """
+    ...

engeom/align.pyi

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import numpy
-from typing import Any, List, Tuple, Union
-from .engeom import DeviationMode, Iso3, Mesh
+from .engeom import DeviationMode
+from .geom3 import Mesh, Iso3
 
 
 def points_to_mesh(

engeom/engeom.pyi

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from enum import Enum
 
-type Resample = Resample_ByCount | Resample_BySpacing | Resample_ByMaxSpacing
+type Resample = Resample_Count | Resample_Spacing | Resample_MaxSpacing
 
 class DeviationMode(Enum):
-    Absolute = 0
-    Normal = 1
+    Point = 0
+    Plane = 1

engeom/geom2.pyi

@@ -1,13 +1,14 @@
 from __future__ import annotations
 import numpy
-from typing import Iterable, Tuple
+from typing import Iterable, Tuple, Type, TypeVar
 
 from engeom.engeom import Resample
 
-type Transformable2 = Vector2 | Point2 | Iso2 | SurfacePoint2
+Transformable2 = TypeVar("Transformable2", Vector2, Point2, Iso2, SurfacePoint2)
+PointOrVec2 = TypeVar("PointOrVec2", Point2, Vector2)
 
 
-class Vector2:
+class Vector2(Iterable[float]):
     def __init__(self, x: float, y: float):
         """
 
@@ -24,13 +25,10 @@ class Vector2:
     def y(self) -> float:
         ...
 
-    def __iter__(self) -> Iterable[float]:
-        ...
-
     def __rmul__(self, other: float) -> Vector2:
         ...
 
-    def __add__(self, other: Vector2 | Point2) -> Vector2 | Point2:
+    def __add__(self, other: PointOrVec2) -> PointOrVec2:
         ...
 
     def __sub__(self, other: Vector2) -> Vector2:
@@ -79,7 +77,7 @@ class Vector2:
         ...
 
 
-class Point2:
+class Point2(Iterable[float]):
     def __init__(self, x: float, y: float):
         """
 
@@ -96,9 +94,6 @@ class Point2:
     def y(self) -> float:
         ...
 
-    def __iter__(self) -> Iterable[float]:
-        ...
-
     @property
     def coords(self) -> Vector2:
         """
@@ -107,7 +102,7 @@ class Point2:
         """
         ...
 
-    def __sub__(self, other: Vector2 | Point2) -> Vector2 | Point2:
+    def __sub__(self, other: PointOrVec2) -> PointOrVec2:
         ...
 
     def __add__(self, other: Vector2) -> Vector2:
@@ -194,6 +189,17 @@ class SurfacePoint2:
         """
         ...
 
+    def shift_orthogonal(self, distance: float) -> SurfacePoint2:
+        """
+        Shift the surface point by a distance orthogonal to the normal vector. The direction of travel is the surface
+        point's normal vector rotated 90 degrees clockwise. For instance, if the normal vector is (0, 1), a positive
+        distance will move the point to the right and a negative distance will move the point to the left.
+
+        :param distance: the distance to shift the surface point.
+        :return: a new surface point shifted by the given distance.
+        """
+        ...
+
 
 class Iso2:
     def __init__(self, tx: float, ty: float, r: float):
@@ -212,7 +218,7 @@ class Iso2:
         """
         ...
 
-    def __matmul__(self, other: Iso2 | Vector2 | Point2) -> Iso2 | Vector2 | Point2:
+    def __matmul__(self, other: Transformable2) -> Transformable2:
         ...
 
     def inverse(self) -> Iso2:
@@ -316,7 +322,7 @@ class Curve2:
             self,
             vertices: numpy.ndarray,
             normals: numpy.ndarray | None = None,
-            tol: float | None = None,
+            tol: float = 1e-6,
             force_closed: bool = False,
             hull_ccw: bool = False,
     ):
@@ -479,9 +485,10 @@ class Curve2:
         """
         ...
 
-    def clone_points(self) -> numpy.ndarray[float]:
+    @property
+    def points(self) -> numpy.ndarray[float]:
         """
-        Clone the points of the curve.
+        Get the points of the curve.
         :return: a numpy array of shape (N, 2) representing the points of the curve.
         """
         ...
@@ -514,3 +521,214 @@ class Curve2:
         :return: a new curve object with the transformed vertices.
         """
         ...
+
+
+class Circle2:
+    def __init__(self, x: float, y: float, r: float):
+        """
+
+        :param x:
+        :param y:
+        :param r:
+        """
+        ...
+
+
+    @property
+    def center(self) -> Point2:
+        """
+        Get the center of the circle.
+        :return: the center of the circle.
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        """
+        Get the x-coordinate of the circle.
+        :return: the x-coordinate of the circle.
+        """
+        ...
+
+    @property
+    def y(self) -> float:
+        """
+        Get the y-coordinate of the circle.
+        :return: the y-coordinate of the circle.
+        """
+        ...
+
+    @property
+    def r(self) -> float:
+        """
+        Get the radius of the circle.
+        :return: the radius of the circle.
+        """
+        ...
+
+    @property
+    def aabb(self) -> Aabb2:
+        """
+        Get the axis-aligned bounding box of the circle.
+        :return: the axis-aligned bounding box of the circle.
+        """
+        ...
+
+
+class Arc2:
+    def __init__(self, x: float, y: float, r: float, start_radians: float, sweep_radians: float):
+        """
+
+        :param x:
+        :param y:
+        :param r:
+        :param start_radians:
+        :param sweep_radians:
+        """
+
+    @property
+    def center(self) -> Point2:
+        """
+        Get the center of the arc.
+        :return: the center of the arc.
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        """
+        Get the x-coordinate of the arc.
+        :return: the x-coordinate of the arc.
+        """
+        ...
+
+    @property
+    def y(self) -> float:
+        """
+        Get the y-coordinate of the arc.
+        :return: the y-coordinate of the arc.
+        """
+        ...
+
+    @property
+    def r(self) -> float:
+        """
+        Get the radius of the arc.
+        :return: the radius of the arc.
+        """
+        ...
+
+    @property
+    def start(self) -> float:
+        """
+        Get the start angle of the arc in radians.
+        :return: the start angle of the arc in radians.
+        """
+        ...
+
+    @property
+    def sweep(self) -> float:
+        """
+        Get the sweep angle of the arc in radians.
+        :return: the sweep angle of the arc in radians.
+        """
+        ...
+
+    @property
+    def aabb(self) -> Aabb2:
+        """
+        Get the axis-aligned bounding box of the arc.
+        :return: the axis-aligned bounding box of the arc.
+        """
+        ...
+
+    @property
+    def start_point(self) -> Point2:
+        """
+        Get the start point of the arc.
+        :return: the start point of the arc.
+        """
+        ...
+
+    @property
+    def end_point(self) -> Point2:
+        """
+        Get the end point of the arc.
+        :return: the end point of the arc.
+        """
+        ...
+
+class Aabb2:
+    def __init__(self, x_min: float, x_max: float, y_min: float, y_max: float):
+        """
+
+        :param x_min:
+        :param x_max:
+        :param y_min:
+        :param y_max:
+        """
+        ...
+
+    @staticmethod
+    def at_point(x: float, y: float, w: float, h: float | None = None) -> Aabb2:
+        """
+        Create an AABB centered at a point with a given width and height.
+        :param x: the x-coordinate of the center of the AABB.
+        :param y: the y-coordinate of the center of the AABB.
+        :param w: the width of the AABB.
+        :param h: the height of the AABB. If not provided, the AABB will be square.
+        :return: a new AABB object.
+        """
+        ...
+
+    @property
+    def min(self) -> Point2:
+        """
+        Get the minimum point of the AABB.
+        :return: the minimum point of the AABB.
+        """
+        ...
+
+    @property
+    def max(self) -> Point2:
+        """
+        Get the maximum point of the AABB.
+        :return: the maximum point of the AABB.
+        """
+        ...
+
+    @property
+    def center(self) -> Point2:
+        """
+        Get the center point of the AABB.
+        :return: the center point of the AABB.
+        """
+        ...
+
+    @property
+    def extent(self) -> Vector2:
+        """
+        Get the extent of the AABB.
+        :return: the extent of the AABB.
+        """
+        ...
+
+    def expand(self, d: float) -> Aabb2:
+        """
+        Expand the AABB by a given distance in all directions. The resulting height and
+        width will be increased by 2 * d.
+
+        :param d: the distance to expand the AABB by.
+        :return: a new AABB object with the expanded bounds.
+        """
+        ...
+
+    def shrink(self, d: float) -> Aabb2:
+        """
+        Shrink the AABB by a given distance in all directions. The resulting height and
+        width will be decreased by 2 * d.
+
+        :param d: the distance to shrink the AABB by.
+        :return: a new AABB object with the shrunk bounds.
+        """
+        ...

engeom/geom3.pyi

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple, Iterable, List
+from typing import Tuple, Iterable, List, TypeVar
 
 import numpy
 from engeom import DeviationMode, Resample
 
-type Transformable3 = Vector3 | Point3 | Plane3 | Iso3 | SurfacePoint3
+Transformable3 = TypeVar("Transformable3", Vector3, Point3, Plane3, Iso3, SurfacePoint3)
+PointOrVector3 = TypeVar("PointOrVector3", Vector3, Point3)
 
 
 class Vector3:
@@ -37,7 +38,7 @@ class Vector3:
     def __rmul__(self, other: float) -> Vector3:
         ...
 
-    def __add__(self, other: Vector3 | Point3) -> Vector3 | Point3:
+    def __add__(self, other: PointOrVector3) -> PointOrVector3:
         ...
 
     def __sub__(self, other: Vector3) -> Vector3:
@@ -125,7 +126,7 @@ class Point3:
         """
         ...
 
-    def __sub__(self, other: Vector3 | Point3) -> Vector3 | Point3:
+    def __sub__(self, other: PointOrVector3) -> PointOrVector3:
         ...
 
     def __add__(self, other: Vector3) -> Vector3:
@@ -434,8 +435,8 @@ class Mesh:
             self,
             vertices: numpy.ndarray[float],
             triangles: numpy.ndarray[numpy.uint32],
-            merge_duplicates: bool | None = None,
-            delete_degenerate: bool | None = None
+            merge_duplicates: bool = False,
+            delete_degenerate: bool = False
     ):
         """
         Create an engeom mesh from vertices and triangles.  The vertices should be a numpy array of shape (n, 3), while
@@ -445,13 +446,18 @@ class Mesh:
 
         :param vertices: a numpy array of shape (n, 3) containing the vertices of the mesh.
         :param triangles: a numpy array of shape (m, 3) containing the triangles of the mesh, should be uint.
-        :param merge_duplicates: merge duplicate vertices and triangles. If None, the default behavior is to do nothing
-        :param delete_degenerate: delete degenerate triangles. If None, the default behavior is to do nothing
+        :param merge_duplicates: merge duplicate vertices and triangles
+        :param delete_degenerate: delete degenerate triangles
         """
         ...
 
+    @property
+    def aabb(self) -> Aabb3:
+        """ Return the axis-aligned bounding box of the mesh. """
+        ...
+
     @staticmethod
-    def load_stl(path: str | Path, merge_duplicates: bool | None = None, delete_degenerate: bool | None = None) -> Mesh:
+    def load_stl(path: str | Path, merge_duplicates: bool = False, delete_degenerate: bool = False) -> Mesh:
         """
         Load a mesh from an STL file. This will return a new mesh object containing the vertices and triangles from the
         file.  Optional parameters can be used to control the behavior of the loader when handling duplicate vertices/
@@ -473,7 +479,7 @@ class Mesh:
         """
         ...
 
-    def clone(self) -> Mesh:
+    def cloned(self) -> Mesh:
         """
         Will return a copy of the mesh. This is a copy of the data, so modifying the returned mesh will not modify the
         original mesh.
@@ -499,21 +505,18 @@ class Mesh:
         """
         ...
 
-    def clone_vertices(self) -> numpy.ndarray[float]:
+    @property
+    def points(self) -> numpy.ndarray[float]:
         """
-        Will return a copy of the vertices of the mesh as a numpy array. If the mesh has not been modified, this will
-        be the same as the original vertices. This is a copy of the data, so modifying the returned array will not
-        modify the mesh.
+        Will return an immutable view of the vertices of the mesh as a numpy array of shape (n, 3).
         :return: a numpy array of shape (n, 3) containing the vertices of the mesh.
         """
         ...
 
-    def clone_triangles(self) -> numpy.ndarray[numpy.uint32]:
+    @property
+    def triangles(self) -> numpy.ndarray[numpy.uint32]:
         """
-        Will return a copy of the triangles of the mesh as a numpy array. If the mesh has not been modified, this will
-        be the same as the original triangles. This is a copy of the data, so modifying the returned array will not
-        modify the mesh.
-
+        Will return an immutable view of the triangles of the mesh as a numpy array of shape (m, 3).
         :return: a numpy array of shape (m, 3) containing the triangles of the mesh.
         """
         ...
@@ -611,11 +614,12 @@ class Curve3:
     between them.
     """
 
-    def __init__(self, vertices: numpy.ndarray):
+    def __init__(self, vertices: numpy.ndarray, tol: float = 1.0e-6):
         """
         Create a curve from a set of vertices. The vertices should be a numpy array of shape (n, 3).
 
         :param vertices: a numpy array of shape (n, 3) containing the vertices of the curve.
+        :param tol: the inherent tolerance of the curve; points closer than this distance will be considered the same.
         """
         ...
 
@@ -636,13 +640,11 @@ class Curve3:
         """
         ...
 
-    def clone_vertices(self) -> numpy.ndarray[float]:
+    @property
+    def points(self) -> numpy.ndarray[float]:
         """
-        Will return a copy of the vertices of the curve as a numpy array. If the curve has not been modified, this will
-        be the same as the original vertices. This is a copy of the data, so modifying the returned array will not
-        modify the curve.
-
-        :return: a numpy array of shape (n, 3) containing the vertices of the curve.
+        Will return an immutable view of the vertices of the mesh as a numpy array of shape (n, 3).
+        :return: a numpy array of shape (n, 3) containing the vertices of the mesh.
         """
         ...
 
@@ -723,3 +725,41 @@ class Curve3:
         :return: a new curve object with the transformed vertices.
         """
         ...
+
+
+class Aabb3:
+    """
+    A class representing an axis-aligned bounding box in 3D space. The box is defined by its minimum and maximum
+    """
+
+    def __init__(self, x_min: float, y_min: float, z_min: float, x_max: float, y_max: float, z_max: float):
+        """
+        Create an axis-aligned bounding box from the minimum and maximum coordinates.
+        :param x_min: the minimum x coordinate of the box.
+        :param y_min: the minimum y coordinate of the box.
+        :param z_min: the minimum z coordinate of the box.
+        :param x_max: the maximum x coordinate of the box.
+        :param y_max: the maximum y coordinate of the box.
+        :param z_max: the maximum z coordinate of the box.
+        """
+        ...
+
+    @property
+    def min(self) -> Point3:
+        """ The minimum point of the box. """
+        ...
+
+    @property
+    def max(self) -> Point3:
+        """ The maximum point of the box. """
+        ...
+
+    @property
+    def center(self) -> Point3:
+        """ The center point of the box. """
+        ...
+
+    @property
+    def extent(self) -> Vector3:
+        """ The extent of the box. """
+        ...

engeom/matplotlib.py

@@ -1,8 +1,18 @@
-from typing import List
-
+from typing import List, Iterable, Tuple, Union
+from enum import Enum
 import matplotlib.lines
 import numpy
-from .geom2 import Curve2
+from .geom2 import Curve2, Circle2, Aabb2, Point2, Vector2, SurfacePoint2
+from .metrology import Length2
+
+PlotCoords = Union[Point2, Vector2, Iterable[float]]
+
+
+class LabelPlace(Enum):
+    Outside = 1
+    Inside = 2
+    OutsideRev = 3
+
 
 try:
     from matplotlib.pyplot import Axes, Circle
@@ -10,18 +20,22 @@ try:
 except ImportError:
     pass
 else:
+
     class GomColorMap(ListedColormap):
         def __init__(self):
-            colors = numpy.array([
-                [1, 0, 160],
-                [1, 0, 255],
-                [0, 254, 255],
-                [0, 160, 0],
-                [0, 254, 0],
-                [255, 255, 0],
-                [255, 128, 0],
-                [255, 1, 0]
-            ], dtype=numpy.float64)
+            colors = numpy.array(
+                [
+                    [1, 0, 160],
+                    [1, 0, 255],
+                    [0, 254, 255],
+                    [0, 160, 0],
+                    [0, 254, 0],
+                    [255, 255, 0],
+                    [255, 128, 0],
+                    [255, 1, 0],
+                ],
+                dtype=numpy.float64,
+            )
             colors /= 256.0
             colors = numpy.hstack((colors, numpy.ones((len(colors), 1))))
             super().__init__(colors)
@@ -30,22 +44,6 @@ else:
 
     GOM_CMAP = GomColorMap()
 
-    def add_curve_plots(ax: Axes, *curves: Curve2, **kwargs) -> List[List[matplotlib.lines.Line2D]]:
-        """
-        Plot a list of curves on a Matplotlib Axes object.
-        :param ax: a Matplotlib Axes object
-        :param curves: a list of Curve2 objects
-        :param kwargs: keyword arguments to pass to the plot function
-        :return: None
-        """
-        actors = []
-        for curve in curves:
-            points = curve.clone_points()
-            a = ax.plot(points[:, 0], points[:, 1], **kwargs)
-            actors.append(a)
-        return actors
-
-
     def set_aspect_fill(ax: Axes):
         """
         Set the aspect ratio of a Matplotlib Axes (subplot) object to be 1:1 in x and y, while also having it expand
@@ -78,3 +76,165 @@ else:
             x_range = x_scale / y_scale * (x1 - x0)
             x_mid = (x0 + x1) / 2
             ax.set_xlim(x_mid - x_range / 2, x_mid + x_range / 2)
+
+    class AxesHelper:
+        def __init__(self, ax: Axes, skip_aspect=False, hide_axes=False):
+            self.ax = ax
+            if not skip_aspect:
+                ax.set_aspect("equal", adjustable="datalim")
+
+            if hide_axes:
+                ax.axis("off")
+
+        def set_bounds(self, box: Aabb2):
+            """
+            Set the bounds of a Matplotlib Axes object.
+            :param box: an Aabb2 object
+            :return: None
+            """
+            self.ax.set_xlim(box.min.x, box.max.x)
+            self.ax.set_ylim(box.min.y, box.max.y)
+
+        def plot_circle(self, *circle: Circle2 | Iterable[float], **kwargs):
+            """
+            Plot a circle on a Matplotlib Axes object.
+            :param circle: a Circle2 object
+            :param kwargs: keyword arguments to pass to the plot function
+            :return: None
+            """
+            from matplotlib.pyplot import Circle
+
+            for cdata in circle:
+                if isinstance(cdata, Circle2):
+                    c = Circle((cdata.center.x, cdata.center.y), cdata.r, **kwargs)
+                else:
+                    x, y, r, *_ = cdata
+                    c = Circle((x, y), r, **kwargs)
+                self.ax.add_patch(c)
+
+        def plot_curve(self, curve: Curve2, **kwargs):
+            """
+            Plot a curve on a Matplotlib Axes object.
+            :param curve: a Curve2 object
+            :param kwargs: keyword arguments to pass to the plot function
+            :return: None
+            """
+            self.ax.plot(curve.points[:, 0], curve.points[:, 1], **kwargs)
+
+        def dimension(
+            self,
+            length: Length2,
+            side_shift: float = 0,
+            format: str = "{value:.3f}",
+            fontsize: int = 10,
+            label_place: LabelPlace = LabelPlace.Outside,
+            label_offset: float | None = None,
+            fontname: str | None = None,
+        ):
+            """
+            Plot a Length2 object on a Matplotlib Axes object.
+            :param side_shift:
+            :param length: a Length2 object
+            :return: None
+            """
+            from matplotlib.pyplot import Line2D
+
+            pad_scale = self._font_height(12) * 1.5
+            center = length.center.shift_orthogonal(side_shift)
+            leader_a = center.projection(length.a)
+            leader_b = center.projection(length.b)
+
+            if label_place == LabelPlace.Inside:
+                label_offset = label_offset or 0.0
+                label_coords = center.at_distance(label_offset)
+                self.arrow(label_coords, leader_a)
+                self.arrow(label_coords, leader_b)
+            elif label_place == LabelPlace.Outside:
+                label_offset = label_offset or pad_scale * 3
+                label_coords = leader_b + length.direction * label_offset
+                self.arrow(leader_a - length.direction * pad_scale, leader_a)
+                self.arrow(label_coords, leader_b)
+            elif label_place == LabelPlace.OutsideRev:
+                label_offset = label_offset or pad_scale * 3
+                label_coords = leader_a - length.direction * label_offset
+                self.arrow(leader_b + length.direction * pad_scale, leader_b)
+                self.arrow(label_coords, leader_a)
+
+            # Do we need sideways leaders?
+            self._line_if_needed(pad_scale, length.a, leader_a)
+            self._line_if_needed(pad_scale, length.b, leader_b)
+
+            kwargs = {"ha": "center", "va": "center", "fontsize": fontsize}
+            if fontname is not None:
+                kwargs["fontname"] = fontname
+
+            result = self.annotate_text_only(
+                format.format(value=length.value),
+                label_coords,
+                bbox=dict(boxstyle="round,pad=0.3", ec="black", fc="white"),
+                **kwargs,
+            )
+
+        def _line_if_needed(self, pad: float, actual: Point2, leader_end: Point2):
+            half_pad = pad * 0.5
+            v: Vector2 = leader_end - actual
+            if v.norm() < half_pad:
+                return
+            work = SurfacePoint2(*actual, *v)
+            t1 = work.scalar_projection(leader_end) + half_pad
+            self.arrow(actual, work.at_distance(t1), arrow="-")
+
+        def annotate_text_only(self, text: str, pos: PlotCoords, **kwargs):
+            """
+            Annotate a Matplotlib Axes object with text only.
+            :param text: the text to annotate
+            :param pos: the position of the annotation
+            :param kwargs: keyword arguments to pass to the annotate function
+            :return: None
+            """
+            return self.ax.annotate(text, xy=_tuplefy(pos), **kwargs)
+
+        def arrow(self, start: PlotCoords, end: PlotCoords, arrow="-|>"):
+            """
+            Plot an arrow on a Matplotlib Axes object.
+            :param start: the start point of the arrow
+            :param end: the end point of the arrow
+            :param kwargs: keyword arguments to pass to the arrow function
+            :return: None
+            """
+            self.ax.annotate(
+                "",
+                xy=_tuplefy(end),
+                xytext=_tuplefy(start),
+                arrowprops=dict(arrowstyle=arrow, fc="black"),
+            )
+
+        def _font_height(self, font_size: int) -> float:
+            """Get the height of a font in data units."""
+            fig_dpi = self.ax.figure.dpi
+            font_height_inches = font_size * 1.0 / 72.0
+            font_height_px = font_height_inches * fig_dpi
+
+            px_per_data = self._get_scale()
+            return font_height_px / px_per_data
+
+        def _get_scale(self) -> float:
+            """Get the scale of the plot in data units per pixel."""
+            x0, x1 = self.ax.get_xlim()
+            y0, y1 = self.ax.get_ylim()
+
+            bbox = self.ax.get_window_extent()
+            width, height = bbox.width, bbox.height
+
+            # Units are pixels per data unit
+            x_scale = width / (x1 - x0)
+            y_scale = height / (y1 - y0)
+
+            return min(x_scale, y_scale)
+
+    def _tuplefy(item: PlotCoords) -> Tuple[float, float]:
+        if isinstance(item, (Point2, Vector2)):
+            return item.x, item.y
+        else:
+            x, y, *_ = item
+            return x, y

engeom/metrology/__init__.py

@@ -0,0 +1,5 @@
+from ..engeom import _metrology
+
+# Global import of all functions
+for name in [n for n in dir(_metrology) if not n.startswith("_")]:
+    globals()[name] = getattr(_metrology, name)

engeom/metrology.pyi

@@ -0,0 +1,32 @@
+from .geom2 import Point2, Vector2, SurfacePoint2
+
+
+class Length2:
+    def __init__(self, a: Point2, b: Point2, direction: Vector2 | None = None):
+        """
+
+        :param a:
+        :param b:
+        :param direction:
+        """
+        ...
+
+    @property
+    def a(self) -> Point2:
+        ...
+
+    @property
+    def b(self) -> Point2:
+        ...
+
+    @property
+    def direction(self) -> Vector2:
+        ...
+
+    @property
+    def value(self) -> float:
+        ...
+
+    @property
+    def center(self) -> SurfacePoint2:
+        ...

engeom/pyvista.py

@@ -1,6 +1,7 @@
 """
-    This module contains helper functions for working with PyVista.
+This module contains helper functions for working with PyVista.
 """
+
 from __future__ import annotations
 
 from typing import List
@@ -16,48 +17,48 @@ except ImportError:
     pass
 else:
 
-    def mesh_polydata(mesh: Mesh) -> pyvista.PolyData:
-        """
-        Creates a PyVista PolyData object from a Mesh object.
-        :param mesh: a Mesh object
-        :return: a PyVista PolyData object
-        """
-
-        if pyvista is None:
-            raise ImportError("PyVista is not installed.")
-
-        vertices = mesh.clone_vertices()
-        faces = mesh.clone_triangles()
-        faces = numpy.hstack((numpy.ones((faces.shape[0], 1), dtype=faces.dtype) * 3, faces))
-        return pyvista.PolyData(vertices, faces)
-
+    class PlotterHelper:
+        def __init__(self, plotter: pyvista.Plotter):
+            self.plotter = plotter
 
-    def add_curves_to_plotter(
-            plotter: pyvista.Plotter,
-            curves: List[Curve3],
-            color: ColorLike = 'w',
+        def add_curves(
+            self,
+            *curves: Curve3,
+            color: ColorLike = "w",
             width: float = 5.0,
             label: str | None = None,
             name: str | None = None,
-    ) -> List[pyvista.vtkActor]:
-        """
-        Adds curves to a PyVista plotter.
-        :param plotter:
-        :param curves:
-        :param color:
-        :param width:
-        :param label:
-        :param name:
-        :return:
-        """
-
-        if pyvista is None:
-            raise ImportError("PyVista is not installed.")
-
-        result_list = []
-        for curve in curves:
-            v = curve.clone_vertices()
-            added = plotter.add_lines(v, connected=True, color=color, width=width, label=label, name=name)
-            result_list.append(added)
-
-        return result_list
+        ) -> List[pyvista.vtkActor]:
+            """
+
+            :param curves:
+            :param color:
+            :param width:
+            :param label:
+            :param name:
+            :return:
+            """
+            result_list = []
+            for curve in curves:
+                added = self.plotter.add_lines(
+                    curve.points,
+                    connected=True,
+                    color=color,
+                    width=width,
+                    label=label,
+                    name=name,
+                )
+                result_list.append(added)
+
+            return result_list
+
+        def add_mesh(self, mesh: Mesh, **kwargs) -> pyvista.vtkActor:
+            """
+
+            :param mesh:
+            :return:
+            """
+            prefix = numpy.ones((mesh.triangles.shape[0], 1), dtype=mesh.triangles.dtype)
+            faces = numpy.hstack((prefix * 3, mesh.triangles))
+            data = pyvista.PolyData(mesh.points, faces)
+            return self.plotter.add_mesh(data, **kwargs)

{engeom-0.1.2.dist-info → engeom-0.2.1.dist-info}/METADATA

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

engeom-0.2.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+engeom-0.2.1.dist-info/METADATA,sha256=8MGvMlNyJjmeSSKaFGTM71uhryuOUrx9K_BpDPwVAfQ,339
+engeom-0.2.1.dist-info/WHEEL,sha256=N94FV15LUMFa6DZ0GIwvnhZKdhS-OmzC5Hp00viT4OQ,90
+engeom/airfoil/__init__.py,sha256=G6m7JEvHVk3sM2JooJPOg8JNA3VuEp0EIqczSEbC_PY,180
+engeom/airfoil.pyi,sha256=0TVpXkolFUXbBqJp93FenA_XqvU7FD1DnbncAF0ubow,14654
+engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
+engeom/align.pyi,sha256=QCSKrTLkCoaIubcrPU9J-wDZe1lRP0GbPgWZmonXjo0,997
+engeom/engeom.pyi,sha256=Il7TIk8Z5QgZENLVBgb2Pj11MIHCRbQCdDvgMh9LRgk,194
+engeom/geom2/__init__.py,sha256=mRu8Zh6DE-EQyhxScoxszPqDjGVzGWVJEQO6RIAtS4A,174
+engeom/geom2.pyi,sha256=Jh0ES-Gvkl7sFQV7VG6KdwgDbCPhmiETG_YOObYazhU,22741
+engeom/geom3/__init__.py,sha256=DG5jt2xgS9WRNb58ZkkrcKQQO6bIG-irg-uV_BkHEj4,174
+engeom/geom3.pyi,sha256=np6QjaeAS1Ms0Y4xNj4IoLRgI-rd9oh2sAH9TJem8Gw,28230
+engeom/matplotlib.py,sha256=3B2gRowUT5UDy-d46i9yANfoxoCa_BBuRo4HHb7NFYU,9275
+engeom/metrology/__init__.py,sha256=cpsB0-hJGitzW79Coxwf7r_mpNaeI6yG3myDEVdBJgk,186
+engeom/metrology.pyi,sha256=dEPRtvc8us6rMLwg3wIWUa92Udew_QN_Y71NV9zGf2s,572
+engeom/pyvista.py,sha256=g3wwolj-F0kDSVuDl03CN-DbbR2R71dz-hzqard3bQs,1703
+engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
+engeom/engeom.pyd,sha256=0ctL7HAYGXQky8eP7PzPPRKcTYtQsnJjyOKsjV6FGcI,1387008
+engeom-0.2.1.dist-info/RECORD,,

engeom-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-engeom-0.1.2.dist-info/METADATA,sha256=ym_mnfPDlcTOzcYgeEZGMCFsgidl30syGoPDLY_B2eA,339
-engeom-0.1.2.dist-info/WHEEL,sha256=N94FV15LUMFa6DZ0GIwvnhZKdhS-OmzC5Hp00viT4OQ,90
-engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
-engeom/align.pyi,sha256=KBC0nwcyp4YMfY2hRN1gr3DqFah-unqAd_o1KYwJAqc,1022
-engeom/engeom.pyi,sha256=J44RFBaKfnr1z7WyXCeE-_wEJZvpRJBfHINfDPR93c4,204
-engeom/geom2/__init__.py,sha256=mRu8Zh6DE-EQyhxScoxszPqDjGVzGWVJEQO6RIAtS4A,174
-engeom/geom2.pyi,sha256=De3YQSGpS4UQ1zawtIsuVR4-7rcFjqmNvL9lbtzN_d4,17117
-engeom/geom3/__init__.py,sha256=DG5jt2xgS9WRNb58ZkkrcKQQO6bIG-irg-uV_BkHEj4,174
-engeom/geom3.pyi,sha256=fEFhdFmEJsDP3X0aE_N0heqMyyPnbYjpeB0hTR2xjOI,27295
-engeom/matplotlib.py,sha256=Y9JZqpEFHm5EVzbr20P-NdxndNZdDH32OhE_KjxG_S4,3025
-engeom/pyvista.py,sha256=Lyvm0K_rvhR2wZACtfwCPYwEuABqYSTdjvbBaQS9yI4,1721
-engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
-engeom/engeom.pyd,sha256=M-hl-H0q3g7MHVvfUoqdrxmnNPmP24F0IxgbBohQWgc,1140224
-engeom-0.1.2.dist-info/RECORD,,