engeom 0.1.1__cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl

engeom/__init__.py

@@ -0,0 +1,6 @@
+from .engeom import *
+
+
+__doc__ = engeom.__doc__
+if hasattr(engeom, "__all__"):
+    __all__ = engeom.__all__

engeom/align/__init__.py

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

engeom/align.pyi

@@ -0,0 +1,24 @@
+from __future__ import annotations
+import numpy
+from typing import Any, List, Tuple, Union
+from .engeom import DeviationMode, Iso3, Mesh
+
+
+def points_to_mesh(
+        points: numpy.ndarray[float],
+        mesh: Mesh,
+        initial: Iso3,
+        mode: DeviationMode
+) -> Iso3:
+    """
+    Perform a Levenberg-Marquardt, least squares optimization to align a set of points to a mesh. This will return the
+    isometry that best aligns the points to the mesh, or will throw an exception if the optimization fails.
+
+    :param points: a numpy array of shape (n, 3) containing the points to align.
+    :param mesh: the mesh to align the points to.
+    :param initial: the initial guess for the isometry. This will be used as the starting point for the optimization.
+    :param mode: the mode to use for the deviation calculation. This will determine how the deviation between the points
+    and the mesh is calculated.
+    :return: the isometry that best aligns the points to the mesh.
+    """
+    ...

engeom/engeom.pyi

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, List, Tuple, Union
+from enum import Enum
+
+import numpy
+
+
+class DeviationMode(Enum):
+    Absolute = 0
+    Normal = 1
+
+

engeom/geom2/__init__.py

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

engeom/geom2.pyi

@@ -0,0 +1,139 @@
+from __future__ import annotations
+import numpy
+
+
+class Vector2:
+    def __init__(self, x: float, y: float):
+        """
+
+        :param x:
+        :param y:
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        ...
+
+    @property
+    def y(self) -> float:
+        ...
+
+    def __rmul__(self, other: float) -> Vector2:
+        ...
+
+    def __add__(self, other: Vector2 | Point2) -> Vector2 | Point2:
+        ...
+
+    def __sub__(self, other: Vector2) -> Vector2:
+        ...
+
+    def __neg__(self) -> Vector2:
+        ...
+
+    def __mul__(self, x: float) -> Vector2:
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """
+        Create a numpy array of shape (2,) from the vector.
+        """
+        ...
+
+
+class Point2:
+    def __init__(self, x: float, y: float):
+        """
+
+        :param x:
+        :param y:
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        ...
+
+    @property
+    def y(self) -> float:
+        ...
+
+    @property
+    def coords(self) -> Vector2:
+        """
+        Get the coordinates of the point as a Vector2 object.
+        :return: a Vector2 object
+        """
+        ...
+
+    def __sub__(self, other: Vector2 | Point2) -> Vector2 | Point2:
+        ...
+
+    def __add__(self, other: Vector2) -> Vector2:
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """
+        Create a numpy array of shape (2,) from the point.
+        """
+        ...
+
+
+class Iso2:
+    def __init__(self, tx: float, ty: float, r: float):
+        """
+
+        :param tx:
+        :param ty:
+        :param r:
+        """
+        ...
+
+    @staticmethod
+    def identity() -> Iso2:
+        """
+        Create the identity isometry.
+        """
+        ...
+
+    def __matmul__(self, other: Iso2 | Vector2 | Point2) -> Iso2 | Vector2 | Point2:
+        ...
+
+    def inverse(self) -> Iso2:
+        """
+        Get the inverse of the isometry.
+        """
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """
+        Create a numpy array of shape (3, 3) from the isometry.
+        """
+        ...
+
+    def transform_points(self, points: numpy.ndarray[float]) -> numpy.ndarray[float]:
+        """
+        Transform an array of points using the isometry.
+        :param points: a numpy array of shape (N, 2)
+        :return: a numpy array of shape (N, 2)
+        """
+        ...
+
+    def transform_vectors(self, vectors: numpy.ndarray[float]) -> numpy.ndarray[float]:
+        """
+        Transform an array of vectors using the isometry. The translation part of the isometry is ignored.
+        :param vectors:
+        :return:
+        """
+        ...
+
+
+class SvdBasis2:
+
+    def __init__(self, points: numpy.ndarray[float], weights: numpy.ndarray[float] | None):
+        """
+
+        :param points:
+        :param weights:
+        """
+        ...

engeom/geom3/__init__.py

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

engeom/geom3.pyi

@@ -0,0 +1,425 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+
+import numpy
+
+from engeom import DeviationMode
+
+type Transformable3 = Vector3 | Point3 | Plane3 | Iso3
+
+
+class Vector3:
+    def __init__(self, x: float, y: float, z: float):
+        """
+
+        :param x:
+        :param y:
+        :param z:
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        ...
+
+    @property
+    def y(self) -> float:
+        ...
+
+    @property
+    def z(self) -> float:
+        ...
+
+    def __rmul__(self, other: float) -> Vector3:
+        ...
+
+    def __add__(self, other: Vector3 | Point3) -> Vector3 | Point3:
+        ...
+
+    def __sub__(self, other: Vector3) -> Vector3:
+        ...
+
+    def __neg__(self) -> Vector3:
+        ...
+
+    def __mul__(self, x: float) -> Vector3:
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """
+        Create a numpy array of shape (3,) from the vector.
+        """
+        ...
+
+
+class Point3:
+    def __init__(self, x: float, y: float, z: float):
+        """
+
+        :param x:
+        :param y:
+        :param z:
+        """
+        ...
+
+    @property
+    def x(self) -> float:
+        ...
+
+    @property
+    def y(self) -> float:
+        ...
+
+    @property
+    def z(self) -> float:
+        ...
+
+    @property
+    def coords(self) -> Vector3:
+        """
+        Get the coordinates of the point as a Vector3 object.
+        :return: a Vector3 object
+        """
+        ...
+
+    def __sub__(self, other: Vector3 | Point3) -> Vector3 | Point3:
+        ...
+
+    def __add__(self, other: Vector3) -> Vector3:
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """
+        Create a numpy array of shape (2,) from the point.
+        """
+        ...
+
+
+class Iso3:
+    """ An isometry (rigid body transformation) in 3D space. """
+
+    def __init__(self, matrix: numpy.ndarray[float]):
+        """ Create an isometry from a 4x4 matrix. """
+        ...
+
+    @staticmethod
+    def identity() -> Iso3:
+        """ Return the identity isometry. """
+        ...
+
+    @staticmethod
+    def from_translation(x: float, y: float, z: float) -> Iso3:
+        """ Create an isometry representing a translation. """
+        ...
+
+    @staticmethod
+    def from_rotation(angle: float, a: float, b: float, c: float) -> Iso3:
+        """
+        Create an isometry representing a rotation around an axis. The axis will be normalized before the rotation is
+        applied.
+        :param angle: the angle to rotate by in radians.
+        :param a: the x component of the rotation axis.
+        :param b: the y component of the rotation axis.
+        :param c: the z component of the rotation axis.
+        :return: the isometry representing the rotation.
+        """
+        ...
+
+    def __matmul__(self, other: Transformable3) -> Transformable3:
+        """
+        Multiply another object by the isometry, transforming it and returning a new object of the same type.
+        :param other: an object of one of the transformable types
+        :return: a new object of the same type as the input object, transformed by the isometry.
+        """
+        ...
+
+    def inverse(self) -> Iso3:
+        """ Return the inverse of the isometry. """
+        ...
+
+    def transform_points(self, points: numpy.ndarray[float]) -> numpy.ndarray[float]:
+        """ Transform a set of points by the isometry. This will transform the points by the rotation and translation
+        of the isometry.
+
+        :param points: a numpy array of shape (n, 3) containing the points to transform.
+        :return: a numpy array of shape (n, 3) containing the transformed points.
+        """
+        ...
+
+    def transform_vectors(self, vector: numpy.ndarray[float]) -> numpy.ndarray[float]:
+        """ Transform a set of vectors by the isometry. This will only transform the direction of the vectors, not
+        their magnitude.
+
+        :param vector: a numpy array of shape (n, 3) containing the vectors to transform.
+        :return: a numpy array of shape (n, 3) containing the transformed vectors.
+        """
+        ...
+
+    def as_numpy(self) -> numpy.ndarray[float]:
+        """ Return a copy of the 4x4 matrix representation of the isometry. This is a copy operation. """
+        ...
+
+    def flip_around_x(self) -> Iso3:
+        """ Return a new isometry that flips the isometry 180° around the x-axis. The origin of the isometry will be
+        preserved, but the y and z axes will point in the opposite directions. """
+        ...
+
+    def flip_around_y(self) -> Iso3:
+        """ Return a new isometry that flips the isometry 180° around the y-axis. The origin of the isometry will be
+        preserved, but the x and z axes will point in the opposite directions. """
+        ...
+
+    def flip_around_z(self) -> Iso3:
+        """ Return a new isometry that flips the isometry 180° around the z-axis. The origin of the isometry will be
+        preserved, but the x and y axes will point in the opposite directions. """
+        ...
+
+
+class SvdBasis3:
+    """
+    A class representing a basis in 3D space. This class is created from a set of points and will calculate the best
+    fitting basis for the points using a singular value decomposition.
+    """
+
+    def __init__(self, points: numpy.ndarray[float], weights: numpy.ndarray[float] | None):
+        """
+        Create a basis from a set of points. The basis will be calculated using a singular value decomposition of the
+        points.
+
+        :param points: a numpy array of shape (n, 3) containing the points to calculate the basis from.
+        :param weights: a numpy array of shape (n,) containing the weights of the points. If None, all points will be
+        weighted equally.
+        """
+        ...
+
+    def to_iso3(self) -> Iso3:
+        """
+        Produce an isometry which will transform from the world space to the basis space.
+
+        For example, if the basis is created from a set of points that lie in an arbitrary plane, transforming the
+        original points by this isometry will move the points such that all points lie on the XY plane.
+        :return: the isometry that transforms from the world space to the basis space.
+        """
+        ...
+
+    def largest(self) -> numpy.ndarray[float]:
+        """
+        Return the largest normalized basis vector.
+        :return: a numpy array of shape (3,) containing the largest basis vector.
+        """
+        ...
+
+    def smallest(self) -> numpy.ndarray[float]:
+        """
+        Return the smallest normalized basis vector.
+        :return: a numpy array of shape (3,) containing the smallest basis vector.
+        """
+        ...
+
+    def basis_variances(self) -> numpy.ndarray[float]:
+        """
+        Return the variances of the basis vectors.
+        :return: a numpy array of shape (3,) containing the variances of the basis vectors.
+        """
+        ...
+
+    def basis_stdevs(self) -> numpy.ndarray[float]:
+        """
+        Return the standard deviations of the basis vectors.
+        :return: a numpy array of shape (3,) containing the standard deviations of the basis vectors.
+        """
+        ...
+
+    def rank(self, tol: float) -> int:
+        """
+        Retrieve the rank of the decomposition by counting the number of singular values that are
+        greater than the provided tolerance.  A rank of 0 indicates that all singular values are
+        less than the tolerance, and thus the point set is essentially a single point. A rank of 1
+        indicates that the point set is essentially a line. A rank of 2 indicates that the point
+        set exists roughly in a plane.  The maximum rank is 3, which indicates that the point set
+        cannot be reduced to a lower dimension.
+
+        The singular values do not directly have a clear physical meaning. They are square roots of
+        the variance multiplied by the number of points used to compute the basis.  Thus, they can
+        be interpreted in relation to each other, and when they are very small.
+
+        This method should be used either when you know roughly what a cutoff tolerance for the
+        problem you're working on should be, or when you know the cutoff value should be very
+        small.  Otherwise, consider examining the standard deviations of the basis vectors
+        instead, as they will be easier to interpret (`basis_stdevs()`).
+        :param tol: the tolerance to use when determining the rank.
+        :return: the rank of the decomposition.
+        """
+        ...
+
+
+class Plane3:
+    """
+    A class representing a plane in 3D space. The plane is represented by a unit normal vector and a distance from the
+    origin along the normal vector.
+    """
+
+    def __init__(self, a: float, b: float, c: float, d: float):
+        """
+        Create a plane from the equation ax + by + cz + d = 0.
+        :param a: the x value of the unit normal vector.
+        :param b: the y value of the unit normal vector.
+        :param c: the z value of the unit normal vector.
+        :param d: the distance from the origin along the normal vector.
+        """
+        ...
+
+    def inverted_normal(self) -> Plane3:
+        """
+        Return a new plane with the normal vector inverted.
+        :return: a new plane with the inverted normal vector.
+        """
+        ...
+
+    def signed_distance_to_point(self, point: Point3) -> float:
+        """
+        Calculate the signed distance from the plane to a point. The distance will be positive if the point is on the
+        same side of the plane as the normal vector, and negative if the point is on the opposite side.
+        :param point: the point to calculate the distance to.
+        :return: the signed distance from the plane to the point.
+        """
+        ...
+
+    def project_point(self, point: Point3) -> Point3:
+        """
+        Project a point onto the plane. The projected point will be the closest point on the plane to the input point.
+        :param point: the point to project.
+        :return: the projected point.
+        """
+        ...
+
+
+class Mesh:
+    """
+    A class holding an unstructured, 3-dimensional mesh of triangles.
+    """
+
+    def __init__(
+            self,
+            vertices: numpy.ndarray[float],
+            triangles: numpy.ndarray[numpy.uint32],
+    ):
+        """
+        Create an engeom mesh from vertices and triangles.  The vertices should be a numpy array of shape (n, 3), while
+        the triangles should be a numpy array of shape (m, 3) containing the indices of the vertices that make up each
+        triangle. The triangles should be specified in counter-clockwise order when looking at the triangle from the
+        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.
+        """
+        ...
+
+    @staticmethod
+    def load_stl(path: str | Path) -> Mesh:
+        """
+        Load a mesh from an STL file. This will return a new mesh object containing the vertices and triangles from the
+        file.
+
+        :param path: the path to the STL file to load.
+        :return: the mesh object containing the data from the 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
+        format.
+
+        :param path: the path to the STL file to write.
+        """
+        ...
+
+    def clone(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.
+
+        :return:
+        """
+
+    def transform_by(self, iso: Iso3):
+        """
+        Transforms the vertices of the mesh by an isometry. This will modify the mesh in place.  Any copies made of
+        the vertices will no longer match the mesh after this operation.
+        :param iso: the isometry to transform the mesh by.
+        :return: None
+        """
+        ...
+
+    def append(self, other: Mesh):
+        """
+        Append another mesh to this mesh. This will add the vertices and triangles from the other mesh to this mesh,
+        changing this one and leaving the other one unmodified.
+
+        :param other: the mesh to append to this mesh, will not be modified in this operation
+        """
+        ...
+
+    def clone_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.
+        :return: a numpy array of shape (n, 3) containing the vertices of the mesh.
+        """
+        ...
+
+    def clone_triangles(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.
+
+        :return: a numpy array of shape (m, 3) containing the triangles of the mesh.
+        """
+        ...
+
+    def split(self, plane: Plane3) -> Tuple[Mesh | None, Mesh | None]:
+        """
+        Split the mesh by a plane. The plane will divide the mesh into two possible parts and return them as two new
+        objects.  If the part lies entirely on one side of the plane, the other part will be None.
+
+        :param plane: the plane to split the mesh by.
+
+        :return: a tuple of two optional meshes, the first being that on the negative side of the plane, the second being
+        that on the positive side of the plane.
+        """
+        ...
+
+    def deviation(self, points: numpy.ndarray[float], mode: DeviationMode) -> numpy.ndarray[float]:
+        """
+        Calculate the deviation between a set of points and their respective closest points on the mesh surface. The
+        deviation can be calculated in two modes: absolute and normal. In the absolute mode, the deviation is the
+        linear distance between the point and the closest point on the mesh. In the normal mode, the deviation is the
+        distance along the normal of the closest point on the mesh.  In both cases, the deviation will be positive if
+        the point is outside the surface and negative if the point is inside the surface.
+
+        :param points: a numpy array of shape (n, 3) containing the points to calculate the deviation for.
+        :param mode: the mode to calculate the deviation in.
+        :return: a numpy array of shape (n,) containing the deviation for each point.
+        """
+        ...
+
+    def sample_poisson(self, radius: float) -> numpy.ndarray[float]:
+        """
+        Sample the surface of the mesh using a Poisson disk sampling algorithm. This will return a numpy array of points
+        and their normals that are approximately evenly distributed across the surface of the mesh. The radius parameter
+        controls the minimum distance between points.
+
+        Internally, this algorithm will first re-sample each triangle of the mesh with a dense array of points at a
+        maximum distance of radius/2, before applying a random poisson disk sampling algorithm to thin the resampled
+        points. This means that the output points are not based on the mesh vertices, so large triangles will not be
+        under-represented and small triangles will not be over-represented.
+
+        :param radius: the minimum distance between points.
+        :return: a numpy array of shape (n, 6) containing the sampled points.
+        """
+        ...

engeom/matplotlib.py

@@ -0,0 +1,44 @@
+import numpy
+
+try:
+    from matplotlib.pyplot import Axes, Circle
+except ImportError:
+    pass
+else:
+
+    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
+        to fill all available space.
+
+        In comparison to the set_aspect('equal') method, this method will also expand the plot to prevent the overall
+        figure from shrinking.  It does this by manually re-checking the x and y limits and adjusting whichever is the
+        limiting value. Essentially, it will honor the larger of the two existing limits which were set before this
+        function was called, and will only expand the limits on the other axis to fill the remaining space.
+
+        Call this function after all visual elements have been added to the plot and any manual adjustments to the axis
+        limits are performed. If you use fig.tight_layout(), call this function after that.
+        :param ax: a Matplotlib Axes object
+        :return: None
+        """
+        x0, x1 = ax.get_xlim()
+        y0, y1 = ax.get_ylim()
+
+        bbox = ax.get_window_extent()
+        width, height = bbox.width, bbox.height
+
+        x_scale = width / (x1 - x0)
+        y_scale = height / (y1 - y0)
+
+        if y_scale > x_scale:
+            y_range = y_scale / x_scale * (y1 - y0)
+            y_mid = (y0 + y1) / 2
+            ax.set_ylim(y_mid - y_range / 2, y_mid + y_range / 2)
+        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)
+
+
+
+

engeom/pyvista.py

@@ -0,0 +1,26 @@
+"""
+    This module contains helper functions for working with PyVista.
+"""
+import numpy
+from .geom3 import Mesh
+
+try:
+    import pyvista
+except ImportError:
+    pass
+else:
+
+    def mesh_polydata(mesh: Mesh) -> pyvista.PolyData:
+        """
+        Creates a PyVista PolyData object from a Mesh object.
+        :param mesh: a Mesh object
+        :return: a PyVista PolyData object
+        """
+
+        if pyvista is None:
+            raise ImportError("PyVista is not installed.")
+
+        vertices = mesh.clone_vertices()
+        faces = mesh.clone_triangles()
+        faces = numpy.hstack((numpy.ones((faces.shape[0], 1), dtype=faces.dtype) * 3, faces))
+        return pyvista.PolyData(vertices, faces)

engeom-0.1.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: engeom
+Version: 0.1.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: numpy
+Requires-Dist: pytest ; extra == 'tests'
+Provides-Extra: tests
+Requires-Python: >=3.8

engeom-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+engeom-0.1.1.dist-info/METADATA,sha256=z8XmJMWeTVLOwcvkJvmggeYXlOUJKfEjA4NfrS8GlX0,339
+engeom-0.1.1.dist-info/WHEEL,sha256=1jk6Pyj4H6zT_Hox5RAAsXMc4iG45kQzjuSbAz0vxzI,129
+engeom/geom2/__init__.py,sha256=mRu8Zh6DE-EQyhxScoxszPqDjGVzGWVJEQO6RIAtS4A,174
+engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
+engeom/engeom.pyi,sha256=flbU5LWg6szeBLTaxa1eNvN8wBhLCf9qdFNgxOYS1ng,203
+engeom/__init__.py,sha256=QN5uETqrN442w41foyrcCPV_x6NP-mrxkPJhdvdey1g,109
+engeom/align.pyi,sha256=KBC0nwcyp4YMfY2hRN1gr3DqFah-unqAd_o1KYwJAqc,1022
+engeom/geom2.pyi,sha256=nwZ8Isy-PdvNIIyZyNuo78Us95CXd1FaWllqnF9MKbE,2978
+engeom/matplotlib.py,sha256=N3CkAtQjh9xZ1hx6_piFGRNzLRLEMh9OVvWDKx5yiL8,1676
+engeom/geom3/__init__.py,sha256=DG5jt2xgS9WRNb58ZkkrcKQQO6bIG-irg-uV_BkHEj4,174
+engeom/geom3.pyi,sha256=PjDbjM3d20PUbP5pmlb8OqpZ7gM0RQL_f7gEVTbr7kE,16198
+engeom/pyvista.py,sha256=zJ-FFwbzxVhhhrh4rfn26iaOK95Tw0L2QZsDNK8MXzg,729
+engeom/engeom.abi3.so,sha256=MaLHka2geUg99tkroeIh_prsCh0PM09WVFFMHQN_uc8,1789656
+engeom-0.1.1.dist-info/RECORD,,

engeom-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.1)
+Root-Is-Purelib: false
+Tag: cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le