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

ostk/mathematics/test/geometry/d2/object/test_multipolygon.py

@@ -0,0 +1,101 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+from ostk.core.type import String
+
+
+Object = mathematics.geometry.d2.Object
+Polygon = mathematics.geometry.d2.object.Polygon
+MultiPolygon = mathematics.geometry.d2.object.MultiPolygon
+
+
+class TestMultipolygon:
+    def test_constructor_success(self, square_1: Polygon, square_2: Polygon):
+        # Construction using a python list of polygons
+        multipolygon: MultiPolygon = MultiPolygon([square_1, square_2])
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined()
+
+        # Construction using a python tuple of polygons
+        multipolygon: MultiPolygon = MultiPolygon((square_1, square_2))
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined()
+
+        # Construction using a python numpy array of polygons
+        multipolygon: MultiPolygon = MultiPolygon(np.array((square_1, square_2)))
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined()
+
+        # Construction using polygon static constructor
+        multipolygon: MultiPolygon = MultiPolygon.polygon(square_1)
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined()
+
+        # Construction using an array of one polygon
+        multipolygon: MultiPolygon = MultiPolygon([square_1])
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined()
+
+    def test_comparators_success(self, square_1: Polygon, square_2: Polygon):
+        # Multiple MultiPolygons
+        multipolygon_1: MultiPolygon = MultiPolygon([square_1, square_2])
+        multipolygon_2: MultiPolygon = MultiPolygon([square_1])
+        multipolygon_3: MultiPolygon = MultiPolygon.polygon(square_1)
+
+        assert multipolygon_1 == multipolygon_1
+        assert multipolygon_1 != multipolygon_2
+        assert multipolygon_1 != multipolygon_3
+        assert multipolygon_2 == multipolygon_3
+
+    def test_undefined_constructor_success(self):
+        multipolygon: MultiPolygon = MultiPolygon.undefined()
+
+        assert multipolygon is not None
+        assert isinstance(multipolygon, MultiPolygon)
+        assert isinstance(multipolygon, Object)
+        assert multipolygon.is_defined() is False
+
+    def test_getters_success(
+        self,
+        square_1: Polygon,
+        square_2: Polygon,
+    ):
+        # Multiple Polygons
+        multipolygon: MultiPolygon = MultiPolygon([square_1, square_2])
+
+        assert multipolygon.get_polygon_count() == 2
+        assert multipolygon.get_polygons()[0] == square_1
+        assert multipolygon.get_polygons()[-1] == square_2
+
+        # One Polygon
+        multipolygon: MultiPolygon = MultiPolygon.polygon(square_1)
+
+        assert multipolygon.get_polygon_count() == 1
+        assert multipolygon.get_polygons()[0] == square_1
+        assert multipolygon.get_convex_hull() == square_1
+
+    # def test_union_with_success (self) :
+
+    # def test_to_string_success (self):
+
+    # def test_apply_transformation_success (self):

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

@@ -0,0 +1,213 @@
+# Apache License 2.0
+
+import pytest
+
+import math
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+from ostk.core.type import String
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+
+
+class TestPoint:
+    def test_constructor_success(self):
+        point: Point = Point(1.0, 2.0)
+
+        assert point is not None
+        assert isinstance(point, Point)
+        assert isinstance(point, Object)
+        assert point.is_defined()
+
+    def test_undefined_constructor_success(self):
+        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_origin_constructor_success(self):
+        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 <= 1e-12
+        assert point.y() - 0.0 <= 1e-12
+
+    def test_vector_constructor_success(self):
+        # Construction using a python list
+        point: Point = Point.vector([3.4, -6.7])
+
+        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
+
+        # Construction using a python tuple
+        point: Point = Point.vector((3.4, -6.7))
+
+        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
+
+        # Construction using a python numpy array
+        point: Point = Point.vector(np.array((3.4, -6.7)))
+
+        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
+
+    def test_comparators_success(self):
+        point_1: Point = Point(3.4, -6.7)
+        point_2: Point = Point.vector([3.4, -6.7])
+        point_3: Point = Point(3.3, -6.5)
+        point_4: Point = Point.vector(
+            (
+                3.4,
+                -6.7,
+            )
+        )
+        point_5: Point = Point.vector(np.array((3.4, -6.7)))
+
+        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_operators_success(self):
+        point_1: Point = Point(3.4, -6.7)
+        point_2: Point = Point.vector([3.4, -6.7])
+        point_3: Point = Point.vector((3.4, -6.7))
+        point_4: Point = Point.vector(np.array((3.3, -6.5)))
+
+        point: Point = point_1 + [3.4, -6.7]
+
+        assert point is not None
+        assert isinstance(point, Point)
+        assert point.is_defined()
+        assert point.x() - (point_1.x() + point_2.x()) <= 1e-12
+        assert point.y() - (point_1.y() + point_2.y()) <= 1e-12
+
+        point: Point = point_3 + [3.4, -6.7]
+
+        assert point is not None
+        assert isinstance(point, Point)
+        assert point.is_defined()
+        assert point.x() - (point_3.x() + point_2.x()) <= 1e-12
+        assert point.y() - (point_3.y() + point_2.y()) <= 1e-12
+
+        point: Point = point_1 + (3.3, -6.5)
+
+        assert point is not None
+        assert isinstance(point, Point)
+        assert point.is_defined()
+        assert point.x() - (point_1.x() + point_4.x()) <= 1e-12
+        assert point.y() - (point_1.y() + point_4.y()) <= 1e-12
+
+        point: Point = point_1 + (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]
+
+        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))
+
+        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_is_defined(self):
+        point: Point = Point(3.5, 5.6)
+
+        assert point.is_defined()
+        assert Point.undefined().is_defined() is False
+
+    def test_is_near(self):
+        point_1: Point = Point(3.5, 5.6)
+        point_2: Point = Point(3.4999999999, 5.5999999999)
+
+        assert point_1.is_near(point_2, 1e-8) is True
+        assert point_2.is_near(point_1, 1e-8) is True
+        assert point_1.is_near(point_2, 1e-11) is False
+        assert point_1.is_near(point_2, 1e-9) is True
+
+    def test_coordinates(self):
+        point: Point = Point(4.5, 34.5)
+
+        assert point.x() == 4.5
+        assert point.y() == 34.5
+
+    def test_as_vector(self):
+        point: Point = Point(3.4, -3.5)
+        vec: np.ndarray = point.as_vector()
+
+        assert vec is not None
+        assert isinstance(vec, np.ndarray)
+
+    def test_distance_to(self):
+        point_1: Point = Point(0.0, 4.0)
+        point_2: Point = Point(0.0, 3.0)
+        point_3: Point = Point(3.0, 0.0)
+        point_4: Point = Point(1.1, 1.0)
+
+        assert point_1.distance_to(point_2) == 1.0
+        assert point_2.distance_to(point_1) == 1.0
+
+        assert point_1.distance_to(point_3) == 5.0
+        assert point_3.distance_to(point_1) == 5.0
+
+        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))
+
+    def test_to_string(self):
+        point: Point = Point(3.0, 5.0)
+
+        assert isinstance(point.to_string(), String)
+        assert point.to_string() == "[3.0, 5.0]"
+
+    # def test_apply_transformation_success (self):
+
+    #     point: Point = Point(4.5, 5.4)

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

@@ -0,0 +1,103 @@
+# Apache License 2.0
+
+from collections.abc import Iterator, Iterable
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+PointSet = mathematics.geometry.d2.object.PointSet
+
+
+class TestPointSet:
+    def test_constructor_success(self):
+        point_1: Point = Point(1.0, 2.0)
+        point_2: Point = Point(3.0, 4.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_comparators_success(self):
+        point_1: Point = Point(1.0, 2.0)
+        point_2: Point = Point(3.0, 4.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_get_size_success(self):
+        point_1: Point = Point(1.0, 2.0)
+        point_2: Point = Point(3.0, 4.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_distance_to_success_point(self, point_set: PointSet):
+        assert point_set.distance_to(Point(1.0, 2.0)) == 0.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):