engeom 0.2.1__cp38-abi3-win_amd64.whl → 0.2.4__cp38-abi3-win_amd64.whl

engeom/engeom.pyi

@@ -6,3 +6,8 @@ type Resample = Resample_Count | Resample_Spacing | Resample_MaxSpacing
 class DeviationMode(Enum):
     Point = 0
     Plane = 1
+
+class SelectOp(Enum):
+    Add=0
+    Remove=1
+    Keep=2

engeom/geom3.pyi

@@ -4,7 +4,8 @@ from pathlib import Path
 from typing import Tuple, Iterable, List, TypeVar
 
 import numpy
-from engeom import DeviationMode, Resample
+from engeom import DeviationMode, Resample, SelectOp
+from .metrology import Length3
 
 Transformable3 = TypeVar("Transformable3", Vector3, Point3, Plane3, Iso3, SurfacePoint3)
 PointOrVector3 = TypeVar("PointOrVector3", Vector3, Point3)
@@ -434,7 +435,7 @@ class Mesh:
     def __init__(
             self,
             vertices: numpy.ndarray[float],
-            triangles: numpy.ndarray[numpy.uint32],
+            faces: numpy.ndarray[numpy.uint32],
             merge_duplicates: bool = False,
             delete_degenerate: bool = False
     ):
@@ -445,7 +446,7 @@ 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 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
         """
@@ -506,7 +507,7 @@ class Mesh:
         ...
 
     @property
-    def points(self) -> numpy.ndarray[float]:
+    def vertices(self) -> numpy.ndarray[float]:
         """
         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.
@@ -514,7 +515,7 @@ class Mesh:
         ...
 
     @property
-    def triangles(self) -> numpy.ndarray[numpy.uint32]:
+    def faces(self) -> numpy.ndarray[numpy.uint32]:
         """
         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.
@@ -573,6 +574,142 @@ 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:
+        """
+
+    def surface_closest_to(self, x: float, y: float, z: float) -> SurfacePoint3:
+        """
+        Find the closest point on the surface of the mesh to a given point in space, returning the point and normal
+        in the form of a `SurfacePoint3` object.
+        :param x: the x coordinate of the point to find the closest point to
+        :param y: the y coordinate of the point to find the closest point to
+        :param z: the z coordinate of the point to find the closest point to
+        :return: a `SurfacePoint3` object containing the closest point and normal
+        """
+        ...
+
+
+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:
     """
@@ -762,4 +899,4 @@ class Aabb3:
     @property
     def extent(self) -> Vector3:
         """ The extent of the box. """
-        ...
+        ...

engeom/matplotlib.py

@@ -125,20 +125,12 @@ else:
             self,
             length: Length2,
             side_shift: float = 0,
-            format: str = "{value:.3f}",
+            template: 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)
@@ -169,7 +161,7 @@ else:
                 kwargs["fontname"] = fontname
 
             result = self.annotate_text_only(
-                format.format(value=length.value),
+                template.format(value=length.value),
                 label_coords,
                 bbox=dict(boxstyle="round,pad=0.3", ec="black", fc="white"),
                 **kwargs,
@@ -232,9 +224,9 @@ else:
 
             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
+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.pyi

@@ -1,4 +1,5 @@
 from .geom2 import Point2, Vector2, SurfacePoint2
+from .geom3 import Point3, Vector3, SurfacePoint3
 
 
 class Length2:
@@ -30,3 +31,34 @@ class Length2:
     @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:
+        ...

engeom/pyvista.py

@@ -4,12 +4,16 @@ This module contains helper functions for working with PyVista.
 
 from __future__ import annotations
 
-from typing import List
+from typing import List, Any, Dict, Union, Iterable, Tuple
 
 import numpy
 from pyvista import ColorLike
 
-from .geom3 import Mesh, Curve3
+from .geom3 import Mesh, Curve3, Vector3, Point3, Iso3
+from .metrology import Length3
+from .matplotlib import LabelPlace
+
+PlotCoords = Union[Point3, Vector3, Iterable[float]]
 
 try:
     import pyvista
@@ -22,12 +26,12 @@ else:
             self.plotter = plotter
 
         def add_curves(
-            self,
-            *curves: Curve3,
-            color: ColorLike = "w",
-            width: float = 5.0,
-            label: str | None = None,
-            name: str | None = None,
+                self,
+                *curves: Curve3,
+                color: ColorLike = "w",
+                width: float = 5.0,
+                label: str | None = None,
+                name: str | None = None,
         ) -> List[pyvista.vtkActor]:
             """
 
@@ -58,7 +62,117 @@ else:
             :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)
+            if "cmap" in kwargs:
+                cmap_extremes = _cmap_extremes(kwargs["cmap"])
+                kwargs.update(cmap_extremes)
+
+            prefix = numpy.ones((mesh.faces.shape[0], 1), dtype=mesh.faces.dtype)
+            faces = numpy.hstack((prefix * 3, mesh.faces))
+            data = pyvista.PolyData(mesh.vertices, faces)
             return self.plotter.add_mesh(data, **kwargs)
+
+        def dimension(
+                self,
+                length: Length3,
+                template: str = "{value:.3f}",
+                label_place: LabelPlace = LabelPlace.Outside,
+                label_offset: float | None = None,
+                text_size: int = 16,
+                scale_value: float = 1.0,
+        ):
+            label_offset = label_offset or max(abs(length.value), 1.0) * 3
+
+            t_a = length.center.scalar_projection(length.a)
+            t_b = length.center.scalar_projection(length.b)
+
+            outside = length.center.at_distance(max(t_a, t_b))
+            inside = length.center.at_distance(min(t_a, t_b))
+
+            circles = []
+            builder = LineBuilder()
+
+            builder.add(inside - length.direction * label_offset * 0.25)
+            builder.add(inside)
+            circles.append(inside)
+            builder.skip()
+
+            circles.append(outside)
+            builder.add(outside)
+            builder.add(outside + length.direction * label_offset)
+
+            points = numpy.array([_tuplefy(p) for p in circles], dtype=numpy.float64)
+            self.plotter.add_points(points, color="black", point_size=4, render_points_as_spheres=True)
+
+            lines = builder.build()
+            self.plotter.add_lines(lines, color="black", width=1.5)
+
+            value = length.value * scale_value
+            label = pyvista.Label(text=template.format(value=value), position=lines[-1], size=text_size)
+            self.plotter.add_actor(label)
+
+        def coordinate_frame(self, iso: Iso3, size: float = 1.0):
+            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=5.0)
+            self.plotter.add_lines(points[[0, 2]], color="green", width=5.0)
+            self.plotter.add_lines(points[[0, 3]], color="blue", width=5.0)
+
+        def label(self, point: PlotCoords, text: str, **kwargs):
+            label = pyvista.Label(text=text, position=_tuplefy(point), **kwargs)
+            self.plotter.add_actor(label)
+
+        def arrow(self, start: PlotCoords, direction: PlotCoords,
+                  tip_length: float = 0.25,
+                  tip_radius: float = 0.1,
+                  shaft_radius: float = 0.05,
+                  **kwargs):
+            pd = pyvista.Arrow(_tuplefy(start), _tuplefy(direction), tip_length=tip_length, tip_radius=tip_radius,
+                               shaft_radius=shaft_radius)
+            self.plotter.add_mesh(pd, **kwargs, color="black")
+
+
+    def _cmap_extremes(item: Any) -> Dict[str, ColorLike]:
+        working = {}
+        try:
+            from matplotlib.colors import Colormap
+        except ImportError:
+            return working
+        else:
+            if isinstance(item, Colormap):
+                over = getattr(item, "_rgba_over", None)
+                under = getattr(item, "_rgba_under", None)
+                if over is not None:
+                    working["above_color"] = over
+                if under is not None:
+                    working["below_color"] = under
+            return working
+
+
+class LineBuilder:
+    def __init__(self):
+        self.vertices = []
+        self._skip = 1
+
+    def add(self, points: PlotCoords):
+        if self.vertices:
+            if self._skip > 0:
+                self._skip -= 1
+            else:
+                self.vertices.append(self.vertices[-1])
+
+        self.vertices.append(_tuplefy(points))
+
+    def skip(self):
+        self._skip = 2
+
+    def build(self) -> numpy.ndarray:
+        return numpy.array(self.vertices, dtype=numpy.float64)
+
+
+def _tuplefy(item: PlotCoords) -> Tuple[float, float, float]:
+    if isinstance(item, (Point3, Vector3)):
+        return item.x, item.y, item.z
+    else:
+        x, y, z, *_ = item
+        return x, y, z

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

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

{engeom-0.2.1.dist-info → engeom-0.2.4.dist-info}/RECORD

@@ -1,18 +1,18 @@
-engeom-0.2.1.dist-info/METADATA,sha256=8MGvMlNyJjmeSSKaFGTM71uhryuOUrx9K_BpDPwVAfQ,339
-engeom-0.2.1.dist-info/WHEEL,sha256=mYDPFrpmO1_UhonyEoMo2i0zHOwqc92hj_Q3CYuEBdM,94
+engeom-0.2.4.dist-info/METADATA,sha256=ihtRy0gEfQ1gc10xbpncuk_Uc_-ocxIR2HyZEejVXto,339
+engeom-0.2.4.dist-info/WHEEL,sha256=_g1M2QM3kt1Ssm_sHOg_3TUY7GxNE2Ueyslb9ZDtPwk,94
 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/engeom.pyi,sha256=Jia11rU8ZnMKdlXgfGeBPlSmsYPEfALM-_ufNwR0ibQ,254
 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/geom3.pyi,sha256=UUUg3OHobF_MfSDJZXD0PEZGSak2XQpiGAkne3lY7fI,34163
+engeom/matplotlib.py,sha256=A0gdQshzE3G7joNHna4viYnioQtA8LVXfSuZ_X6AHeo,9001
 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/metrology.pyi,sha256=P_2pkoLUAOB0-RKppj0FN01XGY0jx1lGw9H1eKXrW8s,1144
+engeom/pyvista.py,sha256=WVjaMG1hhd6hkknfxgkgCH8rZRXaM2AweG39T0UQkGc,6044
 engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
-engeom/engeom.pyd,sha256=UtK_xCx3NZB_wyw6AtsXZrODS-dRgTDvYYVaANM4Moc,1592832
-engeom-0.2.1.dist-info/RECORD,,
+engeom/engeom.pyd,sha256=7G9m_LBBIJkK7bVNkiV0Z6rQ0VA1R-KuVkZcB_w4rPE,2317312
+engeom-0.2.4.dist-info/RECORD,,

{engeom-0.2.1.dist-info → engeom-0.2.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.1)
+Generator: maturin (1.8.2)
 Root-Is-Purelib: false
 Tag: cp38-abi3-win_amd64