open-space-toolkit-mathematics 4.5.2__py313-none-manylinux2014_aarch64.whl → 4.5.4__py313-none-manylinux2014_aarch64.whl

ostk/mathematics/geometry/d2/__init__.pyi

@@ -66,25 +66,102 @@ class Intersection:
     __hash__: typing.ClassVar[None] = None
     @staticmethod
     def empty() -> Intersection:
-        ...
+        """
+                        Create an empty intersection.
+        
+                        Returns:
+                            Intersection: An empty intersection containing no geometry.
+        
+                        Example:
+                            >>> empty_intersection = Intersection.empty()
+                            >>> empty_intersection.is_empty()  # True
+        """
     @staticmethod
     def line(line: object.Line) -> Intersection:
-        ...
+        """
+                        Create an intersection containing a line.
+        
+                        Args:
+                            line (Line): The line to include in the intersection.
+        
+                        Returns:
+                            Intersection: An intersection containing the line.
+        
+                        Example:
+                            >>> line = Line(Point(0.0, 0.0), np.array([1.0, 1.0]))
+                            >>> intersection = Intersection.line(line)
+        """
     @staticmethod
     def point(point: object.Point) -> Intersection:
-        ...
+        """
+                        Create an intersection containing a single point.
+        
+                        Args:
+                            point (Point): The point to include in the intersection.
+        
+                        Returns:
+                            Intersection: An intersection containing the point.
+        
+                        Example:
+                            >>> point = Point(1.0, 2.0)
+                            >>> intersection = Intersection.point(point)
+        """
     @staticmethod
     def point_set(point_set: object.PointSet) -> Intersection:
-        ...
+        """
+                        Create an intersection containing a point set.
+        
+                        Args:
+                            point_set (PointSet): The point set to include in the intersection.
+        
+                        Returns:
+                            Intersection: An intersection containing the point set.
+        
+                        Example:
+                            >>> points = PointSet([Point(1.0, 2.0), Point(3.0, 4.0)])
+                            >>> intersection = Intersection.point_set(points)
+        """
     @staticmethod
     def segment(segment: object.Segment) -> Intersection:
-        ...
+        """
+                        Create an intersection containing a segment.
+        
+                        Args:
+                            segment (Segment): The segment to include in the intersection.
+        
+                        Returns:
+                            Intersection: An intersection containing the segment.
+        
+                        Example:
+                            >>> segment = Segment(Point(0.0, 0.0), Point(1.0, 1.0))
+                            >>> intersection = Intersection.segment(segment)
+        """
     @staticmethod
-    def string_from_type(arg0: typing.Any) -> ostk.core.type.String:
-        ...
+    def string_from_type(type: typing.Any) -> ostk.core.type.String:
+        """
+                        Get the string representation of an intersection type.
+        
+                        Args:
+                            type (Intersection.Type): The intersection type.
+        
+                        Returns:
+                            str: String representation of the type.
+        
+                        Example:
+                            >>> Intersection.string_from_type(Intersection.Type.Point)  # "Point"
+        """
     @staticmethod
     def undefined() -> Intersection:
-        ...
+        """
+                        Create an undefined intersection.
+        
+                        Returns:
+                            Intersection: An undefined intersection.
+        
+                        Example:
+                            >>> undefined_intersection = Intersection.undefined()
+                            >>> undefined_intersection.is_defined()  # False
+        """
     def __add__(self, arg0: Intersection) -> Intersection:
         ...
     def __eq__(self, arg0: Intersection) -> bool:
@@ -98,43 +175,251 @@ class Intersection:
     def __str__(self) -> str:
         ...
     def access_composite(self) -> object.Composite:
-        ...
+        """
+                        Access the composite representation of the intersection.
+        
+                        Returns:
+                            Composite: Reference to the composite containing all intersection objects.
+        
+                        Example:
+                            >>> intersection = Intersection.point(Point(1.0, 2.0))
+                            >>> composite = intersection.access_composite()
+        """
     def as_composite(self) -> object.Composite:
-        ...
+        """
+                        Convert the intersection to a Composite.
+        
+                        Returns:
+                            Composite: The composite contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a Composite.
+        
+                        Example:
+                            >>> composite = Composite(Point(1.0, 2.0))
+                            >>> # intersection = Intersection.composite(composite)
+                            >>> # extracted_composite = intersection.as_composite()
+        """
     def as_line(self) -> object.Line:
-        ...
+        """
+                        Convert the intersection to a Line.
+        
+                        Returns:
+                            Line: The line contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a Line.
+        
+                        Example:
+                            >>> line = Line(Point(0.0, 0.0), np.array([1.0, 1.0]))
+                            >>> intersection = Intersection.line(line)
+                            >>> extracted_line = intersection.as_line()
+        """
     def as_line_string(self) -> object.LineString:
-        ...
+        """
+                        Convert the intersection to a LineString.
+        
+                        Returns:
+                            LineString: The line string contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a LineString.
+        
+                        Example:
+                            >>> points = [Point(0.0, 0.0), Point(1.0, 1.0), Point(2.0, 2.0)]
+                            >>> line_string = LineString(points)
+                            >>> # intersection = Intersection.line_string(line_string)
+                            >>> # extracted_line_string = intersection.as_line_string()
+        """
     def as_point(self) -> object.Point:
-        ...
+        """
+                        Convert the intersection to a Point.
+        
+                        Returns:
+                            Point: The point contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a Point.
+        
+                        Example:
+                            >>> intersection = Intersection.point(Point(1.0, 2.0))
+                            >>> point = intersection.as_point()
+        """
     def as_point_set(self) -> object.PointSet:
-        ...
+        """
+                        Convert the intersection to a PointSet.
+        
+                        Returns:
+                            PointSet: The point set contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a PointSet.
+        
+                        Example:
+                            >>> points = PointSet([Point(1.0, 2.0), Point(3.0, 4.0)])
+                            >>> intersection = Intersection.point_set(points)
+                            >>> point_set = intersection.as_point_set()
+        """
     def as_polygon(self) -> object.Polygon:
-        ...
+        """
+                        Convert the intersection to a Polygon.
+        
+                        Returns:
+                            Polygon: The polygon contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a Polygon.
+        
+                        Example:
+                            >>> vertices = [Point(0.0, 0.0), Point(1.0, 0.0), Point(1.0, 1.0)]
+                            >>> polygon = Polygon(vertices)
+                            >>> # intersection = Intersection.polygon(polygon)
+                            >>> # extracted_polygon = intersection.as_polygon()
+        """
     def as_segment(self) -> object.Segment:
-        ...
+        """
+                        Convert the intersection to a Segment.
+        
+                        Returns:
+                            Segment: The segment contained in the intersection.
+        
+                        Raises:
+                            RuntimeError: If the intersection does not contain a Segment.
+        
+                        Example:
+                            >>> segment = Segment(Point(0.0, 0.0), Point(1.0, 1.0))
+                            >>> intersection = Intersection.segment(segment)
+                            >>> extracted_segment = intersection.as_segment()
+        """
     def get_type(self) -> ...:
-        ...
+        """
+                        Get the type of the intersection.
+        
+                        Returns:
+                            Intersection.Type: The type of geometry contained in the intersection.
+        
+                        Example:
+                            >>> intersection = Intersection.point(Point(1.0, 2.0))
+                            >>> intersection.get_type()  # Intersection.Type.Point
+        """
     def is_complex(self) -> bool:
-        ...
+        """
+                        Check if the intersection is complex (contains multiple different types).
+        
+                        Returns:
+                            bool: True if the intersection is complex, False otherwise.
+        
+                        Example:
+                            >>> # Complex intersections contain multiple geometric types
+                            >>> intersection.is_complex()
+        """
     def is_composite(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a Composite.
+        
+                        Returns:
+                            bool: True if the intersection contains a Composite, False otherwise.
+        
+                        Example:
+                            >>> composite = Composite(Point(1.0, 2.0))
+                            >>> # intersection = Intersection.composite(composite)
+                            >>> # intersection.is_composite()  # True
+        """
     def is_defined(self) -> bool:
-        ...
+        """
+                        Check if the intersection is defined.
+        
+                        Returns:
+                            bool: True if the intersection is defined, False otherwise.
+        
+                        Example:
+                            >>> intersection = Intersection.point(Point(1.0, 2.0))
+                            >>> intersection.is_defined()  # True
+        """
     def is_empty(self) -> bool:
-        ...
+        """
+                        Check if the intersection is empty (no geometric objects).
+        
+                        Returns:
+                            bool: True if the intersection is empty, False otherwise.
+        
+                        Example:
+                            >>> empty_intersection = Intersection.empty()
+                            >>> empty_intersection.is_empty()  # True
+        """
     def is_line(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a Line.
+        
+                        Returns:
+                            bool: True if the intersection contains a Line, False otherwise.
+        
+                        Example:
+                            >>> line = Line(Point(0.0, 0.0), np.array([1.0, 1.0]))
+                            >>> intersection = Intersection.line(line)
+                            >>> intersection.is_line()  # True
+        """
     def is_line_string(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a LineString.
+        
+                        Returns:
+                            bool: True if the intersection contains a LineString, False otherwise.
+        
+                        Example:
+                            >>> points = [Point(0.0, 0.0), Point(1.0, 1.0), Point(2.0, 2.0)]
+                            >>> line_string = LineString(points)
+                            >>> # intersection = Intersection.line_string(line_string)
+                            >>> # intersection.is_line_string()  # True
+        """
     def is_point(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a Point.
+        
+                        Returns:
+                            bool: True if the intersection contains a Point, False otherwise.
+        
+                        Example:
+                            >>> intersection = Intersection.point(Point(1.0, 2.0))
+                            >>> intersection.is_point()  # True
+        """
     def is_point_set(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a PointSet.
+        
+                        Returns:
+                            bool: True if the intersection contains a PointSet, False otherwise.
+        
+                        Example:
+                            >>> points = PointSet([Point(1.0, 2.0), Point(3.0, 4.0)])
+                            >>> intersection = Intersection.point_set(points)
+                            >>> intersection.is_point_set()  # True
+        """
     def is_polygon(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a Polygon.
+        
+                        Returns:
+                            bool: True if the intersection contains a Polygon, False otherwise.
+        
+                        Example:
+                            >>> vertices = [Point(0.0, 0.0), Point(1.0, 0.0), Point(1.0, 1.0)]
+                            >>> polygon = Polygon(vertices)
+                            >>> # intersection = Intersection.polygon(polygon)
+                            >>> # intersection.is_polygon()  # True
+        """
     def is_segment(self) -> bool:
-        ...
+        """
+                        Check if the intersection contains a Segment.
+        
+                        Returns:
+                            bool: True if the intersection contains a Segment, False otherwise.
+        
+                        Example:
+                            >>> segment = Segment(Point(0.0, 0.0), Point(1.0, 1.0))
+                            >>> intersection = Intersection.segment(segment)
+                            >>> intersection.is_segment()  # True
+        """
 class Object:
     class Format:
         """
@@ -178,21 +463,92 @@ class Object:
             ...
     __hash__: typing.ClassVar[None] = None
     def __eq__(self, arg0: Object) -> bool:
-        ...
+        """
+                        Check if two 2D objects are equal.
+        
+                        Args:
+                            other (Object): The object to compare with.
+        
+                        Returns:
+                            bool: True if objects are equal, False otherwise.
+        
+                        Example:
+                            >>> point1 = Point(1.0, 2.0)
+                            >>> point2 = Point(1.0, 2.0)
+                            >>> point1 == point2  # True
+        """
     def __ne__(self, arg0: Object) -> bool:
-        ...
+        """
+                        Check if two 2D objects are not equal.
+        
+                        Args:
+                            other (Object): The object to compare with.
+        
+                        Returns:
+                            bool: True if objects are not equal, False otherwise.
+        
+                        Example:
+                            >>> point1 = Point(1.0, 2.0)
+                            >>> point2 = Point(3.0, 4.0)
+                            >>> point1 != point2  # True
+        """
     def __repr__(self) -> str:
         ...
     def __str__(self) -> str:
         ...
     def apply_transformation(self, transformation: typing.Any) -> None:
-        ...
+        """
+                        Apply a transformation to the 2D object in place.
+        
+                        Args:
+                            transformation (Transformation): The 2D transformation to apply.
+        
+                        Example:
+                            >>> point = Point(1.0, 2.0)
+                            >>> transformation = Translation([1.0, 1.0])
+                            >>> point.apply_transformation(transformation)
+        """
     def contains(self, object: Object) -> bool:
-        ...
+        """
+                        Check if this 2D object contains another object.
+        
+                        Args:
+                            object (Object): The object to check containment for.
+        
+                        Returns:
+                            bool: True if this object contains the other, False otherwise.
+        
+                        Example:
+                            >>> polygon = Polygon([Point(0.0, 0.0), Point(2.0, 0.0), Point(2.0, 2.0)])
+                            >>> point = Point(1.0, 1.0)
+                            >>> polygon.contains(point)  # True
+        """
     def intersects(self, object: Object) -> bool:
-        ...
+        """
+                        Check if this 2D object intersects with another object.
+        
+                        Args:
+                            object (Object): The object to check intersection with.
+        
+                        Returns:
+                            bool: True if objects intersect, False otherwise.
+        
+                        Example:
+                            >>> line1 = Line(Point(0.0, 0.0), np.array([1.0, 0.0]))
+                            >>> line2 = Line(Point(0.0, -1.0), np.array([0.0, 1.0]))
+                            >>> line1.intersects(line2)  # True
+        """
     def is_defined(self) -> bool:
-        ...
+        """
+                        Check if the 2D object is defined.
+        
+                        Returns:
+                            bool: True if the object is defined, False otherwise.
+        
+                        Example:
+                            >>> point = Point(1.0, 2.0)
+                            >>> point.is_defined()  # True
+        """
 class Transformation:
     class Type:
         """
@@ -252,29 +608,123 @@ class Transformation:
     __hash__: typing.ClassVar[None] = None
     @staticmethod
     def identity() -> Transformation:
-        ...
+        """
+                        Create an identity transformation (no change).
+        
+                        Returns:
+                            Transformation: The identity transformation.
+        
+                        Example:
+                            >>> identity = Transformation.identity()
+                            >>> point = Point(1.0, 2.0)
+                            >>> identity.apply_to(point)  # Point(1.0, 2.0) - unchanged
+        """
     @staticmethod
     def rotation(rotation_angle: typing.Any) -> Transformation:
-        ...
+        """
+                        Create a rotation transformation around the origin.
+        
+                        Args:
+                            rotation_angle (Angle): The rotation angle.
+        
+                        Returns:
+                            Transformation: The rotation transformation.
+        
+                        Example:
+                            >>> rotation = Transformation.rotation(Angle.degrees(90.0))
+                            >>> point = Point(1.0, 0.0)
+                            >>> rotation.apply_to(point)  # Point(0.0, 1.0)
+        """
     @staticmethod
     def rotation_around(point: object.Point, rotation_angle: typing.Any) -> Transformation:
-        ...
+        """
+                        Create a rotation transformation around a specific point.
+        
+                        Args:
+                            point (Point): The center point of rotation.
+                            rotation_angle (Angle): The rotation angle.
+        
+                        Returns:
+                            Transformation: The rotation transformation around the specified point.
+        
+                        Example:
+                            >>> center = Point(1.0, 1.0)
+                            >>> rotation = Transformation.rotation_around(center, Angle.degrees(90.0))
+                            >>> point = Point(2.0, 1.0)
+                            >>> rotation.apply_to(point)  # Point(1.0, 2.0)
+        """
     @staticmethod
     def string_from_type(type: typing.Any) -> ostk.core.type.String:
-        ...
+        """
+                        Get the string representation of a transformation type.
+        
+                        Args:
+                            type (Transformation.Type): The transformation type.
+        
+                        Returns:
+                            str: String representation of the type.
+        
+                        Example:
+                            >>> Transformation.string_from_type(Transformation.Type.Translation)  # "Translation"
+        """
     @staticmethod
-    def translation(transaction_vector: numpy.ndarray[numpy.float64[2, 1]]) -> Transformation:
-        ...
+    def translation(translation_vector: numpy.ndarray[numpy.float64[2, 1]]) -> Transformation:
+        """
+                        Create a translation transformation.
+        
+                        Args:
+                            translation_vector (Vector2d): The translation vector.
+        
+                        Returns:
+                            Transformation: The translation transformation.
+        
+                        Example:
+                            >>> translation = Transformation.translation([1.0, 2.0])
+                            >>> point = Point(0.0, 0.0)
+                            >>> translation.apply_to(point)  # Point(1.0, 2.0)
+        """
     @staticmethod
     def type_of_matrix(matrix: numpy.ndarray[numpy.float64[3, 3]]) -> ...:
-        ...
+        """
+                        Determine the transformation type from a matrix.
+        
+                        Args:
+                            matrix (Matrix3d): The transformation matrix to analyze.
+        
+                        Returns:
+                            Transformation.Type: The detected transformation type.
+        
+                        Example:
+                            >>> import numpy as np
+                            >>> matrix = np.eye(3)
+                            >>> Transformation.type_of_matrix(matrix)  # Transformation.Type.Identity
+        """
     @staticmethod
     def undefined() -> Transformation:
-        ...
+        """
+                        Create an undefined transformation.
+        
+                        Returns:
+                            Transformation: An undefined transformation.
+        
+                        Example:
+                            >>> undefined_transform = Transformation.undefined()
+                            >>> undefined_transform.is_defined()  # False
+        """
     def __eq__(self, arg0: Transformation) -> bool:
         ...
     def __init__(self, matrix: numpy.ndarray[numpy.float64[3, 3]]) -> None:
-        ...
+        """
+                        Create a 2D transformation from a 3x3 transformation matrix.
+        
+                        Args:
+                            matrix (Matrix3d): The 3x3 transformation matrix in homogeneous coordinates.
+        
+                        Example:
+                            >>> import numpy as np
+                            >>> matrix = np.eye(3)  # Identity matrix
+                            >>> transformation = Transformation(matrix)
+        """
     def __ne__(self, arg0: Transformation) -> bool:
         ...
     def __repr__(self) -> str:
@@ -283,15 +733,77 @@ class Transformation:
         ...
     @typing.overload
     def apply_to(self, point: object.Point) -> object.Point:
-        ...
+        """
+                        Apply the transformation to a point.
+        
+                        Args:
+                            point (Point): The point to transform.
+        
+                        Returns:
+                            Point: The transformed point.
+        
+                        Example:
+                            >>> point = Point(1.0, 2.0)
+                            >>> translation = Transformation.translation([1.0, 1.0])
+                            >>> transformed = translation.apply_to(point)  # Point(2.0, 3.0)
+        """
     @typing.overload
     def apply_to(self, vector: numpy.ndarray[numpy.float64[2, 1]]) -> numpy.ndarray[numpy.float64[2, 1]]:
-        ...
+        """
+                        Apply the transformation to a vector.
+        
+                        Args:
+                            vector (Vector2d): The vector to transform.
+        
+                        Returns:
+                            Vector2d: The transformed vector.
+        
+                        Example:
+                            >>> vector = np.array([1.0, 0.0])
+                            >>> rotation = Transformation.rotation(Angle.degrees(90.0))
+                            >>> transformed = rotation.apply_to(vector)  # [0.0, 1.0]
+        """
     def get_inverse(self) -> Transformation:
-        ...
+        """
+                        Get the inverse transformation.
+        
+                        Returns:
+                            Transformation: The inverse transformation.
+        
+                        Example:
+                            >>> translation = Transformation.translation([1.0, 2.0])
+                            >>> inverse = translation.get_inverse()  # Translation by [-1.0, -2.0]
+        """
     def get_matrix(self) -> numpy.ndarray[numpy.float64[3, 3]]:
-        ...
+        """
+                        Get the transformation matrix.
+        
+                        Returns:
+                            Matrix3d: The 3x3 transformation matrix in homogeneous coordinates.
+        
+                        Example:
+                            >>> transformation = Transformation.identity()
+                            >>> matrix = transformation.get_matrix()  # 3x3 identity matrix
+        """
     def get_type(self) -> ...:
-        ...
+        """
+                        Get the type of the transformation.
+        
+                        Returns:
+                            Transformation.Type: The transformation type (Identity, Translation, Rotation, etc.).
+        
+                        Example:
+                            >>> transformation = Transformation.identity()
+                            >>> transformation.get_type()  # Transformation.Type.Identity
+        """
     def is_defined(self) -> bool:
-        ...
+        """
+                        Check if the transformation is defined.
+        
+                        Returns:
+                            bool: True if the transformation is defined, False otherwise.
+        
+                        Example:
+                            >>> transformation = Transformation.identity()
+                            >>> transformation.is_defined()  # True
+        """