mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
An imaging satellite with a known sensor can now zoom past 8x, up to 128x, as far as the view stays at least as wide as the sensor's narrowest standard swath at its live altitude; only swaths confirmed on a cited page open those steps. The top step follows the altitude and window shape and steps back when it falls below the zoom shown. The view draws the sensor's swath to scale along the ground track with a SENSOR SWATH readout (approximate off nadir), and a SENSOR button zooms to exactly that width when it lies in range at nadir. From 16x the imagery tiles the view will need 5 to 20 s ahead along the ground track are pre-loaded at the matching level. The mouse wheel steps the zoom one notch at a time, and the identity line shows how old the TLE is. The sensor figures come from a new bundled pack of 46 Earth-observation platforms, each value cited to its operator or agency, with its own data credit.
563 lines
19 KiB
JavaScript
563 lines
19 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import { createState } from './state.js';
|
|
import { createControls } from './controls.js';
|
|
import { createOrbits } from './orbits.js';
|
|
import { createLabels } from './labels.js';
|
|
import { createTracking } from './tracking.js';
|
|
import { createRendering } from './rendering.js';
|
|
import { createCatalog } from './catalog.js';
|
|
import { createLifecycle } from './lifecycle.js';
|
|
import { createInteraction } from './interaction.js';
|
|
import { createIngestion } from './ingestion.js';
|
|
import {
|
|
COCKPIT_ORBIT_DIM_FACTOR,
|
|
applyOrbitPathAlpha,
|
|
createCockpitSubject,
|
|
satelliteCockpitInfo,
|
|
} from './cockpitSubject.js';
|
|
import { groundTrackBearingDeg } from './orbits.js';
|
|
import { indexImagingSensors } from './sensors.js';
|
|
import { ISS_NORAD } from './policy.js';
|
|
|
|
const COMPANION = 25545;
|
|
const GPS = 32711;
|
|
|
|
function tle(name, id, motion = '15.48899044', inclination = ' 51.6326') {
|
|
// Owned synthetic element sets; never live requests. The station pair
|
|
// share elements, so the companion is docked to the ISS.
|
|
return `${name}\n1 ${id}U 98067A 26289.78971908 .00007803 00000+0 15012-3 0 9995\n2 ${id} ${inclination} 58.3278 0006748 271.9059 88.1156 ${motion}590607`;
|
|
}
|
|
|
|
const GROUP_TEXT = {
|
|
stations: [
|
|
tle('ISS (ZARYA)', ISS_NORAD),
|
|
tle('PROGRESS-MS 31', COMPANION),
|
|
].join('\n'),
|
|
'gps-ops': tle('GPS FIXTURE', GPS, ' 2.00563000', ' 55.0000'),
|
|
};
|
|
|
|
/** Whether the tracked entity draws its dot (an unset show is shown). */
|
|
function dotShown(f) {
|
|
const show = f.state._trackedEntity.point.show;
|
|
return show === undefined ? true : show.getValue();
|
|
}
|
|
|
|
const SATCAT_HEADER =
|
|
'OBJECT_NAME,OBJECT_ID,NORAD_CAT_ID,OBJECT_TYPE,OPS_STATUS_CODE,OWNER';
|
|
const SATCAT_TEXT = {
|
|
stations: [
|
|
SATCAT_HEADER,
|
|
`ISS (ZARYA),1998-067A,${ISS_NORAD},PAY,+,ISS`,
|
|
`PROGRESS-MS 31,2026-001A,${COMPANION},PAY,+,CIS`,
|
|
].join('\n'),
|
|
// No designator: the TLE's is used.
|
|
'gps-ops': [SATCAT_HEADER, `GPS FIXTURE,,${GPS},PAY,+,US`].join('\n'),
|
|
};
|
|
const UCS = new Map([
|
|
[
|
|
ISS_NORAD,
|
|
{
|
|
noradId: ISS_NORAD,
|
|
operator: 'NASA/Multinational',
|
|
operatorCountry: 'Multinational',
|
|
purpose: 'Space Science',
|
|
},
|
|
],
|
|
]);
|
|
|
|
// One sensor entry, matched by NORAD number, for the orbital zoom cap.
|
|
const SENSORS = indexImagingSensors({
|
|
entries: [
|
|
{
|
|
id: 'fixture-imager',
|
|
label: 'Fixture imager',
|
|
match: { norad: [GPS] },
|
|
narrowestSwathKm: 50,
|
|
swathConfirmed: true,
|
|
sources: ['https://example.test/spec'],
|
|
},
|
|
],
|
|
});
|
|
|
|
async function fixture(t) {
|
|
const source = {
|
|
async readGroup(group) {
|
|
const text = GROUP_TEXT[group] || '';
|
|
return { ok: true, status: 200, text, stale: false };
|
|
},
|
|
async readSatcat(group) {
|
|
return { ok: true, status: 200, text: SATCAT_TEXT[group] || '' };
|
|
},
|
|
readUcs: async () => UCS,
|
|
readSensors: async () => SENSORS,
|
|
};
|
|
const noop = () => {};
|
|
const services = {
|
|
overlays: {
|
|
setOverlayEntries: noop,
|
|
setOverlaySourceVisible: noop,
|
|
clearOverlaySource: noop,
|
|
},
|
|
layerState: { isExplicitLayerStateOrigin: () => false },
|
|
focus: {
|
|
clearFocusTarget: noop,
|
|
publishFocusTargetFromCachedPosition: noop,
|
|
getFocusTarget: () => null,
|
|
focusNowMs: (now) => now,
|
|
focusPassIsNeeded: () => false,
|
|
},
|
|
context: {
|
|
clearTrackedSubjectContext: noop,
|
|
getContextStore: () => ({ entities: new Map() }),
|
|
refreshTrackedSubjectContext: noop,
|
|
selectTrackedSubjectContext: noop,
|
|
},
|
|
readout: { refreshTrackedReadout: noop },
|
|
render: { holdContinuousRender: noop, releaseContinuousRender: noop },
|
|
picking: { registerPickOwner: noop, unregisterPickOwner: noop },
|
|
};
|
|
const previousDocument = globalThis.document;
|
|
globalThis.document = new EventTarget();
|
|
const state = createState({ services });
|
|
const parts = {};
|
|
const context = { state, services, parts, source };
|
|
for (const [name, factory] of Object.entries({
|
|
controls: createControls,
|
|
orbits: createOrbits,
|
|
labels: createLabels,
|
|
tracking: createTracking,
|
|
rendering: createRendering,
|
|
catalog: createCatalog,
|
|
interaction: createInteraction,
|
|
lifecycle: createLifecycle,
|
|
ingestion: createIngestion,
|
|
cockpit: createCockpitSubject,
|
|
})) {
|
|
parts[name] = factory(context);
|
|
}
|
|
const viewer = {
|
|
trackedEntity: undefined,
|
|
entities: new Cesium.EntityCollection(),
|
|
scene: {
|
|
canvas: new EventTarget(),
|
|
primitives: new Cesium.PrimitiveCollection(),
|
|
preRender: new Cesium.Event(),
|
|
frameState: { frameNumber: 1 },
|
|
},
|
|
trackedEntityChanged: new Cesium.Event(),
|
|
};
|
|
const { log, warn } = console;
|
|
console.log = noop;
|
|
console.warn = noop;
|
|
await parts.lifecycle.methods.init(viewer);
|
|
await parts.ingestion.methods.update(viewer);
|
|
parts.lifecycle.methods.enable(viewer);
|
|
// GPS is TELECOM, hidden by default; these tests need its point on screen.
|
|
parts.controls.methods.setParams({ classes: { telecom: true } });
|
|
Object.assign(console, { log, warn });
|
|
t.after(() => {
|
|
console.log = noop;
|
|
if (state._pointCollection) parts.lifecycle.methods.destroy(viewer);
|
|
console.log = log;
|
|
viewer.scene.primitives.destroy();
|
|
if (previousDocument === undefined) delete globalThis.document;
|
|
else globalThis.document = previousDocument;
|
|
});
|
|
const methods = { ...parts.controls.methods, ...parts.cockpit.methods };
|
|
return {
|
|
state,
|
|
parts,
|
|
viewer,
|
|
methods,
|
|
track(id) {
|
|
const log = console.log;
|
|
console.log = noop;
|
|
try {
|
|
return methods.trackById(id);
|
|
} finally {
|
|
console.log = log;
|
|
}
|
|
},
|
|
nextFrame() {
|
|
viewer.scene.frameState.frameNumber += 1;
|
|
parts.rendering._preRenderTick();
|
|
},
|
|
ring: (id) => state._orbitPaths.get(id)?.primitive,
|
|
detected: () =>
|
|
methods.getDetectableObjects().map((object) => object.sourceId),
|
|
};
|
|
}
|
|
|
|
test('no subject while the layer is off or nothing is tracked', async (t) => {
|
|
const f = await fixture(t);
|
|
assert.equal(f.methods.getCockpitSubject(), null);
|
|
assert.equal(f.methods.getCockpitPosition(), null);
|
|
assert.equal(f.track(ISS_NORAD), true);
|
|
f.state._enabled = false;
|
|
assert.equal(f.methods.getCockpitSubject(), null);
|
|
assert.equal(f.methods.getCockpitPosition(), null);
|
|
});
|
|
|
|
test('the tracked satellite is a subject read from the per-frame sample', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(ISS_NORAD);
|
|
const propagate = f.parts.orbits.propagatePosition;
|
|
let propagations = 0;
|
|
f.parts.orbits.propagatePosition = (...args) => {
|
|
propagations += 1;
|
|
return propagate(...args);
|
|
};
|
|
f.viewer.scene.frameState.frameNumber += 1;
|
|
const subject = f.methods.getCockpitSubject();
|
|
const position = f.methods.getCockpitPosition();
|
|
f.methods.getCockpitSubject();
|
|
assert.equal(propagations, 1, 'one SGP4 sample per frame for every reader');
|
|
|
|
assert.equal(subject.kind, 'satellite');
|
|
assert.equal(subject.layerId, 'satellites');
|
|
assert.equal(subject.id, String(ISS_NORAD));
|
|
assert.equal(subject.noradId, ISS_NORAD);
|
|
assert.equal(subject.name, 'ISS (ZARYA)');
|
|
assert.equal(subject.classLabel, 'STATIONS · ISS');
|
|
assert.equal(subject.stale, false);
|
|
assert.ok(subject.altitudeM > 150e3 && subject.altitudeM < 1000e3);
|
|
assert.ok(subject.velocityMps > 7000 && subject.velocityMps < 8000);
|
|
|
|
// The same point the tracked dot and follow camera use, as a copy.
|
|
const cached = f.state._trackedFrameCartesian;
|
|
assert.ok(Cesium.Cartesian3.equals(position, cached));
|
|
assert.notEqual(position, cached);
|
|
const target = new Cesium.Cartesian3();
|
|
assert.equal(f.methods.getCockpitPosition(target), target);
|
|
const geodetic = Cesium.Cartographic.fromCartesian(position);
|
|
assert.ok(
|
|
Math.abs(Cesium.Math.toDegrees(geodetic.latitude) - subject.latitude) <
|
|
1e-6,
|
|
);
|
|
f.parts.orbits.propagatePosition = propagate;
|
|
});
|
|
|
|
test('the subject says what it is, which TLE it flies, and who owns and runs it', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(ISS_NORAD);
|
|
const iss = f.methods.getCockpitSubject();
|
|
assert.equal(iss.satelliteClass, 'stations');
|
|
assert.equal(iss.cosparId, '1998-067A');
|
|
assert.match(iss.tle.line1, /^1 25544U/);
|
|
assert.match(iss.tle.line2, /^2 25544 /);
|
|
// Day 289.789… of 2026.
|
|
assert.ok(
|
|
Math.abs(
|
|
iss.tle.epochMs - (Date.UTC(2026, 0, 1) + 288.78971908 * 86_400_000),
|
|
) < 1000,
|
|
);
|
|
assert.deepEqual(
|
|
iss.owner,
|
|
{ countryCode: null, label: 'Multinational' },
|
|
'UCS before SATCAT',
|
|
);
|
|
assert.equal(iss.operator, 'NASA/Multinational');
|
|
assert.equal(
|
|
f.methods.getCockpitSubject().owner,
|
|
iss.owner,
|
|
'worked out once',
|
|
);
|
|
|
|
f.track(GPS);
|
|
const gps = f.methods.getCockpitSubject();
|
|
assert.equal(gps.satelliteClass, 'telecom');
|
|
assert.equal(
|
|
gps.cosparId,
|
|
'1998-067A',
|
|
'from TLE line 1 when SATCAT has none',
|
|
);
|
|
assert.deepEqual(gps.owner, { countryCode: 'US', label: 'United States' });
|
|
assert.equal(gps.operator, null);
|
|
// The sensor pack is matched once, at ingestion.
|
|
assert.equal(gps.sensor?.id, 'fixture-imager');
|
|
assert.equal(gps.sensor.narrowestSwathKm, 50);
|
|
assert.equal(iss.sensor, null, 'no sensor entry, no extra zoom');
|
|
|
|
// A bare catalog entry still answers every field.
|
|
const bare = satelliteCockpitInfo(
|
|
GPS,
|
|
{ name: 'X', group: 'gps-ops' },
|
|
{ latitude: 1, longitude: 2, altitude: 3 },
|
|
);
|
|
assert.equal(bare.satelliteClass, 'telecom');
|
|
// An imaging satellite CelesTrak lists among the brightest objects names
|
|
// its class, not the 'visual' group it came in.
|
|
const landsat = satelliteCockpitInfo(
|
|
49260,
|
|
{ name: 'LANDSAT 9', group: 'visual', satelliteClass: 'imaging' },
|
|
{ latitude: 1, longitude: 2, altitude: 3 },
|
|
);
|
|
assert.equal(landsat.classLabel, 'IMAGING');
|
|
assert.equal(bare.tle, null);
|
|
assert.equal(bare.owner, null);
|
|
assert.equal(bare.operator, null);
|
|
assert.equal(bare.cosparId, null);
|
|
});
|
|
|
|
test('a GNSS satellite carries its class and an orbital speed', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(GPS);
|
|
const subject = f.methods.getCockpitSubject();
|
|
assert.equal(subject.classLabel, 'TELECOM · GPS');
|
|
assert.ok(subject.altitudeM > 19e6 && subject.altitudeM < 21.5e6);
|
|
assert.ok(subject.velocityMps > 3500 && subject.velocityMps < 4200);
|
|
assert.equal(
|
|
satelliteCockpitInfo(
|
|
GPS,
|
|
{ name: 'X', group: 'gps-ops' },
|
|
{
|
|
latitude: 1,
|
|
longitude: 2,
|
|
altitude: 3,
|
|
},
|
|
).velocityMps,
|
|
null,
|
|
);
|
|
assert.equal(satelliteCockpitInfo(GPS, null, { latitude: 0 }), null);
|
|
});
|
|
|
|
test('holding the subject hides its dot, ring, docked companions and bracket', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(ISS_NORAD);
|
|
f.nextFrame();
|
|
assert.ok(f.state._dockedCompanions.has(COMPANION));
|
|
assert.equal(dotShown(f), true);
|
|
assert.equal(f.ring(ISS_NORAD).show, true);
|
|
assert.ok(f.detected().includes(ISS_NORAD));
|
|
|
|
assert.equal(f.methods.setCockpitSubject(String(ISS_NORAD)), true);
|
|
assert.equal(dotShown(f), false);
|
|
assert.equal(f.ring(ISS_NORAD).show, false);
|
|
assert.equal(f.state._points.get(COMPANION).show, false);
|
|
assert.equal(f.state._points.get(GPS).show, true);
|
|
assert.ok(!f.detected().includes(ISS_NORAD));
|
|
|
|
// Toggling orbits on again cannot bring the ring back while held.
|
|
f.methods.setParams({ showOrbits: true });
|
|
assert.equal(f.ring(ISS_NORAD).show, true);
|
|
f.nextFrame();
|
|
assert.equal(f.ring(ISS_NORAD).show, false);
|
|
|
|
f.methods.setCockpitSubject(null);
|
|
assert.equal(dotShown(f), true);
|
|
assert.equal(f.ring(ISS_NORAD).show, true);
|
|
assert.equal(f.state._points.get(COMPANION).show, true);
|
|
// The tracked primitive stays hidden: the tracked entity draws the dot.
|
|
assert.equal(f.state._points.get(ISS_NORAD).show, false);
|
|
assert.ok(f.detected().includes(ISS_NORAD));
|
|
});
|
|
|
|
test('a subject that is not tracked holds nothing', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(GPS);
|
|
f.methods.setCockpitSubject(ISS_NORAD);
|
|
f.nextFrame();
|
|
assert.equal(dotShown(f), true);
|
|
assert.equal(f.ring(GPS).show, true);
|
|
assert.equal(f.ring(ISS_NORAD).show, true);
|
|
});
|
|
|
|
test('untracking a held subject gives its marks back', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(ISS_NORAD);
|
|
f.nextFrame();
|
|
f.methods.setCockpitSubject(ISS_NORAD);
|
|
assert.equal(f.ring(ISS_NORAD).show, false);
|
|
f.methods.stopTracking();
|
|
assert.equal(f.methods.getCockpitSubject(), null);
|
|
assert.equal(f.ring(ISS_NORAD).show, true);
|
|
assert.equal(f.state._points.get(COMPANION).show, true);
|
|
assert.equal(f.state._points.get(ISS_NORAD).show, true);
|
|
});
|
|
|
|
test('tracking without a Cockpit subject keeps its marks', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(GPS);
|
|
for (let i = 0; i < 3; i++) f.nextFrame();
|
|
assert.equal(dotShown(f), true);
|
|
assert.equal(f.ring(GPS).show, true);
|
|
assert.equal(f.state._points.get(COMPANION).show, true);
|
|
assert.equal(f.state._cockpitHiddenPoints.size, 0);
|
|
assert.equal(f.state._cockpitHiddenPath, null);
|
|
});
|
|
|
|
/**
|
|
* Give a ring the per-instance attributes Cesium creates on its first
|
|
* update, starting from the colours it was built with. Rings in this
|
|
* fixture are never rendered, so the test stands in for that update.
|
|
*/
|
|
function readyRing(f, id) {
|
|
const path = f.state._orbitPaths.get(id);
|
|
const attributes = {
|
|
color: Cesium.ColorGeometryInstanceAttribute.toValue(path.baseColor),
|
|
depthFailColor: Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
path.baseDepthFailColor,
|
|
),
|
|
};
|
|
path.primitive.getGeometryInstanceAttributes = (instanceId) =>
|
|
instanceId === path.instanceId ? attributes : undefined;
|
|
return attributes;
|
|
}
|
|
|
|
/** A colour attribute's alpha byte. */
|
|
const alphaByte = (value) => value[3];
|
|
|
|
test('a Cockpit subject dims every other orbit ring and restores it exactly', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(GPS);
|
|
f.nextFrame();
|
|
assert.ok(f.ring(ISS_NORAD), 'the ISS ring is drawn beside the tracked one');
|
|
const iss = readyRing(f, ISS_NORAD);
|
|
const gps = readyRing(f, GPS);
|
|
const builtColor = [...iss.color];
|
|
const builtDepthFail = [...iss.depthFailColor];
|
|
const gpsBuilt = [...gps.color];
|
|
|
|
f.methods.setCockpitSubject(GPS);
|
|
const dimmed = (byte) => Math.round(byte * COCKPIT_ORBIT_DIM_FACTOR);
|
|
assert.ok(Math.abs(alphaByte(iss.color) - dimmed(builtColor[3])) <= 1);
|
|
assert.ok(
|
|
Math.abs(alphaByte(iss.depthFailColor) - dimmed(builtDepthFail[3])) <= 1,
|
|
);
|
|
assert.deepEqual([...iss.color].slice(0, 3), builtColor.slice(0, 3));
|
|
assert.equal(f.ring(ISS_NORAD).show, true, 'other rings stay visible');
|
|
assert.equal(f.ring(GPS).show, false, 'the ridden ring stays hidden');
|
|
assert.deepEqual([...gps.color], gpsBuilt, 'the ridden ring is not dimmed');
|
|
// Other satellites' points stay as they are.
|
|
assert.equal(f.state._points.get(COMPANION).show, true);
|
|
|
|
// A rebuilt ring arrives at full alpha and is dimmed again on the tick.
|
|
f.parts.rendering._hideOrbitPath(ISS_NORAD);
|
|
f.parts.rendering._showOrbitPath(ISS_NORAD, Cesium.Color.YELLOW);
|
|
const rebuilt = readyRing(f, ISS_NORAD);
|
|
f.nextFrame();
|
|
assert.ok(alphaByte(rebuilt.color) < builtColor[3]);
|
|
|
|
f.methods.setCockpitSubject(null);
|
|
assert.deepEqual(
|
|
[...rebuilt.color],
|
|
[
|
|
...Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
f.state._orbitPaths.get(ISS_NORAD).baseColor,
|
|
),
|
|
],
|
|
'released rings get their built colours back exactly',
|
|
);
|
|
assert.deepEqual(
|
|
[...rebuilt.depthFailColor],
|
|
[
|
|
...Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
f.state._orbitPaths.get(ISS_NORAD).baseDepthFailColor,
|
|
),
|
|
],
|
|
);
|
|
assert.equal(f.ring(GPS).show, true);
|
|
assert.deepEqual([...gps.color], gpsBuilt);
|
|
});
|
|
|
|
test('a ring not yet updated by Cesium is dimmed once it is', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(GPS);
|
|
f.methods.setCockpitSubject(GPS);
|
|
const path = f.state._orbitPaths.get(ISS_NORAD);
|
|
assert.equal(path.alphaFactor, 1, 'nothing written before the first update');
|
|
const iss = readyRing(f, ISS_NORAD);
|
|
f.nextFrame();
|
|
assert.equal(path.alphaFactor, COCKPIT_ORBIT_DIM_FACTOR);
|
|
assert.ok(alphaByte(iss.color) < 100);
|
|
assert.equal(applyOrbitPathAlpha(path, 1), true);
|
|
assert.deepEqual(
|
|
[...iss.color],
|
|
[...Cesium.ColorGeometryInstanceAttribute.toValue(path.baseColor)],
|
|
);
|
|
});
|
|
|
|
test('a held subject ignores the layer Escape; refocus restores the follow', async (t) => {
|
|
const f = await fixture(t);
|
|
f.track(ISS_NORAD);
|
|
f.nextFrame();
|
|
f.methods.setCockpitSubject(ISS_NORAD);
|
|
f.parts.interaction._onKeyDown({ key: 'Escape' });
|
|
assert.equal(f.state._trackedNorad, ISS_NORAD, 'the Cockpit owns Escape');
|
|
|
|
// The Cockpit took the follow camera off the entity; refocus puts it back.
|
|
f.viewer.trackedEntity = undefined;
|
|
f.methods.setCockpitSubject(null);
|
|
assert.equal(f.methods.refocusTrackedById(GPS), false, 'not the tracked one');
|
|
assert.equal(f.viewer.trackedEntity, undefined);
|
|
assert.equal(f.methods.refocusTrackedById(String(ISS_NORAD)), true);
|
|
assert.equal(f.viewer.trackedEntity, f.state._trackedEntity);
|
|
assert.equal(f.state._trackedNorad, ISS_NORAD);
|
|
|
|
f.parts.interaction._onKeyDown({ key: 'Escape' });
|
|
assert.equal(f.state._trackedNorad, null, 'released, Escape untracks again');
|
|
assert.equal(f.methods.refocusTrackedById(ISS_NORAD), false);
|
|
});
|
|
|
|
test('the ground track bearing comes from the SGP4 velocity, less the Earth turning', () => {
|
|
const near = (actual, expected) =>
|
|
assert.ok(Math.abs(actual - expected) < 0.2, `${actual} vs ${expected}`);
|
|
// An ISS-like orbit (51.6°, 7.66 km/s) crossing the equator northbound at
|
|
// 0°E: inertially 38.4° from north, but the ground turns east beneath it,
|
|
// so the track runs closer to north.
|
|
const inclination = (51.6 * Math.PI) / 180;
|
|
const iss = {
|
|
position: { x: 6771, y: 0, z: 0 },
|
|
velocity: {
|
|
x: 0,
|
|
y: 7.66 * Math.cos(inclination),
|
|
z: 7.66 * Math.sin(inclination),
|
|
},
|
|
};
|
|
near(groundTrackBearingDeg(iss.position, iss.velocity, 0, 0, 0), 35.4);
|
|
// The same state given in TEME a quarter sidereal turn on (GMST 90°):
|
|
// still over 0°E, so the same ground track.
|
|
near(
|
|
groundTrackBearingDeg(
|
|
{ x: 0, y: 6771, z: 0 },
|
|
{ x: -iss.velocity.y, y: 0, z: iss.velocity.z },
|
|
Math.PI / 2,
|
|
0,
|
|
0,
|
|
),
|
|
35.4,
|
|
);
|
|
// Geostationary: it turns with the Earth, so there is no ground track.
|
|
assert.equal(
|
|
groundTrackBearingDeg(
|
|
{ x: 42164, y: 0, z: 0 },
|
|
{ x: 0, y: 3.0747, z: 0 },
|
|
0,
|
|
0,
|
|
0,
|
|
),
|
|
null,
|
|
);
|
|
assert.equal(groundTrackBearingDeg(iss.position, null, 0, 0, 0), null);
|
|
// The subject passes the sample's track through.
|
|
const sat = { name: 'X', group: 'stations' };
|
|
const fix = { latitude: 0, longitude: 0, altitude: 400_000 };
|
|
assert.equal(
|
|
satelliteCockpitInfo(1, sat, { ...fix, groundTrackDeg: 35.4 })
|
|
.groundTrackDeg,
|
|
35.4,
|
|
);
|
|
assert.equal(satelliteCockpitInfo(1, sat, fix).groundTrackDeg, null);
|
|
});
|
|
|
|
test('the subject says whether its class may be ridden', () => {
|
|
const fix = { latitude: 0, longitude: 0, altitude: 400_000 };
|
|
const subject = (satelliteClass) =>
|
|
satelliteCockpitInfo(1, { name: 'X', group: 'visual', satelliteClass }, fix);
|
|
assert.equal(subject('debris').enterable, false);
|
|
for (const satelliteClass of ['stations', 'imaging', 'telecom', 'starlink', 'probes'])
|
|
assert.equal(subject(satelliteClass).enterable, true, satelliteClass);
|
|
});
|