open-space-toolkit-astrodynamics 15.0.0__py39-none-manylinux2014_aarch64.whl → 15.2.0__py39-none-manylinux2014_aarch64.whl

ostk/astrodynamics/test/solvers/test_least_squares_solver.py

@@ -0,0 +1,334 @@
+# Apache License 2.0
+
+from typing import Callable
+
+import pytest
+import numpy as np
+
+from ostk.core.type import Real
+from ostk.core.type import String
+
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.coordinate import Frame
+
+from ostk.astrodynamics.solver import LeastSquaresSolver
+from ostk.astrodynamics.solver import FiniteDifferenceSolver
+from ostk.astrodynamics.trajectory import State
+from ostk.astrodynamics.trajectory.state import CoordinateSubset
+
+
+@pytest.fixture
+def rms_error() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def x_hat() -> np.ndarray:
+    return np.array([1.0, 0.0])
+
+
+@pytest.fixture
+def step(
+    rms_error: float,
+    x_hat: np.ndarray,
+) -> LeastSquaresSolver.Step:
+    return LeastSquaresSolver.Step(
+        rms_error=rms_error,
+        x_hat=x_hat,
+    )
+
+
+@pytest.fixture
+def termination_criteria() -> str:
+    return "RMS Update Threshold"
+
+
+@pytest.fixture
+def estimated_state(coordinate_subsets: list[CoordinateSubset]) -> State:
+    return State(
+        Instant.J2000(),
+        [1.0, 0.0],
+        Frame.GCRF(),
+        coordinate_subsets,
+    )
+
+
+@pytest.fixture
+def estimated_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def estimated_frisbee_covariance() -> np.ndarray:
+    return np.array([[1.0, 0.0], [0.0, 1.0]])
+
+
+@pytest.fixture
+def observation_count() -> int:
+    return 10
+
+
+@pytest.fixture
+def computed_observations(
+    observations: list[State],
+) -> list[State]:
+    return observations
+
+
+@pytest.fixture
+def steps(step: LeastSquaresSolver.Step) -> list[LeastSquaresSolver.Step]:
+    return [step]
+
+
+@pytest.fixture
+def analysis(
+    termination_criteria: str,
+    estimated_state: State,
+    estimated_covariance: np.ndarray,
+    estimated_frisbee_covariance: np.ndarray,
+    computed_observations: list[State],
+    steps: list[LeastSquaresSolver.Step],
+) -> LeastSquaresSolver.Analysis:
+    return LeastSquaresSolver.Analysis(
+        termination_criteria=termination_criteria,
+        estimated_state=estimated_state,
+        estimated_covariance=estimated_covariance,
+        estimated_frisbee_covariance=estimated_frisbee_covariance,
+        computed_observations=computed_observations,
+        steps=steps,
+    )
+
+
+@pytest.fixture
+def max_iteration_count() -> int:
+    return 20
+
+
+@pytest.fixture
+def rms_update_threshold() -> float:
+    return 1.0
+
+
+@pytest.fixture
+def finite_difference_solver() -> FiniteDifferenceSolver:
+    return FiniteDifferenceSolver.default()
+
+
+@pytest.fixture
+def least_squares_solver(
+    max_iteration_count: int,
+    rms_update_threshold: float,
+    finite_difference_solver: FiniteDifferenceSolver,
+) -> LeastSquaresSolver:
+    return LeastSquaresSolver(
+        maximum_iteration_count=max_iteration_count,
+        rms_update_threshold=rms_update_threshold,
+        finite_difference_solver=finite_difference_solver,
+    )
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CoordinateSubset("Position", 1), CoordinateSubset("Velocity", 1)]
+
+
+@pytest.fixture
+def initial_guess_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def observation_sigmas(
+    coordinate_subsets: list[CoordinateSubset],
+) -> dict[CoordinateSubset, list[float]]:
+    return {
+        coordinate_subsets[0]: [1e-1],
+        coordinate_subsets[1]: [1e-2],
+    }
+
+
+@pytest.fixture
+def initial_instant() -> Instant:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def initial_guess(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+) -> State:
+    return State(initial_instant, [1.0, 0.0], frame, coordinate_subsets)
+
+
+@pytest.fixture
+def observations(
+    initial_instant: Instant,
+    coordinate_subsets: list[CoordinateSubset],
+    frame: Frame,
+    observation_count: int,
+) -> list[State]:
+    return [
+        State(
+            initial_instant + Duration.seconds(float(x)),
+            [np.cos(x), -np.sin(x)],
+            frame,
+            coordinate_subsets,
+        )
+        for x in range(0, observation_count)
+    ]
+
+
+@pytest.fixture
+def state_generator() -> Callable:
+    def state_fn(state, instants) -> list[State]:
+        x0: float = state.get_coordinates()[0]
+        v0: float = state.get_coordinates()[1]
+        omega: float = 1.0
+
+        states: list[State] = []
+
+        for instant in instants:
+            t: float = float((instant - state.get_instant()).in_seconds())
+            x: float = x0 * np.cos(omega * t) + v0 / omega * np.sin(omega * t)
+            v: float = -x0 * omega * np.sin(omega * t) + v0 * np.cos(omega * t)
+
+            states.append(
+                State(instant, [x, v], Frame.GCRF(), state.get_coordinate_subsets())
+            )
+
+        return states
+
+    return state_fn
+
+
+class TestLeastSquaresSolverStep:
+
+    def test_constructor(
+        self,
+        step: LeastSquaresSolver.Step,
+    ):
+        assert isinstance(step, LeastSquaresSolver.Step)
+
+    def test_getters(
+        self,
+        step: LeastSquaresSolver.Step,
+        rms_error: float,
+        x_hat: np.ndarray,
+    ):
+        assert step.rms_error == rms_error
+        assert np.array_equal(step.x_hat, x_hat)
+
+
+class TestLeastSquaresSolverAnalysis:
+
+    def test_constructor(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis, LeastSquaresSolver.Analysis)
+
+    def test_getters(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+    ):
+        assert isinstance(analysis.rms_error, Real)
+        assert isinstance(analysis.observation_count, int)
+        assert isinstance(analysis.iteration_count, int)
+        assert isinstance(analysis.termination_criteria, String)
+        assert isinstance(analysis.estimated_state, State)
+        assert isinstance(analysis.estimated_covariance, np.ndarray)
+        assert isinstance(analysis.estimated_frisbee_covariance, np.ndarray)
+        assert isinstance(analysis.computed_observations, list)
+        assert isinstance(analysis.steps, list)
+
+    def test_compute_residual_states(
+        self,
+        analysis: LeastSquaresSolver.Analysis,
+        observations: list[State],
+    ):
+        residuals: list[State] = analysis.compute_residual_states(
+            observations=observations
+        )
+
+        assert isinstance(residuals, list)
+        assert len(residuals) == len(observations)
+
+
+class TestLeastSquaresSolver:
+    def test_constructor(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+    ):
+        assert isinstance(least_squares_solver, LeastSquaresSolver)
+
+    def test_getters(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        max_iteration_count: int,
+        rms_update_threshold: float,
+    ):
+        assert least_squares_solver.get_max_iteration_count() == max_iteration_count
+        assert least_squares_solver.get_rms_update_threshold() == rms_update_threshold
+        assert least_squares_solver.get_finite_difference_solver() is not None
+
+    def test_solve_defaults(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+        )
+
+        assert analysis is not None
+
+    def test_solve(
+        self,
+        least_squares_solver: LeastSquaresSolver,
+        initial_guess: State,
+        observations: list[State],
+        state_generator: callable,
+        initial_guess_sigmas: dict[CoordinateSubset, list[float]],
+        observation_sigmas: dict[CoordinateSubset, list[float]],
+    ):
+        analysis = least_squares_solver.solve(
+            initial_guess=initial_guess,
+            observations=observations,
+            state_generator=state_generator,
+            initial_guess_sigmas=initial_guess_sigmas,
+            observation_sigmas=observation_sigmas,
+        )
+
+        assert analysis is not None
+
+    def test_calculate_empirical_covariance(
+        self,
+        observations: list[State],
+    ):
+        covariance: np.ndarray = LeastSquaresSolver.calculate_empirical_covariance(
+            observations
+        )
+
+        assert isinstance(covariance, np.ndarray)
+        assert covariance.shape == (2, 2)
+
+    def test_default(self):
+        default_solver: LeastSquaresSolver = LeastSquaresSolver.default()
+
+        assert isinstance(default_solver, LeastSquaresSolver)

ostk/astrodynamics/test/test_viewer.py

@@ -36,6 +36,24 @@ def orbit(environment: Environment) -> Orbit:
     )
 
 
+@pytest.fixture
+def orbits(environment: Environment) -> list[Orbit]:
+    return [
+        Orbit.sun_synchronous(
+            epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            altitude=Length.kilometers(500.0),
+            local_time_at_descending_node=Time(14, 0, 0),
+            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        ),
+        Orbit.sun_synchronous(
+            epoch=Instant.date_time(DateTime(2020, 1, 1, 0, 0, 0), Scale.UTC),
+            altitude=Length.kilometers(500.0),
+            local_time_at_descending_node=Time(12, 0, 0),
+            celestial_object=environment.access_celestial_object_with_name("Earth"),
+        ),
+    ]
+
+
 @pytest.fixture
 def profile(orbit: Orbit) -> Profile:
     return Profile.local_orbital_frame_pointing(
@@ -56,6 +74,8 @@ def interval() -> Interval:
 def viewer(interval: Interval) -> Viewer:
     return Viewer(
         interval=interval,
+        zoom_to_entity=False,
+        track_entity=False,
     )
 
 
@@ -74,6 +94,50 @@ class TestViewer:
         assert "var widget = new Cesium.Viewer" in rendered_html
         assert rendered_html.endswith("</script>")
 
+    def test_add_orbit_success(
+        self,
+        viewer: Viewer,
+        orbit: Orbit,
+    ):
+        viewer.add_orbit(
+            orbit=orbit,
+            step=Duration.seconds(5.0),
+            show_orbital_track=True,
+        )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert "new Cesium.SampledProperty(Cesium.Cartesian3)" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert "billboard: {image:" in rendered_html
+        assert rendered_html.endswith("</script>")
+
+    def test_add_orbit_multiple_success(
+        self,
+        viewer: Viewer,
+        orbits: list[Orbit],
+    ):
+        for i, orbit in enumerate(orbits):
+            viewer.add_orbit(
+                orbit=orbit,
+                step=Duration.seconds(5.0),
+                show_orbital_track=True,
+                name=f"Satellite {i}",
+            )
+
+        rendered_html: str = viewer.render()
+
+        assert rendered_html.startswith('<meta charset="utf-8">')
+        assert "var widget = new Cesium.Viewer" in rendered_html
+        assert "new Cesium.SampledProperty(Cesium.Cartesian3)" in rendered_html
+        assert " widget.entities.add({position: widget" in rendered_html
+        assert "widget.entities.add({polyline:" in rendered_html
+        assert "billboard: {image:" in rendered_html
+        assert rendered_html.endswith("</script>")
+
     def test_add_profile_success(
         self,
         viewer: Viewer,

ostk/astrodynamics/viewer.py

@@ -24,11 +24,16 @@ from ostk.physics.coordinate import Frame
 from ostk.physics.coordinate.spherical import LLA
 
 from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.trajectory import Orbit
 from ostk.astrodynamics.trajectory import State
 
 from .converters import coerce_to_datetime
 from .utilities import lla_from_position
 
+DEFAULT_SATELLITE_IMAGE: str = (
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAADJSURBVDhPnZHRDcMgEEMZjVEYpaNklIzSEfLfD4qNnXAJSFWfhO7w2Zc0Tf9QG2rXrEzSUeZLOGm47WoH95x3Hl3jEgilvDgsOQUTqsNl68ezEwn1vae6lceSEEYvvWNT/Rxc4CXQNGadho1NXoJ+9iaqc2xi2xbt23PJCDIB6TQjOC6Bho/sDy3fBQT8PrVhibU7yBFcEPaRxOoeTwbwByCOYf9VGp1BYI1BA+EeHhmfzKbBoJEQwn1yzUZtyspIQUha85MpkNIXB7GizqDEECsAAAAASUVORK5CYII="
+)
+
 
 @dataclass
 class Sensor:
@@ -57,6 +62,8 @@ class Viewer:
         cesium_token: str | None = None,
         width: str = "1500px",
         height: str = "800px",
+        zoom_to_entity: bool = True,
+        track_entity: bool = True,
     ) -> None:
         self._interval: Interval = interval
 
@@ -81,8 +88,8 @@ class Viewer:
             scene_mode_picker=False,
             selection_indicator=False,
             scene3d_only=True,
-            zoom_to_entity=True,
-            track_entity=True,
+            zoom_to_entity=zoom_to_entity,
+            track_entity=track_entity,
             default_access_token=cesium_token,
         )
 
@@ -90,6 +97,73 @@ class Viewer:
     def interval(self) -> Interval:
         return self._interval
 
+    def add_orbit(
+        self,
+        orbit: Orbit,
+        step: Duration,
+        name: str = "Satellite",
+        show_orbital_track: bool = False,
+        color: str | None = None,
+        image: str | None = None,
+    ) -> None:
+        """
+        Add Orbit to Viewer.
+
+        Args:
+            orbit (Orbit): Orbit to be added.
+            step (Duration): Step between two consecutive states.
+            name (str, optional): Name of the orbit. Defaults to "Satellite".
+            show_orbital_track (bool, optional): Whether to show the orbital track. Defaults to False.
+            color (str, optional): Color of the orbit. Defaults to None.
+            image (str, optional): Logo to be added. Defaults to None.
+        """
+        instants: list[Instant] = self._interval.generate_grid(step)
+        states: list[State] = orbit.get_states_at(instants)
+        llas: list[LLA] = _generate_llas(states)
+
+        cesium_positions: cesiumpy.SampledPositionProperty = (
+            _generate_sampled_position_from_states(states)
+        )
+
+        self._viewer.entities.add(
+            cesiumpy.Billboard(
+                name=name,
+                position=cesium_positions,
+                image=image or DEFAULT_SATELLITE_IMAGE,
+            )
+        )
+
+        self._viewer.entities.add(
+            cesiumpy.Label(
+                position=cesium_positions,
+                text=name,
+                scale=1.0,
+                fill_color=color or cesiumpy.color.WHITE,
+                pixel_offset=[0.0, 20.0],
+            )
+        )
+
+        if show_orbital_track:
+            self._viewer.entities.add(
+                cesiumpy.Polyline(
+                    positions=cesiumpy.entities.cartesian.Cartesian3Array(
+                        functools.reduce(
+                            operator.iconcat,
+                            [
+                                [
+                                    float(lla.get_longitude().in_degrees()),
+                                    float(lla.get_latitude().in_degrees()),
+                                    float(lla.get_altitude().in_meters()),
+                                ]
+                                for lla in llas
+                            ],
+                            [],
+                        )
+                    ),
+                    width=1,
+                )
+            )
+
     def add_profile(
         self,
         profile: Profile,
@@ -144,7 +218,7 @@ class Viewer:
             )
 
         satellite = cesiumpy.Satellite(
-            position=_generate_sampled_position(instants, llas),
+            position=_generate_sampled_position_from_llas(instants, llas),
             orientation=_generate_sampled_orientation(states),
             availability=cesiumpy.TimeIntervalCollection(
                 intervals=[
@@ -294,7 +368,7 @@ def _generate_llas(states: list[State]) -> list[LLA]:
     ]
 
 
-def _generate_sampled_position(
+def _generate_sampled_position_from_llas(
     instants: list[Instant],
     llas: list[LLA],
 ) -> cesiumpy.SampledPositionProperty:
@@ -344,6 +418,33 @@ def _generate_sampled_orientation(states: list[State]) -> cesiumpy.SampledProper
     )
 
 
+def _generate_sampled_position_from_states(
+    states: list[State],
+) -> cesiumpy.SampledPositionProperty:
+    """
+    Generate a sampled position property from a list of OSTk States.
+
+    Args:
+        states (list[State]): A list of OSTk States.
+
+    Returns:
+        cesiumpy.SampledPositionProperty: Sampled position property.
+    """
+
+    return cesiumpy.SampledPositionProperty(
+        samples=[
+            (
+                coerce_to_datetime(state.get_instant()),
+                _cesium_from_ostk_position(
+                    position=state.in_frame(Frame.ITRF()).get_position()
+                ),
+                None,
+            )
+            for state in states
+        ],
+    )
+
+
 def _cesium_from_ostk_position(
     position: Position,
     instant: Instant | None = None,