ootk 3.0.0 → 4.0.0-1

package/src/maneuver/Waypoint.ts

@@ -0,0 +1,267 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import {
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  MetersPerSecond,
+  RIC,
+  SecondsPerMeterPerSecond,
+  Vector3D,
+} from 'ootk-core';
+import { Thrust } from '../force/Thrust';
+import { StateInterpolator } from '../interpolator/StateInterpolator';
+import { ForceModel } from './../force/ForceModel';
+import { DownhillSimplex } from './../optimize/DownhillSimplex';
+import { LambertIOD } from './../orbit_determination/LambertIOD';
+import { RungeKutta89Propagator } from './../propagator/RungeKutta89Propagator';
+
+// / Relative waypoint targeting.
+export class Waypoint {
+  epoch: EpochUTC;
+  relativePosition: Vector3D<Kilometers>;
+
+  // / Create a new [Waypoint] object.
+  constructor(epoch: EpochUTC, relativePosition: Vector3D<Kilometers>) {
+    this.epoch = epoch;
+    this.relativePosition = relativePosition;
+  }
+
+  /**
+   * Return the perturbed error in a [maneuver] when compared against the
+   * target [waypoint] given an initial [state], [forceModel],
+   * [target] interpolator, and speculative relative maneuver
+   * [components] _(m/s)_.
+   * @param waypoint The waypoint to target.
+   * @param maneuver The maneuver to perturb.
+   * @param state The initial state of the interceptor.
+   * @param forceModel The force model to use for propagation.
+   * @param target The target interpolator.
+   * @param components The speculative maneuver components.
+   * @returns The perturbed error in the maneuver.
+   */
+  static _error(
+    waypoint: Waypoint,
+    maneuver: Thrust,
+    state: J2000,
+    forceModel: ForceModel,
+    target: StateInterpolator,
+    components: Float64Array, // MetersPerSecond
+  ): number {
+    const testManeuver = new Thrust(
+      maneuver.center,
+      components[0] as MetersPerSecond,
+      components[1] as MetersPerSecond,
+      components[2] as MetersPerSecond,
+      maneuver.durationRate,
+    );
+    const propagator = new RungeKutta89Propagator(state, forceModel);
+    const maneuverSteps = propagator.maneuver(testManeuver);
+    const postManeuver = maneuverSteps[maneuverSteps.length - 1];
+    const interceptor = new RungeKutta89Propagator(postManeuver, forceModel).propagate(waypoint.epoch);
+    const targetState = target.interpolate(waypoint.epoch);
+
+    if (targetState === null) {
+      throw new Error('Error calculation failed; epoch is outside the target interpolator ephemeris window.');
+    }
+    const expected = waypoint.relativePosition;
+    const actual = RIC.fromJ2000(interceptor, targetState);
+
+    return actual.position.distance(expected);
+  }
+
+  /**
+   * Generate a score function for refining perturbed [waypoint] maneuvers.
+   *
+   * The score function takes an array of speculative radial, intrack, and
+   * crosstrack components _(m/s)_ and returns the propagated error from the
+   * desired waypoint target.
+   * @param waypoint The waypoint to target.
+   * @param maneuver The maneuver to perturb.
+   * @param state The initial state of the interceptor.
+   * @param forceModel The force model to use for propagation.
+   * @param target The target interpolator.
+   * @returns A score function for refining maneuvers.
+   */
+  static _refineManeuverScore(
+    waypoint: Waypoint,
+    maneuver: Thrust,
+    state: J2000,
+    forceModel: ForceModel,
+    target: StateInterpolator,
+  ): (components: Float64Array) => number {
+    return (components: Float64Array) => Waypoint._error(waypoint, maneuver, state, forceModel, target, components);
+  }
+
+  /**
+   * Convert an array of [waypoints] into a maneuver sequence given an
+   * [interceptor] state, [pivot] epoch for the first burn to arrive at the
+   * first waypoint, and [target] ephemeris interpolator.
+   *
+   * Optional arguments are as follows:
+   *  - `preManeuvers`: maneuvers to execute before the pivot burn
+   * - `postManeuvers`: maneuvers to execute after the last pivot burn
+   * - `durationRate`: thruster duration rate _(s/m/s)_
+   * - `forceModel`: interceptor force model, defaults to two-body
+   * - `refine`: refine maneuvers to account for perturbations if `true`
+   * - `maxIter`: maximum refinement iterations per maneuver
+   * - `printIter`: print debug information on each refinement iteration
+   * @param interceptor The interceptor state.
+   * @param pivot The epoch of the first burn.
+   * @param waypoints The waypoints to target.
+   * @param target The target interpolator.
+   * @param preManeuvers The maneuvers to execute before the pivot burn.
+   * @param postManeuvers The maneuvers to execute after the last pivot burn.
+   * @param root0 The optional arguments.
+   * @param root0.durationRate The thruster duration rate.
+   * @param root0.forceModel The interceptor force model.
+   * @param root0.refine Whether to refine maneuvers to account for perturbations.
+   * @param root0.maxIter The maximum refinement iterations per maneuver.
+   * @param root0.printIter Whether to print debug information on each refinement iteration.
+   * @returns An array of maneuvers.
+   */
+  static toManeuvers(
+    interceptor: J2000,
+    pivot: EpochUTC,
+    waypoints: Waypoint[],
+    target: StateInterpolator,
+    preManeuvers: Thrust[] | null,
+    postManeuvers: Thrust[] | null,
+    {
+      durationRate = 0.0,
+      forceModel,
+      refine = false,
+      maxIter = 500,
+      printIter = false,
+    }: {
+      durationRate?: number;
+      forceModel?: ForceModel;
+      refine?: boolean;
+      maxIter?: number;
+      printIter?: boolean;
+    } = {},
+  ): Thrust[] {
+    const preMnv = preManeuvers ?? [];
+    const postMnv = postManeuvers ?? [];
+    let state = interceptor;
+
+    if (preMnv.length > 0) {
+      for (const maneuver of preMnv) {
+        const mvrStep = new RungeKutta89Propagator(state, forceModel).maneuver(maneuver);
+
+        state = mvrStep[mvrStep.length - 1];
+      }
+    }
+    state = new RungeKutta89Propagator(state, forceModel).propagate(pivot);
+    const pivotState = state;
+    let waypointManeuvers: Thrust[] = [];
+
+    for (const wp of waypoints) {
+      const targetWp = new RIC(wp.relativePosition, Vector3D.origin as Vector3D<KilometersPerSecond>);
+      const targetState = target.interpolate(wp.epoch);
+
+      if (targetState === null) {
+        throw new Error('Waypoint outside target interpolator window.');
+      }
+      const wpState = targetWp.toJ2000(targetState);
+      const tof = wp.epoch.difference(state.epoch);
+      const revs = Math.floor(tof / state.period);
+      const shortPath = LambertIOD.useShortPath(state, targetState);
+      const lambert = new LambertIOD();
+      const components = lambert.estimate(state.position, wpState.position, state.epoch, wp.epoch, {
+        posigrade: shortPath,
+        nRev: revs,
+      });
+
+      if (components === null) {
+        throw new Error('Lambert solve result is null.');
+      }
+      const componentsRel = RIC.fromJ2000(components, state).velocity.scale(1e3) as Vector3D<MetersPerSecond>;
+      const maneuver = new Thrust(
+        state.epoch,
+        componentsRel.x,
+        componentsRel.y,
+        componentsRel.z,
+        durationRate as SecondsPerMeterPerSecond,
+      );
+      const tempProp = new RungeKutta89Propagator(state, forceModel);
+
+      tempProp.maneuver(maneuver);
+      state = tempProp.propagate(wp.epoch);
+      waypointManeuvers.push(maneuver);
+    }
+    if (refine) {
+      forceModel ??= new ForceModel().setGravity();
+      waypointManeuvers = this._refineManeuvers(waypoints, waypointManeuvers, pivotState, forceModel, target, {
+        maxIter,
+        printIter,
+      });
+    }
+    const output: Thrust[] = [];
+
+    output.push(...preMnv);
+    output.push(...waypointManeuvers);
+    output.push(...postMnv);
+
+    return output;
+  }
+
+  static _refineManeuvers(
+    waypoints: Waypoint[],
+    maneuvers: Thrust[],
+    interceptor: J2000,
+    forceModel: ForceModel,
+    target: StateInterpolator,
+    {
+      maxIter = 500,
+      printIter = false,
+    }: {
+      maxIter?: number;
+      printIter?: boolean;
+    } = {},
+  ): Thrust[] {
+    let state = interceptor;
+    const output: Thrust[] = [];
+
+    for (let i = 0; i < maneuvers.length; i++) {
+      const maneuver = maneuvers[i];
+      const waypoint = waypoints[i];
+      const guess = maneuver.deltaV.scale(1e3).toArray();
+      const simplex = DownhillSimplex.generateSimplex(guess, 1e-1);
+      const scoreFn = this._refineManeuverScore(waypoint, maneuver, state, forceModel, target);
+      const results = DownhillSimplex.solveSimplex(scoreFn, simplex, {
+        maxIter,
+        xTolerance: 1e-6,
+        fTolerance: 1e-6,
+        printIter,
+      });
+      const tR = results[0] as MetersPerSecond;
+      const tI = results[1] as MetersPerSecond;
+      const tC = results[2] as MetersPerSecond;
+      const newManeuver = new Thrust(maneuver.center, tR, tI, tC, maneuver.durationRate);
+
+      output.push(newManeuver);
+      const mvrStep = new RungeKutta89Propagator(state, forceModel).maneuver(newManeuver);
+
+      state = mvrStep[mvrStep.length - 1];
+    }
+
+    return output;
+  }
+}

package/src/objects/DetailedSatellite.ts

@@ -0,0 +1,159 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import {
+  LaunchDetails,
+  OperationsDetails,
+  OptionsParams,
+  Satellite,
+  SpaceCraftDetails,
+} from 'ootk-core';
+import { DetailedSatelliteParams } from '../types/types';
+
+/**
+ * Represents a detailed satellite object with launch, spacecraft, and operations details.
+ */
+export class DetailedSatellite extends Satellite {
+  configuration: string = '';
+  country: string = '';
+  dryMass: string = '';
+  equipment: string = '';
+  launchDate: string = '';
+  launchMass: string = '';
+  launchSite: string = '';
+  launchVehicle: string = '';
+  lifetime: string | number = '';
+  maneuver: string = '';
+  manufacturer: string = '';
+  mission: string = '';
+  bus: string = '';
+  motor: string = '';
+  owner: string = '';
+  payload: string = '';
+  power: string = '';
+  purpose: string = '';
+  length: string = '';
+  diameter: string = '';
+  shape: string = '';
+  span: string = '';
+  user: string = '';
+  source: string = '';
+  vmag: number;
+  rcs: number;
+  altId: string = '';
+  altName: string = '';
+
+  constructor(
+    info: DetailedSatelliteParams & LaunchDetails & OperationsDetails & SpaceCraftDetails,
+    options?: OptionsParams,
+  ) {
+    super(info, options);
+
+    this.active ??= true;
+    this.initSpaceCraftDetails_(info);
+    this.length = info.length ?? '';
+    this.diameter = info.diameter ?? '';
+    this.source = info.source ?? '';
+    this.vmag = info.vmag ?? 0;
+    this.rcs = info.rcs ?? 0;
+    this.altId = info.altId ?? '';
+    this.altName = info.altName ?? '';
+    this.initOperationDetails_(info);
+    this.initLaunchDetails_(info);
+  }
+
+  private initSpaceCraftDetails_(
+    info: DetailedSatelliteParams &
+          LaunchDetails & OperationsDetails &
+          SpaceCraftDetails,
+  ) {
+    this.lifetime = info.lifetime ?? '';
+    this.maneuver = info.maneuver ?? '';
+    this.manufacturer = info.manufacturer ?? '';
+    this.motor = info.motor ?? '';
+    this.power = info.power ?? '';
+    this.payload = info.payload ?? '';
+    this.purpose = info.purpose ?? '';
+    this.shape = info.shape ?? '';
+    this.span = info.span ?? '';
+    this.bus = info.bus ?? '';
+    this.configuration = info.configuration ?? '';
+    this.equipment = info.equipment ?? '';
+    this.dryMass = info.dryMass ?? '';
+  }
+
+  private initOperationDetails_(info: DetailedSatelliteParams & LaunchDetails & OperationsDetails & SpaceCraftDetails) {
+    this.mission = info.mission ?? '';
+    this.user = info.user ?? '';
+    this.owner = info.owner ?? '';
+    this.country = info.country ?? '';
+  }
+
+  private initLaunchDetails_(info: DetailedSatelliteParams & LaunchDetails & OperationsDetails & SpaceCraftDetails) {
+    this.launchDate = info.launchDate ?? '';
+    this.launchMass = info.launchMass ?? '';
+    this.launchSite = info.launchSite ?? '';
+    this.launchVehicle = info.launchVehicle ?? '';
+  }
+
+  /**
+   * Returns the launch details of the satellite.
+   * @returns An object containing the launch date, launch mass, launch site, and launch vehicle of the satellite.
+   */
+  getLaunchDetails(): LaunchDetails {
+    return {
+      launchDate: this.launchDate,
+      launchMass: this.launchMass,
+      launchSite: this.launchSite,
+      launchVehicle: this.launchVehicle,
+    };
+  }
+
+  /**
+   * Returns an object containing the details of the operations.
+   * @returns An object containing the user, mission, owner, and country details.
+   */
+  getOperationsDetails(): OperationsDetails {
+    return {
+      user: this.user,
+      mission: this.mission,
+      owner: this.owner,
+      country: this.country,
+    };
+  }
+
+  /**
+   * Returns the space craft details.
+   * @returns The space craft details.
+   */
+  getSpaceCraftDetails(): SpaceCraftDetails {
+    return {
+      lifetime: this.lifetime,
+      maneuver: this.maneuver,
+      manufacturer: this.manufacturer,
+      motor: this.motor,
+      power: this.power,
+      payload: this.payload,
+      purpose: this.purpose,
+      shape: this.shape,
+      span: this.span,
+      configuration: this.configuration,
+      equipment: this.equipment,
+      dryMass: this.dryMass,
+    };
+  }
+}

package/src/objects/DetailedSensor.ts

@@ -0,0 +1,68 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { BaseObjectParams, Degrees, Milliseconds, Radians, Sensor, SensorParams } from 'ootk-core';
+import { DetailedSensorParams, ZoomValue } from '../types/types';
+
+export class DetailedSensor extends Sensor {
+  country?: string;
+  latRad: Radians;
+  lonRad: Radians;
+  shortName?: string;
+  beamwidth?: Degrees;
+  changeObjectInterval?: Milliseconds;
+  linkAehf?: boolean;
+  linkGalileo?: boolean;
+  linkIridium?: boolean;
+  linkStarlink?: boolean;
+  linkWgs?: boolean;
+  static?: boolean;
+  sensorId?: number;
+  url?: string;
+  volume?: boolean;
+  zoom: ZoomValue;
+  band?: string;
+  objName?: string;
+  uiName?: string;
+  system?: string;
+  operator?: string;
+
+  constructor(info: DetailedSensorParams & SensorParams & BaseObjectParams) {
+    super(info);
+    this.country = info.country;
+    this.latRad = (info.lat * (Math.PI / 180)) as Radians;
+    this.lonRad = (info.lon * (Math.PI / 180)) as Radians;
+    this.shortName = info.shortName;
+    this.beamwidth = info.beamwidth;
+    this.changeObjectInterval = info.changeObjectInterval;
+    this.linkAehf = info.linkAehf;
+    this.linkGalileo = info.linkGalileo;
+    this.linkIridium = info.linkIridium;
+    this.linkStarlink = info.linkStarlink;
+    this.linkWgs = info.linkWgs;
+    this.static = info.static;
+    this.sensorId = info.sensorId;
+    this.url = info.url;
+    this.volume = info.volume;
+    this.zoom = info.zoom;
+    this.band = info.band;
+    this.objName = info.objName;
+    this.uiName = info.uiName;
+    this.system = info.system;
+    this.operator = info.operator;
+  }
+}

package/src/objects/LandObject.ts

@@ -0,0 +1,46 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { BaseObject, BaseObjectParams, Degrees, Kilometers } from 'ootk-core';
+/* eslint-disable class-methods-use-this */
+
+export interface LandObjectParams extends BaseObjectParams {
+  lat: Degrees;
+  lon: Degrees;
+  alt: Kilometers;
+  country?: string;
+  Code?: string;
+}
+
+export class LandObject extends BaseObject {
+  lat: Degrees;
+  lon: Degrees;
+  alt: Kilometers;
+  country?: string;
+  Code?: string;
+
+  constructor(info: LandObjectParams) {
+    super(info);
+    this.lat = info.lat;
+    this.lon = info.lon;
+    this.alt = info.alt;
+  }
+
+  isLandObject() {
+    return true;
+  }
+}

package/src/objects/Marker.ts

@@ -0,0 +1,25 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { BaseObject } from 'ootk-core';
+/* eslint-disable class-methods-use-this */
+
+export class Marker extends BaseObject {
+  isMarker() {
+    return true;
+  }
+}

package/src/objects/RfSensor.ts

@@ -0,0 +1,78 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2024 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { DEG2RAD, Degrees, RAD2DEG, Radians, Sensor, SpaceObjectType } from 'ootk-core';
+import { azel2uv, uv2azel, RfSensorParams } from '../main';
+
+export class RfSensor extends Sensor {
+  coneHalfAngle: Degrees;
+  boresightAz: Degrees;
+  boresightEl: Degrees;
+
+  constructor(info: RfSensorParams) {
+    super(info);
+
+    switch (info.type) {
+      case SpaceObjectType.BISTATIC_RADIO_TELESCOPE:
+      case SpaceObjectType.MECHANICAL:
+      case SpaceObjectType.PHASED_ARRAY_RADAR:
+        break;
+      default:
+        throw new Error('Invalid sensor type');
+    }
+
+    this.coneHalfAngle = info.coneHalfAngle;
+    this.boresightAz = info.boresightAz;
+    this.boresightEl = info.boresightEl;
+  }
+
+  uvFromAzEl(az: Degrees, el: Degrees) {
+    const azRad = (az * DEG2RAD) as Radians;
+    const elRad = (el * DEG2RAD) as Radians;
+    const azDiff = (azRad - this.boresightAzRad) as Radians;
+    const elDiff = (elRad - this.boresightElRad) as Radians;
+
+    return azel2uv(azDiff, elDiff, this.coneHalfAngleRad);
+  }
+
+  azElFromUV(u: number, v: number) {
+    const { az, el } = uv2azel(u, v, this.coneHalfAngleRad);
+
+    return {
+      az: ((az + this.boresightAz) * RAD2DEG) as Degrees,
+      el: ((el + this.boresightEl) * RAD2DEG) as Degrees,
+    };
+  }
+
+  get boresightAzRad() {
+    return (this.boresightAz * DEG2RAD) as Radians;
+  }
+
+  get boresightElRad() {
+    return (this.boresightEl * DEG2RAD) as Radians;
+  }
+
+  get coneHalfAngleRad() {
+    return (this.coneHalfAngle * DEG2RAD) as Radians;
+  }
+}

package/src/objects/index.ts

@@ -0,0 +1,5 @@
+export { DetailedSatellite } from './DetailedSatellite';
+export { DetailedSensor } from './DetailedSensor';
+export { LandObject } from './LandObject';
+export { Marker } from './Marker';
+export { RfSensor } from './RfSensor';