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

engeom/align.pyi

@@ -29,4 +29,25 @@ def points_to_cloud(
         search_radius: float,
         initial: Iso3,
 ) -> Iso3:
+    ...
+
+def mesh_to_mesh_iterative(
+        mesh: Mesh,
+        reference: Mesh,
+         sample_spacing: float,
+        initial: Iso3,
+        mode: DeviationMode,
+        max_iter: int
+) -> Iso3:
+    """
+    Perform an iterative alignment of a mesh to a reference mesh using the specified parameters.
+
+    :param mesh: the mesh to align.
+    :param reference: the reference mesh to align to.
+    :param sample_spacing: the spacing between samples for the alignment.
+    :param initial: the initial guess for the isometry.
+    :param mode: the mode to use for the deviation calculation.
+    :param max_iter: the maximum number of iterations to perform.
+    :return: the isometry that best aligns the mesh to the reference mesh.
+    """
     ...

engeom/geom3.pyi

@@ -11,6 +11,50 @@ import metrology
 Transformable3 = TypeVar("Transformable3", Vector3, Point3, Plane3, Iso3, SurfacePoint3)
 PointOrVector3 = TypeVar("PointOrVector3", Vector3, Point3)
 
+type Lptf3LoadEnum = Lptf3Load.All | Lptf3Load.TakeEveryN | Lptf3Load.SmoothSample
+
+
+class Lptf3Load:
+    """
+    An enumeration representing the different load types that can be used when loading LPTF3 files.
+    """
+
+    class All:
+        def __init__(self):
+            """
+            Load all points from the file
+            """
+            ...
+
+    class TakeEveryN:
+        def __init__(self, n: int):
+            """
+            Load every nth row from the file. The loader will attempt to roughly match the inter-row spacing when
+            loading the individual points, resulting in an approximate grid-like array of points.
+            :param n: the interval at which to take rows from the file.
+            """
+            ...
+
+    class SmoothSample:
+        def __init__(self, take_every: int, look_scale: float, weight_scale: float, max_move: float):
+            """
+            Load the points using a downsampling filter, which downsamples the point cloud similar to the `TakeEveryN`
+            method, but also performs a gaussian smoothing step using the full original cloud.  This takes the longest
+            time, but can remove a significant amount of noise from the data by making use of an adjacency structure
+            that will be lost once the points are turned into a cloud.
+
+            :param take_every: the interval at which to take rows from the file.
+            :param look_scale: smoothing will use a sampling window relative to the `take_every` spacing, so a value
+            of 1 will use the same spacing as `take_every`, while a value of 2 will use twice that spacing. A reasonable
+            default for preserving detail is 0.5.
+            :param weight_scale: during the gaussian smoothing, neighboring points will be weighted by their distance
+            from the point being smoothed.  At `weight_scale` of 1, the standard deviation of the gaussian will be
+            slightly larger than the `look_scale` distance.
+            :param max_move: the maximum distance a point can move when smoothing. If a point attempts to move more
+            than 10x this distance, it will not be moved at all. Otherwise, it will be clamped to within this distance.
+            """
+            ...
+
 
 class Vector3(Iterable[float]):
     """
@@ -487,6 +531,21 @@ class Iso3:
         """ Return the identity isometry. """
         ...
 
+    @staticmethod
+    def from_quaternion(tx: float, ty: float, tz: float, i: float, j: float, k: float, w: float) -> Iso3:
+        """
+        Create an isometry from a translation and a quaternion representing the rotation.
+        :return: an isometry containing both translation and rotation components.
+        """
+        ...
+
+    def to_quaternion(self) -> Tuple[float, float, float, float, float, float, float]:
+        """
+        Convert the isometry to a tuple containing the translation and quaternion components.
+        :return: a tuple of 7 floats in the order (tx, ty, tz, i, j, k, w)
+        """
+        ...
+
     @staticmethod
     def from_translation(x: float, y: float, z: float) -> Iso3:
         """
@@ -956,6 +1015,36 @@ class Mesh:
         """
         ...
 
+    @staticmethod
+    def load_lptf3(path: str | Path, params: Lptf3LoadEnum) -> Mesh:
+        """
+        This function reads a LPTF3 file, which is a compact file format for storing 3D point data
+        taken from a laser profile triangulation scanner. The format is simple and compact, capable
+        of practically storing about 200k points (with an 8-bit color value each) per MB when using a
+        16-bit coordinate format, or half that when using a 32-bit coordinate format.
+
+        There are a few different ways to load the data, controlled by the `Lptf3Load` enum:
+          - `Lptf3Load.All`: Load all points from the file.
+          - `Lptf3Load.TakeEveryN(n)`: Load every Nth row from the file. The loader will attempt to
+            roughly match the x spacing of the points to the gap distance between rows, resulting in a
+            grid-like point cloud with an approximately uniform point spacing when viewed from the
+            X-Y plane.  This is a very fast method of retrieving a downsampled set of points.
+          - `Lptf3Load.SmoothSample(params)`: Load the points using a downsampling filter, which
+            downsamples the point cloud similar to the `TakeEveryN` method, but also performs a gaussian
+            smoothing step using the full original cloud.  This takes the longest time, but can remove
+            a significant amount of noise from the data by making use of an adjacency structure that
+            will be lost once the points are turned into a mesh.
+
+        Once the points are loaded, they will be converted into a triangle mesh by connecting points in adjacent
+        rows with triangles that meet certain edge length criterial. The result is a fast mesh that can be built
+        using knowledge of the LPTF3's internal structure rather than having to rely on more general techniques
+        that can build meshes from arbitrary point clouds.
+
+        :param path: the path to the LPTF3 file to load.
+        :param params: the method and parameters to use when loading the LPTF3 file.
+        """
+        ...
+
     def write_stl(self, path: str | Path):
         """
         Write the mesh to an STL file. This will write the vertices and triangles of the mesh to the file in binary
@@ -1082,6 +1171,35 @@ class Mesh:
         """
         ...
 
+    def sample_alignment_points(
+            self,
+            reference: Mesh,
+            iso: Iso3,
+            max_spacing: float,
+            max_neighbor_angle: float,
+            out_of_plane_ratio: float,
+            centroid_ratio: float,
+            filter_distances: float | None
+    ) -> NDArray[float]:
+        """
+        This is a very specialized, highly selective sampling method used to identify high quality points for
+        the alignment between two meshes. It begins with a Poisson disk sampling of the mesh, and then inspects the
+        individual points to evaluate the quality and consistency of their local neighborhood, before projecting their
+        local neighborhood onto the reference mesh and looking for the same qualities in the projections.
+
+        This method will return a numpy array of points which are spaced at least `max_spacing` apart, and which lie
+        on areas of the mesh of low curvature, away from corners and edges, and which plausibly overlap with a
+        correspondingly low-curvature area of the reference mesh away from its corners and edges.
+
+        :param max_spacing: a Poisson disk sampling radius used to start sampling the mesh. This value is also used to
+        derive a set of physical limits which will selectively filter different aspects of the sample points.
+        :param reference: the reference mesh that the alignment candidates will be sampled against. Assuming these
+        points will be used to perform an alignment, this mesh should be the one that is being aligned to.
+        :param iso: an isometry to apply to the sampled points before checking against the reference mesh.
+        :return: a numpy array of shape (n, 3) containing the sampled points.
+        """
+        ...
+
     def section(self, plane: Plane3, tol: float | None = None) -> List[Curve3]:
         """
         Calculate and return the intersection curves between the mesh and a plane.
@@ -1208,6 +1326,27 @@ class Mesh:
         """
         ...
 
+    def barycentric_closest_to(self, x: float, y: float, z: float) -> Tuple[int, List[float]]:
+        """
+        Find the closest point on the surface of the mesh to a given point in space, returning the triangle index and
+        the barycentric coordinates of the closest point within that triangle.
+        :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 tuple containing the triangle index and a list of three barycentric coordinates
+        """
+        ...
+
+    def point_closest_to(self, x: float, y: float, z: float) -> Point3:
+        """
+        Find the closest point on the surface of the mesh to a given point in space, returning the point
+        :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 `Point3` object containing the closest point and normal
+        """
+        ...
+
     def visual_outline(
             self,
             facing: Vector3,
@@ -1241,6 +1380,16 @@ class Mesh:
         """
         ...
 
+    def boundary_curves(self) -> List[Curve3]:
+        """
+        Extract the boundary curves of the mesh. This will return a list of `Curve3` objects representing the
+        boundaries of the mesh. The curves will be ordered in a way that they can be used to reconstruct the boundary
+        of the mesh.
+
+        :return: a list of `Curve3` objects representing the boundary curves of the mesh.
+        """
+        ...
+
     @staticmethod
     def create_box(length: float, width: float, height: float) -> Mesh:
         """
@@ -1845,15 +1994,38 @@ class PointCloud:
         ...
 
     @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.
+    def load_lptf3(path: str | Path, params: Lptf3LoadEnum) -> PointCloud:
+        """
+        This function reads a LPTF3 file, which is a compact file format for storing 3D point data
+        taken from a laser profile triangulation scanner. The format is simple and compact, capable
+        of practically storing about 200k points (with an 8-bit color value each) per MB when using a
+        16-bit coordinate format, or half that when using a 32-bit coordinate format.
+
+        There are a few different ways to load the data, controlled by the `Lptf3Load` enum:
+          - `Lptf3Load.All`: Load all points from the file.
+          - `Lptf3Load.TakeEveryN(n)`: Load every Nth row from the file. The loader will attempt to
+            roughly match the x spacing of the points to the gap distance between rows, resulting in a
+            grid-like point cloud with an approximately uniform point spacing when viewed from the
+            X-Y plane.  This is a very fast method of retrieving a downsampled point cloud.
+          - `Lptf3Load.SmoothSample(params)`: Load the points using a downsampling filter, which
+            downsamples the point cloud similar to the `TakeEveryN` method, but also performs a gaussian
+            smoothing step using the full original cloud.  This takes the longest time, but can remove
+            a significant amount of noise from the data by making use of an adjacency structure that
+            will be lost once the points are turned into a cloud.
 
         :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.
+        :param params: the method and parameters to use when loading the LPTF3 file.
+        """
+        ...
+
+    @staticmethod
+    def load_bxyz(path: str | Path) -> PointCloud:
+        """
+        Load a point cloud from a BXYZ file. The BXYZ format is a binary format for storing 3D point clouds with
+        optional normals and colors.
+
+        :param path: the path to the BXYZ file to load.
+        :return: a new `PointCloud` object containing the points, normals, and colors from the BXYZ file.
         """
         ...
 
@@ -1928,7 +2100,7 @@ class PointCloud:
         :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

engeom/sensors.pyi

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 from .geom3 import Point3, Mesh, Iso3, Vector3, PointCloud
 
 
@@ -57,8 +59,6 @@ class LaserProfile:
           less than this limit.
         """
         ...
-    
-        
 
     def get_points(self, target: Mesh, obstruction: Mesh | None, iso: Iso3) -> PointCloud:
         """
@@ -70,6 +70,19 @@ class LaserProfile:
         """
         ...
 
+    def load_lptf3(self, path: str | Path, take_every: int | None = None,
+                   normal_neighborhood: float | None = None) -> PointCloud:
+        """
+        Load a laser profile from a LPTF3 file.
+
+        :param path: The path to the LPTF3 file.
+        :param take_every: Optional parameter to take every nth row/col from the file.
+        :param normal_neighborhood: Optional parameter to specify the neighborhood size for normal
+          calculation.
+        :return: A PointCloud containing the points from the LPTF3 file.
+        """
+        ...
+
 
 class PanningLaserProfile:
     def __init__(self, laser_line: LaserProfile, y_step: float, steps: int):

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

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

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

@@ -1,5 +1,5 @@
-engeom-0.2.14.dist-info/METADATA,sha256=oStO5eN3cCvP72aY8o0l-qTLhp91P8-0yG9ASVBFpaA,340
-engeom-0.2.14.dist-info/WHEEL,sha256=fUMUCU57hCqRM9lAdoyg0PVMCOUk2MQLaFVqt4-GBRk,94
+engeom-0.2.16.dist-info/METADATA,sha256=sX-tpGK0jbTlLML0_gcyGd-VcC_Y6Zw7ZdCgHKNnfp0,340
+engeom-0.2.16.dist-info/WHEEL,sha256=F7HFsRl56IeLjGhxiHeG3IpurHNaGNHQJeIy7gdwTO4,94
 engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
 engeom/_plot/__init__.py,sha256=F_KviZtxzZGwfEjjn8Ep46N4UVl8VpFJWBzbBUE_J7A,30
 engeom/_plot/common.py,sha256=Py78ufN3yi59hPwv21SoGcqyZUJS-_PmK8tlAKgSG7Q,517
@@ -7,19 +7,19 @@ engeom/_plot/matplotlib.py,sha256=ahLfgE3QHUFcNig6cHkFu9mwSwfMbDcNqkZmGaBh4Zk,15
 engeom/_plot/pyvista.py,sha256=lzwDWUFTbq1cR46nwVtuK4nn_hzbZnXiJPdoxHcKVDU,13930
 engeom/airfoil.pyi,sha256=SivSrUo3LZSVgXwIFJtgUUejhPh71y8rekzBwaX6exI,24165
 engeom/airfoil/__init__.py,sha256=gpS9pVepUu90XJ-ePndNupbUMKI0RGxNXPxD9x0iVHY,274
-engeom/align.pyi,sha256=OffG6hHhUt8ujWnE2iaH50TxoQ-B-p0Go1DcrftpUYc,1176
+engeom/align.pyi,sha256=SaC46l0mqANzp3JAtIk4DdXTLtKBrEr9_xW21algMTk,1935
 engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
-engeom/engeom.pyd,sha256=SBTV_V58YvXUKpPEt2Hm70XzLQYGeNbS5hZgoLRCGOQ,5931008
+engeom/engeom.pyd,sha256=Mich0vgPnElHMKuVb-LLTDY_6UGDCOf0KUQWh1yx8x0,6128640
 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/geom3.pyi,sha256=yU5Z85XQtr9YlN3fhhi_DQyd-gYNkkL0zb4asscLsaU,84476
+engeom/geom3.pyi,sha256=aO8kj5POqXtHpwV5kNxLJg1yLB9ZhlHadONfgM0NlBw,94397
 engeom/geom3/__init__.py,sha256=l8B0iDhJ4YiRbslJLN791XWai2DWrpmZptnzIETMS9g,370
 engeom/metrology.pyi,sha256=9I5un86VB_2gmQBrVYhX8JzILTUADMLB9Em8ttJxrWg,4044
 engeom/metrology/__init__.py,sha256=XvEhG8uDm1olWwZHDDrQv9LFP5zXhbsGx27PqRq8WE0,304
 engeom/plot.py,sha256=LTqqO-h1EJL6wanM0hB79s9ohWwaCIijMOHVplY3vmc,1079
 engeom/raster3.pyi,sha256=sBXXYXcDBiDU_OFDQiwa7Q3GcwSiUc4CLy6nJ1MwFqM,790
 engeom/raster3/__init__.py,sha256=iaayLrvco-ZMZPyeK47ox7rYne_51DNb2T2Q0iNNeKE,289
-engeom/sensors.pyi,sha256=cnCQLCNq43zkWeIGWNvX409RPhE9T7zhTCu9lvxXF_c,3933
+engeom/sensors.pyi,sha256=8dQS6PVkbBOdbO17x9UskBOIIh6cP0EILhJXxPVXDNw,4525
 engeom/sensors/__init__.py,sha256=vy1CXX3gQcaBL25imYmpSAJhlc8v5aDBEBtF6L0PVCs,182
-engeom-0.2.14.dist-info/RECORD,,
+engeom-0.2.16.dist-info/RECORD,,

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

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