open-space-toolkit-mathematics 4.6.0__py39-none-manylinux2014_aarch64.whl

ostk/mathematics/test/geometry/d3/object/test_point.py

@@ -0,0 +1,234 @@
+# Apache License 2.0
+
+import pytest
+
+import math
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+Object = mathematics.geometry.d3.Object
+Point = mathematics.geometry.d3.object.Point
+Transformation = mathematics.geometry.d3.Transformation
+
+
+def test_geometry_d3_object_point_constructor():
+    point: Point = Point(1.0, 2.0, 3.0)
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined()
+
+
+def test_geometry_d3_object_point_undefined():
+    point: Point = Point.undefined()
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined() is False
+
+
+def test_geometry_d3_object_point_origin():
+    point: Point = Point.origin()
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined()
+    assert point.x() == 0.0
+    assert point.y() == 0.0
+    assert point.z() == 0.0
+
+
+def test_geometry_d3_object_point_vector():
+    # Construction using a python list
+    point: Point = Point.vector([3.4, -6.7, 1.0])
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined()
+    assert (point.x() - 3.4) <= 1e-15
+    assert (point.y() + 6.7) <= 1e-15
+    assert (point.z() - 1.0) <= 1e-15
+
+    # Construction using a python tuple
+    point: Point = Point.vector((3.4, -6.7, 1.0))
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined()
+    assert (point.x() - 3.4) <= 1e-15
+    assert (point.y() + 6.7) <= 1e-15
+    assert (point.z() - 1.0) <= 1e-15
+
+    # Construction using a python numpy array
+    point: Point = Point.vector(np.array((3.4, -6.7, 1.0)))
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert isinstance(point, Object)
+    assert point.is_defined()
+    assert (point.x() - 3.4) <= 1e-15
+    assert (point.y() + 6.7) <= 1e-15
+    assert (point.z() - 1.0) <= 1e-15
+
+
+def test_geometry_d3_object_point_comparators():
+    point_1: Point = Point(3.4, -6.7, 1.0)
+    point_2: Point = Point.vector([3.4, -6.7, 1.0])
+    point_3: Point = Point(3.3, -6.5, 1.0)
+    point_4: Point = Point.vector(
+        (
+            3.4,
+            -6.7,
+            1.0,
+        )
+    )
+    point_5: Point = Point.vector(np.array((3.4, -6.7, 1.0)))
+
+    assert point_1 == point_1
+    assert point_1 == point_2
+    assert point_1 != point_3
+    assert point_2 != point_3
+    assert point_1 == point_4
+    assert point_1 == point_5
+    assert point_2 == point_4
+    assert point_2 == point_5
+    assert point_3 != point_4
+
+
+def test_geometry_d3_object_point_operators():
+    point_1: Point = Point(3.4, -6.7, 1.0)
+    point_2: Point = Point.vector([3.4, -6.7, 1.0])
+    point_3: Point = Point.vector((3.4, -6.7, 1.0))
+    point_4: Point = Point.vector(np.array((3.3, -6.5, 1.0)))
+
+    point: Point = point_1 + [3.4, -6.7, 1.0]
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point.x() == point_1.x() + point_2.x()
+    assert point.y() == point_1.y() + point_2.y()
+    assert point.z() == point_1.z() + point_2.z()
+
+    point: Point = point_3 + [3.4, -6.7, 1.0]
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point.x() == point_3.x() + point_2.x()
+    assert point.y() == point_3.y() + point_2.y()
+    assert point.z() == point_3.z() + point_2.z()
+
+    point: Point = point_1 + (3.3, -6.5, 1.0)
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point.x() == point_1.x() + point_4.x()
+    assert point.y() == point_1.y() + point_4.y()
+    assert point.z() == point_1.z() + point_4.z()
+
+    point: Point = point_1 + (0.0, 0.0, 0.0)
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point == point_1
+
+    point: Point = point_1 + [0.0, 0.0, 0.0]
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point == point_1
+
+    point: Point = point_1 + np.array((0.0, 0.0, 0.0))
+
+    assert point is not None
+    assert isinstance(point, Point)
+    assert point.is_defined()
+    assert point == point_1
+
+    # point: Point = point_1 - point_1
+
+    # assert point is not None
+    # assert isinstance(point, Point)
+    # assert isinstance(point, Object)
+    # assert point.is_defined()
+    # assert point.x == 0.0
+    # assert point.y == 0.0
+    # assert point == Point.origin()
+
+
+def test_geometry_d3_object_point_is_defined():
+    point: Point = Point(3.5, 5.6, 4.3)
+
+    assert point.is_defined()
+    assert Point.undefined().is_defined() is False
+
+
+def test_geometry_d3_object_point_is_near():
+    point_1: Point = Point(3.5, 5.6, 4.3)
+    point_2: Point = Point(3.4999999999, 5.5999999999, 4.30000000000001)
+
+    assert point_1.is_near(point_2, 1e-8)
+    assert point_2.is_near(point_1, 1e-8)
+    assert point_1.is_near(point_2, 1e-11) is False
+    assert point_1.is_near(point_2, 1e-9) is True
+
+
+def test_geometry_d3_object_point_components():
+    point: Point = Point(4.5, 34.5, 3.9)
+
+    assert point.x() == 4.5
+    assert point.y() == 34.5
+    assert point.z() == 3.9
+
+
+def test_geometry_d3_object_point_as_vector():
+    point: Point = Point(3.4, -3.5, 1.0)
+    vec: np.ndarray = point.as_vector()
+
+    assert vec is not None
+    assert isinstance(vec, np.ndarray)
+    assert (vec[0] - 3.4) <= 1e-12
+    assert (vec[1] + 3.5) <= 1e-12
+    assert (vec[2] - 1.0) <= 1e-12
+
+
+def test_geometry_d3_object_point_distance_to():
+    point_1: Point = Point(0.0, 4.0, 0.0)
+    point_2: Point = Point(0.0, 3.0, 0.0)
+    point_3: Point = Point(3.0, 0.0, 0.0)
+    point_4: Point = Point(1.1, 1.0, 0.0)
+
+    assert point_1.distance_to(point_2) - 1.0 <= 1e-12
+    assert point_2.distance_to(point_1) - 1.0 <= 1e-12
+
+    assert point_1.distance_to(point_3) - 5.0 <= 1e-12
+    assert point_3.distance_to(point_1) - 5.0 <= 1e-12
+
+    assert point_1.distance_to(point_4) == math.sqrt((1.1 * 1.1) + 9.0)
+    assert point_4.distance_to(point_1) == math.sqrt((1.1 * 1.1) + 9.0)
+
+    with pytest.raises(TypeError):
+        point_1.distance_to((0.0, 0.0, 0.0))
+
+
+# def test_geometry_d3_object_point_to_string ():
+
+#     point: Point = Point(3.0, 5.0, 1.0)
+
+#     assert isinstance(point.to_string(), String)
+#     assert point.to_string() == '[3.0, 5.0, 1.0]'
+
+# def test_geometry_d3_object_point_apply_transformation ():
+
+#     point: Point = Point(4.5, 5.4, 3.1)

ostk/mathematics/test/geometry/d3/object/test_point_set.py

@@ -0,0 +1,113 @@
+# Apache License 2.0
+
+from collections.abc import Iterator, Iterable
+
+import pytest
+
+from ostk.mathematics.geometry.d3 import Object
+from ostk.mathematics.geometry.d3 import Transformation
+from ostk.mathematics.geometry.d3.object import Point
+from ostk.mathematics.geometry.d3.object import PointSet
+
+
+@pytest.fixture
+def point_set() -> PointSet:
+    return PointSet(
+        [
+            Point(1.0, 2.0, 1.0),
+            Point(3.0, 4.0, 1.0),
+        ]
+    )
+
+
+class TestPointSet:
+    def test_constructor_success(self):
+        point_1: Point = Point(1.0, 2.0, 1.0)
+        point_2: Point = Point(3.0, 4.0, 1.0)
+
+        # Construction using python list
+        point_set: PointSet = PointSet([point_1, point_2])
+
+        assert point_set is not None
+        assert isinstance(point_set, PointSet)
+        assert isinstance(point_set, Object)
+        assert point_set.is_defined()
+
+        # Construction using python tuple
+        point_set = PointSet((point_1, point_2))
+
+        assert point_set is not None
+        assert isinstance(point_set, PointSet)
+        assert isinstance(point_set, Object)
+        assert point_set.is_defined()
+
+        point_set = PointSet((point_1,))
+
+        assert point_set is not None
+        assert isinstance(point_set, PointSet)
+        assert isinstance(point_set, Object)
+        assert point_set.is_defined()
+
+    def test_empty_success(self):
+        point_set: PointSet = PointSet.empty()
+
+        assert point_set is not None
+        assert isinstance(point_set, PointSet)
+        assert isinstance(point_set, Object)
+        assert point_set.is_defined() is False
+        assert point_set.is_empty()
+
+    def test_get_size_success(self):
+        point_1: Point = Point(1.0, 2.0, 1.0)
+        point_2: Point = Point(3.0, 4.0, 1.0)
+
+        point_set_1: PointSet = PointSet([point_1, point_2])
+        point_set_2: PointSet = PointSet((point_2, point_1))
+        point_set_3: PointSet = PointSet([point_2])
+        point_set_4: PointSet = PointSet.empty()
+        point_set_5: PointSet = PointSet([point_1, point_1])
+
+        assert point_set_1.get_size() == 2
+        assert point_set_2.get_size() == 2
+        assert point_set_3.get_size() == 1
+        assert point_set_4.get_size() == 0
+        assert point_set_5.get_size() == 1
+
+    def test_comparators_success(self):
+        point_1: Point = Point(1.0, 2.0, 1.0)
+        point_2: Point = Point(3.0, 4.0, 1.0)
+
+        point_set_1: PointSet = PointSet([point_1, point_2])
+        point_set_2: PointSet = PointSet((point_2, point_1))
+        point_set_3: PointSet = PointSet([point_2])
+
+        assert point_set_1 == point_set_2
+        assert point_set_1 == point_set_2
+        assert point_set_3 != point_set_1
+        assert point_set_2 != point_set_3
+
+    def test_distance_to_success_point(self, point_set: PointSet):
+        assert point_set.distance_to(Point(1.0, 2.0, 3.0)) == 2.0
+
+    def test_len_success(self, point_set: PointSet):
+        assert len(point_set) == 2
+        assert len(PointSet.empty()) == 0
+
+    def test_iter_success(self, point_set: PointSet):
+        for point in point_set:
+            assert isinstance(point, Point)
+
+        assert iter(point_set) is not None
+        assert isinstance(iter(point_set), Iterator)
+        assert isinstance(iter(point_set), Iterable)
+
+    def test_get_item_success(self, point_set: PointSet):
+        assert point_set[0] is not None
+
+    # def test_is_near_success(self):
+
+    # def test_get_point_closest_to_success(self):
+
+    # def test_to_string_success(self):
+
+    # def test_apply_transformation_success(self):

ostk/mathematics/test/geometry/d3/object/test_polygon.py

@@ -0,0 +1,141 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+from ostk.core.type import String
+
+
+Point3d = mathematics.geometry.d3.object.Point
+Point2d = mathematics.geometry.d2.object.Point
+Polygon3d = mathematics.geometry.d3.object.Polygon
+Object3d = mathematics.geometry.d3.Object
+Polygon2d = mathematics.geometry.d2.object.Polygon
+Transformation = mathematics.geometry.d3.Transformation
+
+
+def test_geometry_d3_object_polygon():
+    ## Constructors
+
+    # Construct a Polygon2d
+    point_1: Point2d = Point2d(-1.0, 1.0)
+    point_2: Point2d = Point2d(1.0, 1.0)
+    point_3: Point2d = Point2d(1.0, -1.0)
+    point_4: Point2d = Point2d(-1.0, -1.0)
+
+    polygon2d: Polygon2d = Polygon2d([point_1, point_2, point_3, point_4])
+
+    assert polygon2d is not None
+    assert isinstance(polygon2d, Polygon2d)
+    assert polygon2d.is_defined()
+
+    # Construct a Polygon3d using python list constructors for vectors
+    point_5: Point3d = Point3d(1.0, 1.0, 1.0)
+    vector_1 = [1.0, 0.0, 0.0]
+    vector_2 = [0.0, 1.0, 0.0]
+
+    polygon3d_1: Polygon3d = Polygon3d(polygon2d, point_5, vector_1, vector_2)
+
+    assert polygon3d_1 is not None
+    assert isinstance(polygon3d_1, Polygon3d)
+    assert isinstance(polygon3d_1, Object3d)
+    assert polygon3d_1.is_defined()
+
+    # Construct a Polygon3d using python tuple constructors for vectors
+    point_5: Point3d = Point3d(1.0, 1.0, 1.0)
+    vector_1 = (1.0, 0.0, 0.0)
+    vector_2 = (0.0, 1.0, 0.0)
+
+    polygon3d_2: Polygon3d = Polygon3d(polygon2d, point_5, vector_1, vector_2)
+
+    assert polygon3d_2 is not None
+    assert isinstance(polygon3d_2, Polygon3d)
+    assert isinstance(polygon3d_2, Object3d)
+    assert polygon3d_2.is_defined()
+
+    # Construct a Polygon3d using python numpy array constructors for vectors
+    point_5: Point3d = Point3d(1.0, 1.0, 1.0)
+    vector_3 = np.array((1.0, 0.0, 0.0))
+    vector_4 = (0.0, 1.0, 1.0)
+
+    polygon3d_3: Polygon3d = Polygon3d(polygon2d, point_5, vector_3, vector_4)
+
+    assert polygon3d_3 is not None
+    assert isinstance(polygon3d_3, Polygon3d)
+    assert isinstance(polygon3d_3, Object3d)
+    assert polygon3d_3.is_defined()
+
+    # Construct using the static "undefined" method
+    polygon3d_4: Polygon3d = Polygon3d.undefined()
+
+    assert polygon3d_4 is not None
+    assert isinstance(polygon3d_4, Polygon3d)
+    assert isinstance(polygon3d_4, Object3d)
+    assert polygon3d_4.is_defined() is False
+
+    ## Comparators
+
+    assert polygon3d_1 == polygon3d_1
+    assert polygon3d_2 == polygon3d_2
+    assert polygon3d_3 == polygon3d_3
+    assert polygon3d_1 == polygon3d_2
+    assert polygon3d_3 != polygon3d_1
+    assert polygon3d_3 != polygon3d_2
+
+    ## get_polygon2d
+
+    polygon2d_1: Polygon2d = polygon3d_1.get_polygon2d()
+    polygon2d_2: Polygon2d = polygon3d_2.get_polygon2d()
+    polygon2d_3: Polygon2d = polygon3d_2.get_polygon2d()
+
+    assert polygon2d_1 is not None
+    assert polygon2d_2 is not None
+    assert polygon2d_3 is not None
+
+    assert isinstance(polygon2d_1, Polygon2d)
+    assert isinstance(polygon2d_2, Polygon2d)
+    assert isinstance(polygon2d_3, Polygon2d)
+
+    assert polygon2d_1 == polygon2d_2
+    assert polygon2d_2 == polygon2d_3
+
+    ## get_origin
+
+    origin_1: Point3d = polygon3d_1.get_origin()
+    origin_2: Point3d = polygon3d_2.get_origin()
+    origin_3: Point3d = polygon3d_3.get_origin()
+
+    assert origin_1 == point_5
+    assert origin_2 == point_5
+    assert origin_3 == point_5
+
+    ## get_x_axis
+
+    xaxis_1: np.ndarray = polygon3d_1.get_x_axis()
+    xaxis_2: np.ndarray = polygon3d_2.get_x_axis()
+    xaxis_3: np.ndarray = polygon3d_3.get_x_axis()
+
+    assert np.array_equal(xaxis_1, np.array(vector_1))
+    assert np.array_equal(xaxis_2, np.array(vector_1))
+    assert np.array_equal(xaxis_3, np.array(vector_3))
+
+    ## get_y_axis
+
+    yaxis_1: np.ndarray = polygon3d_1.get_y_axis()
+    yaxis_2: np.ndarray = polygon3d_2.get_y_axis()
+    yaxis_3: np.ndarray = polygon3d_3.get_y_axis()
+
+    assert np.array_equal(yaxis_1, np.array(vector_2))
+    assert np.array_equal(yaxis_2, np.array(vector_2))
+    assert np.array_equal(
+        yaxis_3, np.array(vector_4) / np.linalg.norm(np.array(vector_4))
+    )
+
+    ## is_near
+
+    ## get_normal_vector
+
+    ## apply_transformation

ostk/mathematics/test/geometry/d3/object/test_segment.py

@@ -0,0 +1,120 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d3.Object
+Point = mathematics.geometry.d3.object.Point
+PointSet = mathematics.geometry.d3.object.PointSet
+Segment = mathematics.geometry.d3.object.Segment
+Line = mathematics.geometry.d3.object.Line
+Plane = mathematics.geometry.d3.object.Plane
+Sphere = mathematics.geometry.d3.object.Sphere
+Ellipsoid = mathematics.geometry.d3.object.Ellipsoid
+Intersection = mathematics.geometry.d3.Intersection
+Transformation = mathematics.geometry.d3.Transformation
+
+
+@pytest.fixture
+def segment() -> Segment:
+    return Segment(
+        Point(0.0, 0.0, 0.0),
+        Point(0.0, 0.0, 2.0),
+    )
+
+
+class TestSegment:
+    def test_constructor_success(self):
+        point_1: Point = Point(-1.0, 1.0, 0.0)
+        point_2: Point = Point(1.0, 1.0, 1.0)
+
+        segment: Segment = Segment(point_1, point_2)
+
+        assert segment is not None
+        assert isinstance(segment, Segment)
+        assert isinstance(segment, Object)
+        assert segment.is_defined()
+
+        segment: Segment = Segment(point_1, point_1)
+
+        assert segment is not None
+        assert isinstance(segment, Segment)
+        assert isinstance(segment, Object)
+        assert segment.is_defined()
+
+    def test_comparators_success(self):
+        point_1: Point = Point(-1.0, 1.0, 0.0)
+        point_2: Point = Point(1.0, 1.0, 0.0)
+
+        segment_1: Segment = Segment(point_1, point_2)
+        segment_2: Segment = Segment(point_1, point_1)
+
+        assert segment_1 == segment_1
+        assert segment_1 != segment_2
+
+    def test_getters_success(self):
+        point_1: Point = Point(-1.0, 1.0, 0.0)
+        point_2: Point = Point(1.0, 1.0, 0.0)
+
+        segment: Segment = Segment(point_1, point_2)
+
+        assert isinstance(segment.get_first_point(), Point)
+        assert segment.get_first_point() == point_1
+
+        assert isinstance(segment.get_second_point(), Point)
+        assert segment.get_second_point() == point_2
+
+        assert isinstance(segment.get_center(), Point)
+        assert segment.get_center() == Point(0.0, 1.0, 0.0)
+
+        assert isinstance(segment.get_direction(), np.ndarray)
+        assert np.array_equal(segment.get_direction(), np.array((1.0, 0.0, 0.0)))
+
+        assert segment.get_length() == 2.0
+
+    def test_is_defined_success(self, segment: Segment):
+        assert segment.is_defined() is True
+
+    def test_is_degenerate_success(self, segment: Segment):
+        assert segment.is_degenerate() is False
+
+    def test_intersects_success_plane(self, segment: Segment):
+        assert (
+            segment.intersects(Plane(Point(0.0, 0.0, 0.0), np.array((1.0, 0.0, 0.0))))
+            is True
+        )
+
+    def test_intersects_success_sphere(self, segment: Segment):
+        assert segment.intersects(Sphere(Point(0.0, 0.0, 0.0), 1.0)) is True
+
+    def test_intersects_success_ellipsoid(self, segment: Segment):
+        assert segment.intersects(Ellipsoid(Point(0.0, 0.0, 0.0), 0.5, 0.5, 0.5)) is True
+
+    def test_contains_success_point(self, segment: Segment):
+        assert segment.contains(Point(0.0, 0.0, 0.0)) is True
+
+    def test_get_length_success(self, segment: Segment):
+        assert segment.get_length() == 2.0
+
+    def test_distance_to_success_point(self, segment: Segment):
+        assert segment.distance_to(Point(0.0, 0.0, 0.0)) == 0.0
+
+    def test_distance_to_success_point_set(self, segment: Segment):
+        assert (
+            segment.distance_to(PointSet([Point(0.0, 0.0, 0.0), Point(1.0, 0.0, 0.0)]))
+            == 0.0
+        )
+
+    def test_intersection_with_success_plane(self, segment: Segment):
+        assert segment.intersection_with(
+            Plane(Point(0.0, 0.0, 0.0), np.array((0.0, 0.0, 1.0)))
+        ) == Intersection.point(Point(0.0, 0.0, 0.0))
+
+    def test_to_line_success(self, segment: Segment):
+        assert segment.to_line() == Line(Point(0.0, 0.0, 0.0), np.array((0.0, 0.0, 1.0)))
+
+    # def test_apply_transformation_success (self):

ostk/mathematics/test/geometry/d3/objects/test_cuboid.py

@@ -0,0 +1,20 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+from ostk.core.type import String
+
+
+Point3d = mathematics.geometry.d3.object.Point
+Point2d = mathematics.geometry.d2.object.Point
+Polygon3d = mathematics.geometry.d3.object.Polygon
+Object3d = mathematics.geometry.d3.Object
+Polygon2d = mathematics.geometry.d2.object.Polygon
+Transformation = mathematics.geometry.d3.Transformation
+
+
+# def test_geometry_d3_objects_cuboid ():

ostk/mathematics/test/geometry/d3/test_intersection.py

@@ -0,0 +1,3 @@
+# Apache License 2.0
+
+import ostk.mathematics as mathematics

ostk/mathematics/test/geometry/d3/test_object.py

@@ -0,0 +1,3 @@
+# Apache License 2.0
+
+import ostk.mathematics as mathematics

ostk/mathematics/test/geometry/d3/test_transformation.py

@@ -0,0 +1,3 @@
+# Apache License 2.0
+
+import ostk.mathematics as mathematics

ostk/mathematics/test/geometry/d3/transformation/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/test/geometry/d3/transformation/rotation/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0