engeom 0.1.1__cp38-abi3-macosx_10_12_x86_64.whl → 0.1.2__cp38-abi3-macosx_10_12_x86_64.whl

engeom/engeom.pyi

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

engeom/geom2.pyi

@@ -1,5 +1,10 @@
 from __future__ import annotations
 import numpy
+from typing import Iterable, Tuple
+
+from engeom.engeom import Resample
+
+type Transformable2 = Vector2 | Point2 | Iso2 | SurfacePoint2
 
 
 class Vector2:
@@ -19,6 +24,9 @@ class Vector2:
     def y(self) -> float:
         ...
 
+    def __iter__(self) -> Iterable[float]:
+        ...
+
     def __rmul__(self, other: float) -> Vector2:
         ...
 
@@ -40,6 +48,36 @@ class Vector2:
         """
         ...
 
+    def dot(self, other: Vector2) -> float:
+        """
+        Compute the dot product of two vectors.
+        """
+        ...
+
+    def cross(self, other: Vector2) -> float:
+        """
+        Compute the cross product of two vectors.
+        """
+        ...
+
+    def norm(self) -> float:
+        """
+        Compute the norm of the vector.
+        """
+        ...
+
+    def normalized(self) -> Vector2:
+        """
+        Return a normalized version of the vector.
+        """
+        ...
+
+    def angle_to(self, other: Vector2) -> float:
+        """
+        Compute the smallest angle between two vectors and return it in radians.
+        """
+        ...
+
 
 class Point2:
     def __init__(self, x: float, y: float):
@@ -58,6 +96,9 @@ class Point2:
     def y(self) -> float:
         ...
 
+    def __iter__(self) -> Iterable[float]:
+        ...
+
     @property
     def coords(self) -> Vector2:
         """
@@ -79,6 +120,81 @@ class Point2:
         ...
 
 
+class SurfacePoint2:
+    def __init__(self, x: float, y: float, nx: float, ny: float):
+        """
+
+        :param x:
+        :param y:
+        :param nx:
+        :param ny:
+        """
+        ...
+
+    @property
+    def point(self) -> Point2:
+        """
+        Get the coordinates of the point as a Point2 object.
+        :return: a Point2 object
+        """
+        ...
+
+    @property
+    def normal(self) -> Vector2:
+        """
+        Get the normal of the point as a Vector2 object.
+        :return: a Vector2 object
+        """
+        ...
+
+    def at_distance(self, distance: float) -> Point2:
+        """
+        Get the point at a distance along the normal from the surface point.
+        :param distance: the distance to move along the normal.
+        :return: the point at the distance along the normal.
+        """
+        ...
+
+    def scalar_projection(self, point: Point2) -> float:
+        """
+        Calculate the scalar projection of a point onto the axis defined by the surface point position and direction.
+        Positive values indicate that the point is in the normal direction from the surface point, while negative values
+        indicate that the point is in the opposite direction.
+
+        :param point: the point to calculate the projection of.
+        :return: the scalar projection of the point onto the normal.
+        """
+        ...
+
+    def projection(self, point: Point2) -> Point2:
+        """
+        Calculate the projection of a point onto the axis defined by the surface point position and direction.
+
+        :param point: the point to calculate the projection of.
+        :return: the projection of the point onto the plane.
+        """
+        ...
+
+    def reversed(self) -> SurfacePoint2:
+        """
+        Return a new surface point with the normal vector inverted, but the position unchanged.
+        :return: a new surface point with the inverted normal vector.
+        """
+        ...
+
+    def planar_distance(self, point: Point2) -> float:
+        """
+        Calculate the planar (non-normal) distance between the surface point and a point. This is complementary to the
+        scalar projection. A point is projected onto the plane defined by the position and normal of the surface point,
+        and the distance between the surface point position and the projected point is returned.  The value will always
+        be positive.
+
+        :param point: the point to calculate the distance to.
+        :return: the planar distance between the surface point and the point.
+        """
+        ...
+
+
 class Iso2:
     def __init__(self, tx: float, ty: float, r: float):
         """
@@ -130,10 +246,271 @@ class Iso2:
 
 class SvdBasis2:
 
-    def __init__(self, points: numpy.ndarray[float], weights: numpy.ndarray[float] | None):
+    def __init__(
+            self,
+            points: numpy.ndarray[float],
+            weights: numpy.ndarray[float] | None = None
+    ):
         """
 
         :param points:
         :param weights:
         """
         ...
+
+
+class CurveStation2:
+    """
+    A class representing a station along a curve in 3D space. The station is represented by a point on the curve, a
+    tangent (direction) vector, and a length along the curve.
+    """
+
+    @property
+    def point(self) -> Point2:
+        """ The 2d position in space on the curve. """
+        ...
+
+    @property
+    def direction(self) -> Vector2:
+        """ The tangent (direction) vector of the curve at the station. """
+        ...
+
+    @property
+    def normal(self) -> Vector2:
+        """ The normal vector of the curve at the station. """
+        ...
+
+    @property
+    def direction_point(self) -> SurfacePoint2:
+        """
+        A `SurfacePoint2` object representing the point on the curve and the curve's tangent/direction vector.
+        """
+        ...
+
+    @property
+    def surface_point(self) -> SurfacePoint2:
+        """
+        A `SurfacePoint2` object representing the point on the curve and the curve's normal vector.
+        """
+        ...
+
+    @property
+    def index(self) -> int:
+        """ The index of the previous vertex on the curve, at or before the station. """
+        ...
+
+    @property
+    def length_along(self) -> float:
+        """ The length along the curve from the start of the curve to the station. """
+        ...
+
+
+class Curve2:
+    """
+    A class representing a curve in 2D space. The curve is defined by a set of vertices and the line segments between
+    them. In two dimensions, the curve also has the concepts of closed/open, surface direction, and hull.
+
+    """
+
+    def __init__(
+            self,
+            vertices: numpy.ndarray,
+            normals: numpy.ndarray | None = None,
+            tol: float | None = None,
+            force_closed: bool = False,
+            hull_ccw: bool = False,
+    ):
+        """
+        Create a 2d curve from a set of vertices and some additional options.
+
+        It's important to note that in 2d, a curve has a concept of a normal direction, built from the concept of
+        inside/outside defined through the winding order of the vertices. This extra information can allow a 2d curve
+        to model a manifold surface.
+
+        There are three ways to specify the winding order of the vertices:
+        1. Control it manually by passing the vertices array with the rows already organized so that an exterior surface
+        is counter-clockwise.
+        2. If the vertices represent an exterior shape, pass `hull_ccw=True` to have the constructor automatically
+        check the winding order and reverse it if point ordering in the convex hull does not match ordering in the
+        original array.
+        3. Pass a `normals` array the same size as the `vertices` array, where the normals are non-zero vectors pointed
+        in the "outside" direction at each point. The constructor will reverse the winding if the majority of normals
+        do not point in the same direction as the winding.
+
+        :param vertices: a numpy array of shape (N, 2) representing the vertices of the curve.
+        :param normals: an optional numpy array of shape (N, 2) representing the normals of the curve associated with
+        each vertex.
+        :param tol: a tolerance value for the curve. If not provided, a default value of 1e-6 is used. This is the
+        distance at which two points are considered to be the same.
+        :param force_closed: If True, the curve will be closed even if the first and last points are not the same, which
+        will be done by adding a new point at the end of the array that is the same as the first point.
+        :param hull_ccw: If True, the constructor will check the winding order of the vertices and reverse it if the
+        convex hull of the points is not in the same order as the original array. This will do nothing if the `normals`
+        parameter is provided.
+        """
+        ...
+
+    def length(self) -> float:
+        """
+        Get the length of the curve.
+        :return: the length of the curve.
+        """
+        ...
+
+    def at_front(self) -> CurveStation2:
+        """
+        Get the station at the front of the curve.
+        :return: the station at the front of the curve.
+        """
+        ...
+
+    def at_back(self) -> CurveStation2:
+        """
+        Get the station at the back of the curve.
+        :return: the station at the back of the curve.
+        """
+        ...
+
+    def at_length(self, length: float) -> CurveStation2:
+        """
+        Get the station at a given length along the curve. Will throw a ValueError if the length is less than zero or
+        greater than the length of the curve.
+        :param length: the length along the curve.
+        :return: the station at the given length.
+        """
+        ...
+
+    def at_fraction(self, fraction: float) -> CurveStation2:
+        """
+        Get the station at a given fraction of the length of the curve. Will throw a ValueError if the fraction is less
+        than zero or greater than one.
+        :param fraction: the fraction of the length of the curve.
+        :return: the station at the given fraction.
+        """
+        ...
+
+    def at_closest_to_point(self, point: Point2) -> CurveStation2:
+        """
+        Get the station on the curve that is closest to a given point.
+        :param point: the point to find the closest station to.
+        :return: the station on the curve that is closest to the given point.
+        """
+        ...
+
+    @property
+    def is_closed(self) -> bool:
+        """
+        Check if the curve is closed.
+        :return: True if the curve is closed, False otherwise.
+        """
+        ...
+
+    def trim_front(self, length: float) -> Curve2:
+        """
+        Remove the front of the curve by a given length and return a new curve.
+        :param length: the length to trim from the front of the curve.
+        :return: a new curve with the front trimmed by the given length.
+        """
+        ...
+
+    def trim_back(self, length: float) -> Curve2:
+        """
+        Remove the back of the curve by a given length and return a new curve.
+        :param length: the length to trim from the back of the curve.
+        :return: a new curve with the back trimmed by the given length.
+        """
+        ...
+
+    def between_lengths(self, l0: float, l1: float) -> Curve2:
+        """
+        Attempt to get a new curve cut between two lengths along the curve. If the lengths are not valid, a ValueError
+        will be thrown.
+
+        If the curve is closed, the lengths will be wrapped around the curve. If the curve is not closed, the value
+        of `l0` must be less than `l1`. In either case, the lengths must be within the bounds of the curve.
+
+        :param l0: the start length.
+        :param l1: the end length.
+        :return: a new curve between the two lengths.
+        """
+        ...
+
+    def between_lengths_by_control(self, a: float, b: float, control: float) -> Curve2:
+        """
+        Attempt to get a new curve cut between two lengths along the curve, with a control point that will be used to
+        determine which side of the curve to keep. This is primarily helpful on closed curves when you can find a length
+        (usually via use of the `at_closest_to_point` method) that is on the side of the curve you want to keep.
+
+        If the lengths are not valid, a ValueError will be thrown.
+
+        :param a: the first length along the curve to cut
+        :param b: the second length along the curve to cut
+        :param control: a length along the curve that is on a point in the portion of the result that you want to keep
+        :return: a new curve between the two lengths
+        """
+
+    def reversed(self) -> Curve2:
+        """
+        Reverse the curve and return a new curve.
+        :return: a new curve with the vertices in reverse order.
+        """
+        ...
+
+    def make_hull(self) -> numpy.ndarray[float]:
+        """
+        Get the vertices of a convex hull of the curve, in counter-clockwise order.
+        :return: a numpy array of shape (N, 2) representing the convex hull of the curve.
+        """
+        ...
+
+    def max_point_in_direction(self, direction: Vector2) -> Tuple[int, Point2]:
+        """
+        Find the point on the curve that is furthest in a given direction.
+        :param direction: the direction to find the furthest point in.
+        :return: a tuple of the index of the point and the point itself.
+        """
+        ...
+
+    def max_distance_in_direction(self, surf_point: SurfacePoint2) -> float:
+        """
+        Find the maximum scalar projection of all vertices of the curve onto a surface point.
+        :param surf_point: the direction to find the furthest point in.
+        :return: the maximum scalar projection of all vertices of the curve onto a surface point.
+        """
+        ...
+
+    def clone_points(self) -> numpy.ndarray[float]:
+        """
+        Clone the points of the curve.
+        :return: a numpy array of shape (N, 2) representing the points of the curve.
+        """
+        ...
+
+    def simplify(self, tol: float) -> Curve2:
+        """
+        Simplify the curve using the Ramer-Douglas-Peucker algorithm.
+        :param tol: the tolerance to use for simplification.
+        :return: a new curve with the simplified points.
+        """
+        ...
+
+    def resample(self, resample: Resample) -> Curve2:
+        """
+        Resample the curve using the given resampling method. The resampling method can be one of the following:
+
+        - `Resample.ByCount(count: int)`: resample the curve to have the given number of points.
+        - `Resample.BySpacing(distance: float)`: resample the curve to have points spaced by the given distance.
+        - `Resample.ByMaxSpacing(distance: float)`: resample the curve to have points spaced by a maximum distance.
+
+        :param resample: the resampling method to use.
+        :return: a new curve object with the resampled vertices.
+        """
+        ...
+
+    def transformed_by(self, transform: Iso2) -> Curve2:
+        """
+        Transform the curve by the given transform and return a new curve.
+        :param transform: the transform to apply to the curve.
+        :return: a new curve object with the transformed vertices.
+        """
+        ...

engeom/geom3.pyi

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple
+from typing import Tuple, Iterable, List
 
 import numpy
+from engeom import DeviationMode, Resample
 
-from engeom import DeviationMode
-
-type Transformable3 = Vector3 | Point3 | Plane3 | Iso3
+type Transformable3 = Vector3 | Point3 | Plane3 | Iso3 | SurfacePoint3
 
 
 class Vector3:
@@ -32,6 +31,9 @@ class Vector3:
     def z(self) -> float:
         ...
 
+    def __iter__(self) -> Iterable[float]:
+        ...
+
     def __rmul__(self, other: float) -> Vector3:
         ...
 
@@ -53,6 +55,42 @@ class Vector3:
         """
         ...
 
+    def dot(self, other: Vector3) -> float:
+        """
+        Calculate the dot product of this vector with another vector.
+        :param other: the other vector to calculate the dot product with.
+        :return: the dot product of the two vectors.
+        """
+        ...
+
+    def cross(self, other: Vector3) -> Vector3:
+        """
+        Calculate the cross product of this vector with another vector.
+        :param other: the other vector to calculate the cross product with.
+        :return: the cross product of the two vectors.
+        """
+        ...
+
+    def norm(self) -> float:
+        """
+        Calculate the norm (length) of the vector.
+        :return:
+        """
+
+    def normalized(self) -> Vector3:
+        """
+        Return a normalized version of the vector.
+        :return: a new vector that has unit length
+        """
+
+    def angle_to(self, other: Vector3) -> float:
+        """
+        Calculate the smallest angle between this vector and another vector.
+        :param other: the other vector to calculate the angle to.
+        :return: the angle between the two vectors in radians.
+        """
+        ...
+
 
 class Point3:
     def __init__(self, x: float, y: float, z: float):
@@ -76,6 +114,9 @@ class Point3:
     def z(self) -> float:
         ...
 
+    def __iter__(self) -> Iterable[float]:
+        ...
+
     @property
     def coords(self) -> Vector3:
         """
@@ -97,6 +138,90 @@ class Point3:
         ...
 
 
+class SurfacePoint3:
+    def __init__(self, x: float, y: float, z: float, nx: float, ny: float, nz: float):
+        """
+
+        :param x:
+        :param y:
+        :param z:
+        :param nx:
+        :param ny:
+        :param nz:
+        """
+        ...
+
+    @property
+    def point(self) -> Point3:
+        """
+        Get the coordinates of the point as a Point3 object.
+        :return: a Point3 object
+        """
+        ...
+
+    @property
+    def normal(self) -> Vector3:
+        """
+        Get the normal of the point as a Vector3 object.
+        :return: a Vector3 object
+        """
+        ...
+
+    def at_distance(self, distance: float) -> Point3:
+        """
+        Get the point at a distance along the normal from the surface point.
+        :param distance: the distance to move along the normal.
+        :return: the point at the distance along the normal.
+        """
+        ...
+
+    def scalar_projection(self, point: Point3) -> float:
+        """
+        Calculate the scalar projection of a point onto the axis defined by the surface point position and direction.
+        Positive values indicate that the point is in the normal direction from the surface point, while negative values
+        indicate that the point is in the opposite direction.
+
+        :param point: the point to calculate the projection of.
+        :return: the scalar projection of the point onto the normal.
+        """
+        ...
+
+    def projection(self, point: Point3) -> Point3:
+        """
+        Calculate the projection of a point onto the axis defined by the surface point position and direction.
+
+        :param point: the point to calculate the projection of.
+        :return: the projection of the point onto the plane.
+        """
+        ...
+
+    def reversed(self) -> SurfacePoint3:
+        """
+        Return a new surface point with the normal vector inverted, but the position unchanged.
+        :return: a new surface point with the inverted normal vector.
+        """
+        ...
+
+    def planar_distance(self, point: Point3) -> float:
+        """
+        Calculate the planar (non-normal) distance between the surface point and a point. This is complementary to the
+        scalar projection. A point is projected onto the plane defined by the position and normal of the surface point,
+        and the distance between the surface point position and the projected point is returned.  The value will always
+        be positive.
+
+        :param point: the point to calculate the distance to.
+        :return: the planar distance between the surface point and the point.
+        """
+        ...
+
+    def get_plane(self) -> Plane3:
+        """
+        Get the plane defined by the surface point.
+        :return: the plane defined by the surface point.
+        """
+        ...
+
+
 class Iso3:
     """ An isometry (rigid body transformation) in 3D space. """
 
@@ -183,7 +308,11 @@ class SvdBasis3:
     fitting basis for the points using a singular value decomposition.
     """
 
-    def __init__(self, points: numpy.ndarray[float], weights: numpy.ndarray[float] | None):
+    def __init__(
+            self,
+            points: numpy.ndarray[float],
+            weights: numpy.ndarray[float] | None = None
+    ):
         """
         Create a basis from a set of points. The basis will be calculated using a singular value decomposition of the
         points.
@@ -305,6 +434,8 @@ class Mesh:
             self,
             vertices: numpy.ndarray[float],
             triangles: numpy.ndarray[numpy.uint32],
+            merge_duplicates: bool | None = None,
+            delete_degenerate: bool | None = None
     ):
         """
         Create an engeom mesh from vertices and triangles.  The vertices should be a numpy array of shape (n, 3), while
@@ -314,16 +445,21 @@ class Mesh:
 
         :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 merge_duplicates: merge duplicate vertices and triangles. If None, the default behavior is to do nothing
+        :param delete_degenerate: delete degenerate triangles. If None, the default behavior is to do nothing
         """
         ...
 
     @staticmethod
-    def load_stl(path: str | Path) -> Mesh:
+    def load_stl(path: str | Path, merge_duplicates: bool | None = None, delete_degenerate: bool | None = None) -> Mesh:
         """
         Load a mesh from an STL file. This will return a new mesh object containing the vertices and triangles from the
-        file.
+        file.  Optional parameters can be used to control the behavior of the loader when handling duplicate vertices/
+        triangles and degenerate triangles.
 
         :param path: the path to the STL file to load.
+        :param merge_duplicates: merge duplicate vertices and triangles. If None, the default behavior is to do nothing
+        :param delete_degenerate: delete degenerate triangles. If None, the default behavior is to do nothing
         :return: the mesh object containing the data from the file.
         """
         ...
@@ -423,3 +559,167 @@ class Mesh:
         :return: a numpy array of shape (n, 6) 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.
+
+        :param plane:
+        :param tol:
+        :return:
+        """
+        ...
+
+
+class CurveStation3:
+    """
+    A class representing a station along a curve in 3D space. The station is represented by a point on the curve, a
+    tangent (direction) vector, and a length along the curve.
+    """
+
+    @property
+    def point(self) -> Point3:
+        """ The 3d position in space on the curve. """
+        ...
+
+    @property
+    def direction(self) -> Vector3:
+        """ The tangent (direction) vector of the curve at the station. """
+        ...
+
+    @property
+    def direction_point(self) -> SurfacePoint3:
+        """
+        A `SurfacePoint3` object representing the point on the curve and the curve's tangent/direction vector.
+        """
+        ...
+
+    @property
+    def index(self) -> int:
+        """ The index of the previous vertex on the curve, at or before the station. """
+        ...
+
+    @property
+    def length_along(self) -> float:
+        """ The length along the curve from the start of the curve to the station. """
+        ...
+
+
+class Curve3:
+    """
+    A class representing a polyline in 3D space. The curve is represented by a set of vertices and the segments
+    between them.
+    """
+
+    def __init__(self, vertices: numpy.ndarray):
+        """
+        Create a curve from a set of vertices. The vertices should be a numpy array of shape (n, 3).
+
+        :param vertices: a numpy array of shape (n, 3) containing the vertices of the curve.
+        """
+        ...
+
+    def clone(self) -> Curve3:
+        """
+        Will return a copy of the curve. This is a copy of the data, so modifying the returned curve will not modify
+        the original curve.
+
+        :return: a copy of the curve.
+        """
+        ...
+
+    def length(self) -> float:
+        """
+        Return the total length of the curve in the units of the vertices.
+
+        :return: the length of the curve.
+        """
+        ...
+
+    def clone_vertices(self) -> numpy.ndarray[float]:
+        """
+        Will return a copy of the vertices of the curve as a numpy array. If the curve 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 curve.
+
+        :return: a numpy array of shape (n, 3) containing the vertices of the curve.
+        """
+        ...
+
+    def at_length(self, length: float) -> CurveStation3:
+        """
+        Return a station along the curve at the given length. The length is measured from the start of the curve to the
+        station. If the length is greater than the length of the curve or less than 0, an error will be raised.
+
+        :param length: the length along the curve to return the station at.
+        :return: a `CurveStation3` object representing the station along the curve.
+        """
+        ...
+
+    def at_fraction(self, fraction: float) -> CurveStation3:
+        """
+        Return a station along the curve at the given fraction of the length of the curve. If the fraction is greater
+        than 1 or less than 0, an error will be raised.
+
+        :param fraction: the fraction of the length of the curve to return the station at.
+        :return: a `CurveStation3` object representing the station along the curve.
+        """
+        ...
+
+    def at_closest_to_point(self, point: Point3) -> CurveStation3:
+        """
+        Return a station along the curve at the closest point to the given point. The station will be the point on the
+        curve that is closest to the given point.
+
+        :param point: the point to find the closest station to.
+        :return: a `CurveStation3` object representing the station along the curve.
+        """
+        ...
+
+    def at_front(self) -> CurveStation3:
+        """
+        Return a station at the front of the curve. This is equivalent to calling `at_length(0)`.
+
+        :return: a `CurveStation3` object representing the station at the front of the curve.
+        """
+        ...
+
+    def at_back(self) -> CurveStation3:
+        """
+        Return a station at the back of the curve. This is equivalent to calling `at_length(length)`.
+
+        :return: a `CurveStation3` object representing the station at the back of the curve.
+        """
+        ...
+
+    def resample(self, resample: Resample) -> Curve3:
+        """
+        Resample the curve using the given resampling method. The resampling method can be one of the following:
+
+        - `Resample.ByCount(count: int)`: resample the curve to have the given number of points.
+        - `Resample.BySpacing(distance: float)`: resample the curve to have points spaced by the given distance.
+        - `Resample.ByMaxSpacing(distance: float)`: resample the curve to have points spaced by a maximum distance.
+
+        :param resample: the resampling method to use.
+        :return: a new curve object with the resampled vertices.
+        """
+        ...
+
+    def simplify(self, tolerance: float) -> Curve3:
+        """
+        Simplify the curve using the Ramer-Douglas-Peucker algorithm. This will remove vertices from the curve that are
+        within the given tolerance of the line between the previous and next vertices.
+
+        :param tolerance: the tolerance to use when simplifying the curve.
+        :return: a new curve object with the simplified vertices.
+        """
+        ...
+
+    def transformed_by(self, iso: Iso3) -> Curve3:
+        """
+        Transform the curve by an isometry. This will return a new curve object with the transformed vertices.
+
+        :param iso: the isometry to transform the curve by.
+        :return: a new curve object with the transformed vertices.
+        """
+        ...

engeom/matplotlib.py

@@ -1,10 +1,50 @@
+from typing import List
+
+import matplotlib.lines
 import numpy
+from .geom2 import Curve2
 
 try:
     from matplotlib.pyplot import Axes, Circle
+    from matplotlib.colors import ListedColormap
 except ImportError:
     pass
 else:
+    class GomColorMap(ListedColormap):
+        def __init__(self):
+            colors = numpy.array([
+                [1, 0, 160],
+                [1, 0, 255],
+                [0, 254, 255],
+                [0, 160, 0],
+                [0, 254, 0],
+                [255, 255, 0],
+                [255, 128, 0],
+                [255, 1, 0]
+            ], dtype=numpy.float64)
+            colors /= 256.0
+            colors = numpy.hstack((colors, numpy.ones((len(colors), 1))))
+            super().__init__(colors)
+            self.set_under("magenta")
+            self.set_over("darkred")
+
+    GOM_CMAP = GomColorMap()
+
+    def add_curve_plots(ax: Axes, *curves: Curve2, **kwargs) -> List[List[matplotlib.lines.Line2D]]:
+        """
+        Plot a list of curves on a Matplotlib Axes object.
+        :param ax: a Matplotlib Axes object
+        :param curves: a list of Curve2 objects
+        :param kwargs: keyword arguments to pass to the plot function
+        :return: None
+        """
+        actors = []
+        for curve in curves:
+            points = curve.clone_points()
+            a = ax.plot(points[:, 0], points[:, 1], **kwargs)
+            actors.append(a)
+        return actors
+
 
     def set_aspect_fill(ax: Axes):
         """
@@ -38,7 +78,3 @@ 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

@@ -1,8 +1,14 @@
 """
     This module contains helper functions for working with PyVista.
 """
+from __future__ import annotations
+
+from typing import List
+
 import numpy
-from .geom3 import Mesh
+from pyvista import ColorLike
+
+from .geom3 import Mesh, Curve3
 
 try:
     import pyvista
@@ -23,4 +29,35 @@ else:
         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)
+        return pyvista.PolyData(vertices, faces)
+
+
+    def add_curves_to_plotter(
+            plotter: pyvista.Plotter,
+            curves: List[Curve3],
+            color: ColorLike = 'w',
+            width: float = 5.0,
+            label: str | None = None,
+            name: str | None = None,
+    ) -> List[pyvista.vtkActor]:
+        """
+        Adds curves to a PyVista plotter.
+        :param plotter:
+        :param curves:
+        :param color:
+        :param width:
+        :param label:
+        :param name:
+        :return:
+        """
+
+        if pyvista is None:
+            raise ImportError("PyVista is not installed.")
+
+        result_list = []
+        for curve in curves:
+            v = curve.clone_vertices()
+            added = plotter.add_lines(v, connected=True, color=color, width=width, label=label, name=name)
+            result_list.append(added)
+
+        return result_list

{engeom-0.1.1.dist-info → engeom-0.1.2.dist-info}/METADATA

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

engeom-0.1.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+engeom-0.1.2.dist-info/METADATA,sha256=ym_mnfPDlcTOzcYgeEZGMCFsgidl30syGoPDLY_B2eA,339
+engeom-0.1.2.dist-info/WHEEL,sha256=ajTxDRk-ooZz0dnA2NZaw_ASzODvtK_6X8l0woIlBl4,104
+engeom/geom2.pyi,sha256=De3YQSGpS4UQ1zawtIsuVR4-7rcFjqmNvL9lbtzN_d4,17117
+engeom/geom3.pyi,sha256=fEFhdFmEJsDP3X0aE_N0heqMyyPnbYjpeB0hTR2xjOI,27295
+engeom/geom3/__init__.py,sha256=DG5jt2xgS9WRNb58ZkkrcKQQO6bIG-irg-uV_BkHEj4,174
+engeom/pyvista.py,sha256=Lyvm0K_rvhR2wZACtfwCPYwEuABqYSTdjvbBaQS9yI4,1721
+engeom/geom2/__init__.py,sha256=mRu8Zh6DE-EQyhxScoxszPqDjGVzGWVJEQO6RIAtS4A,174
+engeom/matplotlib.py,sha256=Y9JZqpEFHm5EVzbr20P-NdxndNZdDH32OhE_KjxG_S4,3025
+engeom/__init__.py,sha256=QN5uETqrN442w41foyrcCPV_x6NP-mrxkPJhdvdey1g,109
+engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
+engeom/engeom.pyi,sha256=pLlD_YazsO0zu3guQZx85btESz0gAwVv79xD0pjd7Nc,196
+engeom/align.pyi,sha256=KBC0nwcyp4YMfY2hRN1gr3DqFah-unqAd_o1KYwJAqc,1022
+engeom/engeom.abi3.so,sha256=pXKp5LBjoNK1-rFdzXxIj3Dyyfc1gWM2zjaLAHvBp28,1735644
+engeom-0.1.2.dist-info/RECORD,,

engeom-0.1.1.dist-info/RECORD

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