open-space-toolkit-physics 11.2.1__py313-none-manylinux2014_x86_64.whl

ostk/physics/test/coordinate/spherical/test_lla.py

@@ -0,0 +1,490 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.core.type import String
+
+from ostk.physics import Environment
+from ostk.physics.unit import Angle, Length
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+
+Spherical = EarthGravitationalModel.spherical
+WGS84_EGM96 = EarthGravitationalModel.WGS84_EGM96
+
+ENVIRONMENT = Environment.default(True)  # set global environment
+
+
+@pytest.fixture
+def latitude_deg() -> float:
+    return 30.0
+
+
+@pytest.fixture
+def longitude_deg() -> float:
+    return 30.0
+
+
+@pytest.fixture
+def altitude_deg() -> float:
+    return 1000.0
+
+
+@pytest.fixture
+def latitude(latitude_deg: float) -> Angle:
+    return Angle(latitude_deg, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def longitude(longitude_deg: float) -> Angle:
+    return Angle(longitude_deg, Angle.Unit.Degree)
+
+
+@pytest.fixture
+def altitude(altitude_deg: float) -> Length:
+    return Length(altitude_deg, Length.Unit.Meter)
+
+
+@pytest.fixture
+def lla(
+    latitude: Angle,
+    longitude: Angle,
+    altitude: Length,
+) -> LLA:
+    return LLA(latitude, longitude, altitude)
+
+
+@pytest.fixture
+def lla_point_equator_1() -> LLA:
+    return LLA(
+        Angle(0.0, Angle.Unit.Degree),
+        Angle(0.0, Angle.Unit.Degree),
+        Length(1.0, Length.Unit.Meter),
+    )
+
+
+@pytest.fixture
+def lla_point_equator_2() -> LLA:
+    return LLA(
+        Angle(0.0, Angle.Unit.Degree),
+        Angle(90.0, Angle.Unit.Degree),
+        Length(1.0, Length.Unit.Meter),
+    )
+
+
+@pytest.fixture
+def lla_point_equator_3() -> LLA:
+    return LLA(
+        Angle(0.0, Angle.Unit.Degree),
+        Angle(180.0, Angle.Unit.Degree),
+        Length(1.0, Length.Unit.Meter),
+    )
+
+
+@pytest.fixture
+def lla_north_pole() -> LLA:
+    return LLA(
+        Angle(90.0, Angle.Unit.Degree),
+        Angle(0.0, Angle.Unit.Degree),
+        Length(1.0, Length.Unit.Meter),
+    )
+
+
+@pytest.fixture
+def lla_south_pole() -> LLA:
+    return LLA(
+        Angle(-90.0, Angle.Unit.Degree),
+        Angle(0.0, Angle.Unit.Degree),
+        Length(1.0, Length.Unit.Meter),
+    )
+
+
+class TestLLA:
+    def test_constructor_list_success(
+        self,
+        latitude_deg: float,
+        longitude_deg: float,
+        altitude_deg: float,
+    ):
+        lla: LLA = LLA.vector([latitude_deg, longitude_deg, altitude_deg])
+        assert lla is not None
+
+    def test_constructor_tuple_success(
+        self,
+        latitude_deg: float,
+        longitude_deg: float,
+        altitude_deg: float,
+    ):
+        lla: LLA = LLA.vector((latitude_deg, longitude_deg, altitude_deg))
+        assert lla is not None
+
+    def test_constructor_numpy_array_success(
+        self,
+        latitude_deg: float,
+        longitude_deg: float,
+        altitude_deg: float,
+    ):
+        lla: LLA = LLA.vector(np.array((latitude_deg, longitude_deg, altitude_deg)))
+        assert lla is not None
+
+    def test_constructor_vector_failure_latitude(self):
+        with pytest.raises(RuntimeError):
+            lla: LLA = LLA.vector((95.0, 1.0, 1.0))
+
+    def test_constructor_vector_failure_longitude(self):
+        with pytest.raises(RuntimeError):
+            lla: LLA = LLA.vector((1.0, -181.0, 1.0))
+
+    def test_constructor_vector_success_altitude_negative(self):
+        lla: LLA = LLA.vector((5.0, 1.0, -1.0))
+        assert lla is not None
+
+    def test_constructor_cartesian_success(self):
+        lla: LLA = LLA.cartesian([1.0, 1.0, 1.0], Length(1.0, Length.Unit.Meter), 0.001)
+        assert lla is not None
+
+    def test_comparator(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        assert lla_point_equator_1 == lla_point_equator_1
+        assert lla_point_equator_2 == lla_point_equator_2
+        assert lla_point_equator_1 != lla_point_equator_2
+
+    def test_is_defined(
+        self,
+        lla: LLA,
+    ):
+        assert lla.is_defined()
+        assert lla.undefined().is_defined() is False
+
+    def test_getters(
+        self,
+        latitude: Angle,
+        longitude: Angle,
+        altitude: Length,
+        lla: LLA,
+    ):
+        assert lla.get_latitude() == latitude
+        assert lla.get_longitude() == longitude
+        assert lla.get_altitude() == altitude
+
+    def test_on_surface(
+        self,
+        lla: LLA,
+    ):
+        assert lla.on_surface() is not None
+
+    def test_calculate_distance_to(
+        self,
+        lla_north_pole: LLA,
+        lla_south_pole: LLA,
+    ):
+        zero_distance_spherical: Length = lla_north_pole.calculate_distance_to(
+            lla_north_pole,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert zero_distance_spherical is not None
+        assert zero_distance_spherical.in_meters() == 0.0
+
+        distance_spherical_poles: Length = lla_south_pole.calculate_distance_to(
+            lla_north_pole,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert (
+            distance_spherical_poles.in_meters()
+            == Spherical.equatorial_radius.in_meters() * np.pi
+        )
+
+        assert lla_south_pole.calculate_distance_to(lla_north_pole) is not None
+
+    def test_calculate_azimuth_to(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        azimuths: Angle = lla_point_equator_1.calculate_azimuth_to(
+            lla_point_equator_2,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert azimuths is not None
+        assert isinstance(azimuths, tuple)
+        assert len(azimuths) == 2
+        assert isinstance(azimuths[0], Angle)
+        assert isinstance(azimuths[1], Angle)
+
+        assert lla_point_equator_1.calculate_azimuth_to(lla_point_equator_2) is not None
+
+    def test_calculate_intermediate_to(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        lla_intermediate: LLA = lla_point_equator_1.calculate_intermediate_to(
+            lla_point_equator_2,
+            0.3,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert lla_intermediate is not None
+        assert isinstance(lla_intermediate, LLA)
+
+        assert (
+            lla_point_equator_1.calculate_intermediate_to(lla_point_equator_2, 0.3)
+            is not None
+        )
+
+    def test_calculate_forward(
+        self,
+        lla: LLA,
+    ):
+        lla_forward: LLA = lla.calculate_forward(
+            Angle.degrees(0.0),
+            Length.meters(5000.0),
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert lla_forward is not None
+        assert isinstance(lla_forward, LLA)
+
+        assert (
+            lla.calculate_forward(Angle.degrees(0.0), Length.meters(5000.0)) is not None
+        )
+
+    def test_calculate_linspace_to(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        n_points: int = 10
+        llas: LLA = lla_point_equator_1.calculate_linspace_to(
+            lla_point_equator_2,
+            n_points,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert llas is not None
+        assert len(llas) == n_points
+
+        assert (
+            lla_point_equator_1.calculate_linspace_to(lla_point_equator_2, n_points)
+            is not None
+        )
+
+    def test_to_vector(
+        self,
+        latitude_deg: float,
+        longitude_deg: float,
+        altitude_deg: float,
+        lla: LLA,
+    ):
+        vector: np.ndarray = lla.to_vector()
+
+        assert vector[0] == latitude_deg
+        assert vector[1] == longitude_deg
+        assert vector[2] == altitude_deg
+
+    def test_to_cartesian(
+        self,
+        lla: LLA,
+    ):
+        cartesian: np.ndarray = LLA.to_cartesian(lla, Length.meters(3.0), 3.0)
+        assert cartesian is not None
+
+        assert LLA.to_cartesian(lla) is not None
+
+    def test_conversion_string(
+        self,
+        latitude_deg: float,
+        longitude_deg: float,
+        altitude_deg: float,
+        lla: LLA,
+    ):
+        lla_string: String = lla.to_string()
+
+        assert lla_string is not None
+        assert isinstance(lla_string, String)
+        assert (
+            lla_string
+            == f"[{latitude_deg} [deg], {longitude_deg} [deg], {altitude_deg} [m]]"
+        )
+
+    def test_distance_between(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+        lla_point_equator_3: LLA,
+        lla_north_pole: LLA,
+        lla_south_pole: LLA,
+    ):
+        zero_distance_spherical: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_point_equator_1,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert zero_distance_spherical is not None
+        assert zero_distance_spherical.in_meters() == 0.0
+
+        distance_spherical_equatorial_1_2: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_point_equator_2,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        distance_spherical_equatorial_2_1: Length = LLA.distance_between(
+            lla_point_equator_2,
+            lla_point_equator_1,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert (
+            distance_spherical_equatorial_1_2.in_meters()
+            == Spherical.equatorial_radius.in_meters() * np.pi / 2
+        )
+        assert (
+            distance_spherical_equatorial_2_1.in_meters()
+            == Spherical.equatorial_radius.in_meters() * np.pi / 2
+        )
+
+        distance_spherical_equatorial_1_3: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_point_equator_3,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        distance_spherical_equatorial_3_1: Length = LLA.distance_between(
+            lla_point_equator_3,
+            lla_point_equator_1,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert (
+            distance_spherical_equatorial_1_3.in_meters()
+            == Spherical.equatorial_radius.in_meters() * np.pi
+        )
+        assert (
+            distance_spherical_equatorial_3_1.in_meters()
+            == Spherical.equatorial_radius.in_meters() * np.pi
+        )
+
+        distance_spherical_poles: Length = LLA.distance_between(
+            lla_north_pole,
+            lla_south_pole,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert distance_spherical_poles == distance_spherical_equatorial_1_3
+
+        distance_wgs84_equatorial_1_2: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_point_equator_2,
+            WGS84_EGM96.equatorial_radius,
+            WGS84_EGM96.flattening,
+        )
+        assert (
+            distance_wgs84_equatorial_1_2 == distance_spherical_equatorial_1_2
+        )  # on equator
+
+        distance_wgs84_equatorial_1_3: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_point_equator_3,
+            WGS84_EGM96.equatorial_radius,
+            WGS84_EGM96.flattening,
+        )  # through the poles
+        distance_wgs84_equatorial_3_1: Length = LLA.distance_between(
+            lla_point_equator_3,
+            lla_point_equator_1,
+            WGS84_EGM96.equatorial_radius,
+            WGS84_EGM96.flattening,
+        )  # through the poles
+        distance_wgs84_equatorial_2_3: Length = LLA.distance_between(
+            lla_point_equator_2,
+            lla_point_equator_3,
+            WGS84_EGM96.equatorial_radius,
+            WGS84_EGM96.flattening,
+        )
+
+        assert distance_wgs84_equatorial_3_1 == distance_wgs84_equatorial_1_3
+        assert (
+            distance_wgs84_equatorial_1_3
+            < distance_wgs84_equatorial_1_2 + distance_wgs84_equatorial_2_3
+        )
+
+        distance_wgs84_1_north_pole: Length = LLA.distance_between(
+            lla_point_equator_1,
+            lla_north_pole,
+            WGS84_EGM96.equatorial_radius,
+            WGS84_EGM96.flattening,
+        )
+        assert (
+            distance_wgs84_1_north_pole < distance_wgs84_equatorial_1_2
+        )  # flattened surface at poles
+        assert distance_wgs84_1_north_pole < distance_spherical_equatorial_1_2
+
+    def test_azimuth_between(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        azimuths: Angle = LLA.azimuth_between(
+            lla_point_equator_1,
+            lla_point_equator_2,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert azimuths is not None
+        assert isinstance(azimuths, tuple)
+        assert len(azimuths) == 2
+        assert isinstance(azimuths[0], Angle)
+        assert isinstance(azimuths[1], Angle)
+
+    def test_intermediate_between(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        lla_intermediate: LLA = LLA.intermediate_between(
+            lla_point_equator_1,
+            lla_point_equator_2,
+            0.3,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert lla_intermediate is not None
+        assert isinstance(lla_intermediate, LLA)
+
+    def test_forward(
+        self,
+        lla: LLA,
+    ):
+        lla_forward: LLA = LLA.forward(
+            lla,
+            Angle.degrees(0.0),
+            Length.meters(5000.0),
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert lla_forward is not None
+        assert isinstance(lla_forward, LLA)
+
+    def test_linspace(
+        self,
+        lla_point_equator_1: LLA,
+        lla_point_equator_2: LLA,
+    ):
+        n_points: int = 10
+        llas: LLA = LLA.linspace(
+            lla_point_equator_1,
+            lla_point_equator_2,
+            n_points,
+            Spherical.equatorial_radius,
+            Spherical.flattening,
+        )
+        assert llas is not None
+        assert len(llas) == n_points

ostk/physics/test/coordinate/test_axes.py

@@ -0,0 +1,116 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+import ostk.physics as physics
+
+Scale = physics.time.Scale
+DateTime = physics.time.DateTime
+Instant = physics.time.Instant
+Frame = physics.coordinate.Frame
+Axes = physics.coordinate.Axes
+
+
+def test_coordinate_axes_constructors():
+    # Construct arbitrary Frame
+    frame: Frame = Frame.GCRF()
+
+    # Construction using python lists
+    vector_1 = [1.0, 0.0, 0.0]
+    vector_2 = [0.0, 1.0, 0.0]
+    vector_3 = [0.0, 0.0, 1.0]
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    assert axes is not None
+    assert isinstance(axes, Axes)
+    assert axes.is_defined() is True
+
+    # Construction using python tuples
+    vector_1 = (1.0, 0.0, 0.0)
+    vector_2 = (0.0, 1.0, 0.0)
+    vector_3 = (0.0, 0.0, 1.0)
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    assert axes is not None
+    assert isinstance(axes, Axes)
+    assert axes.is_defined() is True
+
+    # Construction using python numpy arrays
+    vector_1 = np.array(vector_1)
+    vector_2 = np.array(vector_2)
+    vector_3 = np.array(vector_3)
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    assert axes is not None
+    assert isinstance(axes, Axes)
+    assert axes.is_defined() is True
+
+    # Construction using undefined method
+
+    axes: Axes = Axes.undefined()
+
+    assert axes is not None
+    assert isinstance(axes, Axes)
+    assert axes.is_defined() is False
+
+
+def test_coordinate_axes_xyz():
+    frame: Frame = Frame.GCRF()
+    vector_1 = [1.0, 0.0, 0.0]
+    vector_2 = [0.0, 1.0, 0.0]
+    vector_3 = [0.0, 0.0, 1.0]
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    x = axes.x()
+    y = axes.y()
+    z = axes.z()
+
+    assert x is not None
+    assert isinstance(x, np.ndarray)
+    assert np.array_equal(x, vector_1)
+
+    assert y is not None
+    assert isinstance(y, np.ndarray)
+    assert np.array_equal(y, vector_2)
+
+    assert z is not None
+    assert isinstance(z, np.ndarray)
+    assert np.array_equal(z, vector_3)
+
+
+def test_coordinate_axes_get_frame():
+    frame: Frame = Frame.GCRF()
+    vector_1 = [1.0, 0.0, 0.0]
+    vector_2 = [0.0, 1.0, 0.0]
+    vector_3 = [0.0, 0.0, 1.0]
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    assert axes.get_frame() is not None
+    assert isinstance(axes.get_frame(), Frame)
+    assert axes.get_frame() == frame
+
+
+@pytest.mark.skip
+def test_coordinate_axes_in_frame():
+    frame: Frame = Frame.GCRF()
+    vector_1 = [1.0, 0.0, 0.0]
+    vector_2 = [0.0, 1.0, 0.0]
+    vector_3 = [0.0, 0.0, 1.0]
+
+    axes: Axes = Axes(vector_1, vector_2, vector_3, frame)
+
+    instant: Instant = Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+    assert axes.in_frame(Frame.GCRF(), instant) is not None
+    assert isinstance(axes.in_frame(Frame.GCRF(), instant), Axes)
+    assert axes.in_frame(Frame.GCRF(), instant) == axes
+
+    assert axes.in_frame(Frame.TEME(), instant) is not None
+    assert isinstance(axes.in_frame(Frame.TEME(), instant), Axes)
+    assert axes.in_frame(Frame.TEME(), instant) != axes

ostk/physics/test/coordinate/test_frame.py

@@ -0,0 +1,107 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.time import Instant
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.frame.provider import iau
+from ostk.physics.coordinate.frame.provider import Dynamic
+
+
+@pytest.fixture
+def epoch() -> Instant:
+    return Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.ITRF()
+
+
+class TestFrame:
+    def test_is_defined(self, frame: Frame):
+        assert frame.is_defined() is True
+
+    def test_is_quasi_inertial(self, frame: Frame):
+        assert frame.is_quasi_inertial() is False
+
+    def test_has_parent(self, frame: Frame):
+        assert frame.has_parent() is True
+
+    def test_access_parent(self, frame: Frame):
+        assert frame.access_parent() is not None
+
+    def test_access_ancestor(self, frame: Frame):
+        assert frame.access_ancestor(ancestor_degree=1) is not None
+
+    def test_access_provider(self, frame: Frame):
+        assert frame.access_provider()
+
+    def test_get_name(self, frame: Frame):
+        assert frame.get_name() == "ITRF"
+
+    def test_get_origin_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_origin_in(frame=frame, instant=epoch) is not None
+
+    def test_get_velocity_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_velocity_in(frame=frame, instant=epoch) is not None
+
+    def test_get_axes_in(self, epoch: Instant, frame: Frame):
+        assert frame.get_axes_in(frame=frame, instant=epoch) is not None
+
+    def test_get_transform_to(self, epoch: Instant, frame: Frame):
+        assert frame.get_transform_to(frame=frame, instant=epoch) is not None
+
+    def test_undefined(self):
+        assert Frame.undefined() is not None
+
+    def test_GCRF(self):
+        assert Frame.GCRF() is not None
+
+    def test_J2000(self):
+        assert Frame.J2000(theory=iau.Theory.IAU_2006) is not None
+
+    def test_MOD(self, epoch: Instant):
+        assert Frame.MOD(epoch=epoch) is not None
+
+    def test_TOD(self, epoch: Instant):
+        assert Frame.TOD(epoch=epoch, theory=iau.Theory.IAU_2006) is not None
+
+    def test_TEME(self):
+        assert Frame.TEME() is not None
+
+    def test_TEME_of_epoch(self, epoch: Instant):
+        assert Frame.TEME_of_epoch(epoch=epoch) is not None
+
+    def test_CIRF(self):
+        assert Frame.CIRF() is not None
+
+    def test_TIRF(self):
+        assert Frame.TIRF() is not None
+
+    def test_ITRF(self):
+        assert Frame.ITRF() is not None
+
+    def test_with_name(self, frame: Frame):
+        assert Frame.with_name(name=frame.get_name()) is not None
+
+    def test_exists(self, frame: Frame):
+        assert Frame.exists(name=frame.get_name()) is True
+
+    def test_construct_destruct(self, frame: Frame):
+        custom_frame = Frame.construct(
+            name="Custom Frame",
+            is_quasi_inertial=True,
+            parent_frame=frame,
+            provider=Dynamic(lambda _: None),
+        )
+
+        assert custom_frame is not None
+
+        Frame.destruct(custom_frame.get_name())
+
+        assert Frame.exists(name="Custom Frame") is False