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

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

@@ -0,0 +1,93 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.mathematics.geometry.d2 import Object
+from ostk.mathematics.geometry.d2.object import Point
+from ostk.mathematics.geometry.d2.object import Polygon
+from ostk.mathematics.geometry.d2.object import Composite
+
+
+class TestComposite:
+    def test_constructor_success(self, polygon: Polygon):
+        composite: Composite = Composite(polygon)
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+
+    def test_empty_success(self):
+        composite: Composite = Composite.empty()
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert isinstance(composite, Object)
+        assert composite.is_defined()
+        assert composite.is_empty()
+
+    def test_is_defined_success(self):
+        composite: Composite = Composite.undefined()
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert isinstance(composite, Object)
+        assert composite.is_defined() is False
+
+    def test_comparators_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        other_composite: Composite = Composite(polygon)
+
+        assert composite == composite
+        assert composite != other_composite
+        assert other_composite != composite
+
+    def test_addition_operator_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+        assert composite.get_object_count() == 2
+
+        with pytest.raises(RuntimeError):
+            other_composite = Composite.undefined() + composite
+
+        with pytest.raises(RuntimeError):
+            other_composite = composite + Composite.undefined()
+
+        composite += composite
+
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+        assert composite.get_object_count() == 4
+
+        with pytest.raises(RuntimeError):
+            composite += Composite.undefined()
+
+    def test_is_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        assert composite.is_point() is False
+        assert composite.is_polygon() is False
+
+        assert Composite(polygon).is_polygon()
+
+    def test_access_object_at_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+        point: Point,
+    ):
+        assert composite.get_object_count() == 2
+        assert composite.access_object_at(0) == polygon
+        assert composite.access_object_at(1) == point
+
+        with pytest.raises(RuntimeError):
+            composite.access_object_at(2)

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

@@ -0,0 +1,57 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+PointSet = mathematics.geometry.d2.object.PointSet
+Line = mathematics.geometry.d2.object.Line
+
+
+class TestLine:
+    def test_constructor_success(self):
+        line = Line(
+            Point(1.0, 2.0),
+            np.array((3.4, 1.0)),
+        )
+
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined()
+
+    def test_contains_success_point_set(
+        self,
+        line: Line,
+        point_set: PointSet,
+    ):
+        assert line.contains(point_set) is True
+
+    def test_distance_to_success_point(
+        self,
+        line: Line,
+    ):
+        assert float(line.distance_to(Point(2.0, 3.0))) == pytest.approx(0.0, 1e-5)
+        assert float(line.distance_to(Point(1.0, 5.0))) == pytest.approx(2.12132, 1e-5)
+
+    def test_undefined_success(self):
+        line = Line.undefined()
+
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined() is False
+
+    def test_points_success(
+        self,
+        line: Line,
+    ):
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined() is True

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

@@ -0,0 +1,174 @@
+# Apache License 2.0
+
+from collections.abc import Iterator, Iterable
+
+import numpy as np
+
+import pytest
+
+from ostk.core.type import String
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+LineString = mathematics.geometry.d2.object.LineString
+
+
+class TestLineString:
+    def test_constructor_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+        point_3: Point = Point(1.0, -1.0)
+        point_4: Point = Point(-1.0, -1.0)
+
+        # Construction with Array of Points using python list
+        linestring: LineString = LineString([point_1, point_2, point_3, point_4])
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+        # Construction with Array of Points using python tuple
+        linestring: LineString = LineString((point_1, point_2, point_3, point_4))
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+        # Construction with Array of Points using python numpy array
+        linestring: LineString = LineString(
+            np.array((point_1, point_2, point_3, point_4))
+        )
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+    def test_empty_constructor_success(self):
+        linestring: LineString = LineString.empty()
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined() is False
+        assert linestring.is_empty()
+
+    def test_comparators_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring_1: LineString = LineString([point_1, point_2])
+        linestring_2: LineString = LineString((point_1, point_2))
+        linestring_3: LineString = LineString(np.array([point_1, point_2]))
+        linestring_4: LineString = LineString([point_1])
+
+        assert linestring_1 == linestring_1
+        assert linestring_1 == linestring_2
+        assert linestring_1 == linestring_3
+        assert linestring_1 != linestring_4
+        assert linestring_2 != linestring_4
+        assert linestring_3 != linestring_4
+
+    def test_is_near_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        point_3: Point = Point(-0.996, 0.9995)
+        point_4: Point = Point(0.997, 0.996)
+
+        linestring_1: LineString = LineString([point_1, point_2])
+        linestring_2: LineString = LineString([point_3, point_4])
+
+        assert linestring_1.is_near(linestring_1, 10.0)
+        assert linestring_1.is_near(linestring_1, 0.1)
+        assert linestring_1.is_near(linestring_1, 1e-9)
+
+        assert linestring_2.is_near(linestring_2, 10.0)
+        assert linestring_2.is_near(linestring_2, 0.1)
+        assert linestring_2.is_near(linestring_2, 1e-9)
+
+        assert linestring_1.is_near(linestring_2, 1e-1)
+        assert linestring_1.is_near(linestring_2, 1e-2)
+
+        assert linestring_2.is_near(linestring_1, 1e-1)
+        assert linestring_2.is_near(linestring_1, 1e-2)
+
+    def test_getters_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring_1: LineString = LineString([point_1])
+        linestring_2: LineString = LineString([point_1, point_2])
+
+        assert LineString.empty().get_point_count() == 0
+        assert linestring_1.get_point_count() == 1
+        assert linestring_2.get_point_count() == 2
+
+        assert linestring_1.get_point_closest_to(Point(0.0, 0.0)) == point_1
+
+        assert linestring_2.get_point_closest_to(Point(0.0, 0.0)) == point_1
+        assert linestring_2.get_point_closest_to(Point(-0.9, 1.0)) == point_1
+        assert linestring_2.get_point_closest_to(Point(0.9, 1.0)) == point_2
+
+    def test_get_point_count_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert len(linestring) == 2
+        assert len(linestring) == linestring.get_point_count()
+        assert len(LineString.empty()) == 0
+
+    def test_len_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert len(linestring) == 2
+        assert len(LineString.empty()) == 0
+
+    def test_getitem_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert linestring[0] == point_1
+        assert linestring[1] == point_2
+
+        assert isinstance(linestring[0], Point)
+        assert isinstance(linestring[1], Point)
+
+        with pytest.raises(RuntimeError):
+            point = linestring[2]
+
+        linestring_list = list(linestring)
+
+        assert isinstance(linestring_list, list)
+        assert isinstance(linestring_list[0], Point)
+        assert isinstance(linestring_list[1], Point)
+        assert len(linestring_list) == 2
+
+    def test_iter_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        for point in linestring:
+            assert isinstance(point, Point)
+
+        assert iter(linestring) is not None
+        assert isinstance(iter(linestring), Iterator)
+        assert isinstance(iter(linestring), Iterable)
+
+    # def test_to_string_success(self):
+
+    # def test_apply_transformation_success(self):

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

@@ -0,0 +1,94 @@
+# Apache License 2.0
+
+import numpy as np
+
+from ostk.mathematics.geometry.d2 import Object
+from ostk.mathematics.geometry.d2.object import Polygon
+from ostk.mathematics.geometry.d2.object import 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)