open-space-toolkit-astrodynamics 12.0.1__py39-none-manylinux2014_x86_64.whl

ostk/astrodynamics/utilities.py

@@ -0,0 +1,245 @@
+# Apache License 2.0
+
+from datetime import datetime
+from datetime import timezone
+
+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.unit import Length
+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) -> LLA:
+    """
+    Return latitude (degrees), longitude (degrees), altitude (meters) float list from a state.
+
+    Args:
+        state (trajectory.State): A state.
+
+    Returns:
+        LLA: The LLA.
+    """
+
+    return lla_from_position(state.get_position(), state.get_instant())
+
+
+def lla_from_position(
+    position: Position,
+    instant: Instant | None = None,
+) -> LLA:
+    """
+    Return LLA from position and instant.
+
+    Args:
+        position (Position): A position.
+        instant (Instant): An instant.
+
+    Returns:
+        LLA: The LLA.
+    """
+
+    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.
+
+    Args:
+        lla (LLA): A LLA.
+
+    Returns:
+        Position: The position.
+    """
+
+    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,
+) -> AER:
+    """
+    Return AER from Instant and Positions (observer, target).
+
+    Args:
+        instant (Instant): An instant.
+        from_position (Position): An observer position.
+        to_position (Position): A target position.
+        environment (Environment): An environment.
+
+    Returns:
+        AER: The AER.
+    """
+
+    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)
+
+    return AER.from_position_to_position(from_position_NED, to_position_NED, True)
+
+
+def compute_time_lla_aer_coordinates(
+    state: trajectory.State,
+    from_position: Position,
+    environment: Environment,
+) -> tuple[datetime, float, float, float, float, float, float]:
+    """
+    Return [datetime, latitude, longitude, altitude, azimuth, elevation, range] from State and observer Position.
+
+    Args:
+        state (trajectory.State): A state.
+        from_position (Position): An observer position.
+        environment (Environment): An environment.
+
+    Returns:
+        tuple[datetime, float, float, float, float, float, float]: The [datetime, latitude, longitude, altitude, azimuth, elevation, range].
+    """
+
+    instant: Instant = state.get_instant()
+
+    lla: LLA = lla_from_state(state)
+
+    aer: AER = compute_aer(
+        instant,
+        from_position,
+        state.get_position().in_frame(Frame.ITRF(), state.get_instant()),
+        environment,
+    )
+
+    return (
+        instant.get_date_time(Scale.UTC).replace(tzinfo=timezone.utc),
+        float(lla.get_latitude().in_degrees()),
+        float(lla.get_longitude().in_degrees()),
+        float(lla.get_altitude().in_meters()),
+        float(aer.get_azimuth().in_degrees()),
+        float(aer.get_elevation().in_degrees()),
+        float(aer.get_range().in_meters()),
+    )
+
+
+def compute_trajectory_geometry(
+    trajectory: Trajectory,
+    interval: Interval,
+    step: Duration = Duration.minutes(1.0),
+) -> list[LLA]:
+    """
+    Return list of LLA along a Trajectory during the Interval at the provided step.
+
+    Args:
+        trajectory (Trajectory): A trajectory.
+        interval (Interval): An interval.
+        step (Duration): A step. Defaults to 1.0 minutes.
+
+    Returns:
+        list[LLA]: The list of LLA.
+    """
+
+    return [
+        lla_from_state(state)
+        for state in trajectory.get_states_at(interval.generate_grid(step))
+    ]
+
+
+def compute_ground_track(
+    trajectory: Trajectory,
+    interval: Interval,
+    step: Duration = Duration.minutes(1.0),
+) -> list[LLA]:
+    """
+    Return list of LLA along a Trajectory ground track (altitude set to 10.0 meters) during the Interval at the provided step.
+
+    Args:
+        trajectory (Trajectory): A trajectory.
+        interval (Interval): An interval.
+        step (Duration): A step. Defaults to 1.0 minutes.
+
+    Returns:
+        list[LLA]: The list of LLA.
+    """
+
+    ground_llas: list[LLA] = []
+    for state in trajectory.get_states_at(interval.generate_grid(step)):
+        lla: LLA = lla_from_state(state)
+
+        ground_lla: LLA = LLA(
+            lla.get_latitude(),
+            lla.get_longitude(),
+            Length.meters(10.0),
+        )
+
+        ground_llas.append(ground_lla)
+
+    return ground_llas
+
+
+def convert_state(
+    state: trajectory.State,
+) -> tuple[str, float, float, float, float, float, float, float, float, float]:
+    """
+    Convert a State into dataframe-ready values.
+    - Instant (str)
+    - Modified Julian Date (float)
+    - Position X [meters] (float)
+    - Position Y [meters] (float)
+    - Position Z [meters] (float)
+    - Velocity X [meters/second] (float)
+    - Velocity Y [meters/second] (float)
+    - Velocity Z [meters/second] (float)
+    - Latitude [degrees] (float)
+    - Longitude [degrees] (float)
+    - Altitude [meters] (float)
+
+    Args:
+        state (trajectory.State): A state.
+
+    Returns:
+        tuple[str, float, float, float, float, float, float, float, float, float]: The dataframe-ready values.
+    """
+
+    lla: LLA = lla_from_state(state)
+
+    instant: Instant = state.get_instant()
+
+    return (
+        str(instant.to_string()),
+        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.")