open-space-toolkit-astrodynamics 9.4.1__py38-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/trajectory/test_state_builder.py

@@ -0,0 +1,171 @@
+# 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.astrodynamics.trajectory import (
+    State,
+    StateBuilder,
+)
+from ostk.astrodynamics.trajectory.state import (
+    CoordinateBroker,
+    CoordinateSubset,
+)
+from ostk.astrodynamics.trajectory.state.coordinate_subset import (
+    CartesianPosition,
+    CartesianVelocity,
+)
+
+
+@pytest.fixture()
+def instant() -> Instant:
+    return Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def coordinate_subsets() -> list[CoordinateSubset]:
+    return [CartesianPosition.default(), CartesianVelocity.default()]
+
+
+@pytest.fixture
+def coordinates() -> list[float]:
+    return [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+
+
+@pytest.fixture
+def coordinate_broker(
+    coordinate_subsets: list[CoordinateSubset],
+) -> CoordinateBroker:
+    return CoordinateBroker(coordinate_subsets)
+
+
+@pytest.fixture
+def state(
+    instant: Instant,
+    coordinates: list[float],
+    frame: Frame,
+    coordinate_broker: CoordinateBroker,
+) -> State:
+    return State(instant, coordinates, frame, coordinate_broker)
+
+
+@pytest.fixture
+def state_builder(frame: Frame, coordinate_broker: CoordinateBroker) -> State:
+    return StateBuilder(frame, coordinate_broker)
+
+
+class TestStateBuilder:
+    def test_broker_constructor(
+        self,
+        frame: Frame,
+        coordinate_broker: CoordinateBroker,
+    ):
+        builder = StateBuilder(frame, coordinate_broker)
+        assert builder is not None
+        assert isinstance(builder, StateBuilder)
+        assert builder.is_defined()
+
+    def test_subsets_constructor(
+        self,
+        frame: Frame,
+        coordinate_subsets: list[CoordinateSubset],
+    ):
+        builder = StateBuilder(frame, coordinate_subsets)
+        assert builder is not None
+        assert isinstance(builder, StateBuilder)
+        assert builder.is_defined()
+
+    def test_state_constructor(
+        self,
+        state: State,
+    ):
+        builder = StateBuilder(state)
+        assert builder is not None
+        assert isinstance(builder, StateBuilder)
+        assert builder.is_defined()
+
+    def test_comparators(self, state_builder: StateBuilder):
+        assert (state_builder == state_builder) is True
+        assert (state_builder != state_builder) is False
+
+    def test_operators(
+        self,
+        state_builder: StateBuilder,
+    ):
+        added_builder: StateBuilder = state_builder + CoordinateSubset.mass()
+        assert isinstance(added_builder, StateBuilder)
+        assert state_builder != added_builder
+
+        subtracted_builder: StateBuilder = state_builder - CartesianPosition.default()
+        assert isinstance(subtracted_builder, StateBuilder)
+        assert state_builder != subtracted_builder
+
+    def test_build(
+        self,
+        instant: Instant,
+        state_builder: StateBuilder,
+    ):
+        coordinates = [1, 2, 3, 1, 2, 3]
+        state: State = state_builder.build(instant, coordinates)
+
+        assert state is not None
+        assert isinstance(state, State)
+        assert state.is_defined()
+        assert state.get_instant() == instant
+        assert (state.get_coordinates() == coordinates).all()
+        assert state.get_frame() == state_builder.get_frame()
+        assert state.get_coordinate_subsets() == state_builder.get_coordinate_subsets()
+
+    def test_reduce(
+        self,
+        state: State,
+    ):
+        builder = StateBuilder(state.get_frame(), [CartesianPosition.default()])
+        reduced_state: State = builder.reduce(state)
+
+        assert isinstance(reduced_state, State)
+        assert state != reduced_state
+
+    def test_expand(
+        self,
+        state: State,
+    ):
+        builder = StateBuilder(
+            state.get_frame(),
+            [
+                CartesianPosition.default(),
+                CartesianVelocity.default(),
+                CoordinateSubset.mass(),
+            ],
+        )
+        default_state: State = State(
+            state.get_instant(),
+            [100],
+            state.get_frame(),
+            CoordinateBroker([CoordinateSubset.mass()]),
+        )
+        expanded_state: State = builder.expand(state, default_state)
+
+        assert isinstance(expanded_state, State)
+        assert state != expanded_state
+        assert default_state != expanded_state
+
+    def test_getters(
+        self,
+        state_builder: StateBuilder,
+        frame: Frame,
+        coordinate_broker: CoordinateBroker,
+    ):
+        assert state_builder.get_frame() == frame
+        assert state_builder.get_coordinate_subsets() == coordinate_broker.get_subsets()

ostk/astrodynamics/utilities.py

@@ -0,0 +1,158 @@
+# Apache License 2.0
+
+from .OpenSpaceToolkitAstrodynamicsPy import *
+
+from ostk.physics import Environment
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+from ostk.physics.coordinate.spherical import LLA
+from ostk.physics.coordinate.spherical import AER
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.environment.object.celestial import Earth
+from ostk.physics.environment.gravitational import Earth as EarthGravitationalModel
+
+
+def lla_from_state(state: trajectory.State) -> tuple[float, float, float]:
+    """
+    Return latitude (degrees), longitude (degrees), altitude (meters) float list from a state.
+    """
+
+    lla: LLA = lla_from_position(state.get_position(), state.get_instant())
+
+    return (
+        float(lla.get_latitude().in_degrees()),
+        float(lla.get_longitude().in_degrees()),
+        float(lla.get_altitude().in_meters()),
+    )
+
+
+def lla_from_position(
+    position: Position,
+    instant: Instant | None = None,
+) -> LLA:
+    """
+    Return LLA from position and instant.
+    """
+
+    if position.access_frame() != Frame.ITRF():
+        if instant is None:
+            raise ValueError(
+                "Instant must be provided if position is not expressed in ECEF."
+            )
+        position: Position = position.in_frame(Frame.ITRF(), instant)
+
+    return LLA.cartesian(
+        position.get_coordinates(),
+        EarthGravitationalModel.EGM2008.equatorial_radius,
+        EarthGravitationalModel.EGM2008.flattening,
+    )
+
+
+def position_from_lla(lla: LLA) -> Position:
+    """
+    Return position from lla.
+    """
+
+    return Position.meters(
+        lla.to_cartesian(
+            EarthGravitationalModel.EGM2008.equatorial_radius,
+            EarthGravitationalModel.EGM2008.flattening,
+        ),
+        Frame.ITRF(),
+    )
+
+
+def compute_aer(
+    instant: Instant,
+    from_position: Position,
+    to_position: Position,
+    environment: Environment,
+) -> tuple[float, float, float]:
+    """
+    Return [azimuth (degrees), elevation (degrees), range (meters)] from Instant and Positions (observer, target).
+    """
+
+    from_lla: LLA = lla_from_position(from_position, instant)
+
+    earth: Earth = environment.access_celestial_object_with_name("Earth")
+    ned_frame: Frame = earth.get_frame_at(from_lla, Earth.FrameType.NED)
+
+    from_position_NED: Position = from_position.in_frame(ned_frame, instant)
+    to_position_NED: Position = to_position.in_frame(ned_frame, instant)
+
+    aer: AER = AER.from_position_to_position(from_position_NED, to_position_NED, True)
+
+    return (
+        float(aer.get_azimuth().in_degrees()),
+        float(aer.get_elevation().in_degrees()),
+        float(aer.get_range().in_meters()),
+    )
+
+
+def compute_time_lla_aer_state(
+    state: trajectory.State,
+    from_position: Position,
+    environment: Environment,
+) -> tuple[Instant, float, float, float, float, float, float]:
+    """
+    Return [instant, latitude, longitude, altitude, azimuth, elevation, range] from State and observer Position.
+    """
+
+    instant: Instant = state.get_instant()
+
+    lla: tuple[float, float, float] = lla_from_state(state)
+    aer: AER = compute_aer(
+        instant,
+        from_position,
+        state.get_position().in_frame(Frame.ITRF(), state.get_instant()),
+        environment,
+    )
+
+    return (instant, lla[0], lla[1], lla[2], aer[0], aer[1], aer[2])
+
+
+def compute_trajectory_geometry(
+    trajectory: Trajectory,
+    interval: Interval,
+) -> list[tuple[float, float, float]]:
+    """
+    Return [latitude (degrees), longitude (degrees), altitude (meters)] values along a Trajectory during Interval.
+    """
+
+    return [
+        lla_from_state(state)
+        for state in trajectory.get_states_at(
+            interval.generate_grid(Duration.minutes(1.0))
+        )
+    ]
+
+
+def convert_state(
+    state: trajectory.State,
+) -> tuple[str, float, float, float, float, float, float, float, float, float]:
+    """
+    Convert an input (Instant, State) into dataframe-ready values.
+    """
+
+    lla: LLA = LLA.cartesian(
+        state.get_position()
+        .in_frame(Frame.ITRF(), state.get_instant())
+        .get_coordinates(),
+        EarthGravitationalModel.EGM2008.equatorial_radius,
+        EarthGravitationalModel.EGM2008.flattening,
+    )
+
+    instant: Instant = state.get_instant()
+
+    return (
+        repr(instant),
+        float(instant.get_modified_julian_date(Scale.UTC)),
+        *state.get_position().get_coordinates().transpose().tolist(),
+        *state.get_velocity().get_coordinates().transpose().tolist(),
+        float(lla.get_latitude().in_degrees()),
+        float(lla.get_longitude().in_degrees()),
+        float(lla.get_altitude().in_meters()),
+    )

ostk/astrodynamics/viewer.py

@@ -0,0 +1,392 @@
+# Apache License 2.0
+
+from __future__ import annotations
+
+import functools
+import operator
+from dataclasses import dataclass
+
+import numpy as np
+
+try:
+    import cesiumpy
+
+except ImportError:
+    ...
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+
+from ostk.physics.unit import Length
+from ostk.physics.unit import Angle
+from ostk.physics.time import Instant, Interval, Duration
+from ostk.physics.coordinate import Position
+from ostk.physics.coordinate import Frame
+from ostk.physics.coordinate.spherical import LLA
+
+from ostk.astrodynamics.flight import Profile
+from ostk.astrodynamics.trajectory import State
+
+from .converters import coerce_to_datetime
+from .utilities import lla_from_position
+
+
+@dataclass
+class Sensor:
+    name: str
+    direction: tuple[float, float, float] | np.ndarray
+    color: str
+
+
+@dataclass
+class ConicSensor(Sensor):
+    half_angle: Angle
+    length: Length
+
+
+@dataclass
+class RectangularSensor(Sensor):
+    x_half_angle: Angle
+    y_half_angle: Angle
+    radius: Length
+
+
+class Viewer:
+    def __init__(
+        self,
+        interval: Interval,
+        cesium_token: str | None = None,
+        width: str = "1500px",
+        height: str = "800px",
+    ) -> None:
+        self._interval: Interval = interval
+
+        self._viewer: cesiumpy.Viewer = cesiumpy.Viewer(
+            width=width,
+            height=height,
+            clock_view_model=cesiumpy.ClockViewModel(
+                clock=cesiumpy.Clock(
+                    start_time=coerce_to_datetime(interval.get_start()),
+                    stop_time=coerce_to_datetime(interval.get_end()),
+                    clock_range=cesiumpy.Clock.Range.CLAMPED,
+                    can_animate=True,
+                    should_animate=False,
+                )
+            ),
+            fullscreen_button=False,
+            home_button=False,
+            info_box=False,
+            timeline=True,
+            navigation_help_button=False,
+            navigation_instructions_initially_visible=False,
+            scene_mode_picker=False,
+            selection_indicator=False,
+            scene3d_only=True,
+            zoom_to_entity=True,
+            track_entity=True,
+            default_access_token=cesium_token,
+        )
+
+    @property
+    def interval(self) -> Interval:
+        return self._interval
+
+    def add_profile(
+        self,
+        profile: Profile,
+        step: Duration,
+        show_orbital_track: bool = False,
+        cesium_asset_id: int | None = None,
+        sensors: list[Sensor] | None = None,
+        show_xyz_axes: bool = False,
+    ) -> None:
+        """
+        Add Profile to Viewer.
+
+        Args:
+            profile (Profile): Profile to be added.
+            step (Duration): Step between two consecutive states.
+            show_orbital_track (bool, optional): Whether to show the orbital track. Defaults to False.
+            cesium_asset_id (int, optional): The Cesium asset ID. Defaults to None.
+            sensors (list[Sensor], optional): Sensors to be added to the asset. Defaults to None.
+            show_xyz_axes (bool, optional): Whether to show the XYZ axes. Defaults to False.
+        """
+
+        instants: list[Instant] = self._interval.generate_grid(step)
+        states: list[State] = profile.get_states_at(instants)
+        llas: list[LLA] = _generate_llas(states)
+
+        sensors = sensors or []
+        if show_xyz_axes:
+            sensors.extend(
+                [
+                    ConicSensor(
+                        name="x_axis",
+                        direction=(+1.0, 0.0, 0.0),
+                        half_angle=Angle.degrees(1.0),
+                        length=Length.meters(2.0),
+                        color="red",
+                    ),
+                    ConicSensor(
+                        name="y_axis",
+                        direction=(0.0, +1.0, 0.0),
+                        half_angle=Angle.degrees(1.0),
+                        length=Length.meters(2.0),
+                        color="blue",
+                    ),
+                    ConicSensor(
+                        name="z_axis",
+                        direction=(0.0, 0.0, +1.0),
+                        half_angle=Angle.degrees(1.0),
+                        length=Length.meters(2.0),
+                        color="green",
+                    ),
+                ]
+            )
+
+        satellite = cesiumpy.Satellite(
+            position=_generate_sampled_position(instants, llas),
+            orientation=_generate_sampled_orientation(states),
+            availability=cesiumpy.TimeIntervalCollection(
+                intervals=[
+                    cesiumpy.TimeInterval(
+                        start=coerce_to_datetime(self._interval.get_start()),
+                        stop=coerce_to_datetime(self._interval.get_end()),
+                    ),
+                ],
+            ),
+            model=cesiumpy.IonResource(
+                asset_id=cesium_asset_id or 0
+            ),  # TBM: Should be made more robust
+            sensors=[_cesium_from_ostk_sensor(sensor) for sensor in sensors or []],
+        )
+
+        satellite.render(self._viewer)
+
+        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 _generate_llas(states)
+                            ],
+                            [],
+                        )
+                    ),
+                    width=1,
+                )
+            )
+
+    def add_target(
+        self,
+        position: Position,
+        size: int | None = None,
+        color: str | None = None,
+    ) -> None:
+        """
+        Add target to Viewer.
+
+        Args:
+            position (Position): Target position.
+            size (int, optional): Target size. Defaults to None.
+            color (str, optional): Target color. Defaults to None.
+        """
+
+        self._viewer.entities.add(
+            cesiumpy.Point(
+                position=_cesium_from_ostk_position(position),
+                pixel_size=size or 10,
+                color=color or cesiumpy.color.YELLOW,
+            )
+        )
+
+    def add_line(
+        self,
+        positions: list[Position],
+        size: int | None = None,
+        color: str | None = None,
+    ) -> None:
+        """
+        Add line to Viewer.
+
+        Args:
+            positions (list[Position]): Line positions.
+            size (int, optional): Line size. Defaults to None.
+            color (str, optional): Line color. Defaults to None.
+        """
+
+        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()),
+                                10.0,
+                            ]
+                            for lla in map(lla_from_position, positions)
+                        ],
+                        [],
+                    )
+                ),
+                width=size or 1,
+                material=color or cesiumpy.color.YELLOW,
+            )
+        )
+
+    def render(self) -> str:
+        """
+        Render Viewer as HTML string.
+
+        Returns:
+            str: Rendered HTML string.
+        """
+
+        return self._viewer.to_html()
+
+    def _repr_html_(self) -> str:
+        return self.render()
+
+
+def _generate_llas(states: list[State]) -> list[LLA]:
+    return [
+        lla_from_position(state.get_position(), state.get_instant()) for state in states
+    ]
+
+
+def _generate_sampled_position(
+    instants: list[Instant],
+    llas: list[LLA],
+) -> cesiumpy.SampledPositionProperty:
+    """
+    Generate a sampled position property from a list of OSTk LLAs.
+
+    Args:
+        states (list[LLA]): A list of OSTk LLAs.
+
+    Returns:
+        cesiumpy.SampledPositionProperty: Sampled position property.
+    """
+
+    return cesiumpy.SampledPositionProperty(
+        samples=[
+            (
+                coerce_to_datetime(instant),
+                _cesium_from_ostk_lla(lla),
+                None,
+            )
+            for instant, lla in zip(instants, llas)
+        ],
+    )
+
+
+def _generate_sampled_orientation(states: list[State]) -> cesiumpy.SampledProperty:
+    """
+    Generate a sampled orientation property from a list of OSTk States.
+
+    Args:
+        states (list[State]): A list of OSTk States.
+
+    Returns:
+        cesiumpy.SampledProperty: Sampled orientation property.
+    """
+
+    return cesiumpy.SampledProperty(
+        type=cesiumpy.Quaternion,
+        samples=[
+            (
+                coerce_to_datetime(state.get_instant()),
+                _cesium_from_ostk_quaternion(state.in_frame(Frame.ITRF()).get_attitude()),
+                None,
+            )
+            for state in states
+        ],
+    )
+
+
+def _cesium_from_ostk_position(
+    position: Position,
+    instant: Instant | None = None,
+) -> cesiumpy.Cartesian3:
+    """
+    Convert OSTk Position into Cesium Cartesian3.
+
+    Args:
+        position (Position): Position to convert.
+        instant (Instant, optional): Instant at which the position is valid (required if position is not expressed in ECEF).
+
+    Returns:
+        cesiumpy.Cartesian3: Converted position.
+    """
+
+    return _cesium_from_ostk_lla(lla_from_position(position, instant))
+
+
+def _cesium_from_ostk_lla(
+    lla: LLA,
+) -> cesiumpy.Cartesian3:
+    """
+    Convert OSTk LLA into Cesium Cartesian3.
+
+    Args:
+        lla (LLA): LLA to convert.
+
+    Returns:
+        cesiumpy.Cartesian3: Converted LLA.
+    """
+
+    return cesiumpy.Cartesian3.fromDegrees(
+        float(lla.get_longitude().in_degrees()),
+        float(lla.get_latitude().in_degrees()),
+        float(lla.get_altitude().in_meters()),
+    )
+
+
+def _cesium_from_ostk_quaternion(quaternion: Quaternion) -> cesiumpy.Quaternion:
+    """
+    Convert OSTk Quaternion into Cesium Quaternion.
+
+    Args:
+        quaternion (Quaternion): Quaternion to convert.
+
+    Returns:
+        cesiumpy.Quaternion: Converted quaternion.
+    """
+
+    return cesiumpy.Quaternion(
+        float(quaternion.x()),
+        float(quaternion.y()),
+        float(quaternion.z()),
+        float(quaternion.s()),
+    )
+
+
+def _cesium_from_ostk_sensor(sensor: Sensor) -> cesiumpy.Sensor:
+    if isinstance(sensor, ConicSensor):
+        return cesiumpy.ConicSensor(
+            name=sensor.name,
+            direction=cesiumpy.Cartesian3(*sensor.direction),
+            half_angle=float(sensor.half_angle.in_radians()),
+            length=float(sensor.length.in_meters()),
+            material=sensor.color or cesiumpy.color.RED,
+        )
+
+    elif isinstance(sensor, RectangularSensor):
+        return cesiumpy.RectangularSensor(
+            name=sensor.name,
+            direction=cesiumpy.Cartesian3(*sensor.direction),
+            x_half_angle=float(sensor.x_half_angle.in_radians()),
+            y_half_angle=float(sensor.y_half_angle.in_radians()),
+            radius=float(sensor.radius.in_meters()),
+            material=sensor.color or cesiumpy.color.ORANGE,
+        )
+
+    raise NotImplementedError("{sensor.__name__} is not supported yet.")