engeom 0.2.8__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.2.10__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

engeom/_plot/matplotlib.py

@@ -1,10 +1,13 @@
 from typing import List, Iterable, Tuple, Union
 import numpy
+
 from .common import LabelPlace
 from engeom.geom2 import Curve2, Circle2, Aabb2, Point2, Vector2, SurfacePoint2
+from engeom.geom3 import Vector3, Mesh, Point3
 from engeom.metrology import Distance2
 
 PlotCoords = Union[Point2, Vector2, Iterable[float]]
+PointLike = Union[Point2, Tuple[float, float], Point3]
 
 try:
     from matplotlib.pyplot import Axes, Circle
@@ -207,7 +210,7 @@ else:
 
             value = distance.value * scale_value
             box_style = dict(boxstyle="round,pad=0.3", ec="black", fc="white")
-            self.annotate_text_only(template.format(value=value), label_coords, bbox=box_style, **kwargs)
+            self.text(template.format(value=value), label_coords, bbox=box_style, **kwargs)
 
         def _line_if_needed(self, pad: float, actual: Point2, leader_end: Point2):
             half_pad = pad * 0.5
@@ -218,31 +221,78 @@ else:
             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):
+        def text(self, text: str, pos: PlotCoords, shift: PlotCoords | None = None, ha: str = "center",
+                 va: str = "center", **kwargs):
             """
-            Annotate a Matplotlib Axes object with text only.
+            Annotate a Matplotlib Axes object with text only, by default in the xy data plane.
             :param text: the text to annotate
             :param pos: the position of the annotation
+            :param shift: an optional shift vector to apply to the position
+            :param ha: horizontal alignment
+            :param va: vertical alignment
             :param kwargs: keyword arguments to pass to the annotate function
             :return: the annotation object
             """
-            return self.ax.annotate(text, xy=_tuplefy(pos), **kwargs)
+            xy = _tuplefy(pos)
+            if shift is not None:
+                shift = _tuplefy(shift)
+                xy = (xy[0] + shift[0], xy[1] + shift[1])
+
+            return self.ax.annotate(text, xy=xy, ha=ha, va=va, **kwargs)
 
-        def arrow(self, start: PlotCoords, end: PlotCoords, arrow="-|>"):
+        def points(self, *points: PlotCoords, marker="o", markersize="5", **kwargs):
+            x, y = zip(*[_tuplefy(p) for p in points])
+            return self.ax.plot(x, y, marker, markersize=markersize, **kwargs)
+
+        def labeled_arrow(self, start: PlotCoords, end: PlotCoords, text: str, fraction: float = 0.5,
+                          shift: PlotCoords | None = None,
+                          arrow="->", color="black", linewidth: float | None = None, linestyle="-",
+                          **text_kwargs):
             """
-            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 arrow: the style of arrow to use
-            :return: the annotation object
+
+            :param start:
+            :param end:
+            :param text:
+            :param shift:
+            :param fraction:
+            :param arrow:
+            :param color:
+            :param linewidth:
+            :param linestyle:
+            :param text_kwargs: parameters to pass to the text function
+            :return:
             """
-            return self.ax.annotate(
-                "",
-                xy=_tuplefy(end),
-                xytext=_tuplefy(start),
-                arrowprops=dict(arrowstyle=arrow, fc="black"),
+            start = Point2(*_tuplefy(start))
+            end = Point2(*_tuplefy(end))
+
+            self.arrow(start, end, arrow=arrow, color=color, linewidth=linewidth, linestyle=linestyle)
+
+            v: Vector2 = end - start
+            position = start + v * fraction
+            self.text(text, position, shift=shift, color=color, **text_kwargs)
+
+        def arrow(self, start: PlotCoords, end: PlotCoords, arrow="->", color="black", linewidth: float | None = None,
+                  linestyle="-"):
+            """
+            Draw an arrow on a Matplotlib Axes object from `start` to `end`.
+            :param start:
+            :param end:
+            :param arrow:
+            :param color:
+            :param linewidth:
+            :param linestyle:
+            :return:
+            """
+            props = dict(
+                arrowstyle=arrow,
+                fc=color,
+                ec=color,
+                linewidth=linewidth,
+                linestyle=linestyle,
             )
 
+            return self.ax.annotate("", xy=_tuplefy(end), xytext=_tuplefy(start), arrowprops=props)
+
         def _font_height(self, font_size: int) -> float:
             # Get the height of a font in data units
             fig_dpi = self.ax.figure.dpi
@@ -273,3 +323,50 @@ def _tuplefy(item: PlotCoords) -> Tuple[float, float]:
     else:
         x, y, *_ = item
         return x, y
+
+
+class TraceBuilder:
+    def __init__(self):
+        self.xs = []
+        self.ys = []
+        self.c = []
+
+    def bounds(self) -> Aabb2:
+        xs = [x for x in self.xs if x is not None]
+        ys = [y for y in self.ys if y is not None]
+        return Aabb2(
+            x_min=min(xs),
+            x_max=max(xs),
+            y_min=min(ys),
+            y_max=max(ys),
+        )
+
+    def add_segment(self, *points: PointLike):
+        self.add_points(*points)
+        self.add_blank()
+
+    def add_blank(self):
+        self.xs.append(None)
+        self.ys.append(None)
+        self.c.append(None)
+
+    def add_points(self, *points: PointLike):
+        for x, y, *_ in points:
+            self.xs.append(x)
+            self.ys.append(y)
+
+    def add_point_and_color(self, point: PointLike, color: float):
+        self.xs.append(point[0])
+        self.ys.append(point[1])
+        self.c.append(color)
+
+    def invert_y(self):
+        self.ys = [-y if y is not None else None for y in self.ys]
+
+    @property
+    def kwargs(self):
+        return dict(x=self.xs, y=self.ys)
+
+    @property
+    def xy(self):
+        return self.xs, self.ys

engeom/_plot/pyvista.py

@@ -40,6 +40,25 @@ else:
             """
             self.plotter = plotter
 
+        def add_points(self, *points, color: pyvista.ColorLike = "b", point_size: float = 5.0,
+                       render_points_as_spheres: bool = True, **kwargs) -> pyvista.vtkActor:
+            """
+            Add one or more points to be plotted.
+            :param points: The points to add.
+            :param color: The color to use for the point(s).
+            :param point_size: The size of the point(s).
+            :param render_points_as_spheres: Whether to render the points as spheres or not.
+            :param kwargs: Additional keyword arguments to pass to the PyVista `Plotter.add_points` method.
+            :return: The PyVista actor that was added to the plotter.
+            """
+            return self.plotter.add_points(
+                numpy.array([_tuplefy(p) for p in points], dtype=numpy.float64),
+                color=color,
+                point_size=point_size,
+                render_points_as_spheres=render_points_as_spheres,
+                **kwargs
+            )
+
         def add_curves(
                 self,
                 *curves: Curve3,
@@ -204,12 +223,12 @@ else:
             points = numpy.array([[0, 0, 0], [size, 0, 0], [0, size, 0], [0, 0, size]], dtype=numpy.float64)
             points = iso.transform_points(points)
 
-            self.plotter.add_lines(points[[0, 1]], color="red", width=line_width)
-            self.plotter.add_lines(points[[0, 2]], color="green", width=line_width)
-            self.plotter.add_lines(points[[0, 3]], color="blue", width=line_width)
+            actors = [self.plotter.add_lines(points[[0, 1]], color="red", width=line_width),
+                      self.plotter.add_lines(points[[0, 2]], color="green", width=line_width),
+                      self.plotter.add_lines(points[[0, 3]], color="blue", width=line_width)]
 
             if label:
-                self.plotter.add_point_labels(
+                actors.append(self.plotter.add_point_labels(
                     [points[0]],
                     [label],
                     show_points=False,
@@ -217,7 +236,9 @@ else:
                     font_family="courier",
                     font_size=label_size,
                     bold=False,
-                )
+                ))
+
+            return actors
 
         def label(self, point: PlotCoords, text: str, **kwargs):
             """

engeom/geom2.pyi

@@ -236,6 +236,13 @@ class Point2(Iterable[float]):
         """
         ...
 
+    @staticmethod
+    def mid(a: Point2, b: Point2) -> Point2:
+        """
+        Return the midpoint between two points. This is the average of the x and y components of the two points.
+        """
+        ...
+
 
 class SurfacePoint2:
     """
@@ -377,6 +384,23 @@ class SurfacePoint2:
         """
         ...
 
+    def offset(self, offset: Vector2) -> SurfacePoint2:
+        """
+        Offset the surface point by a given vector. The normal vector is not affected.
+        :param offset: the vector to offset the surface point by.
+        :return: a new surface point with the position offset by the given vector.
+        """
+        ...
+
+    def shift(self, distance: float) -> SurfacePoint2:
+        """
+        Shift the surface point by a given distance along the normal vector. The position of the surface point is
+        affected, but the normal vector is not.
+        :param distance: the distance to shift the surface point.
+        :return: a new surface point with the position shifted by the given distance.
+        """
+        ...
+
 
 class Iso2:
     """
@@ -855,6 +879,14 @@ class Curve2:
         """
         ...
 
+    @property
+    def aabb(self) -> Aabb2:
+        """
+        Get the axis-aligned bounding box of the curve.
+        :return: the axis-aligned bounding box of the curve.
+        """
+        ...
+
 
 class Circle2:
     """
@@ -910,6 +942,14 @@ class Circle2:
         """
         ...
 
+    def point_at_angle(self, angle: float) -> Point2:
+        """
+        Get the point on the circle at a given angle.
+        :param angle: the angle in radians.
+        :return: the point on the circle at the given angle.
+        """
+        ...
+
 
 class Arc2:
     """

engeom/geom3.pyi

@@ -260,6 +260,13 @@ class Point3(Iterable[float]):
         """
         ...
 
+    @staticmethod
+    def mid(a: Point3, b: Point3) -> Point3:
+        """
+        Return the midpoint between two points. This is the average of the x, y, and z coordinates of the two points.
+        """
+        ...
+
 
 class SurfacePoint3:
     """
@@ -389,6 +396,15 @@ class SurfacePoint3:
         """
         ...
 
+    def shift(self, offset: float) -> SurfacePoint3:
+        """
+        Return a new surface point with the position shifted by the specified distance along the normal vector. The
+        normal vector is unchanged.
+        :param offset: the distance to shift the position by along the normal vector.
+        :return:
+        """
+        ...
+
 
 class Iso3:
     """
@@ -521,6 +537,153 @@ class Iso3:
         """
         ...
 
+    def translation(self) -> Iso3:
+        """
+        Return the translation component of the isometry as a separate isometry.
+        """
+        ...
+
+    def rotation(self) -> Iso3:
+        """
+        Return the rotation component of the isometry as a separate isometry.
+        """
+        ...
+
+    @staticmethod
+    def from_rx(angle: float) -> Iso3:
+        """
+        Create an isometry representing a rotation around the x-axis by the specified angle in radians.
+        :param angle: the angle to rotate by in radians.
+        :return: an isometry containing only a rotation component
+        """
+        ...
+
+    @staticmethod
+    def from_ry(angle: float) -> Iso3:
+        """
+        Create an isometry representing a rotation around the y-axis by the specified angle in radians.
+        :param angle: the angle to rotate by in radians.
+        :return: an isometry containing only a rotation component
+        """
+        ...
+
+    @staticmethod
+    def from_rz(angle: float) -> Iso3:
+        """
+        Create an isometry representing a rotation around the z-axis by the specified angle in radians.
+        :param angle: the angle to rotate by in radians.
+        :return: an isometry containing only a rotation component
+        """
+        ...
+
+    @staticmethod
+    def from_basis_xy(e0: Vector3, e1: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the X and Y axes.
+
+        This method creates an isometry where:
+        - The X axis aligns with e0 (normalized)
+        - The Y axis aligns with e1 (normalized and adjusted to be orthogonal to e0)
+        - The Z axis is calculated as the cross product of X and Y
+
+        :param e0: Vector defining the X axis direction
+        :param e1: Vector defining the approximate Y axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
+    @staticmethod
+    def from_basis_xz(e0: Vector3, e2: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the X and Z axes.
+
+        This method creates an isometry where:
+        - The X axis aligns with e0 (normalized)
+        - The Z axis aligns with e2 (normalized and adjusted to be orthogonal to e0)
+        - The Y axis is calculated as the cross product of Z and X
+
+        :param e0: Vector defining the X axis direction
+        :param e2: Vector defining the approximate Z axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
+    @staticmethod
+    def from_basis_yz(e1: Vector3, e2: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the Y and Z axes.
+
+        This method creates an isometry where:
+        - The Y axis aligns with e1 (normalized)
+        - The Z axis aligns with e2 (normalized and adjusted to be orthogonal to e1)
+        - The X axis is calculated as the cross product of Y and Z
+
+        :param e1: Vector defining the Y axis direction
+        :param e2: Vector defining the approximate Z axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
+    @staticmethod
+    def from_basis_yx(e1: Vector3, e0: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the Y and X axes.
+
+        This method creates an isometry where:
+        - The Y axis aligns with e1 (normalized)
+        - The X axis aligns with e0 (normalized and adjusted to be orthogonal to e1)
+        - The Z axis is calculated as the cross product of X and Y
+
+        :param e1: Vector defining the Y axis direction
+        :param e0: Vector defining the approximate X axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
+    @staticmethod
+    def from_basis_zx(e2: Vector3, e0: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the Z and X axes.
+
+        This method creates an isometry where:
+        - The Z axis aligns with e2 (normalized)
+        - The X axis aligns with e0 (normalized and adjusted to be orthogonal to e2)
+        - The Y axis is calculated as the cross product of Z and X
+
+        :param e2: Vector defining the Z axis direction
+        :param e0: Vector defining the approximate X axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
+    @staticmethod
+    def from_basis_zy(e2: Vector3, e1: Vector3, origin: Point3 | None = None) -> Iso3:
+        """
+        Create an isometry from two vectors defining the Z and Y axes.
+
+        This method creates an isometry where:
+        - The Z axis aligns with e2 (normalized)
+        - The Y axis aligns with e1 (normalized and adjusted to be orthogonal to e2)
+        - The X axis is calculated as the cross product of Y and Z
+
+        :param e2: Vector defining the Z axis direction
+        :param e1: Vector defining the approximate Y axis direction (will be orthogonalized)
+        :param origin: Optional point to use as the origin of the isometry (defaults to world origin)
+        :return: A new Iso3 representing the coordinate system
+        :raises: ValueError if the vectors are parallel or too small to create a valid basis
+        """
+        ...
+
 
 class SvdBasis3:
     """
@@ -646,6 +809,14 @@ class Plane3:
         """
         ...
 
+    def intersection_distance(self, sp: SurfacePoint3) -> float | None:
+        """
+
+        :param sp:
+        :return:
+        """
+        ...
+
 
 class Mesh:
     """
@@ -745,6 +916,25 @@ class Mesh:
         """
         ...
 
+    @property
+    def face_normals(self) -> NDArray[float]:
+        """
+        Will return an immutable view of the face normals of the mesh as a numpy array of shape (m, 3), where m is the
+        number of triangles in the mesh.
+        :return: a numpy array of shape (m, 3) containing the normals of the triangles of the mesh.
+        """
+        ...
+
+    @property
+    def vertex_normals(self) -> NDArray[float]:
+        """
+        Will return an immutable view of the vertex normals of the mesh as a numpy array of shape (n, 3), where n is the
+        number of vertices in the mesh.  If a vertex has no faces, the normal will be (0, 0, 0), otherwise the normal
+        will have been averaged from the normals of the faces that share the vertex.
+        :return: a numpy array of shape (n, 3) containing the normals of the vertices of the mesh.
+        """
+        ...
+
     @property
     def faces(self) -> NDArray[numpy.uint32]:
         """
@@ -933,6 +1123,66 @@ class Mesh:
         """
         ...
 
+    def visual_outline(
+            self,
+            facing: Vector3,
+            max_edge_length: float,
+            corner_angle: float | None = None
+    ) -> Tuple[NDArray[float], NDArray[numpy.uint8]]:
+        """
+        Capture the edges of a visual outline of the mesh, used to draw a line diagram of the mesh in a 2D space. The
+        returned results will consist of two numpy arrays.  The first will be a floating point array of shape (N, 6)
+        where N is the number of edges in the outline. The first three columns will be the start point of the edge, and
+        the last three columns will be the end point of the edge. The second array will be a numpy array of shape (N,)
+        containing a 0 or 1 for each edge at the associated index. A 0 indicates that the edge is unobstructed in the
+        view direction, while a 1 indicates that the edge is obstructed by the mesh.
+
+        :param facing: A vector with the direction to look at the mesh
+        :param max_edge_length: The maximum length of an edge to be included in the outline. Edges longer than this
+        will be broken up into smaller edges.
+        :param corner_angle: The minimum angle between two adjacent faces for the common edge to be considered a corner
+        and included in the outline. If None, the default value is 45 degrees.
+        :return: a tuple of two numpy arrays. The first array is the outline edges, and the second array is a mask
+        indicating whether the edge is obstructed or not.
+        """
+        ...
+
+    def convex_hull(self) -> Mesh:
+        """
+        Calculate the convex hull of the mesh. The convex hull is the smallest convex shape that contains all the
+        vertices of the mesh. This will return a new mesh object containing the vertices and triangles of the convex
+        hull. This method will not modify the original mesh.
+        :return: a new mesh object containing the convex hull of the original mesh.
+        """
+        ...
+
+    @staticmethod
+    def create_box(width: float, height: float, depth: float) -> Mesh:
+        """
+        Creates a box with the corner at the origin and the specified width, height, and depth all positive.
+
+        :param width:
+        :param height:
+        :param depth:
+        :return:
+        """
+        ...
+
+    @staticmethod
+    def create_cylinder(radius: float, height: float, steps: int) -> Mesh:
+        """
+        Creates a cylinder with a radius and height. The cylinder will be centered at the origin and oriented along the
+        Z-axis. The bottom of the cylinder will be at Z = 0 and the top will be at Z = height. The cylinder will be
+        created with a number of steps around the circumference, which will determine the number of vertices used to
+        create the cylinder. The number of steps should be at least 3. The first set of vertices will be at X = radius,
+        Y = 0.
+        :param radius:
+        :param height:
+        :param steps:
+        :return:
+        """
+        ...
+
 
 class FaceFilterHandle:
     """
@@ -1009,6 +1259,51 @@ class FaceFilterHandle:
         ...
 
 
+class MeshCollisionSet:
+    """
+    A class holding a set of meshes for collision detection. This class is used to perform collision detection between
+    a set of moving and stationary meshes in 3D space.
+    """
+
+    def __init__(self):
+        """
+        Creates an empty collision set.
+        """
+        ...
+
+    def add_stationary(self, mesh: Mesh) -> int:
+        """
+        Add a stationary mesh to the collision set. This mesh will be used as a reference for collision detection.
+        :param mesh: the mesh to add to the collision set.
+        :return: the ID of the mesh in the collision set.
+        """
+        ...
+
+    def add_moving(self, mesh: Mesh) -> int:
+        """
+        Add a moving mesh to the collision set. This mesh will be used to check for collisions against the stationary
+        meshes in the set.
+        :param mesh: the mesh to add to the collision set.
+        :return: the ID of the mesh in the collision set.
+        """
+        ...
+
+    def add_exception(self, id1: int, id2: int):
+        """
+        Add an exception to the collision set. This will prevent the two meshes from being checked for collisions.
+        :param id1: the ID of the first mesh.
+        :param id2: the ID of the second mesh.
+        """
+        ...
+
+    def check_all(self, transforms: List[Tuple[int, Iso3]], stop_at_first: bool) -> List[Tuple[int, int]]:
+        """
+        Check all moving meshes against all stationary meshes for collisions. This will return a list of tuples
+        containing the IDs of the two meshes that are colliding.
+        :return: a list of tuples containing the IDs of the colliding meshes.
+        """
+        ...
+
 class CurveStation3:
     """
     A class representing a station along a curve in 3D space. The station is represented by a point on the curve, a

engeom/plot.py

@@ -21,6 +21,6 @@ except ImportError:
     pass
 
 try:
-    from ._plot.matplotlib import GOM_CMAP, GomColorMap, MatplotlibAxesHelper
+    from ._plot.matplotlib import GOM_CMAP, GomColorMap, MatplotlibAxesHelper, TraceBuilder
 except ImportError:
     pass

engeom/sensor/__init__.py

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

engeom/sensor.pyi

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from .geom3 import Point3, Mesh, Iso3, Vector3
+from numpy.typing import NDArray
+
+
+class LaserLine:
+    def __init__(
+            self,
+            ray_origin: Point3,
+            detect_origin: Point3,
+            line_start: Point3,
+            line_end: Point3,
+            min_range: float,
+            max_range: float,
+            rays: int,
+            angle_limit: float | None = None,
+    ):
+        """
+
+        :param ray_origin:
+        :param detect_origin:
+        :param line_start:
+        :param line_end:
+        :param min_range:
+        :param max_range:
+        :param rays:
+        :param angle_limit:
+        """
+        ...
+
+    def get_points(self, target: Mesh, obstruction: Mesh | None, iso: Iso3) -> NDArray[float]:
+        """
+
+        :param target:
+        :param obstruction:
+        :param iso:
+        :return:
+        """
+        ...
+
+
+class PanningLaserLine:
+    def __init__(self, laser_line: LaserLine, pan_vector: Vector3, steps: int):
+        """
+        :param laser_line:
+        :param pan_vector:
+        :param steps:
+        """
+        ...
+
+    def get_points(self, target: Mesh, obstruction: Mesh | None, iso: Iso3) -> NDArray[float]:
+        """
+        :param target:
+        :param obstruction:
+        :param iso:
+        :return:
+        """
+        ...

{engeom-0.2.8.dist-info → engeom-0.2.10.dist-info}/METADATA

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

{engeom-0.2.8.dist-info → engeom-0.2.10.dist-info}/RECORD

@@ -1,23 +1,25 @@
-engeom-0.2.8.dist-info/METADATA,sha256=JEVnOcfRIqLGQ4lLnjmICd0plsKM9yq-GCYZi1K4L1g,494
-engeom-0.2.8.dist-info/WHEEL,sha256=k0er-u5m64P9DpEYbKzvuotgEtd5z5FLn8Li8lnOqEs,129
-engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
-engeom/plot.py,sha256=2b81-dW7aKKC1TjoDtRmppFKpzQOia7w6c4T2pExN0E,1065
-engeom/airfoil/__init__.py,sha256=gpS9pVepUu90XJ-ePndNupbUMKI0RGxNXPxD9x0iVHY,274
-engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
-engeom/_plot/matplotlib.py,sha256=tTk4Fu6hDVxP1655koeT9B0JxkoURTr30ZyBV_jzTi8,11643
-engeom/_plot/pyvista.py,sha256=COVgiw4XlcbGjiLYE-eJjK_TJgONMGdW54pFsLczFm4,11879
-engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
-engeom/__init__.py,sha256=QN5uETqrN442w41foyrcCPV_x6NP-mrxkPJhdvdey1g,109
+engeom-0.2.10.dist-info/METADATA,sha256=pspg1fX2bXgPBv5Ohzo6PabHa0gSDMki855BQddwTOo,495
+engeom-0.2.10.dist-info/WHEEL,sha256=k0er-u5m64P9DpEYbKzvuotgEtd5z5FLn8Li8lnOqEs,129
 engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
-engeom/geom3.pyi,sha256=fcWaBcwVp76enp9aZrpnmVhIDpWxgay8eBauLR9T1Lk,56105
-engeom/geom3/__init__.py,sha256=l8B0iDhJ4YiRbslJLN791XWai2DWrpmZptnzIETMS9g,370
-engeom/raster3.pyi,sha256=sBXXYXcDBiDU_OFDQiwa7Q3GcwSiUc4CLy6nJ1MwFqM,790
-engeom/airfoil.pyi,sha256=VTeJBoS9Iij7p-92R7jCqzPasHmvAUocyzc6BSx7mvM,23557
-engeom/metrology.pyi,sha256=9I5un86VB_2gmQBrVYhX8JzILTUADMLB9Em8ttJxrWg,4044
-engeom/geom2.pyi,sha256=508YJVNAJcZxEIZcWi4upcGtiZKoRnGtAW7TfTU3b3A,42922
-engeom/engeom.pyi,sha256=BtUBtYZ_MX8Xk2x_FyzVxRXjJQIazQ1xscbCLO_Y3HA,1516
+engeom/plot.py,sha256=LTqqO-h1EJL6wanM0hB79s9ohWwaCIijMOHVplY3vmc,1079
+engeom/sensor.pyi,sha256=a9y62FqhG-CFFHnJiC03PqBpFtxtfkH0zoDkk9LXWnU,1399
 engeom/geom2/__init__.py,sha256=JFpiLyROUh6vyakG-7JDSlCMCn4QB2MQ8bz3uVCaAIk,373
+engeom/raster3.pyi,sha256=sBXXYXcDBiDU_OFDQiwa7Q3GcwSiUc4CLy6nJ1MwFqM,790
+engeom/sensor/__init__.py,sha256=p-1osXrlBX_hXSSlvySszSimMv_4_n273joBcTFx2V0,179
+engeom/__init__.py,sha256=QN5uETqrN442w41foyrcCPV_x6NP-mrxkPJhdvdey1g,109
 engeom/align.pyi,sha256=QCSKrTLkCoaIubcrPU9J-wDZe1lRP0GbPgWZmonXjo0,997
+engeom/geom3.pyi,sha256=VYxc9kZQhfHNN13E1DpAzea9z6R6gvpKtxyL8Wm9oWU,69140
+engeom/engeom.pyi,sha256=BtUBtYZ_MX8Xk2x_FyzVxRXjJQIazQ1xscbCLO_Y3HA,1516
 engeom/raster3/__init__.py,sha256=iaayLrvco-ZMZPyeK47ox7rYne_51DNb2T2Q0iNNeKE,289
-engeom/engeom.abi3.so,sha256=AacYClSMsRGWHVP6i4qsugKaLlnRW4MEjIbiSKgXNWo,3169120
-engeom-0.2.8.dist-info/RECORD,,
+engeom/geom3/__init__.py,sha256=l8B0iDhJ4YiRbslJLN791XWai2DWrpmZptnzIETMS9g,370
+engeom/airfoil/__init__.py,sha256=gpS9pVepUu90XJ-ePndNupbUMKI0RGxNXPxD9x0iVHY,274
+engeom/_plot/matplotlib.py,sha256=rFL1CPNMUqGO-fwD45V3-shektBMeNq5U15Zxp96hYw,14824
+engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
+engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
+engeom/_plot/pyvista.py,sha256=PylGVOa9RtRIYPyHLy969eyW8yIgAk-URVZT0R7WoQ8,12980
+engeom/airfoil.pyi,sha256=VTeJBoS9Iij7p-92R7jCqzPasHmvAUocyzc6BSx7mvM,23557
+engeom/geom2.pyi,sha256=uMi4WD6-DtFx8H-RZsKIi-p1fN4p8SzOfBZmEuvNGDU,44357
+engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
+engeom/metrology.pyi,sha256=9I5un86VB_2gmQBrVYhX8JzILTUADMLB9Em8ttJxrWg,4044
+engeom/engeom.abi3.so,sha256=m4xlDeIQKUnCbYyD6-GnL36dHsx84zTPNfFeY4BdUSo,3534872
+engeom-0.2.10.dist-info/RECORD,,