engeom 0.2.7__cp38-abi3-win_amd64.whl → 0.2.9__cp38-abi3-win_amd64.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
@@ -273,3 +276,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

@@ -176,19 +176,48 @@ else:
                 bold=False,
             )
 
-        def coordinate_frame(self, iso: Iso3, size: float = 1.0):
+        def coordinate_frame(self, iso, size: float = 1.0, line_width=3.0, label: str | None = None,
+                             label_size: int = 12):
             """
             Add a coordinate frame to the plotter.  This will appear as three lines, with X in red, Y in green,
             and Z in blue.  The length of each line is determined by the `size` parameter.
-            :param iso: The isometry to use as the origin and orientation of the coordinate frame.
+            :param iso: The isometry to use as the origin and orientation of the coordinate frame. May be an `Iso3`, a
+            4x4 `numpy.ndarray` that validly converts into an `Iso3`, or anything with an `as_numpy` method that
+            returns a valid 4x4 `numpy.ndarray`.
             :param size: The length of each line in the coordinate frame.
+            :param line_width: The width of the lines in the coordinate frame.
+            :param label: An optional label to display at the origin of the coordinate frame.
+            :param label_size: The size of the label text.
             """
+            if not isinstance(iso, Iso3):
+                if hasattr(iso, "as_numpy"):
+                    iso = iso.as_numpy()
+
+                if isinstance(iso, numpy.ndarray):
+                    if iso.shape == (4, 4):
+                        iso = Iso3(iso)
+                    else:
+                        raise ValueError("Invalid shape for iso: expected (4, 4), got {iso.shape}")
+                else:
+                    raise TypeError("Invalid type for iso: expected Iso3 or numpy.ndarray, got {type(iso)}")
+
             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)
+            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(
+                    [points[0]],
+                    [label],
+                    show_points=False,
+                    background_color="white",
+                    font_family="courier",
+                    font_size=label_size,
+                    bold=False,
+                )
 
         def label(self, point: PlotCoords, text: str, **kwargs):
             """

engeom/geom3.pyi

@@ -745,6 +745,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]:
         """
@@ -1282,3 +1301,29 @@ class Aabb3:
         :return: a new AABB object with the shrunk bounds.
         """
         ...
+
+
+class RayBundle3:
+    """
+    A class representing a bundle of rays in 3D space. The rays are represented by a set of origins and directions,
+    which are used to define the rays.
+
+    This class is used for ray tracing operations, such as intersection tests with meshes or other geometric objects.
+    """
+
+    def __init__(self, array: NDArray[float]):
+        """
+        Create a ray bundle from a numpy array of shape (n, 6) containing the origins and directions of the rays.
+        :param array: a numpy array of shape (n, 6) containing the origins and directions of the rays.
+        """
+        ...
+
+    def intersect_mesh(self, mesh: Mesh, iso: Iso3 | None = None, angle: float | None = None) -> NDArray[float]:
+        """
+
+        :param angle:
+        :param mesh:
+        :param iso:
+        :return:
+        """
+        ...

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-0.2.7.dist-info → engeom-0.2.9.dist-info}/METADATA

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

{engeom-0.2.7.dist-info → engeom-0.2.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
-engeom-0.2.7.dist-info/METADATA,sha256=l4kyI3OQAPNlQO0i4sA_QzrrbVZfBVXA-Typl8O3AtU,497
-engeom-0.2.7.dist-info/WHEEL,sha256=hKPP3BCTWtTwj6SFaSI--T5aOGqh_llYfbZ_BsqivwA,94
+engeom-0.2.9.dist-info/METADATA,sha256=ySmYFygY2YZDxjNhkPBFDEvrC-IkmqFjysrpHSdaq3E,497
+engeom-0.2.9.dist-info/WHEEL,sha256=hKPP3BCTWtTwj6SFaSI--T5aOGqh_llYfbZ_BsqivwA,94
 engeom/airfoil/__init__.py,sha256=gpS9pVepUu90XJ-ePndNupbUMKI0RGxNXPxD9x0iVHY,274
 engeom/airfoil.pyi,sha256=VTeJBoS9Iij7p-92R7jCqzPasHmvAUocyzc6BSx7mvM,23557
 engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
@@ -8,16 +8,16 @@ engeom/engeom.pyi,sha256=J0L_D-Sc2laJHL36nUAvIP3eN9BDryAxd_6aMQarlZc,1561
 engeom/geom2/__init__.py,sha256=JFpiLyROUh6vyakG-7JDSlCMCn4QB2MQ8bz3uVCaAIk,373
 engeom/geom2.pyi,sha256=508YJVNAJcZxEIZcWi4upcGtiZKoRnGtAW7TfTU3b3A,42922
 engeom/geom3/__init__.py,sha256=l8B0iDhJ4YiRbslJLN791XWai2DWrpmZptnzIETMS9g,370
-engeom/geom3.pyi,sha256=ZW37Pg2SLA74RTUmz0Ac82UmLTFm6K9BSHG_rWeX-Ro,55237
+engeom/geom3.pyi,sha256=EFVmO1VaR5EHQeGR0FZCR-XqXQA9_XUP9kky7o3kovI,57003
 engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
 engeom/metrology.pyi,sha256=9I5un86VB_2gmQBrVYhX8JzILTUADMLB9Em8ttJxrWg,4044
-engeom/plot.py,sha256=2b81-dW7aKKC1TjoDtRmppFKpzQOia7w6c4T2pExN0E,1065
+engeom/plot.py,sha256=LTqqO-h1EJL6wanM0hB79s9ohWwaCIijMOHVplY3vmc,1079
 engeom/raster3/__init__.py,sha256=iaayLrvco-ZMZPyeK47ox7rYne_51DNb2T2Q0iNNeKE,289
 engeom/raster3.pyi,sha256=sBXXYXcDBiDU_OFDQiwa7Q3GcwSiUc4CLy6nJ1MwFqM,790
 engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
-engeom/_plot/matplotlib.py,sha256=tTk4Fu6hDVxP1655koeT9B0JxkoURTr30ZyBV_jzTi8,11643
-engeom/_plot/pyvista.py,sha256=-G7ZxJQVfLLsVQP03jRRuu-F3Gq3bQxectBVS2L-bdk,10454
+engeom/_plot/matplotlib.py,sha256=eqZsm-Lhq2svFSusW6_09T4UuxW9F0hBEbmMj6ZMywI,12934
+engeom/_plot/pyvista.py,sha256=COVgiw4XlcbGjiLYE-eJjK_TJgONMGdW54pFsLczFm4,11879
 engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
 engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
-engeom/engeom.pyd,sha256=jUOWeKKvqB8LWZOY2Dxio-p5K9uUBRr5R2JblYLmhdQ,2360832
-engeom-0.2.7.dist-info/RECORD,,
+engeom/engeom.pyd,sha256=D3LeWbFwwYzrdW54HjVUeYtyz_pmpypaWXTo3b-z2lQ,2446848
+engeom-0.2.9.dist-info/RECORD,,