engeom 0.2.12__cp38-abi3-win_amd64.whl → 0.2.14__cp38-abi3-win_amd64.whl

engeom/_plot/matplotlib.py

@@ -147,6 +147,15 @@ else:
             """
             self.ax.plot(curve.points[:, 0], curve.points[:, 1], **kwargs)
 
+        def fill_curve(self, curve: Curve2, **kwargs):
+            """
+            Fill a curve on a Matplotlib Axes object.
+            :param curve: a Curve2 object (can be closed but doesn't need to be, will be closed automatically)
+            :param kwargs: keyword arguments to pass to the inner Axes.fill function
+            :return:
+            """
+            self.ax.fill(curve.points[:, 0], curve.points[:, 1], **kwargs)
+
         def distance(
                 self,
                 distance: Distance2,

engeom/_plot/pyvista.py

@@ -8,7 +8,7 @@ from typing import List, Any, Dict, Union, Iterable, Tuple
 
 import numpy
 
-from engeom.geom3 import Mesh, Curve3, Vector3, Point3, Iso3, SurfacePoint3
+from engeom.geom3 import Mesh, Curve3, Vector3, Point3, Iso3, SurfacePoint3, PointCloud
 from engeom.metrology import Distance3
 from .common import LabelPlace
 
@@ -43,7 +43,7 @@ else:
         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.
+            Add one or more discrete 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).
@@ -111,6 +111,24 @@ else:
             data = pyvista.PolyData(mesh.vertices, faces)
             return self.plotter.add_mesh(data, **kwargs)
 
+        def add_point_cloud(self, cloud: PointCloud, use_colors: bool = True, normal_arrow_size: float = 0.0, **kwargs):
+            actors = []
+            if normal_arrow_size >= 0.0 and cloud.normals is not None:
+                arrow_color = kwargs.get("color", "gray")
+                arrow_actor = self.plotter.add_arrows(cloud.points, cloud.normals, mag=normal_arrow_size,
+                                                      color=arrow_color, reset_camera=False)
+                actors.append(arrow_actor)
+
+            if use_colors and cloud.colors is not None:
+                kwargs.pop("color", None)  # Remove color if it's set, as colors will be used from the cloud
+                kwargs["scalars"] = cloud.colors
+                kwargs["rgba"] = True
+
+            point_actor = self.plotter.add_points(cloud.points, **kwargs)
+            actors.append(point_actor)
+
+            return actors
+
         def distance(
                 self,
                 distance: Distance3,

engeom/airfoil.pyi

@@ -315,6 +315,23 @@ class AirfoilGeometry:
     from .geom2 import Curve2, Circle2
     from .metrology import Distance2
 
+    @staticmethod
+    def from_bytes(data: bytes) -> AirfoilGeometry:
+        """
+        Create an instance of `AirfoilGeometry` from a byte string containing the airfoil geometry data serialized in
+        a msgpack format.
+        :param data: The byte string containing the serialized data
+        :return: An instance of `AirfoilGeometry`
+        """
+        ...
+
+    def to_bytes(self) -> bytes:
+        """
+        Serialize the `AirfoilGeometry` instance to a byte string msgpack representation.
+        :return: A byte string containing the serialized data
+        """
+        ...
+
     @staticmethod
     def from_analyze(
             section: Curve2,

engeom/align.pyi

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import numpy
 from .engeom import DeviationMode
-from .geom3 import Mesh, Iso3
+from .geom3 import Mesh, Iso3, PointCloud
 
 
 def points_to_mesh(
@@ -21,4 +21,12 @@ def points_to_mesh(
     and the mesh is calculated.
     :return: the isometry that best aligns the points to the mesh.
     """
+    ...
+
+def points_to_cloud(
+        points: numpy.ndarray[float],
+        cloud: PointCloud,
+        search_radius: float,
+        initial: Iso3,
+) -> Iso3:
     ...

engeom/geom2.pyi

@@ -919,6 +919,55 @@ class Curve2:
         """
         ...
 
+    def offset_vertices(self, offset: float) -> Curve2:
+        """
+        Create a new curve which is the result of offsetting the vertices of this curve by the
+        given offset. The direction of each vertex offset will be the same as the direction of the
+        surface normal at the curve station corresponding to that vertex, which is the angle
+        bisecting the normals of the two edges that meet at the vertex.  Vertices at the ends of
+        the curve (on an open curve) will have the same normal as the edge they are connected to.
+
+        Compared to `offset_segments`, this method will move the vertices of the curve while
+        allowing the distance between the bodies of the initial and resulting segments to change.
+        Generally speaking, use this method if you primarily care about the vertices and not the
+        segments, or if the curvature between adjacent segments is very low.
+
+        :param offset: the distance to offset the vertices by.
+        :return: a new curve with the vertices offset by the given distance.
+        """
+        ...
+
+    def offset_segments(self, offset: float) -> Curve2:
+        """
+        Create a new curve which is the result of offsetting the segments of this curve by the
+        given offset. The direction of the offset is perpendicular to the direction of the segment,
+        and a positive offset will move the segment outward from the curve, while a negative offset
+        will move it inward.  Outward and inward are defined based on the counter-clockwise winding
+        convention.
+
+        Vertices will be moved to the intersection of their adjacent segments.
+
+        Compared to `offset_vertices`, this method will preserve the distance between the segments
+        bodies of the initial and resulting curves, while allowing vertices on outside corners to
+        get farther from the original as necessary for the segments to be straight lines.
+
+        :param offset: the distance to offset the segments by.
+        :return: a new curve with the segments offset by the given distance.
+        """
+        ...
+
+    def __add__(self, other: Curve2) -> Curve2:
+        """
+        Concatenate two curves together, returning a new curve that is the result of appending the vertices of the
+        second curve to the first curve. Both curves must be open or this will throw an error. The resulting curve
+        will be open.
+
+        :param other: the curve to append to this curve.
+        :return: a new curve that is the result of concatenating the two curves.
+        """
+        ...
+
+
 
 class Circle2:
     """
@@ -1225,3 +1274,19 @@ class Aabb2:
         :return: a new AABB object that is the result of merging this AABB with the other AABB.
         """
         ...
+
+    def indices_contained(self, points: NDArray[float]) -> NDArray[int]:
+        """
+        Get the indices of the points that are contained within the AABB.
+        :param points: a numpy array of shape (N, 2) containing the points to check.
+        :return: a numpy array of indices of the points that are contained within the AABB.
+        """
+        ...
+
+    def contains_point(self, point: Point2) -> bool:
+        """
+        Check if a point is contained within the AABB.
+        :param point: the point to check.
+        :return: True if the point is contained within the AABB, False otherwise.
+        """
+        ...

engeom/geom3.pyi

@@ -1751,6 +1751,26 @@ class Aabb3:
         """
         ...
 
+    def indices_contained(self, points: NDArray[float]) -> NDArray[int]:
+        """
+        Get the indices of the points that are contained within this AABB. The points should be a numpy array of shape
+        (n, 3) where n is the number of points.
+
+        :param points: a numpy array of shape (n, 3) containing the points to check.
+        :return: a numpy array of shape (m,) containing the indices of the points that are contained within this AABB,
+        where m is the number of points contained within the AABB.
+        """
+        ...
+
+    def contains_point(self, point: Point3) -> bool:
+        """
+        Check if a point is contained within this AABB.
+
+        :param point: the point to check.
+        :return: True if the point is contained within the AABB, False otherwise.
+        """
+        ...
+
 
 class RayBundle3:
     """
@@ -1776,3 +1796,153 @@ class RayBundle3:
         :return:
         """
         ...
+
+
+class PointCloud:
+    """
+
+    """
+
+    def __init__(self, points: NDArray[float], normals: NDArray[float] | None = None,
+                 colors: NDArray[numpy.uint8] | None = None):
+        ...
+
+    @property
+    def points(self) -> NDArray[float]:
+        """
+        Get the points of the point cloud as a numpy array of shape (n, 3).
+        :return: a numpy array of shape (n, 3) containing the points of the point cloud.
+        """
+        ...
+
+    @property
+    def normals(self) -> NDArray[float] | None:
+        """
+        Get the normals of the point cloud as a numpy array of shape (n, 3). If no normals were provided, this will
+        return None.
+        :return: a numpy array of shape (n, 3) containing the normals of the point cloud, or None if no normals were
+        provided.
+        """
+        ...
+
+    @property
+    def colors(self) -> NDArray[numpy.uint8] | None:
+        """
+        Get the colors of the point cloud as a numpy array of shape (n, 3). If no colors were provided, this will
+        return None.
+        :return: a numpy array of shape (n, 3) containing the colors of the point cloud, or None if no colors were
+        provided.
+        """
+        ...
+
+    def cloned(self) -> PointCloud:
+        """
+        Create a copy of the point cloud. This will return a new `PointCloud` object with the same points, normals, and
+        colors as the original.
+
+        :return: a new `PointCloud` object with the same points, normals, and colors as the original.
+        """
+        ...
+
+    @staticmethod
+    def load_lptf3(path: str | Path, take_every : int | None = None) -> PointCloud:
+        """
+        Load a point cloud from a LPTF3 file. The LPTF3 format is a binary format used to store measurements from a
+        triangulation-based laser profile sensor.
+
+        :param path: the path to the LPTF3 file to load.
+        :param take_every: if provided, this will take every nth row from the file, and will be used to estimate the
+        spacing of the points along the profile to also sample at a rough distance
+        :return: a `PointCloud` object containing the points, normals, and colors from the file.
+        """
+        ...
+
+    def append(self, other: PointCloud) -> PointCloud:
+        """
+        Append another point cloud to this one. The points, normals, and colors from the other point cloud will be
+        added to this point cloud.
+
+        Will throw an error if the other point cloud has a different combination of normals and colors than this one.
+
+        :param other: the other point cloud to append.
+        :return: a new `PointCloud` object containing the combined points, normals, and colors.
+        """
+        ...
+
+    def sample_poisson_disk(self, radius: float) -> list[int]:
+        """
+        Sample a subset of points from the point cloud using a Poisson disk sampling algorithm. This will return a list
+        of indices of the points that were preserved. The points will be selected such that no two points are closer
+        than the given radius.
+
+        :param radius: the minimum distance between sampled points.
+        :return: a list of indices of the points that were selected.
+        """
+        ...
+
+    def create_from_indices(self, indices: list[int]) -> PointCloud:
+        """
+        Create a new point cloud from a subset of the points in this point cloud, specified by the given indices.
+        The normals and colors will also be subsetted to match the points.
+
+        :param indices: a list of indices to select from the point cloud.
+        :return: a new `PointCloud` object containing the selected points, normals, and colors.
+        """
+        ...
+
+    def create_from_poisson_sample(self, radius: float) -> PointCloud:
+        """
+        Create a new point cloud from a Poisson disk sampling of the points in this point cloud. The points will be
+        selected such that no two points are closer than the given radius.
+
+        :param radius: the minimum distance between sampled points.
+        :return: a new `PointCloud` object containing the sampled points, normals, and colors.
+        """
+        ...
+
+    def transform_by(self, iso: Iso3) -> PointCloud:
+        """
+        Transform the point cloud by an isometry. This will return a new `PointCloud` object with the transformed
+        points, normals, and colors.
+
+        :param iso: the isometry to transform the point cloud by.
+        :return: a new `PointCloud` object with the transformed points, normals, and colors.
+        """
+        ...
+
+    def overlap_points_by_reciprocity(self, other: PointCloud, max_distance: float) -> list[int]:
+        """
+        Find the indices of points in this point cloud that "overlap" with points in another point
+        cloud by looking for reciprocity in the closest point in each direction.
+
+        For each point in this point cloud "p_this", we will find the closest point in the other
+        point cloud "p_other".  Then we take "p_other" and find the closest point to it in this
+        point cloud, "p_recip".
+
+        In an ideally overlapping point cloud, "p_recip" should be the same as "p_this".  We will
+        use a maximum distance tolerance to determine if "p_recip" is close enough to "p_this" that
+        "p_this" is considered to be overlapping with the other point cloud.
+
+        :param other: the other point cloud to check for overlap.
+        :param max_distance: the maximum distance to consider a point as overlapping.
+        :return: a list of indices of points in this point cloud that overlap with points in the other point cloud.
+        """
+        ...
+    
+    def overlap_mesh_by_reciprocity(self, mesh: Mesh, max_distance: float) -> list[int]:
+        """
+        Find the indices of points in this point cloud that "overlap" with triangles in a mesh by looking for
+        reciprocity in the closest point in each direction.
+
+        For each point in this point cloud "p_this", we will find the closest point on the surface of the mesh 
+        "p_other".  Then we will take "p_other" and find the closest point in the point cloud, "p_recip".
+
+        In an ideally overlapping point cloud, "p_this" should be the same as "p_recip".  We will use a maximum 
+        distance tolerance instead to determine if "p_recip" is close enough to "p_this" that "p_this" is 
+        considered to be overlapping with the mesh.
+
+        :param mesh: the mesh to check for overlap.
+        :param max_distance: the maximum distance to consider a point as overlapping.
+        :return: a list of indices of points in this point cloud that overlap with triangles in the mesh.
+        """
+        ...

engeom/sensors/__init__.py

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

engeom/sensors.pyi

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from .geom3 import Point3, Mesh, Iso3, Vector3, PointCloud
+
+
+class LaserProfile:
+    def __init__(
+            self,
+            emitter_z: float,
+            detector_y: float,
+            detector_z: float,
+            volume_width: float,
+            volume_z_min: float,
+            volume_z_max: float,
+            resolution: int,
+            angle_limit: float | None = None,
+    ):
+        """
+        Create the base geometry of a laser profile line sensor, which emits a laser line into a
+        scene and detects the reflection of that line to triangulate the distance to points on a
+        surface.
+       
+        The general coordinate system is specified in X and Z. The center of the detection volume
+        is at the origin, with the laser line ranging from the -X direction to the +X direction.
+        The +Z direction points directly up towards the emitter.  The +Y direction is orthogonal to
+        laser line and is typically the direction which the sensor will be panned.
+       
+        The geometry is specified with the following assumptions:
+          - The laser line is emitted from a point directly on the +Z axis, with no offset in
+            the X or Y direction.
+          - The detector is not offset in the X direction, and can be specified with a Y and
+            Z offset from the center of the detection volume.
+          - The detection volume is trapezoidal, and its flat top and bottom are specified by a
+            maximum and minimum Z value.
+          - The detection volume's with is specified at Z=0, and is symmetrical around X=0.
+       
+        # Arguments
+       
+        :param emitter_z: The Z coordinate of the laser emitter. This is the height from the volume
+          center where the laser fans into a triangle.
+        :param detector_y: The Y coordinate of the detector's optical center. This is the out-of-plane
+          offset from the plane of the laser line.
+        :param detector_z: The Z coordinate of the detector's optical center. This is the height from
+          the volume center where the detector's optical center is located.
+        :param volume_width: The width of the detection volume at Z=0. The volume is assumed to be
+          symmetrical around the X axis, ranging from -volume_width/2 to +volume_width/2.
+        :param volume_z_min: The minimum Z value of the detection volume. This is the bottom of the
+          trapezoidal volume, the farthest distance from the emitter where the sensor will still
+          return points.
+        :param volume_z_max: The maximum Z value of the detection volume. This is the top of the
+          trapezoidal volume, the closest distance to the emitter where the sensor will still
+          return points.
+        :param resolution: The number of rays to cast across the laser line. This is the number of
+          points that will be returned in the point cloud.
+        :param angle_limit: An optional angle limit in radians. If specified, the sensor will only
+          return a point if the angle between the surface normal at the point and the detector is
+          less than this limit.
+        """
+        ...
+    
+        
+
+    def get_points(self, target: Mesh, obstruction: Mesh | None, iso: Iso3) -> PointCloud:
+        """
+
+        :param target:
+        :param obstruction:
+        :param iso:
+        :return:
+        """
+        ...
+
+
+class PanningLaserProfile:
+    def __init__(self, laser_line: LaserProfile, y_step: float, steps: int):
+        """
+        :param laser_line:
+        :param y_step:
+        :param steps:
+        """
+        ...
+
+    def get_points(self, target: Mesh, obstruction: Mesh | None, iso: Iso3) -> PointCloud:
+        """
+        :param target:
+        :param obstruction:
+        :param iso:
+        :return:
+        """
+        ...

{engeom-0.2.12.dist-info → engeom-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engeom
-Version: 0.2.12
+Version: 0.2.14
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -8,9 +8,3 @@ Requires-Dist: numpy
 Requires-Dist: pytest ; extra == 'tests'
 Provides-Extra: tests
 Requires-Python: >=3.8
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# Engeom Python Bindings
-
-Full documentation at https://mattj23.github.io/py-engeom/
-

{engeom-0.2.12.dist-info → engeom-0.2.14.dist-info}/RECORD

@@ -1,25 +1,25 @@
-engeom-0.2.12.dist-info/METADATA,sha256=pZZKympYzuY4vEG5d2rFiFldZiW1hpwK3ZPitByowLw,498
-engeom-0.2.12.dist-info/WHEEL,sha256=hKPP3BCTWtTwj6SFaSI--T5aOGqh_llYfbZ_BsqivwA,94
+engeom-0.2.14.dist-info/METADATA,sha256=oStO5eN3cCvP72aY8o0l-qTLhp91P8-0yG9ASVBFpaA,340
+engeom-0.2.14.dist-info/WHEEL,sha256=fUMUCU57hCqRM9lAdoyg0PVMCOUk2MQLaFVqt4-GBRk,94
+engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
+engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
+engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
+engeom/_plot/matplotlib.py,sha256=ahLfgE3QHUFcNig6cHkFu9mwSwfMbDcNqkZmGaBh4Zk,15267
+engeom/_plot/pyvista.py,sha256=lzwDWUFTbq1cR46nwVtuK4nn_hzbZnXiJPdoxHcKVDU,13930
+engeom/airfoil.pyi,sha256=SivSrUo3LZSVgXwIFJtgUUejhPh71y8rekzBwaX6exI,24165
 engeom/airfoil/__init__.py,sha256=gpS9pVepUu90XJ-ePndNupbUMKI0RGxNXPxD9x0iVHY,274
-engeom/airfoil.pyi,sha256=VTeJBoS9Iij7p-92R7jCqzPasHmvAUocyzc6BSx7mvM,23557
+engeom/align.pyi,sha256=OffG6hHhUt8ujWnE2iaH50TxoQ-B-p0Go1DcrftpUYc,1176
 engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
-engeom/align.pyi,sha256=QCSKrTLkCoaIubcrPU9J-wDZe1lRP0GbPgWZmonXjo0,997
+engeom/engeom.pyd,sha256=SBTV_V58YvXUKpPEt2Hm70XzLQYGeNbS5hZgoLRCGOQ,5931008
 engeom/engeom.pyi,sha256=J0L_D-Sc2laJHL36nUAvIP3eN9BDryAxd_6aMQarlZc,1561
+engeom/geom2.pyi,sha256=oUSner8BEJzJLv82POfOGyjAESw-McZzPq51o9VbdYg,51601
 engeom/geom2/__init__.py,sha256=JFpiLyROUh6vyakG-7JDSlCMCn4QB2MQ8bz3uVCaAIk,373
-engeom/geom2.pyi,sha256=Gg6Dw9yKOjc_1-sJiBPWDbGgQH5P5g6Ac80XRS-ziSQ,48330
+engeom/geom3.pyi,sha256=yU5Z85XQtr9YlN3fhhi_DQyd-gYNkkL0zb4asscLsaU,84476
 engeom/geom3/__init__.py,sha256=l8B0iDhJ4YiRbslJLN791XWai2DWrpmZptnzIETMS9g,370
-engeom/geom3.pyi,sha256=p6wiyIRMNFVBe6zgNGkDVqC1JRysq5OwwO654BPWoOI,76829
-engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
 engeom/metrology.pyi,sha256=9I5un86VB_2gmQBrVYhX8JzILTUADMLB9Em8ttJxrWg,4044
+engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
 engeom/plot.py,sha256=LTqqO-h1EJL6wanM0hB79s9ohWwaCIijMOHVplY3vmc,1079
-engeom/raster3/__init__.py,sha256=iaayLrvco-ZMZPyeK47ox7rYne_51DNb2T2Q0iNNeKE,289
 engeom/raster3.pyi,sha256=sBXXYXcDBiDU_OFDQiwa7Q3GcwSiUc4CLy6nJ1MwFqM,790
-engeom/sensor/__init__.py,sha256=p-1osXrlBX_hXSSlvySszSimMv_4_n273joBcTFx2V0,179
-engeom/sensor.pyi,sha256=a9y62FqhG-CFFHnJiC03PqBpFtxtfkH0zoDkk9LXWnU,1399
-engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
-engeom/_plot/matplotlib.py,sha256=rFL1CPNMUqGO-fwD45V3-shektBMeNq5U15Zxp96hYw,14824
-engeom/_plot/pyvista.py,sha256=PylGVOa9RtRIYPyHLy969eyW8yIgAk-URVZT0R7WoQ8,12980
-engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
-engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
-engeom/engeom.pyd,sha256=44INKWmXjNsb0jGmVyuKO1v1kFds1jVQPqq0X2dmWm0,2817536
-engeom-0.2.12.dist-info/RECORD,,
+engeom/raster3/__init__.py,sha256=iaayLrvco-ZMZPyeK47ox7rYne_51DNb2T2Q0iNNeKE,289
+engeom/sensors.pyi,sha256=cnCQLCNq43zkWeIGWNvX409RPhE9T7zhTCu9lvxXF_c,3933
+engeom/sensors/__init__.py,sha256=vy1CXX3gQcaBL25imYmpSAJhlc8v5aDBEBtF6L0PVCs,182
+engeom-0.2.14.dist-info/RECORD,,

{engeom-0.2.12.dist-info → engeom-0.2.14.dist-info}/WHEEL

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

engeom/sensor/__init__.py

@@ -1,6 +0,0 @@
-
-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

@@ -1,58 +0,0 @@
-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:
-        """
-        ...