engeom 0.1.2__cp38-abi3-macosx_11_0_arm64.whl → 0.2.3__cp38-abi3-macosx_11_0_arm64.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,13 @@
 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
+
+class SelectOp(Enum):
+    Add=0
+    Remove=1
+    Keep=2

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.
+        """
+        ...