engeom 0.1.2__cp38-abi3-win_amd64.whl → 0.2.3__cp38-abi3-win_amd64.whl

engeom/geom3.pyi

@@ -1,12 +1,14 @@
 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
+from engeom import DeviationMode, Resample, SelectOp
+from .metrology import Length3
 
-type Transformable3 = Vector3 | Point3 | Plane3 | Iso3 | SurfacePoint3
+Transformable3 = TypeVar("Transformable3", Vector3, Point3, Plane3, Iso3, SurfacePoint3)
+PointOrVector3 = TypeVar("PointOrVector3", Vector3, Point3)
 
 
 class Vector3:
@@ -37,7 +39,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 +127,7 @@ class Point3:
         """
         ...
 
-    def __sub__(self, other: Vector3 | Point3) -> Vector3 | Point3:
+    def __sub__(self, other: PointOrVector3) -> PointOrVector3:
         ...
 
     def __add__(self, other: Vector3) -> Vector3:
@@ -433,9 +435,9 @@ class Mesh:
     def __init__(
             self,
             vertices: numpy.ndarray[float],
-            triangles: numpy.ndarray[numpy.uint32],
-            merge_duplicates: bool | None = None,
-            delete_degenerate: bool | None = None
+            faces: numpy.ndarray[numpy.uint32],
+            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
@@ -444,14 +446,19 @@ class Mesh:
         front/outside.
 
         :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 faces: a numpy array of shape (m, 3) containing the triangles of the mesh, should be uint.
+        :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 +480,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 +506,18 @@ class Mesh:
         """
         ...
 
-    def clone_vertices(self) -> numpy.ndarray[float]:
+    @property
+    def vertices(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 faces(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.
         """
         ...
@@ -570,6 +574,131 @@ class Mesh:
         """
         ...
 
+    def face_select_none(self) -> MeshTriangleFilter:
+        """
+        Start a filter operation on the faces of the mesh beginning with no faces selected. This will return a filter
+        object that can be used to further add or remove faces from the selection.
+
+        :return: a filter object for the triangles of the mesh.
+        """
+        ...
+
+    def face_select_all(self) -> MeshTriangleFilter:
+        """
+        Start a filter operation on the faces of the mesh beginning with all faces selected. This will return a filter
+        object that can be used to further add or remove faces from the selection.
+
+        :return: a filter object for the triangles of the mesh.
+        """
+        ...
+
+    def separate_patches(self) -> List[Mesh]:
+        """
+        Separate the mesh into connected patches. This will return a list of new mesh objects, each containing one
+        connected patch of the original mesh. These objects will be clones of the original mesh, so modifying them will
+        have no effect on the original mesh.
+        :return:
+        """
+
+    def create_from_indices(self, indices: List[int]) -> Mesh:
+        """
+        Create a new mesh from a list of triangle indices. This will build a new mesh object containing only the
+        triangles (and their respective vertices) identified by the given list of indices.  Do not allow duplicate
+        indices in the list.
+        :param indices: the triangle indices to include in the new mesh
+        :return:
+        """
+        ...
+
+    def measure_point_deviation(self, x: float, y: float, z: float, dist_mode: DeviationMode) -> Length3:
+        """
+        Compute the deviation of a point from this mesh's surface and return it as a measurement object.
+
+        The deviation is the distance from the point to its closest projection onto the mesh using
+        the specified distance mode.  The direction of the measurement is the direction between the
+        point and the projection, flipped into the positive half-space of the mesh surface at the
+        projection point.
+
+        If the distance is less than a very small floating point epsilon, the direction will be
+        taken directly from the mesh surface normal.
+
+        The first point `.a` of the measurement is the reference point, and the second point `.b`
+        is the test point.
+
+        :param x: the x component of the point to measure
+        :param y: the y component of the point to measure
+        :param z: the z component of the point to measure
+        :param dist_mode: the deviation mode to use
+        :return:
+        """
+
+    def boundary_first_flatten(self) -> numpy.ndarray[float]:
+        """
+
+        :return:
+        """
+
+
+class MeshTriangleFilter:
+    def collect(self) -> List[int]:
+        """
+        Collect the final indices of the triangles that passed the filter.
+        :return:
+        """
+        ...
+
+    def create_mesh(self) -> Mesh:
+        """
+        Create a new mesh from the filtered triangles. This will build a new mesh object containing only the triangles
+        (and their respective vertices) that are still retained in the filter.
+        :return:
+        """
+        ...
+
+    def facing(self, x: float, y: float, z: float, angle: float, mode: SelectOp) -> MeshTriangleFilter:
+        """
+
+        :param x:
+        :param y:
+        :param z:
+        :param angle:
+        :param mode:
+        :return:
+        """
+        ...
+
+    def near_mesh(
+            self,
+            other: Mesh,
+            all_points: bool,
+            distance_tol: float,
+            mode: SelectOp,
+            planar_tol: float | None = None,
+            angle_tol: float | None = None,
+    ) -> MeshTriangleFilter:
+        """
+        Reduce the list of indices to only include triangles that are within a certain distance of
+        their closest projection onto another mesh. The distance can require that all points of the
+        triangle are within the tolerance, or just one.
+
+        There are two additional optional tolerances that can be applied.
+
+        1. A planar tolerance, which checks the distance of the vertex projected onto the plane of
+           the reference mesh triangle and looks at how far it is from the projection point. This
+           is useful to filter out triangles that go past the edge of the reference mesh.
+        2. An angle tolerance, which checks the angle between the normal of the current triangle
+           and the normal of the reference triangle. This is useful to filter out triangles that
+           are not facing the same direction as the reference mesh.
+
+        :param other: the mesh to use as a reference
+        :param all_points: if True, all points of the triangle must be within the tolerance, if False, only one point
+        :param distance_tol: the maximum distance between the triangle and its projection onto the reference mesh
+        :param mode:
+        :param planar_tol: the maximum in-plane distance between the triangle and its projection onto the reference mesh
+        :param angle_tol: the maximum angle between the normals of the triangle and the reference mesh
+        """
+        ...
+
 
 class CurveStation3:
     """
@@ -611,11 +740,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 +766,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 +851,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,157 @@ 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,
+            template: str = "{value:.3f}",
+            fontsize: int = 10,
+            label_place: LabelPlace = LabelPlace.Outside,
+            label_offset: float | None = None,
+            fontname: str | None = None,
+        ):
+            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(
+                template.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,64 @@
+from .geom2 import Point2, Vector2, SurfacePoint2
+from .geom3 import Point3, Vector3, SurfacePoint3
+
+
+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:
+        ...
+
+
+class Length3:
+    def __init__(self, a: Point3, b: Point3, direction: Vector3 | None = None):
+        """
+
+        :param a:
+        :param b:
+        :param direction:
+        """
+        ...
+
+    @property
+    def a(self) -> Point3:
+        ...
+
+    @property
+    def b(self) -> Point3:
+        ...
+
+    @property
+    def direction(self) -> Vector3:
+        ...
+
+    @property
+    def value(self) -> float:
+        ...
+
+    @property
+    def center(self) -> SurfacePoint3:
+        ...