Merge branch 'main' into german/recent-imagery-auto-successor

This commit is contained in:
German Khokhlov authored and GitHub committed 2026-11-20 17:03:24 +04:00
commit 4262829e27
178 files changed
+18826 -537

No files matched your search

+1
View File
@@ -126,6 +126,7 @@ export function createApplicationCatalog({
});
const satellites = createApplicationSatellites({
source: sources.satellites,
...(resolveAsset ? { resolveAsset } : {}),
});
const catalog = createLayerCatalog(
[
+4
View File
@@ -1,12 +1,16 @@
import {
clearOverlaySource,
getOverlayPaintRect,
getWorldOverlayDiagnostics,
hitTestWorldOverlay,
setOverlayEntries,
setOverlaySourceVisible,
} from '../../overlays/worldOverlay.js';
export const overlayHost = Object.freeze({
clearSource: clearOverlaySource,
getDiagnostics: getWorldOverlayDiagnostics,
hitTest: hitTestWorldOverlay,
paintRect: getOverlayPaintRect,
setEntries: setOverlayEntries,
setVisible: setOverlaySourceVisible,
});
+6 -1
View File
@@ -8,9 +8,14 @@ import * as render from '../../renderGovernor.js';
import * as layerState from '../../data/layerState.js';
/** Construct one layer using the application scene owners and a supplied source. */
export function createApplicationSatellites({ source }) {
export function createApplicationSatellites({
source,
resolveAsset = (url) =>
`${import.meta.env?.BASE_URL || '/'}${url.replace(/^\//, '')}`,
}) {
return createSatellitesLayer({
source,
resolveAsset,
services: {
picking,
focus,
+18
View File
@@ -1157,6 +1157,15 @@ test('mobile Cockpit prioritizes flight instruments and collision-safe controls'
mobileCockpit[1],
/body\.cockpit-mode \.cockpit-utility-controls[\s\S]*?bottom:\s*152px;/,
);
assert.match(
mobileCockpit[1],
/body\.cockpit-mode\.mobile-shell[^{]*?\.cockpit-utility-controls \{[^}]*?top:[^;]*?var\(--cockpit-visor-top\)/,
);
assert.match(
mobileCockpit[1],
/@media \(min-width: 390px\) and \(min-height: 240px\),\s*\(min-height: 450px\) \{\s*body\.cockpit-mode\.mobile-shell/,
);
assert.match(css, /\.cockpit-visor-shell \{[^}]*?inset:\s*var\(--cockpit-visor-top\)/);
assert.match(
mobileCockpit[1],
/body\.cockpit-mode \.cockpit-utility-control\.is-expanded[\s\S]*?top:\s*96px;/,
@@ -1175,6 +1184,15 @@ test('mobile Cockpit prioritizes flight instruments and collision-safe controls'
);
});
test('the unread Stories announcement waits until Cockpit closes', () => {
assert.match(css, /body\.cockpit-mode #gev-stories #hPop \{\s*display:\s*none;\s*\}/);
const storiesView = fs.readFileSync(path.join(ROOT, 'src', 'ui', 'views', 'StoriesView.vue'), 'utf8');
assert.match(
storiesView,
/async function openExplore\(\) \{[^}]*?if \(await store\.controller\.open\(\)\) markPopSeen\(\);/,
);
});
test('cockpit route direction uses self-contained vector artwork, not a font ligature', () => {
const match = html.match(/<div id="cockpit-route-direction"[\s\S]*?<\/div>/);
assert.ok(match, 'cockpit route-direction markup is missing');
+1
View File
@@ -335,6 +335,7 @@ test('the Google places route throttles by default and keeps its places[] contra
const overLimit = await request(handler, { url, method: 'GET' });
assert.equal(overLimit.status, 429);
assert.equal(overLimit.headers['retry-after'], '5');
assert.equal(overLimit.headers['cache-control'], 'no-store');
// Every error response on this route carries places[]; the client reads it
// unconditionally, so a throttled reply must not be the one shape that omits it.
assert.deepEqual(JSON.parse(overLimit.body).places, []);
+1 -53
View File
@@ -5,6 +5,7 @@ import {
findQuery,
} from '../render/rendererOf.js';
import { dot, sub } from '../geo/vector.js';
import { loadYouTubeApi } from './youtubeApi.js';
import { t, msg, onLocaleChange } from '../i18n/index.js';
import { h, render as renderVue } from 'vue';
import BhoteKoshiMediaCards from '../ui/bhoteKoshi/BhoteKoshiMediaCards.vue';
@@ -101,59 +102,6 @@ let _xWidgetsPromise = null;
let _facebookSdkPromise = null;
let _facebookEmbedSequence = 0;
let _cardSequence = 0;
const youtubeApis = new WeakMap();
function loadYouTubeApi(documentRef, globalRef) {
if (typeof globalRef.YT?.Player === 'function')
return Promise.resolve(globalRef.YT);
if (youtubeApis.has(documentRef)) return youtubeApis.get(documentRef);
const pending = new Promise((resolve, reject) => {
const previous = globalRef.onYouTubeIframeAPIReady;
let timer;
let settled = false;
const script = documentRef.createElement('script');
const finish = (error) => {
if (settled) return;
settled = true;
globalRef.clearTimeout(timer);
if (globalRef.onYouTubeIframeAPIReady === ready)
globalRef.onYouTubeIframeAPIReady = previous;
if (error) {
script.remove();
reject(error);
} else resolve(globalRef.YT);
};
const ready = () => {
try {
previous?.();
} finally {
finish(
typeof globalRef.YT?.Player === 'function'
? null
: new Error('YouTube API unavailable'),
);
}
};
globalRef.onYouTubeIframeAPIReady = ready;
script.src = 'https://www.youtube.com/iframe_api';
script.async = true;
script.addEventListener(
'error',
() => finish(new Error('YouTube API unavailable')),
{ once: true },
);
timer = globalRef.setTimeout(
() => finish(new Error('YouTube API timed out')),
5000,
);
documentRef.head.append(script);
}).catch((error) => {
youtubeApis.delete(documentRef);
throw error;
});
youtubeApis.set(documentRef, pending);
return pending;
}
/** A trimmed clip follows provider time, never time spent loading its iframe. */
export function createTrimmedYouTubePlayback({
+155 -54
View File
@@ -12,6 +12,14 @@ import {
parseTarkteeDatexLocations,
} from '../../server/providers/cctv/sources.js';
/**
* Disarm the 30 s deadline, so a loader that only stops at that deadline
* fails at the test timeout instead of passing late.
*/
function withoutDeadline(t) {
t.mock.method(AbortSignal, 'timeout', () => new AbortController().signal);
}
/** Silence the loaders' progress and failure logging. */
function quiet(t) {
t.mock.method(console, 'log', () => {});
@@ -97,6 +105,29 @@ test('Tarktee DATEX image parser rejects non-official hosts', () => {
assert.equal(images.size, 0);
});
test('Tarktee DATEX requests wait 30 s, past the slow answers measured live', async (t) => {
const timeouts = [];
const timeout = AbortSignal.timeout;
t.mock.method(AbortSignal, 'timeout', (ms) => {
timeouts.push(ms);
return timeout.call(AbortSignal, ms);
});
t.mock.method(console, 'log', () => {});
t.mock.method(
globalThis,
'fetch',
async (url) =>
new Response(
String(url).includes('roadCameraLocations')
? SAMPLE_LOCATIONS_XML
: SAMPLE_IMAGES_XML,
),
);
const cameras = await loadTarkteeSourcesFromDatex();
assert.deepEqual(timeouts, [30_000]);
assert.equal(cameras.length, 1);
});
test('Tarktee loader deduplicates cameras sharing an image number before the cap', async (t) => {
quiet(t);
const dupLocationsXml = `<?xml version="1.0" encoding="UTF-8"?>
@@ -168,46 +199,6 @@ test('Tarktee loader refuses a redirect and cancels both response bodies', async
assert.equal(cancelled.images, true, 'sibling 200 body is also cancelled');
});
test('Tarktee loader cancels fulfilled bodies when either fetch rejects', async (t) => {
for (const failedUrl of [TARKTEE_LOCATIONS_URL, TARKTEE_IMAGES_URL]) {
for (const delayedSibling of [false, true]) {
await t.test(
`${failedUrl}, delayed sibling: ${delayedSibling}`,
async (t) => {
quiet(t);
let cancelled = false;
const response = new Response(
new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode('<xml/>'));
},
cancel() {
cancelled = true;
},
}),
);
t.mock.method(globalThis, 'fetch', async (url) => {
if (String(url) === failedUrl) throw new TypeError('fetch failed');
if (delayedSibling) await new Promise(setImmediate);
return response;
});
try {
assert.deepEqual(await loadTarkteeSourcesFromDatex(), []);
assert.equal(
cancelled,
true,
'fulfilled sibling body is cancelled',
);
} finally {
await response.body.cancel();
}
},
);
}
}
});
test('Tarktee loader cancels the sibling body when one feed fails or overflows the byte cap', async (t) => {
quiet(t);
let siblingCancelled = false;
@@ -264,25 +255,135 @@ test('Tarktee loader cancels the sibling body when one feed fails or overflows t
);
});
test('Tarktee DATEX requests wait 30 s, past the slow answers measured live', async (t) => {
const timeouts = [];
const timeout = AbortSignal.timeout;
t.mock.method(AbortSignal, 'timeout', (ms) => {
timeouts.push(ms);
return timeout.call(AbortSignal, ms);
});
t.mock.method(console, 'log', () => {});
for (const failingUrl of [TARKTEE_LOCATIONS_URL, TARKTEE_IMAGES_URL]) {
for (const lateSibling of [false, true]) {
test(
`Tarktee cancels a ${lateSibling ? 'late' : 'received'} sibling when ${failingUrl} rejects before headers`,
{ timeout: 2000 },
async (t) => {
quiet(t);
withoutDeadline(t);
let cancelled = false;
let siblingSignal;
let release;
const gate = new Promise((resolve) => {
release = resolve;
});
t.mock.method(globalThis, 'fetch', async (url, init) => {
if (String(url) === failingUrl)
throw new Error('headers unavailable');
siblingSignal = init.signal;
// A late transport answers once the sibling is aborted, or on release.
if (lateSibling)
await Promise.race([
gate,
new Promise((resolve) =>
init.signal.addEventListener('abort', resolve, { once: true }),
),
]);
return new Response(
new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode('<xml/>'));
},
cancel() {
cancelled = true;
},
}),
);
});
assert.deepEqual(await loadTarkteeSourcesFromDatex(), []);
// Also exercise a response arriving after abort, as a queued transport
// completion can race the rejection owner even when fetch honors abort.
if (lateSibling) {
release();
await new Promise((resolve) => setImmediate(resolve));
}
assert.equal(cancelled, true, 'every obtained body must be cancelled');
assert.equal(
siblingSignal.aborted,
true,
'a pending transport is aborted immediately',
);
},
);
}
test(
`Tarktee aborts a pending sibling when ${failingUrl} rejects`,
{ timeout: 2000 },
async (t) => {
quiet(t);
withoutDeadline(t);
let aborted = false;
t.mock.method(globalThis, 'fetch', async (url, init) => {
if (String(url) === failingUrl) throw new Error('headers unavailable');
return new Promise((resolve, reject) => {
init.signal.addEventListener(
'abort',
() => {
aborted = true;
reject(init.signal.reason);
},
{ once: true },
);
});
});
assert.deepEqual(await loadTarkteeSourcesFromDatex(), []);
assert.equal(aborted, true, 'do not wait for the 30-second deadline');
},
);
}
test('Tarktee cancels both lengthless streams when one exceeds the byte cap', async (t) => {
quiet(t);
const cancelled = [];
t.mock.method(
globalThis,
'fetch',
async (url) =>
new Response(
String(url).includes('roadCameraLocations')
? SAMPLE_LOCATIONS_XML
: SAMPLE_IMAGES_XML,
new ReadableStream({
start(controller) {
const oversized = String(url) === TARKTEE_LOCATIONS_URL;
controller.enqueue(
new Uint8Array(oversized ? TARKTEE_MAX_CATALOG_BYTES + 1 : 1),
);
},
cancel() {
cancelled.push(String(url));
},
}),
),
);
const cameras = await loadTarkteeSourcesFromDatex();
assert.deepEqual(timeouts, [30_000, 30_000]);
assert.equal(cameras.length, 1);
assert.deepEqual(await loadTarkteeSourcesFromDatex(), []);
assert.deepEqual(
cancelled.sort(),
[TARKTEE_LOCATIONS_URL, TARKTEE_IMAGES_URL].sort(),
);
});
test(
'Tarktee aborts pending headers as soon as its sibling returns an HTTP error',
{ timeout: 2000 },
async (t) => {
quiet(t);
withoutDeadline(t);
let aborted = false;
t.mock.method(globalThis, 'fetch', async (url, init) => {
if (String(url) === TARKTEE_LOCATIONS_URL)
return new Response('unavailable', { status: 503 });
return new Promise((resolve, reject) => {
init.signal.addEventListener(
'abort',
() => {
aborted = true;
reject(init.signal.reason);
},
{ once: true },
);
});
});
assert.deepEqual(await loadTarkteeSourcesFromDatex(), []);
assert.equal(aborted, true);
},
);
+112
View File
@@ -0,0 +1,112 @@
// A body-phase failure of one Tarktee DATEX feed must abort the sibling that is
// still waiting for headers instead of leaving it until the 30 s deadline.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import {
TARKTEE_IMAGES_URL,
TARKTEE_LOCATIONS_URL,
TARKTEE_MAX_CATALOG_BYTES,
} from '../../server/providers/cctv/constants.js';
import { loadTarkteeSourcesFromDatex } from '../../server/providers/cctv/sources.js';
/** The sibling sends its headers this late; the loader must not wait for it. */
const SIBLING_HEADER_DELAY_MS = 2000;
/** Generous bound for "at once" on a loaded CI machine. */
const FAIL_FAST_MS = 1000;
function startServer(handlers) {
const server = http.createServer((req, res) => handlers[req.url](req, res));
return new Promise((resolve) => {
server.listen(0, '127.0.0.1', () => resolve(server));
});
}
/** Send the two DATEX URLs to the local server through the real fetch. */
function routeFetchTo(t, port) {
const realFetch = globalThis.fetch;
t.mock.method(globalThis, 'fetch', (url, init) => {
const path =
String(url) === TARKTEE_LOCATIONS_URL
? '/loc'
: String(url) === TARKTEE_IMAGES_URL
? '/img'
: null;
assert.ok(path, `unexpected url ${url}`);
return realFetch(`http://127.0.0.1:${port}${path}`, init);
});
}
/** The sibling answers late and reports whether it was cut off before headers. */
function slowSibling() {
const arrived = Promise.withResolvers();
const closed = Promise.withResolvers();
return {
arrived: arrived.promise,
closed: closed.promise,
handler(req, res) {
arrived.resolve();
const timer = setTimeout(() => {
res.writeHead(200, { 'content-type': 'application/xml' });
res.end('<d2LogicalModel/>');
}, SIBLING_HEADER_DELAY_MS);
res.on('close', () => {
clearTimeout(timer);
closed.resolve({ beforeHeaders: !res.headersSent });
});
},
};
}
const failingBodies = {
'declares a body over the byte cap': (req, res) => {
res.writeHead(200, {
'content-type': 'application/xml',
'content-length': String(TARKTEE_MAX_CATALOG_BYTES + 1),
});
res.write('<d2LogicalModel>');
},
'resets the connection mid-body': (req, res) => {
res.writeHead(200, { 'content-type': 'application/xml' });
res.write('<d2LogicalModel><payloadPublication>');
setTimeout(() => res.socket.destroy(), 20);
},
};
for (const [label, failingFeed] of Object.entries(failingBodies)) {
for (const [failing, pending] of [
['/loc', '/img'],
['/img', '/loc'],
]) {
test(`Tarktee aborts ${pending} pending headers when ${failing} ${label}`, { timeout: 10_000 }, async (t) => {
t.mock.method(console, 'log', () => {});
t.mock.method(console, 'warn', () => {});
const sibling = slowSibling();
const server = await startServer({
[failing]: (req, res) =>
sibling.arrived.then(() => failingFeed(req, res)),
[pending]: sibling.handler,
});
t.after(() => {
server.closeAllConnections();
server.close();
});
routeFetchTo(t, server.address().port);
const started = Date.now();
const cameras = await loadTarkteeSourcesFromDatex();
const elapsed = Date.now() - started;
assert.deepEqual(cameras, []);
assert.ok(
elapsed < FAIL_FAST_MS,
`loader waited ${elapsed} ms for the sibling's headers instead of aborting it`,
);
assert.deepEqual(
await sibling.closed,
{ beforeHeaders: true },
`${pending} was not aborted`,
);
});
}
}
@@ -0,0 +1,138 @@
// An explicit pick of the camera that a settled move just re-opened must end
// the opening pick. That pick goes through setActiveCamera's UNCHANGED path
// (same camera, already activated); if that path keeps the provisional flag,
// the next settled move (a pan, or the landing of NEAREST's own flight)
// switches the camera away from the one the user chose.
import assert from 'node:assert/strict';
import test from 'node:test';
import * as Cesium from 'cesium';
import cctvLayer, {
_setCctvCoverageStateForTest,
_setCctvOverlayHostForTest,
reopenNearestCamera,
} from './cctv.js';
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
const BASE = {
headingDeg: 41,
pitchDeg: -5,
fovDeg: 56,
rangeM: 210,
mountHeightM: 100,
groundElevationM: 0,
city: 'London',
};
function record(id, lat, lon) {
return {
camera: { ...BASE, id, name: `Camera ${id}`, lat, lon },
coverageEntities: [],
projection: null,
activationDone: true,
groundResolved: {},
groundSamples: {},
groundPrior: 0,
frustumGeometry: null,
frustumPositions: null,
probeClampRangeM: null,
position: Cesium.Cartesian3.fromDegrees(lon, lat, 100),
};
}
function viewerAt(lat, lon) {
const viewer = {
isDestroyed: () => false,
eye: { lat, lon, height: 300 },
scene: {
canvas: { clientWidth: 1200, clientHeight: 800 },
cartesianToCanvasCoordinates: () => undefined,
primitives: { add: (p) => p, remove: () => true },
requestRender() {},
},
};
// The layer reads the eye and flies through the renderer's camera port.
viewer.draw = bindFakeDraw(viewer, {
camera: {
pose: () => ({ ...viewer.eye }),
on: () => () => {},
followed: null,
flyToBounds() {},
},
}).draw;
return viewer;
}
function moveViewer(viewer, lat, lon) {
viewer.eye = { lat, lon, height: 300 };
}
function withReopenedLayer(fn) {
_setCctvOverlayHostForTest({
setEntries() {},
setVisible() {},
clearSource() {},
});
// Activation builds the projection canvas and frame image.
const originalDocument = globalThis.document;
const originalImage = globalThis.Image;
globalThis.document = { createElement: () => ({ getContext: () => null }) };
globalThis.Image = class {};
try {
const trafalgar = record('a-trafalgar', 51.508, -0.128);
const cambridge = record('b-cambridge', 51.513, -0.129);
// enable() assigned the opening camera without activating it.
trafalgar.activationDone = false;
const viewer = viewerAt(51.5081, -0.1281);
_setCctvCoverageStateForTest({
viewer,
records: [trafalgar, cambridge],
activeCameraId: 'a-trafalgar',
enabled: true,
openingCameraProvisional: true,
});
// A settled move next to Cambridge Circus re-opens there, still as the
// opening pick.
moveViewer(viewer, 51.5131, -0.1291);
assert.equal(reopenNearestCamera(), true);
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
fn(viewer);
} finally {
globalThis.document = originalDocument;
globalThis.Image = originalImage;
_setCctvOverlayHostForTest();
_setCctvCoverageStateForTest({ enabled: false });
}
}
for (const [name, pick] of [
['NEAREST (focusNearest)', () => cctvLayer.focusNearest({ focus: false })],
['selectCamera', () => cctvLayer.selectCamera('b-cambridge')],
[
'setParams({ selectedCameraId })',
() => cctvLayer.setParams({ selectedCameraId: 'b-cambridge' }),
],
[
'focusNearestToPoint',
() => cctvLayer.focusNearestToPoint(51.513, -0.129, { focus: false }),
],
]) {
test(`an explicit ${name} pick of the re-opened camera ends the opening pick`, () => {
withReopenedLayer((viewer) => {
pick();
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
// A later settled move (a pan, or the landing of the pick's own flight)
// leaves the explicit choice alone.
moveViewer(viewer, 51.5081, -0.1281);
assert.equal(reopenNearestCamera(), false);
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
});
});
}
test('without a pick, the next settled move still follows the view', () => {
withReopenedLayer((viewer) => {
moveViewer(viewer, 51.5081, -0.1281);
assert.equal(reopenNearestCamera(), true);
assert.equal(cctvLayer.getUIState().activeCameraId, 'a-trafalgar');
});
});
+20 -17
View File
@@ -140,25 +140,28 @@ for (const [label, flag] of [
});
}
test('a failed catalog cancels the sibling request instead of waiting for the timeout', async (t) => {
t.mock.method(console, 'warn', () => {});
let siblingSignal;
t.mock.method(globalThis, 'fetch', async (url, options) => {
if (url === LITHUANIA_CAMERAS_URL) {
return new Response('', { status: 503 });
}
siblingSignal = options.signal;
// Never settles on its own; only an abort ends it.
return new Promise((_, reject) => {
options.signal.addEventListener('abort', () =>
reject(options.signal.reason),
);
for (const [failure, camerasResponse] of [
['failed', () => new Response('', { status: 503 })],
['malformed', () => new Response('<html>error page</html>')],
]) {
test(`a ${failure} catalog cancels the sibling request instead of waiting for the timeout`, async (t) => {
t.mock.method(console, 'warn', () => {});
let siblingSignal;
t.mock.method(globalThis, 'fetch', async (url, options) => {
if (url === LITHUANIA_CAMERAS_URL) return camerasResponse();
siblingSignal = options.signal;
// Never settles on its own; only an abort ends it.
return new Promise((_, reject) => {
options.signal.addEventListener('abort', () =>
reject(options.signal.reason),
);
});
});
assert.deepEqual(await loadLithuaniaSources(), []);
assert.equal(siblingSignal?.aborted, true);
assert.notEqual(siblingSignal.reason?.name, 'TimeoutError');
});
assert.deepEqual(await loadLithuaniaSources(), []);
assert.equal(siblingSignal?.aborted, true);
assert.notEqual(siblingSignal.reason?.name, 'TimeoutError');
});
}
test('a redirected catalog is reported as not followed', async (t) => {
const warnings = [];
+103 -2
View File
@@ -111,6 +111,7 @@ function mount(t, respond) {
austin: process.env.CCTV_FORCE_AUSTIN,
serverKey: process.env.GOOGLE_MAPS_SERVER_API_KEY,
browserKey: process.env.GOOGLE_MAPS_API_KEY,
rateLimit: process.env.GEV_RATELIMIT_GOOGLE_PER_MIN,
};
process.env.CCTV_SOURCES_JSON = JSON.stringify([
STILL,
@@ -125,6 +126,8 @@ function mount(t, respond) {
// than a network call this file does not model.
delete process.env.GOOGLE_MAPS_SERVER_API_KEY;
delete process.env.GOOGLE_MAPS_API_KEY;
// The default Google budget, whatever the shell sets.
delete process.env.GEV_RATELIMIT_GOOGLE_PER_MIN;
const nativeFetch = globalThis.fetch;
const requests = [];
globalThis.fetch = async (url, init = {}) => {
@@ -139,6 +142,7 @@ function mount(t, respond) {
['CCTV_FORCE_AUSTIN', before.austin],
['GOOGLE_MAPS_SERVER_API_KEY', before.serverKey],
['GOOGLE_MAPS_API_KEY', before.browserKey],
['GEV_RATELIMIT_GOOGLE_PER_MIN', before.rateLimit],
]) {
if (value === undefined) delete process.env[name];
else process.env[name] = value;
@@ -155,9 +159,9 @@ function mount(t, respond) {
});
assert.ok(handler, 'the CCTV provider must mount a middleware');
const call = async (path, headers = {}) => {
const call = async (path, headers = {}, socket) => {
const { res, done } = recordingResponse();
await handler({ url: path, headers, method: 'GET', on() {} }, res);
await handler({ url: path, headers, method: 'GET', on() {}, socket }, res);
await done;
return res;
};
@@ -528,3 +532,100 @@ test('a forwarded same-origin request reaches every CCTV route but not the Stree
assert.equal(direct.body, 'street-view');
assert.equal(streetViewCalls(), 1);
});
test('the Street View fallback frames catalog cameras only, from the catalog position', async (t) => {
const app = mount(t, ({ url }) =>
url.startsWith('https://maps.googleapis.com/')
? trackedUpstream({
headers: { 'content-type': 'image/jpeg' },
body: 'street-view',
}).response
: upstreamResponse({ status: 503 }),
);
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
const streetView = () =>
app.requests.filter(({ url }) =>
url.startsWith('https://maps.googleapis.com/'),
);
const unknown = await app.call('/frame/not-a-camera?lat=48.85&lon=2.29');
assert.equal(unknown.headers['X-CCTV-Source'], 'synthetic');
assert.deepEqual(streetView(), [], 'no Google call for an unknown id');
const steered = await app.call(
`/frame/${STILL.id}?lat=48.85&lon=2.29&heading=90&fov=74&pitch=-17`,
);
assert.equal(steered.headers['X-CCTV-Source'], 'streetview');
const sv = new URL(streetView()[0].url).searchParams;
assert.equal(sv.get('location'), `${STILL.lat},${STILL.lon}`);
assert.equal(sv.get('heading'), '90');
assert.equal(sv.get('fov'), '74');
assert.equal(sv.get('pitch'), '-17');
});
test('the Street View fallback spends a per-IP Google budget, and only with a key', async (t) => {
const app = mount(t, ({ url }) =>
url.startsWith('https://maps.googleapis.com/')
? trackedUpstream({
headers: { 'content-type': 'image/jpeg' },
body: 'street-view',
}).response
: upstreamResponse({ status: 503 }),
);
// Read when the first keyed fallback builds the limiter, so after mount().
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '2';
const streetViewCalls = () =>
app.requests.filter(({ url }) =>
url.startsWith('https://maps.googleapis.com/'),
).length;
const first = { remoteAddress: '203.0.113.7' };
const frameSource = async (socket) =>
(await app.call(`/frame/${STILL.id}`, {}, socket)).headers['X-CCTV-Source'];
// Without a key nothing is spent.
for (let i = 0; i < 3; i++)
assert.equal(await frameSource(first), 'synthetic');
assert.equal(streetViewCalls(), 0);
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
// Neither an unknown id nor a forwarded request spends the window.
assert.equal(
(await app.call('/frame/not-a-camera', {}, first)).headers['X-CCTV-Source'],
'synthetic',
);
assert.equal(
(
await app.call(
`/frame/${STILL.id}`,
{ 'x-forwarded-for': '203.0.113.9' },
first,
)
).headers['X-CCTV-Source'],
'synthetic',
);
assert.deepEqual(
[
await frameSource(first),
await frameSource(first),
await frameSource(first),
],
['streetview', 'streetview', 'synthetic'],
);
assert.equal(streetViewCalls(), 2, 'no Google call over the budget');
// Another address has a budget of its own.
assert.equal(
await frameSource({ remoteAddress: '203.0.113.8' }),
'streetview',
);
assert.equal(streetViewCalls(), 3);
// Addresses within one IPv6 /64 share a budget.
const v6 = (remoteAddress) => frameSource({ remoteAddress });
assert.deepEqual(
[await v6('2001:db8::1'), await v6('2001:db8::2'), await v6('2001:db8::3')],
['streetview', 'streetview', 'synthetic'],
);
assert.equal(await v6('2001:db8:0:1::1'), 'streetview', 'another /64');
assert.equal(streetViewCalls(), 6);
});
@@ -0,0 +1,87 @@
// Real sockets: a client that closes its connection while the camera upstream
// is still pending must not get a Street View call outside its own budget.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import { cctvProxy } from '../../server/providers/cctv.js';
const CAM = {
id: 'still-fixture',
name: 'Still fixture',
lat: 30.27,
lon: -97.74,
feedType: 'image',
url: 'https://cams.upstream.invalid/still.jpg',
};
test('a client that disconnects mid-fetch stays inside its own Street View budget', async (t) => {
const saved = { ...process.env };
process.env.CCTV_SOURCES_JSON = JSON.stringify([CAM]);
process.env.CCTV_SOURCES_FILE = 'absent-source-file.json';
process.env.CCTV_FORCE_AUSTIN = '0';
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
delete process.env.GOOGLE_MAPS_API_KEY;
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '1';
const nativeFetch = globalThis.fetch;
let streetViewCalls = 0;
globalThis.fetch = async (url) => {
if (String(url).startsWith('https://maps.googleapis.com/')) {
streetViewCalls += 1;
return new Response('street-view', {
headers: { 'content-type': 'image/jpeg' },
});
}
await new Promise((r) => setTimeout(r, 400));
return new Response(null, { status: 503 });
};
let handler;
cctvProxy().configureServer({
middlewares: { use: (_r, fn) => (handler = fn) },
});
const server = http.createServer((req, res) => {
req.url = req.url.replace(/^\/api\/cctv/, '');
handler(req, res, () => res.end());
});
await new Promise((r) => server.listen(0, '127.0.0.1', r));
t.after(() => {
server.close();
globalThis.fetch = nativeFetch;
for (const k of Object.keys(process.env))
if (!(k in saved)) delete process.env[k];
Object.assign(process.env, saved);
});
const { port } = server.address();
const get = (abortAfterMs) =>
new Promise((resolve) => {
const req = http.get(
{
host: '127.0.0.1',
port,
path: `/api/cctv/frame/${CAM.id}`,
headers: { host: `localhost:${port}` },
agent: false,
},
(res) => {
res.resume();
res.on('end', () => resolve(res.headers['x-cctv-source']));
},
);
req.on('error', () => resolve('aborted'));
if (abortAfterMs)
setTimeout(() => {
req.destroy();
resolve('aborted');
}, abortAfterMs);
});
assert.equal(await get(), 'streetview');
assert.equal(await get(), 'synthetic', 'the cap of one is spent');
assert.equal(streetViewCalls, 1);
await get(50);
await new Promise((r) => setTimeout(r, 800));
assert.equal(
streetViewCalls,
1,
'an aborted request spent the key outside its own budget',
);
});
+27 -3
View File
@@ -166,6 +166,30 @@ export const DATA_CREDITS = [
'(<a href="https://celestrak.org" target="_blank" rel="noopener">celestrak.org</a>), ' +
'Dr. T.S. Kelso',
},
{
key: 'nasa-iss-model',
html:
'ISS model: ' +
'<a href="https://science.nasa.gov/3d-resources/international-space-station-iss-d-igoal/" target="_blank" rel="noopener">NASA 3D Resources</a> (JSC IGOAL)',
},
{
key: 'tiangong-model',
html:
"Tiangong model: made for God's Eye View; dimensions from " +
'<a href="https://doi.org/10.34133/space.0035" target="_blank" rel="noopener">Wang, Zhang &amp; Wang 2023</a> ' +
'(CC BY 4.0) and eoPortal',
},
{
key: 'nasa-iss-telemetry',
html: 'ISS joint telemetry (where switched on): NASA ISSLive, via Lightstreamer',
},
{
key: 'nasa-iss-live',
html:
'ISS live video (LIVE section): NASA, via YouTube ' +
'(<a href="https://www.youtube.com/watch?v=ROboUHfPUrU" target="_blank" rel="noopener">exterior cameras</a>, ' +
'<a href="https://www.youtube.com/watch?v=M3HKLzjvKPc" target="_blank" rel="noopener">live video and audio</a>)',
},
{
key: 'ucs-satellite-database',
html:
@@ -303,9 +327,9 @@ export const DATA_CREDITS = [
key: 'ontario-511-cctv',
html:
'CCTV cameras &amp; frames (Ontario): ' +
'<a href="https://511on.ca/" target="_blank" rel="noopener">Ontario 511</a> ' +
'(<a href="https://www.ontario.ca/page/open-government-licence-ontario" target="_blank" rel="noopener">Open Government Licence - Ontario</a>) ' +
'· provided as is, without warranty; actual road conditions may differ',
'<a href="https://511on.ca/" target="_blank" rel="noopener">Ontario 511</a>. ' +
'Contains information licensed under the <a href="https://www.ontario.ca/page/open-government-licence-ontario" target="_blank" rel="noopener">Open Government Licence – Ontario</a>. ' +
'Provided as is, without warranty; actual road conditions may differ.',
},
{
key: 'fintraffic-cctv',
+12
View File
@@ -173,6 +173,18 @@ test('the NYC camera credit carries NYC DOT’s requested disclaimer', () => {
assert.match(credit.html, /observe posted signage/);
});
test('the Ontario 511 camera credit carries the licence attribution statement', () => {
const credit = DATA_CREDITS.find((entry) => entry.key === 'ontario-511-cctv');
assert.ok(credit, 'Ontario 511 camera frames must be credited');
assert.ok(
credit.html.includes(
'Contains information licensed under the <a href="https://www.ontario.ca/page/open-government-licence-ontario"',
),
);
assert.match(credit.html, />Open Government Licence – Ontario<\/a>/);
assert.match(credit.html, /Provided as is, without warranty/);
});
test("the Houston camera credit names TranStar's terms and the permission they require", () => {
const credit = DATA_CREDITS.find((entry) => entry.key === 'houston-cctv');
assert.ok(credit, 'Houston TranStar camera frames must be credited');
+1 -1
View File
@@ -32,7 +32,7 @@ export function createInfrastructureLayers(services) {
name: 'Dams',
color: '#0088ff', // Blue
icon: '▰',
source: 'USACE',
source: 'OpenStreetMap / OpenInfraMap',
osmDerived: true,
labels: true,
labelMax: 900,
+79 -2
View File
@@ -6,6 +6,7 @@ import { createInfrastructureLayers } from 'gods-eye-view/infrastructure';
import { createLocalGeoJsonLayer } from 'gods-eye-view/infrastructure/geojson';
import { fakeInput } from '../input/testDoubles.mjs';
import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs';
import { parseGeojsonLines } from '../sources/infrastructureData.js';
function services() {
const records = new Map();
@@ -34,6 +35,20 @@ function services() {
};
}
// Added from the OSM API, not the OpenInfraMap extract: [id, name, OSM
// object, version]. Both must stay polygons: the Dams layer skips
// LineStrings.
const OSM_API_DAMS = [
[262532166, 'Acaray', 'way/262532166', 7],
[-5671745, 'Represa Yacyretá-Apipé', 'relation/5671745', 2],
];
const DAMS = parseGeojsonLines(
readFileSync(
new URL('./local_data/dams/dams.geojsonl', import.meta.url),
'utf8',
),
);
test('package exports import without an application, DOM, fetch, or timers', () => {
const result = spawnSync(
process.execPath,
@@ -66,7 +81,11 @@ test('infrastructure factory preserves identity and creates independent state wi
first.map(({ id, name, source }) => ({ id, name, source })),
[
{ id: 'local-datacenters', name: 'Datacenters', source: 'Local' },
{ id: 'local-dams', name: 'Dams', source: 'USACE' },
{
id: 'local-dams',
name: 'Dams',
source: 'OpenStreetMap / OpenInfraMap',
},
],
);
first.forEach((layer, index) => {
@@ -84,7 +103,7 @@ test('infrastructure factory preserves identity and creates independent state wi
test('dataset URLs still name the complete bundled sources', () => {
for (const [file, count] of [
['datacenters', 4352],
['dams', 704],
['dams', 706],
]) {
const lines = readFileSync(
new URL(`./local_data/${file}/${file}.geojsonl`, import.meta.url),
@@ -96,6 +115,64 @@ test('dataset URLs still name the complete bundled sources', () => {
}
});
test('Acaray and Yacyretá appear once each with OSM provenance', () => {
for (const [id, name, object, version] of OSM_API_DAMS) {
const matches = DAMS.filter((feature) => feature.id === id);
assert.equal(matches.length, 1);
const { properties } = matches[0];
assert.equal(properties.name, name);
assert.equal(properties.osm_id, id);
assert.equal(properties.source_version, version);
assert.equal(
properties.source_url,
`https://www.openstreetmap.org/${object}`,
);
assert.equal(properties.retrieved_at, '2026-10-15');
}
});
test('Acaray and Yacyretá each get a stem, a selection context and an analyst record', async (t) => {
const added = DAMS.filter((feature) =>
OSM_API_DAMS.some(([id]) => id === feature.id),
);
t.mock.method(globalThis, 'fetch', async () => ({
ok: true,
text: async () =>
added.map((feature) => JSON.stringify(feature)).join('\n'),
}));
const host = services();
const layer = createLocalGeoJsonLayer(
{
id: 'local-dams',
name: 'Dams',
osmDerived: true,
color: '#0088ff',
url: '/dams.geojsonl',
},
host,
);
const viewer = {
scene: { screenSpaceCameraController: { enableInputs: true } },
};
const fake = bindFakeGroundRenderer(viewer);
fakeInput(viewer);
t.after(() => layer.destroy(viewer));
await layer.enable(viewer);
const names = OSM_API_DAMS.map(([, name]) => name).sort();
assert.equal(fake.set('stems').items.size, 2, 'both dams get a stem');
assert.deepEqual(
[...host.records.values()].map((record) => record.label).sort(),
names,
);
assert.deepEqual(
layer
.getAnalystRecords()
.map((record) => record.name)
.sort(),
names,
);
});
test('two viewers use their supplied contexts and dispose independently', async (t) => {
t.mock.method(globalThis, 'fetch', async () => ({
ok: true,
+83
View File
@@ -0,0 +1,83 @@
import { msg } from '../i18n/marker.js';
/**
* Live streams the app can show for a selected object: a fixed list, each
* entry a broadcast on a platform's own player (YouTube today), attached to
* the subjects it shows by key. Any layer can name its selected subject's
* keys (`getLiveSubjectKeys`), and the LIVE section in Context offers the
* streams that match; the satellites layer names the ISS as `station:iss`
* whichever of the station's catalog entries is selected.
*
* These are broadcasts in the platform's embedded player, not camera feeds:
* the CCTV layer is for those. A stream's id changes when its broadcaster
* restarts it, so each entry is one line to update.
*/
/** Where YouTube's embedded player is served from: the privacy-enhanced host. */
export const YOUTUBE_EMBED_HOST = 'https://www.youtube-nocookie.com';
/** @typedef {{id: string, platform: 'youtube', videoId: string, title: string,
* owner: string, ownerUrl: string, subjects: readonly string[],
* note: string}} LiveStream */
/** @type {readonly LiveStream[]} */
export const LIVE_STREAMS = Object.freeze([
Object.freeze({
id: 'iss-exterior',
platform: 'youtube',
videoId: 'ROboUHfPUrU',
title: msg('Exterior cameras'),
owner: 'NASA',
ownerUrl: 'https://www.youtube.com/@NASA',
subjects: Object.freeze(['station:iss']),
note: msg('NASA video, via YouTube'),
}),
Object.freeze({
id: 'iss-crew',
platform: 'youtube',
videoId: 'M3HKLzjvKPc',
title: msg('Live video and space-to-ground audio'),
owner: 'NASA',
ownerUrl: 'https://www.youtube.com/@NASA',
subjects: Object.freeze(['station:iss']),
note: msg('NASA video, via YouTube'),
}),
]);
/**
* The streams attached to any of `subjectKeys`, in list order.
* @param {Iterable<string>|null|undefined} subjectKeys
* @param {readonly LiveStream[]} [streams]
* @returns {LiveStream[]}
*/
export function liveStreamsFor(subjectKeys, streams = LIVE_STREAMS) {
const keys = new Set(subjectKeys ?? []);
if (!keys.size) return [];
return streams.filter((stream) =>
stream.subjects.some((subject) => keys.has(subject)),
);
}
/** The video's own page, for the "Open on YouTube" link. */
export function youtubeWatchUrl(videoId) {
return `https://www.youtube.com/watch?v=${encodeURIComponent(videoId)}`;
}
/**
* The parameters the live player is created with: starts on creation (the
* player is built only when the viewer presses Play), muted so the browser
* lets it start once the player API has loaded, inline on phones, no related
* videos, and the page's origin so the player API may be spoken to.
* @param {string} origin The page's origin.
* @returns {Record<string, string|number>}
*/
export function youtubeLivePlayerVars(origin) {
return {
autoplay: 1,
mute: 1,
playsinline: 1,
rel: 0,
enablejsapi: 1,
...(origin ? { origin } : {}),
};
}
+80
View File
@@ -0,0 +1,80 @@
// src/data/liveStreams.test.mjs — the fixed list of live streams and how a
// selected object's keys pick from it.
import test from 'node:test';
import assert from 'node:assert/strict';
import {
LIVE_STREAMS,
YOUTUBE_EMBED_HOST,
liveStreamsFor,
youtubeLivePlayerVars,
youtubeWatchUrl,
} from './liveStreams.js';
test('every listed stream is a complete YouTube entry with a distinct id', () => {
assert.ok(LIVE_STREAMS.length >= 2, 'the ISS has two streams');
const ids = new Set(LIVE_STREAMS.map((stream) => stream.id));
assert.equal(ids.size, LIVE_STREAMS.length);
for (const stream of LIVE_STREAMS) {
assert.equal(stream.platform, 'youtube');
assert.match(stream.videoId, /^[\w-]{11}$/, `${stream.id} video id`);
assert.ok(stream.title.length > 0);
assert.ok(stream.owner.length > 0);
assert.match(stream.ownerUrl, /^https:\/\/www\.youtube\.com\//);
assert.ok(stream.subjects.length > 0, `${stream.id} names a subject`);
assert.ok(Object.isFrozen(stream), 'entries cannot be edited at run time');
}
});
test('the ISS streams attach to the station key, in list order', () => {
const found = liveStreamsFor(['station:iss']);
assert.deepEqual(
found.map((stream) => stream.id),
['iss-exterior', 'iss-crew'],
);
});
test('a key no stream names, or no keys at all, finds nothing', () => {
assert.deepEqual(liveStreamsFor(['satellites:25544']), []);
assert.deepEqual(liveStreamsFor([]), []);
assert.deepEqual(liveStreamsFor(null), []);
assert.deepEqual(liveStreamsFor(undefined), []);
});
test('a subject known by several keys gets the union, each stream once', () => {
const streams = [
{ id: 'a', subjects: ['x'] },
{ id: 'b', subjects: ['y', 'x'] },
{ id: 'c', subjects: ['z'] },
];
assert.deepEqual(
liveStreamsFor(new Set(['x', 'y']), streams).map((s) => s.id),
['a', 'b'],
);
});
test('the watch link is the video page on YouTube proper', () => {
assert.equal(
youtubeWatchUrl('ROboUHfPUrU'),
'https://www.youtube.com/watch?v=ROboUHfPUrU',
);
assert.equal(
youtubeWatchUrl('a b&c'),
'https://www.youtube.com/watch?v=a%20b%26c',
);
});
test('the player is created on the privacy-enhanced host, muted, with the API on', () => {
assert.equal(YOUTUBE_EMBED_HOST, 'https://www.youtube-nocookie.com');
const vars = youtubeLivePlayerVars('http://localhost:5190');
assert.equal(vars.autoplay, 1);
assert.equal(vars.mute, 1);
assert.equal(vars.playsinline, 1);
assert.equal(vars.rel, 0);
assert.equal(vars.enablejsapi, 1);
assert.equal(vars.origin, 'http://localhost:5190');
assert.equal(
'origin' in youtubeLivePlayerVars(undefined),
false,
'no origin is passed when the page has none',
);
});
+14 -1
View File
@@ -4,7 +4,7 @@ Extracted from local decoded OpenInfraMap/PostGIS layers.
Filters: `waterway=dam`, `man_made=dam`, or `building=dam`.
Feature count: 704
Feature count: 706
Runtime output: `dams.geojsonl`
@@ -15,3 +15,16 @@ this derived database.
The public-release snapshot removes contact-oriented fields and note values
that contain email or phone identifiers. The runtime layer does not display or
depend on those fields.
## OSM API additions
Two dams come from the public OpenStreetMap API rather than the extract:
- Acaray: [way 262532166](https://www.openstreetmap.org/way/262532166), its closed outline of nine nodes.
- Represa Yacyretá-Apipé: [relation 5671745](https://www.openstreetmap.org/relation/5671745), its eight outer ways joined into one closed outline.
Both are under the same ODbL 1.0; the relation keeps the extract's negative ID (-5671745).
Keep both as polygons: the Dams layer skips LineStrings.
The layer puts a polygon's marker at the centre of its bounding sphere. The Yacyretá outline is L-shaped, so its
marker sits about 1.6 km from the outline, over the reservoir.
+2
View File
@@ -702,3 +702,5 @@
{"id":1415605139,"type":"Feature","geometry":{"type":"LineString","coordinates":[[169.362055788,-45.423612051],[169.360158461,-45.423276272],[169.358642426,-45.4229907],[169.357633077,-45.422794061],[169.356944755,-45.42275366],[169.356044036,-45.422764473]]},"properties":{"id":2377429,"line":"","tags":{"power":"minor_line","voltage":"11000","operator":"Aurora Energy","waterway":"dam","operator:wikidata":"Q4822522"},"type":"minor_line","osm_id":1415605139,"tunnel":false,"disused":"","voltage":"11000","circuits":null,"location":"","frequency":"","construction":"","source_layer":"osm_power_line"}}
{"id":405007988,"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[51.592068922,43.199413946],[51.59684602,43.199885177],[51.59724064,43.197759191],[51.593578084,43.197397847],[51.59272137,43.197675623],[51.592397577,43.197643772],[51.592068922,43.199413946]]]},"properties":{"id":33090,"name":"","tags":{"man_made":"wastewater_plant","waterway":"dam"},"type":"wastewater_plant","osm_id":405007988,"source_layer":"osm_wastewater_plant"}}
{"id":-19953989,"type":"Feature","geometry":{"type":"MultiLineString","coordinates":[[[14.292237283,46.169084857],[14.292230326,46.169090389],[14.292224878,46.169096341],[14.292219346,46.169103549],[14.292216999,46.169113188],[14.292215322,46.169122744],[14.29221658,46.169131796],[14.292221273,46.169138334],[14.292231918,46.169148225],[14.29223963,46.169150823]],[[14.292171736,46.168911268],[14.292167462,46.168929289],[14.29216654,46.168975893],[14.292183555,46.169023083],[14.292186321,46.169030124],[14.292204593,46.169025933],[14.292237283,46.169084857]],[[14.293466824,46.169211843],[14.293464394,46.169201869],[14.293090644,46.16923657],[14.293067678,46.169224248],[14.293022583,46.169223662],[14.292636178,46.169247718],[14.292563842,46.169209496],[14.292558394,46.169207988],[14.292478766,46.169186446],[14.292457643,46.169185021],[14.292426882,46.169183429],[14.29241347,46.169186446],[14.292388492,46.169203545],[14.292448842,46.169220477],[14.292470384,46.169226428],[14.292521681,46.169242772],[14.292532661,46.169225673],[14.292546659,46.169229529],[14.29256468,46.169234558],[14.292535679,46.169293483],[14.292533499,46.169297925],[14.292576582,46.169300859],[14.292619162,46.169286191],[14.293023422,46.169262554],[14.293072791,46.169259536],[14.293092321,46.169248388],[14.293466824,46.169211843]],[[14.292535679,46.169293483],[14.29249905,46.169285185],[14.292510198,46.169267248],[14.292313977,46.169211927],[14.292318755,46.169203042],[14.29232546,46.169190721],[14.292333256,46.169176472],[14.292290089,46.169164653],[14.292276175,46.169192062],[14.292257986,46.169227769],[14.29231163,46.169241767],[14.292303919,46.169254842],[14.292294196,46.169271439],[14.292207024,46.169244868],[14.292170647,46.169314522],[14.29248589,46.169394736],[14.292518496,46.169328436],[14.292526123,46.169312845],[14.292533499,46.169297925],[14.292535679,46.169293483]],[[14.292426882,46.169183429],[14.292448172,46.169103549],[14.292476838,46.169107153],[14.292457643,46.169185021],[14.292426882,46.169183429]],[[14.292237283,46.169084857],[14.292246922,46.169084941],[14.292247257,46.169081086],[14.292319845,46.169084857],[14.292448172,46.169103549],[14.292476838,46.169107153],[14.292575074,46.169109333],[14.292575493,46.169095838],[14.292480777,46.169093156],[14.292326383,46.169069099],[14.292247341,46.169065747],[14.292242228,46.169055269],[14.292266117,46.169050324],[14.292263099,46.169041858],[14.292231835,46.169048899],[14.292217418,46.169022161],[14.292267374,46.16901336],[14.292264943,46.169006235],[14.292183555,46.169023083],[14.292186321,46.169030124],[14.292204593,46.169025933],[14.292237283,46.169084857]]]},"properties":{"name":"HE Podlubnik - Centrala","tags":{"name":"HE Podlubnik - Centrala","type":"site","power":"plant","alt_name":"HE Škofja Loka","operator":"Elektro Gorenjska","waterway":"dam","start_date":"1969","plant:method":"run-of-the-river","plant:source":"hydro","plant:output:electricity":"330KW"},"osm_id":-19953989,"output":"330KW","source":"hydro","construction":"","source_layer":"power_plant_relation_by_geom_type"}}
{"type":"Feature","id":-5671745,"geometry":{"type":"Polygon","coordinates":[[[-56.7356385,-27.4830326],[-56.7356372,-27.4836817],[-56.7356918,-27.4837745],[-56.7356509,-27.4838875],[-56.7355326,-27.4837665],[-56.7354735,-27.4836131],[-56.7353507,-27.4835526],[-56.7353552,-27.4830522],[-56.7354053,-27.483032],[-56.7354041,-27.4829378],[-56.7350345,-27.4826704],[-56.7321442,-27.4826598],[-56.7319588,-27.4828659],[-56.7018972,-27.4827418],[-56.7018797,-27.4821358],[-56.706089,-27.4821869],[-56.7060921,-27.4821089],[-56.7063455,-27.482095],[-56.7063734,-27.4821649],[-56.7090948,-27.482163],[-56.7091818,-27.4821095],[-56.7093995,-27.4820799],[-56.7094201,-27.4821854],[-56.7106196,-27.4821876],[-56.7109955,-27.4820628],[-56.7121754,-27.4820408],[-56.7121751,-27.4817168],[-56.712209,-27.4817165],[-56.7122144,-27.4803221],[-56.7121755,-27.4803209],[-56.7121781,-27.4793322],[-56.7122425,-27.4793286],[-56.7122439,-27.4791204],[-56.7121688,-27.479118],[-56.7121795,-27.4788039],[-56.7122371,-27.4788007],[-56.7122492,-27.4788015],[-56.7122948,-27.4790038],[-56.7123002,-27.4793441],[-56.7123005,-27.4796668],[-56.7124411,-27.4796679],[-56.7125759,-27.4796689],[-56.7125765,-27.47935],[-56.7125805,-27.4792477],[-56.7125939,-27.4790371],[-56.7126422,-27.4788016],[-56.7126649,-27.4788009],[-56.7127186,-27.4788051],[-56.7127213,-27.4791216],[-56.7126462,-27.4791276],[-56.7126516,-27.4793274],[-56.7127079,-27.4793263],[-56.7127072,-27.4803126],[-56.7126744,-27.4803132],[-56.712673,-27.4817118],[-56.7127239,-27.481713],[-56.7127247,-27.4820404],[-56.7132439,-27.4820594],[-56.7135349,-27.4821853],[-56.716431,-27.4821918],[-56.7166924,-27.4821402],[-56.7169096,-27.482192],[-56.7354167,-27.4822992],[-56.7432767,-27.4822775],[-56.7432829,-27.4821624],[-56.7433092,-27.4820925],[-56.7433441,-27.4820092],[-56.743387,-27.4819117],[-56.7433977,-27.481826],[-56.7434058,-27.481362],[-56.743385,-27.4806888],[-56.7435047,-27.4806879],[-56.7435053,-27.480804],[-56.7517581,-27.4808023],[-56.7519858,-27.4807842],[-56.7522074,-27.4807224],[-56.7529074,-27.4805122],[-56.7530675,-27.4804512],[-56.753188,-27.4804018],[-56.7536873,-27.4801667],[-56.7539035,-27.480035],[-56.7540186,-27.4799455],[-56.7546428,-27.4793125],[-56.7548624,-27.4789803],[-56.755134,-27.4784449],[-56.7553243,-27.4776504],[-56.7553385,-27.4775558],[-56.7553453,-27.4773839],[-56.7553663,-27.453364],[-56.756278,-27.4533505],[-56.7566902,-27.4545407],[-56.7565699,-27.4671653],[-56.7566153,-27.4769172],[-56.7565098,-27.4782975],[-56.7561882,-27.4791614],[-56.7557343,-27.4797995],[-56.7548315,-27.4808659],[-56.7541622,-27.4813087],[-56.753515,-27.4815729],[-56.7529038,-27.4817915],[-56.7522708,-27.4819086],[-56.7486914,-27.4820093],[-56.7480953,-27.4820155],[-56.7478466,-27.4820264],[-56.747675,-27.4820455],[-56.7475127,-27.4820919],[-56.7469953,-27.4823096],[-56.7450435,-27.4829093],[-56.7443696,-27.4830283],[-56.7436163,-27.4830891],[-56.7434021,-27.483068],[-56.7396907,-27.4830592],[-56.7396861,-27.4833826],[-56.7394399,-27.4833826],[-56.739439,-27.4830604],[-56.7356385,-27.4830326]]]},"properties":{"name":"Represa Yacyretá-Apipé","tags":{"name":"Represa Yacyretá-Apipé","type":"multipolygon","waterway":"dam"},"osm_id":-5671745,"source_layer":"osm_relation","source_url":"https://www.openstreetmap.org/relation/5671745","source_version":2,"retrieved_at":"2026-10-15"}}
{"type":"Feature","id":262532166,"geometry":{"type":"Polygon","coordinates":[[[-54.6285064,-25.4587626],[-54.628456,-25.4586556],[-54.6286513,-25.458535],[-54.6287352,-25.4587382],[-54.6292971,-25.459876],[-54.6290649,-25.4599721],[-54.6285037,-25.4588762],[-54.6285459,-25.4588065],[-54.6285064,-25.4587626]]]},"properties":{"name":"Acaray","tags":{"name":"Acaray","waterway":"dam","wikidata":"Q3433454"},"osm_id":262532166,"source_layer":"osm_way","source_url":"https://www.openstreetmap.org/way/262532166","source_version":7,"retrieved_at":"2026-10-15"}}
+68
View File
@@ -0,0 +1,68 @@
/**
* YouTube's IFrame Player API, loaded once per document: the only in-page
* way to learn a player's state (playing, ended) and errors (video gone,
* embedding refused), which the live-stream player needs to tell an offline
* stream from one still loading. The page's script-src allows
* `https://www.youtube.com`.
*/
const youtubeApis = new WeakMap();
/**
* Load the API, or return the one already there.
* @param {Document} documentRef
* @param {object} globalRef The window: `YT`, `onYouTubeIframeAPIReady`,
* timers.
* @returns {Promise<object>} The `YT` namespace.
*/
export function loadYouTubeApi(documentRef, globalRef) {
if (typeof globalRef.YT?.Player === 'function')
return Promise.resolve(globalRef.YT);
if (youtubeApis.has(documentRef)) return youtubeApis.get(documentRef);
const pending = new Promise((resolve, reject) => {
const previous = globalRef.onYouTubeIframeAPIReady;
let timer;
let settled = false;
const script = documentRef.createElement('script');
const finish = (error) => {
if (settled) return;
settled = true;
globalRef.clearTimeout(timer);
if (globalRef.onYouTubeIframeAPIReady === ready)
globalRef.onYouTubeIframeAPIReady = previous;
if (error) {
script.remove();
reject(error);
} else resolve(globalRef.YT);
};
const ready = () => {
try {
previous?.();
} finally {
finish(
typeof globalRef.YT?.Player === 'function'
? null
: new Error('YouTube API unavailable'),
);
}
};
globalRef.onYouTubeIframeAPIReady = ready;
script.src = 'https://www.youtube.com/iframe_api';
script.async = true;
script.addEventListener(
'error',
() => finish(new Error('YouTube API unavailable')),
{ once: true },
);
timer = globalRef.setTimeout(
() => finish(new Error('YouTube API timed out')),
5000,
);
documentRef.head.append(script);
}).catch((error) => {
youtubeApis.delete(documentRef);
throw error;
});
youtubeApis.set(documentRef, pending);
return pending;
}
+84
View File
@@ -0,0 +1,84 @@
// src/data/youtubeApi.test.mjs — YouTube's IFrame API loader, with the page
// faked: one load per document, and a load that fails is not kept, so the
// LIVE section's Try again loads the API afresh.
import test from 'node:test';
import assert from 'node:assert/strict';
import { loadYouTubeApi } from './youtubeApi.js';
/** A document whose head records the scripts put in it. */
function fakePage() {
const scripts = [];
const timers = [];
const documentRef = {
createElement(tag) {
const listeners = {};
return {
tag,
removed: false,
addEventListener(name, listener) {
listeners[name] = listener;
},
fire(name) {
listeners[name]?.();
},
remove() {
this.removed = true;
},
};
},
head: {
append(node) {
scripts.push(node);
},
},
};
const globalRef = {
setTimeout(callback, delay) {
timers.push({ callback, delay, cleared: false });
return timers.length;
},
clearTimeout(id) {
if (timers[id - 1]) timers[id - 1].cleared = true;
},
};
return { documentRef, globalRef, scripts, timers };
}
class Player {}
test('the API loads once per document, and a loaded one is reused', async () => {
const { documentRef, globalRef, scripts } = fakePage();
const first = loadYouTubeApi(documentRef, globalRef);
assert.equal(loadYouTubeApi(documentRef, globalRef), first);
assert.equal(scripts.length, 1);
assert.equal(scripts[0].src, 'https://www.youtube.com/iframe_api');
globalRef.YT = { Player };
globalRef.onYouTubeIframeAPIReady();
assert.equal(await first, globalRef.YT);
assert.equal(await loadYouTubeApi(documentRef, globalRef), globalRef.YT);
assert.equal(scripts.length, 1);
});
test('a script that fails to load is removed, and the next call loads afresh', async () => {
const { documentRef, globalRef, scripts } = fakePage();
const failed = loadYouTubeApi(documentRef, globalRef);
scripts[0].fire('error');
await assert.rejects(failed, /YouTube API unavailable/);
assert.equal(scripts[0].removed, true);
const again = loadYouTubeApi(documentRef, globalRef);
assert.notEqual(again, failed);
assert.equal(scripts.length, 2);
globalRef.YT = { Player };
globalRef.onYouTubeIframeAPIReady();
assert.equal(await again, globalRef.YT);
});
test('a load slower than 5 s fails, and the next call loads afresh', async () => {
const { documentRef, globalRef, scripts, timers } = fakePage();
const slow = loadYouTubeApi(documentRef, globalRef);
assert.equal(timers[0].delay, 5000);
timers[0].callback();
await assert.rejects(slow, /YouTube API timed out/);
loadYouTubeApi(documentRef, globalRef);
assert.equal(scripts.length, 2);
});
+124
View File
@@ -0,0 +1,124 @@
import { loadYouTubeApi } from './youtubeApi.js';
import { YOUTUBE_EMBED_HOST, youtubeLivePlayerVars } from './liveStreams.js';
/**
* One live stream in YouTube's embedded player, with its state read back
* through the player API: `loading` until the video plays, `playing`, and
* `offline` once the player says the video has ended, cannot be found or
* never starts. The player cannot say "this broadcast is off air" in so
* many words: a live stream that is off air is reported as a video that
* cannot play, or that never reaches playing, so both read as offline here.
* An API that does not load (blocked, or slower than its 5 s) is offline too,
* reason `api`: Try again loads it afresh. Embedding refused by the video's
* owner is `unavailable`, which no retry will change.
*/
/** A stream that has not started playing this long after its player was ready is offline. */
export const LIVE_START_TIMEOUT_MS = 25_000;
/** YouTube's player states. */
const ENDED = 0;
const PLAYING = 1;
/** Error codes: embedding not allowed on this page. */
const EMBED_REFUSED = new Set([101, 150]);
/**
* @param {{host: HTMLElement, videoId: string, documentRef?: Document,
* globalRef?: object, loadApi?: typeof loadYouTubeApi,
* onChange: (state: {state: 'loading'|'playing'|'offline'|'unavailable',
* reason: string|null}) => void}} options `host` is emptied and given the
* player's iframe.
* @returns {{destroy: () => void}}
*/
export function createYouTubeLivePlayer({
host,
videoId,
documentRef = globalThis.document,
globalRef = globalThis,
loadApi = loadYouTubeApi,
onChange,
}) {
let destroyed = false;
let player = null;
let timer = null;
let current = null;
const set = (state, reason = null) => {
if (destroyed || current === state) return;
current = state;
onChange({ state, reason });
};
const clearTimer = () => {
if (timer !== null) globalRef.clearTimeout(timer);
timer = null;
};
const armTimer = () => {
clearTimer();
timer = globalRef.setTimeout(() => {
timer = null;
if (current === 'loading') set('offline', 'timeout');
}, LIVE_START_TIMEOUT_MS);
};
set('loading');
host.replaceChildren();
const mount = documentRef.createElement('div');
host.append(mount);
loadApi(documentRef, globalRef).then(
(YT) => {
if (destroyed) return;
try {
player = new YT.Player(mount, {
host: YOUTUBE_EMBED_HOST,
videoId,
playerVars: youtubeLivePlayerVars(globalRef.location?.origin),
events: {
onReady: () => {
if (!destroyed) armTimer();
},
onStateChange: (event) => {
if (destroyed) return;
if (event?.data === PLAYING) {
clearTimer();
set('playing');
} else if (event?.data === ENDED) {
clearTimer();
set('offline', 'ended');
}
},
onError: (event) => {
if (destroyed) return;
clearTimer();
const code = Number(event?.data);
if (EMBED_REFUSED.has(code)) set('unavailable', `error-${code}`);
else set('offline', `error-${code}`);
},
},
});
// The API may never call onReady for a video it cannot load.
armTimer();
} catch {
set('offline', 'player');
}
},
() => {
if (!destroyed) set('offline', 'api');
},
);
return {
destroy() {
if (destroyed) return;
destroyed = true;
clearTimer();
try {
player?.destroy?.();
} catch {
// A player half-created has nothing to destroy.
}
player = null;
host.replaceChildren();
},
};
}
+188
View File
@@ -0,0 +1,188 @@
// src/data/youtubeLivePlayer.test.mjs — one live stream in YouTube's player,
// with the player API faked: its states and errors read back as the LIVE
// section's loading / playing / offline / unavailable.
import test from 'node:test';
import assert from 'node:assert/strict';
import {
LIVE_START_TIMEOUT_MS,
createYouTubeLivePlayer,
} from './youtubeLivePlayer.js';
import { YOUTUBE_EMBED_HOST } from './liveStreams.js';
/** A stand-in for the panel's host element: counts what is put in it. */
function fakeHost() {
return {
children: [],
replaceChildren() {
this.children = [];
},
append(...nodes) {
this.children.push(...nodes);
},
};
}
/**
* The player as YouTube's API builds it: records its options and lets the
* test fire its events.
*/
function fakeApi() {
const players = [];
class Player {
constructor(mount, options) {
this.mount = mount;
this.options = options;
this.destroyed = 0;
players.push(this);
}
fire(name, data) {
this.options.events[name]?.({ data, target: this });
}
destroy() {
this.destroyed += 1;
}
}
return { YT: { Player }, players };
}
function fixture({ apiFails = false } = {}) {
const api = fakeApi();
const timers = [];
const globalRef = {
location: { origin: 'http://localhost:5190' },
setTimeout(callback, delay) {
const id = timers.length + 1;
timers.push({ id, callback, delay, cleared: false });
return id;
},
clearTimeout(id) {
const timer = timers.find((entry) => entry.id === id);
if (timer) timer.cleared = true;
},
};
const documentRef = { createElement: (tag) => ({ tag }) };
const states = [];
const host = fakeHost();
const player = createYouTubeLivePlayer({
host,
videoId: 'ROboUHfPUrU',
documentRef,
globalRef,
loadApi: () =>
apiFails ? Promise.reject(new Error('blocked')) : Promise.resolve(api.YT),
onChange: (state) => states.push(state),
});
// Let the API promise settle and the player be built.
const settle = () => new Promise((resolve) => setImmediate(resolve));
const pending = () => timers.filter((timer) => !timer.cleared);
return { api, timers, pending, states, host, player, settle };
}
test('the player is built on the privacy host with the live parameters, once the API loads', async () => {
const { api, states, host, settle } = fixture();
assert.deepEqual(states, [{ state: 'loading', reason: null }]);
assert.equal(host.children.length, 1, 'a mount for the iframe is placed');
await settle();
assert.equal(api.players.length, 1);
const { options } = api.players[0];
assert.equal(options.host, YOUTUBE_EMBED_HOST);
assert.equal(options.videoId, 'ROboUHfPUrU');
assert.equal(options.playerVars.enablejsapi, 1);
assert.equal(options.playerVars.mute, 1);
assert.equal(options.playerVars.origin, 'http://localhost:5190');
});
test('playing clears the start timer; the same state is not reported twice', async () => {
const { api, pending, states, settle } = fixture();
await settle();
const [player] = api.players;
player.fire('onReady');
assert.equal(pending().length, 1, 'one start timer is running');
assert.equal(pending()[0].delay, LIVE_START_TIMEOUT_MS);
player.fire('onStateChange', 1);
player.fire('onStateChange', 1);
assert.equal(pending().length, 0, 'the timer went when playback began');
assert.deepEqual(states.at(-1), { state: 'playing', reason: null });
assert.equal(states.length, 2);
});
test('a video that ends, or errors for any other reason, reads as offline', async () => {
const ended = fixture();
await ended.settle();
ended.api.players[0].fire('onStateChange', 0);
assert.deepEqual(ended.states.at(-1), { state: 'offline', reason: 'ended' });
const errored = fixture();
await errored.settle();
errored.api.players[0].fire('onError', 100);
assert.deepEqual(errored.states.at(-1), {
state: 'offline',
reason: 'error-100',
});
assert.equal(errored.pending().length, 0, 'the start timer is cleared');
});
test('embedding refused by the owner is unavailable, which no retry would change', async () => {
for (const code of [101, 150]) {
const { api, states, settle } = fixture();
await settle();
api.players[0].fire('onError', code);
assert.deepEqual(states.at(-1), {
state: 'unavailable',
reason: `error-${code}`,
});
}
});
test('a stream that never starts playing is offline when the start timer runs out', async () => {
const { api, pending, states, settle } = fixture();
await settle();
api.players[0].fire('onReady');
const [timer] = pending();
timer.callback();
assert.deepEqual(states.at(-1), { state: 'offline', reason: 'timeout' });
// Buffering states before the timer do not count as playing.
assert.equal(
states.some((entry) => entry.state === 'playing'),
false,
);
});
test('a timer that fires after playback began changes nothing', async () => {
const { api, timers, states, settle } = fixture();
await settle();
api.players[0].fire('onReady');
api.players[0].fire('onStateChange', 1);
for (const timer of timers) timer.callback();
assert.deepEqual(states.at(-1), { state: 'playing', reason: null });
});
test('an API that does not load reads as offline, which Try again can change', async () => {
const { states, settle } = fixture({ apiFails: true });
await settle();
assert.deepEqual(states.at(-1), { state: 'offline', reason: 'api' });
});
test('destroy empties the host, destroys the player and silences later events', async () => {
const { api, host, pending, player, states, settle } = fixture();
await settle();
const built = api.players[0];
built.fire('onReady');
player.destroy();
player.destroy();
assert.equal(built.destroyed, 1);
assert.equal(host.children.length, 0);
assert.equal(pending().length, 0);
const before = states.length;
built.fire('onStateChange', 1);
built.fire('onError', 150);
assert.equal(states.length, before, 'nothing is reported after destroy');
});
test('destroy before the API loads builds no player', async () => {
const { api, player, states, settle } = fixture();
player.destroy();
await settle();
assert.equal(api.players.length, 0);
assert.deepEqual(states, [{ state: 'loading', reason: null }]);
});
+29
View File
@@ -144,3 +144,32 @@ export function followOffsetFitting(sphere, at, view = {}) {
2 - 1 / Math.max(1, Math.hypot(at.x, at.y, at.z) / WGS84.radii.x);
return offsetFromHeadingPitchRange(0, (-Math.PI / 4) * factor, range);
}
/**
* The heading, pitch and roll that turn the east-north-up frame at `origin`
* onto `axes`: three unit vectors in the Earth-fixed frame that are a
* body's own x, y and z axes there (a right-handed set). The inverse of the
* renderer's placing of a model by `{heading, pitch, roll}` at a position
* (Cesium's `headingPitchRollToFixedFrame`): heading turns about down,
* pitch about the turned east axis, roll about the body's own x. Radians.
* @param {{x: number, y: number, z: number}} origin
* @param {{x: {x: number, y: number, z: number},
* y: {x: number, y: number, z: number},
* z: {x: number, y: number, z: number}}} axes
* @returns {{heading: number, pitch: number, roll: number}}
*/
export function headingPitchRollOfAxes(origin, axes) {
const enu = eastNorthUp(origin);
// M = ENUᵀ · [x y z]: the body's axes on the local east, north, up.
const m00 = dot(enu.x, axes.x);
const m10 = dot(enu.y, axes.x);
const m20 = dot(enu.z, axes.x);
const m21 = dot(enu.z, axes.y);
const m22 = dot(enu.z, axes.z);
// M = Rz(-heading) · Ry(-pitch) · Rx(roll).
return {
heading: -Math.atan2(m10, m00),
pitch: Math.asin(Math.max(-1, Math.min(1, m20))),
roll: Math.atan2(m21, m22),
};
}
+30
View File
@@ -134,6 +134,7 @@ test('a bad or keyless geocode request never reaches Google', async () => {
]) {
const response = await invokeRoute(routes.get(path), { url });
assert.equal(response.statusCode, 400);
assert.equal(response.headers['cache-control'], 'no-store');
assert.deepEqual(response.body.results, []);
assert.equal(response.body.status, 'REQUEST_DENIED');
}
@@ -144,6 +145,7 @@ test('a bad or keyless geocode request never reaches Google', async () => {
url: '/?address=Austin&lat=30&lon=-97',
});
assert.equal(rejected.statusCode, 405);
assert.equal(rejected.headers['cache-control'], 'no-store');
}
// Keyless is an empty capability, not an outage: a 200 the browser adapters
@@ -167,6 +169,33 @@ test('a bad or keyless geocode request never reaches Google', async () => {
assert.deepEqual(upstream, []);
});
test('only a Geocoding answer is kept by the browser', async () => {
// Google can report a denied key or exhausted quota with HTTP 200.
for (const [httpStatus, status, cacheControl] of [
[200, 'OK', 'private, max-age=300'],
[200, 'ZERO_RESULTS', 'private, max-age=300'],
[200, 'REQUEST_DENIED', 'no-store'],
[200, 'OVER_QUERY_LIMIT', 'no-store'],
[200, 'OVER_DAILY_LIMIT', 'no-store'],
[200, 'UNKNOWN_ERROR', 'no-store'],
[503, 'ZERO_RESULTS', 'no-store'],
]) {
const routes = installRoutes({
fetchImpl: async () =>
Response.json({ status, results: [] }, { status: httpStatus }),
});
for (const path of ['/api/google/geocode', '/api/google/reverse-geocode']) {
const label = `${path} ${httpStatus} ${status}`;
const response = await invokeRoute(routes.get(path), {
url: '/?address=Austin&lat=30&lon=-97',
});
assert.equal(response.statusCode, httpStatus, label);
assert.equal(response.body.status, status, label);
assert.equal(response.headers['cache-control'], cacheControl, label);
}
}
});
test('an upstream failure reaches the browser as fixed public text', async () => {
const routes = installRoutes({
fetchImpl: async () => {
@@ -178,6 +207,7 @@ test('an upstream failure reaches the browser as fixed public text', async () =>
url: '/?address=Austin&lat=30&lon=-97',
});
assert.equal(response.statusCode, 502);
assert.equal(response.headers['cache-control'], 'no-store');
assert.deepEqual(response.body, {
status: 'UNKNOWN_ERROR',
results: [],
+107 -1
View File
@@ -4743,5 +4743,111 @@
"Finding it…": "جارٍ البحث عنه…",
"No reading at this time": "لا توجد قراءة في هذا الوقت",
"Last reading · {age}": "آخر قراءة · {age}",
"Find it": "اعثر عليه"
"Find it": "اعثر عليه",
"Underneath": "تحت",
"Open on YouTube": "فتح على YouTube",
"Video plays from YouTube, which sees your IP address.": "يُشغَّل الفيديو من YouTube، الذي يرى عنوان IP الخاص بك.",
"Automatic": "تلقائي",
"Manual": "يدوي",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "الألواح والمشعّات تتبع الشمس، والأطباق تتجه نحو أقمار الترحيل، والأذرع تتحرك للتوضيح فقط. محسوبة، وليست قياسات حية.",
"Overhead": "فوق المحطة",
"Ahead": "أمام",
"Behind": "خلف",
"Port side": "الجانب الأيسر",
"Starboard side": "الجانب الأيمن",
"Night (shadow)": "ليل (ظل)",
"Sun position": "موضع الشمس",
"Follow the Sun": "اتبع الشمس",
"Fast orbit (40 s)": "مدار سريع (40 ث)",
"Solar arrays": "الألواح الشمسية",
"Demonstration: the real arrays stay extended.": "للتوضيح: الألواح الحقيقية تبقى مفرودة.",
"Retract": "طيّ",
"Extend": "فرد",
"Radiators": "المشعّات",
"Demonstration: the real radiators can fold but stay extended.": "للتوضيح: المشعّات الحقيقية قابلة للطي لكنها تبقى مفرودة.",
"Dishes": "الأطباق",
"Relay satellites": "أقمار الترحيل",
"Up": "أعلى",
"Forward": "أمام",
"Sideways": "جانبًا",
"Shoulder roll": "دوران الكتف",
"Shoulder yaw": "انعراج الكتف",
"Shoulder pitch": "ميل الكتف",
"Elbow": "المرفق",
"Wrist pitch": "ميل المعصم",
"Wrist yaw": "انعراج المعصم",
"Wrist roll": "دوران المعصم",
"Canadarm2 (degrees)": "Canadarm2 (درجات)",
"Resume sway": "استئناف الحركة التلقائية",
"Zoom to the ISS": "تقريب إلى المحطة الدولية",
"Now: in sunlight": "الآن: في ضوء الشمس",
"Now: in the Earth's shadow": "الآن: في ظل الأرض",
"{label} · STATION VIEW": "{label} · منظر المحطة",
"STATION VIEW · {name}": "منظر المحطة · {name}",
"Previous station view": "منظر المحطة السابق",
"Next station view": "منظر المحطة التالي",
"OBSERVATION MODULE · ISS": "وحدة رصد · محطة الفضاء الدولية",
"European Space Agency (ESA)": "وكالة الفضاء الأوروبية (ESA)",
"7 WINDOWS": "7 نوافذ",
"LAUNCHED 8 FEB 2010 · STS-130": "أُطلقت 8 فبراير 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "ترانكويليتي · المنفذ المواجه للأرض",
"LABORATORY MODULE · ISS": "وحدة مختبر · محطة الفضاء الدولية",
"Japan Aerospace Exploration Agency (JAXA)": "وكالة استكشاف الفضاء اليابانية (JAXA)",
"2 WINDOWS": "نافذتان",
"LAUNCHED 31 MAY 2008 · STS-124": "أُطلقت 31 مايو 2008 · STS-124",
"HARMONY · PORT SIDE": "هارموني · الجانب الأيسر",
"Return to the default view": "العودة إلى العرض الافتراضي",
"ON AIR": "على الهواء",
"Starting…": "جارٍ البدء…",
"Stream is offline": "البث غير متاح حاليًا",
"LIVE VIDEO": "فيديو مباشر",
"STREAM ATTACHED TO THE SUBJECT": "بث مرتبط بالعنصر",
"Live video": "الفيديو المباشر",
"Show Live Video": "عرض الفيديو المباشر",
"This stream cannot play here": "لا يمكن تشغيل هذا البث هنا",
"Expand Live section": "توسيع قسم البث المباشر",
"Collapse Live section": "طيّ قسم البث المباشر",
"Expand Live": "توسيع البث المباشر",
"Collapse Live": "طيّ البث المباشر",
"Live streams for the selected object": "البث المباشر للعنصر المحدد",
"Stream": "البث",
"Previous stream": "البث السابق",
"Next stream": "البث التالي",
"Try again": "حاول مرة أخرى",
"Exterior cameras": "الكاميرات الخارجية",
"Live video and space-to-ground audio": "فيديو مباشر وصوت الاتصال بين الفضاء والأرض",
"NASA video, via YouTube": "فيديو ناسا، عبر يوتيوب",
"Controls for the selected space station": "عناصر التحكم في المحطة الفضائية المحددة",
"Expand Station section": "توسيع قسم المحطة",
"Collapse Station section": "طيّ قسم المحطة",
"Expand Station": "توسيع المحطة",
"Collapse Station": "طيّ المحطة",
"Manual · telemetry paused": "يدوي · القياسات متوقفة مؤقتًا",
"Telemetry · updated {ago} ago": "القياسات · آخر تحديث قبل {ago}",
"No signal since {time} · computed values": "لا إشارة منذ {time} · قيم محسوبة",
"No signal · computed values": "لا إشارة · قيم محسوبة",
"Telemetry unavailable · last update {ago} ago · computed values": "القياسات غير متاحة · آخر تحديث قبل {ago} · قيم محسوبة",
"Telemetry unavailable · computed values": "القياسات غير متاحة · قيم محسوبة",
"Telemetry not enabled on this server · computed values": "القياسات غير مفعّلة على هذا الخادم · قيم محسوبة",
"No public telemetry · computed values": "لا توجد قياسات عامة · قيم محسوبة",
"Zoom to Tiangong": "تقريب إلى تيانغونغ",
"Tianhe arm (degrees)": "ذراع تيانهه (درجات)",
"Tianhe wings (degrees)": "أجنحة تيانخه (درجات)",
"Lab wings (degrees)": "أجنحة المختبرين (درجات)",
"Port wing": "الجناح الأيسر",
"Starboard wing": "الجناح الأيمن",
"Wentian forward · alpha": "ونتيان الأمامي · ألفا",
"Wentian forward · beta": "ونتيان الأمامي · بيتا",
"Wentian aft · alpha": "ونتيان الخلفي · ألفا",
"Wentian aft · beta": "ونتيان الخلفي · بيتا",
"Mengtian forward · alpha": "منغتيان الأمامي · ألفا",
"Mengtian forward · beta": "منغتيان الأمامي · بيتا",
"Mengtian aft · alpha": "منغتيان الخلفي · ألفا",
"Mengtian aft · beta": "منغتيان الخلفي · بيتا",
"Wentian arm (degrees)": "ذراع ونتيان (درجات)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "الألواح تتبع الشمس، والهوائي يتجه نحو أقمار التتابع، والأذرع تتمايل للتوضيح. محسوب: الصين لا تنشر قياسات حية.",
"Telemetry reads while the model is on screen": "تُقرأ القياسات أثناء ظهور النموذج على الشاشة",
"Connecting to telemetry…": "جارٍ الاتصال بالقياسات…",
"{seconds} s": "{seconds} ث",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "الألواح والمشعّات وأحد الأطباق تتبع القياسات الحية من ناسا. الطبق الآخر ثابت، والأذرع تتحرك للتوضيح فقط."
}
+107 -1
View File
@@ -4319,5 +4319,111 @@
"Finding it…": "Wird gesucht…",
"No reading at this time": "Zu dieser Zeit kein Messwert",
"Last reading · {age}": "Letzter Stand · {age}",
"Find it": "Finden"
"Find it": "Finden",
"Underneath": "Darunter",
"Open on YouTube": "Auf YouTube öffnen",
"Video plays from YouTube, which sees your IP address.": "Das Video wird von YouTube abgespielt, das Ihre IP-Adresse sieht.",
"Automatic": "Automatisch",
"Manual": "Manuell",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Solarflügel und Radiatoren folgen der Sonne, die Antennen richten sich auf Relaissatelliten aus und die Arme bewegen sich zur Veranschaulichung. Berechnet, keine Live-Telemetrie.",
"Overhead": "Über der Station",
"Ahead": "Voraus",
"Behind": "Dahinter",
"Port side": "Backbord",
"Starboard side": "Steuerbord",
"Night (shadow)": "Nacht (Schatten)",
"Sun position": "Sonnenstand",
"Follow the Sun": "Der Sonne folgen",
"Fast orbit (40 s)": "Schneller Umlauf (40 s)",
"Solar arrays": "Solarflügel",
"Demonstration: the real arrays stay extended.": "Demonstration: Die echten Solarflügel bleiben ausgefahren.",
"Retract": "Einfahren",
"Extend": "Ausfahren",
"Radiators": "Radiatoren",
"Demonstration: the real radiators can fold but stay extended.": "Demonstration: Die echten Radiatoren lassen sich falten, bleiben aber ausgefahren.",
"Dishes": "Antennen",
"Relay satellites": "Relaissatelliten",
"Up": "Nach oben",
"Forward": "Nach vorn",
"Sideways": "Zur Seite",
"Shoulder roll": "Schulter-Rollen",
"Shoulder yaw": "Schulter-Gieren",
"Shoulder pitch": "Schulter-Nicken",
"Elbow": "Ellbogen",
"Wrist pitch": "Handgelenk-Nicken",
"Wrist yaw": "Handgelenk-Gieren",
"Wrist roll": "Handgelenk-Rollen",
"Canadarm2 (degrees)": "Canadarm2 (Grad)",
"Resume sway": "Bewegung fortsetzen",
"Zoom to the ISS": "Auf die ISS zoomen",
"Now: in sunlight": "Jetzt: im Sonnenlicht",
"Now: in the Earth's shadow": "Jetzt: im Erdschatten",
"STATION VIEW · {name}": "STATIONSANSICHT · {name}",
"Previous station view": "Vorherige Stationsansicht",
"Next station view": "Nächste Stationsansicht",
"OBSERVATION MODULE · ISS": "BEOBACHTUNGSMODUL · ISS",
"European Space Agency (ESA)": "Europäische Weltraumorganisation (ESA)",
"7 WINDOWS": "7 FENSTER",
"LAUNCHED 8 FEB 2010 · STS-130": "GESTARTET 8. FEB. 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · ERDZUGEWANDTER PORT",
"LABORATORY MODULE · ISS": "LABORMODUL · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Japanische Raumfahrtagentur (JAXA)",
"2 WINDOWS": "2 FENSTER",
"LAUNCHED 31 MAY 2008 · STS-124": "GESTARTET 31. MAI 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · BACKBORDSEITE",
"Return to the default view": "Zur Standardansicht zurückkehren",
"{label} · STATION VIEW": "{label} · STATIONSANSICHT",
"ON AIR": "ON AIR",
"Starting…": "Startet…",
"Stream is offline": "Der Stream ist offline",
"LIVE VIDEO": "LIVE-VIDEO",
"STREAM ATTACHED TO THE SUBJECT": "STREAM ZUM OBJEKT",
"Live video": "Live-Video",
"Show Live Video": "Live-Video anzeigen",
"This stream cannot play here": "Dieser Stream kann hier nicht abgespielt werden",
"Expand Live section": "Live-Bereich ausklappen",
"Collapse Live section": "Live-Bereich einklappen",
"Expand Live": "Live ausklappen",
"Collapse Live": "Live einklappen",
"Live streams for the selected object": "Livestreams zum ausgewählten Objekt",
"Stream": "Stream",
"Previous stream": "Vorheriger Stream",
"Next stream": "Nächster Stream",
"Try again": "Erneut versuchen",
"Exterior cameras": "Außenkameras",
"Live video and space-to-ground audio": "Livevideo und Funkverkehr mit dem Boden",
"NASA video, via YouTube": "NASA-Video, über YouTube",
"Controls for the selected space station": "Steuerung der ausgewählten Raumstation",
"Expand Station section": "Stationsbereich ausklappen",
"Collapse Station section": "Stationsbereich einklappen",
"Expand Station": "Station ausklappen",
"Collapse Station": "Station einklappen",
"Manual · telemetry paused": "Manuell · Telemetrie pausiert",
"Telemetry · updated {ago} ago": "Telemetrie · aktualisiert vor {ago}",
"No signal since {time} · computed values": "Kein Signal seit {time} · berechnete Werte",
"No signal · computed values": "Kein Signal · berechnete Werte",
"Telemetry unavailable · last update {ago} ago · computed values": "Telemetrie nicht verfügbar · letzte Aktualisierung vor {ago} · berechnete Werte",
"Telemetry unavailable · computed values": "Telemetrie nicht verfügbar · berechnete Werte",
"Telemetry not enabled on this server · computed values": "Telemetrie auf diesem Server nicht aktiviert · berechnete Werte",
"No public telemetry · computed values": "Keine öffentliche Telemetrie · berechnete Werte",
"Zoom to Tiangong": "Auf Tiangong zoomen",
"Tianhe arm (degrees)": "Tianhe-Arm (Grad)",
"Tianhe wings (degrees)": "Tianhe-Flügel (Grad)",
"Lab wings (degrees)": "Labor-Flügel (Grad)",
"Port wing": "Backbordflügel",
"Starboard wing": "Steuerbordflügel",
"Wentian forward · alpha": "Wentian vorn · Alpha",
"Wentian forward · beta": "Wentian vorn · Beta",
"Wentian aft · alpha": "Wentian hinten · Alpha",
"Wentian aft · beta": "Wentian hinten · Beta",
"Mengtian forward · alpha": "Mengtian vorn · Alpha",
"Mengtian forward · beta": "Mengtian vorn · Beta",
"Mengtian aft · alpha": "Mengtian hinten · Alpha",
"Mengtian aft · beta": "Mengtian hinten · Beta",
"Wentian arm (degrees)": "Wentian-Arm (Grad)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Solarflügel folgen der Sonne, die Antenne richtet sich auf Relaissatelliten und die Arme schwenken zur Veranschaulichung. Berechnet: China veröffentlicht keine Live-Telemetrie.",
"Telemetry reads while the model is on screen": "Telemetrie wird gelesen, solange das Modell zu sehen ist",
"Connecting to telemetry…": "Verbindung zur Telemetrie…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Solarflügel, Radiatoren und eine Antenne folgen der Live-Telemetrie der NASA. Die andere Antenne steht still und die Arme bewegen sich zur Veranschaulichung."
}
+107 -1
View File
@@ -4425,5 +4425,111 @@
"Finding it…": "Buscando…",
"No reading at this time": "Sin lectura a esta hora",
"Last reading · {age}": "Última lectura · {age}",
"Find it": "Encontrar"
"Find it": "Encontrar",
"Underneath": "Abajo",
"Open on YouTube": "Abrir en YouTube",
"Video plays from YouTube, which sees your IP address.": "El vídeo se reproduce desde YouTube, que ve tu dirección IP.",
"Automatic": "Automático",
"Manual": "Manual",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Los paneles y radiadores siguen al Sol, las antenas apuntan a los satélites de retransmisión y los brazos se mueven a modo de ilustración. Calculado, no es telemetría en vivo.",
"Overhead": "Arriba",
"Ahead": "Delante",
"Behind": "Detrás",
"Port side": "Babor",
"Starboard side": "Estribor",
"Night (shadow)": "Noche (sombra)",
"Sun position": "Posición del Sol",
"Follow the Sun": "Seguir al Sol",
"Fast orbit (40 s)": "Órbita rápida (40 s)",
"Solar arrays": "Paneles solares",
"Demonstration: the real arrays stay extended.": "Demostración: los paneles reales permanecen desplegados.",
"Retract": "Recoger",
"Extend": "Desplegar",
"Radiators": "Radiadores",
"Demonstration: the real radiators can fold but stay extended.": "Demostración: los radiadores reales pueden plegarse, pero permanecen desplegados.",
"Dishes": "Antenas",
"Relay satellites": "Satélites de retransmisión",
"Up": "Arriba",
"Forward": "Adelante",
"Sideways": "De lado",
"Shoulder roll": "Alabeo del hombro",
"Shoulder yaw": "Guiñada del hombro",
"Shoulder pitch": "Cabeceo del hombro",
"Elbow": "Codo",
"Wrist pitch": "Cabeceo de la muñeca",
"Wrist yaw": "Guiñada de la muñeca",
"Wrist roll": "Alabeo de la muñeca",
"Canadarm2 (degrees)": "Canadarm2 (grados)",
"Resume sway": "Reanudar movimiento",
"Zoom to the ISS": "Acercar a la ISS",
"Now: in sunlight": "Ahora: a la luz del Sol",
"Now: in the Earth's shadow": "Ahora: a la sombra de la Tierra",
"{label} · STATION VIEW": "{label} · VISTA DE LA ESTACIÓN",
"STATION VIEW · {name}": "VISTA DE LA ESTACIÓN · {name}",
"Previous station view": "Vista anterior de la estación",
"Next station view": "Siguiente vista de la estación",
"OBSERVATION MODULE · ISS": "MÓDULO DE OBSERVACIÓN · ISS",
"European Space Agency (ESA)": "Agencia Espacial Europea (ESA)",
"7 WINDOWS": "7 VENTANAS",
"LAUNCHED 8 FEB 2010 · STS-130": "LANZADO EL 8 FEB 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · PUERTO ORIENTADO A LA TIERRA",
"LABORATORY MODULE · ISS": "MÓDULO LABORATORIO · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Agencia Japonesa de Exploración Aeroespacial (JAXA)",
"2 WINDOWS": "2 VENTANAS",
"LAUNCHED 31 MAY 2008 · STS-124": "LANZADO EL 31 MAY 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · LADO DE BABOR",
"Return to the default view": "Volver a la vista predeterminada",
"ON AIR": "EN EL AIRE",
"Starting…": "Iniciando…",
"Stream is offline": "La transmisión está fuera de línea",
"LIVE VIDEO": "VÍDEO EN VIVO",
"STREAM ATTACHED TO THE SUBJECT": "TRANSMISIÓN VINCULADA AL OBJETO",
"Live video": "Vídeo en vivo",
"Show Live Video": "Mostrar Vídeo en vivo",
"This stream cannot play here": "Esta transmisión no se puede reproducir aquí",
"Expand Live section": "Expandir la sección En directo",
"Collapse Live section": "Contraer la sección En directo",
"Expand Live": "Expandir En directo",
"Collapse Live": "Contraer En directo",
"Live streams for the selected object": "Transmisiones en directo del objeto seleccionado",
"Stream": "Transmisión",
"Previous stream": "Transmisión anterior",
"Next stream": "Siguiente transmisión",
"Try again": "Reintentar",
"Exterior cameras": "Cámaras exteriores",
"Live video and space-to-ground audio": "Vídeo en directo y audio espacio-tierra",
"NASA video, via YouTube": "Vídeo de la NASA, vía YouTube",
"Controls for the selected space station": "Controles de la estación espacial seleccionada",
"Expand Station section": "Expandir la sección Estación",
"Collapse Station section": "Contraer la sección Estación",
"Expand Station": "Expandir Estación",
"Collapse Station": "Contraer Estación",
"Manual · telemetry paused": "Manual · telemetría en pausa",
"Telemetry · updated {ago} ago": "Telemetría · actualizada hace {ago}",
"No signal since {time} · computed values": "Sin señal desde las {time} · valores calculados",
"No signal · computed values": "Sin señal · valores calculados",
"Telemetry unavailable · last update {ago} ago · computed values": "Telemetría no disponible · última actualización hace {ago} · valores calculados",
"Telemetry unavailable · computed values": "Telemetría no disponible · valores calculados",
"Telemetry not enabled on this server · computed values": "Telemetría no activada en este servidor · valores calculados",
"No public telemetry · computed values": "Sin telemetría pública · valores calculados",
"Zoom to Tiangong": "Acercar a Tiangong",
"Tianhe arm (degrees)": "Brazo de Tianhe (grados)",
"Tianhe wings (degrees)": "Alas de Tianhe (grados)",
"Lab wings (degrees)": "Alas de los laboratorios (grados)",
"Port wing": "Ala de babor",
"Starboard wing": "Ala de estribor",
"Wentian forward · alpha": "Wentian delantera · alfa",
"Wentian forward · beta": "Wentian delantera · beta",
"Wentian aft · alpha": "Wentian trasera · alfa",
"Wentian aft · beta": "Wentian trasera · beta",
"Mengtian forward · alpha": "Mengtian delantera · alfa",
"Mengtian forward · beta": "Mengtian delantera · beta",
"Mengtian aft · alpha": "Mengtian trasera · alfa",
"Mengtian aft · beta": "Mengtian trasera · beta",
"Wentian arm (degrees)": "Brazo de Wentian (grados)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Los paneles siguen al Sol, la antena apunta a los satélites de retransmisión y los brazos se mueven a modo de ilustración. Calculado: China no publica telemetría en directo.",
"Telemetry reads while the model is on screen": "La telemetría se lee mientras el modelo está en pantalla",
"Connecting to telemetry…": "Conectando con la telemetría…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Los paneles, los radiadores y una antena siguen la telemetría en vivo de la NASA. La otra antena permanece quieta y los brazos se mueven a modo de ilustración."
}
+107 -1
View File
@@ -4425,5 +4425,111 @@
"Finding it…": "Recherche…",
"No reading at this time": "Aucune donnée à cette heure",
"Last reading · {age}": "Dernière donnée · {age}",
"Find it": "Retrouver"
"Find it": "Retrouver",
"Underneath": "En dessous",
"Open on YouTube": "Ouvrir sur YouTube",
"Video plays from YouTube, which sees your IP address.": "La vidéo est lue depuis YouTube, qui voit votre adresse IP.",
"Automatic": "Automatique",
"Manual": "Manuel",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Les panneaux et les radiateurs suivent le Soleil, les antennes visent les satellites relais et les bras bougent à titre d'illustration. Calculé, pas de télémétrie en direct.",
"Overhead": "Au-dessus",
"Ahead": "Devant",
"Behind": "Derrière",
"Port side": "Bâbord",
"Starboard side": "Tribord",
"Night (shadow)": "Nuit (ombre)",
"Sun position": "Position du Soleil",
"Follow the Sun": "Suivre le Soleil",
"Fast orbit (40 s)": "Orbite rapide (40 s)",
"Solar arrays": "Panneaux solaires",
"Demonstration: the real arrays stay extended.": "Démonstration : les vrais panneaux restent déployés.",
"Retract": "Rétracter",
"Extend": "Déployer",
"Radiators": "Radiateurs",
"Demonstration: the real radiators can fold but stay extended.": "Démonstration : les vrais radiateurs peuvent se replier mais restent déployés.",
"Dishes": "Antennes",
"Relay satellites": "Satellites relais",
"Up": "Vers le haut",
"Forward": "Vers l'avant",
"Sideways": "Sur le côté",
"Shoulder roll": "Roulis d'épaule",
"Shoulder yaw": "Lacet d'épaule",
"Shoulder pitch": "Tangage d'épaule",
"Elbow": "Coude",
"Wrist pitch": "Tangage du poignet",
"Wrist yaw": "Lacet du poignet",
"Wrist roll": "Roulis du poignet",
"Canadarm2 (degrees)": "Canadarm2 (degrés)",
"Resume sway": "Reprendre le mouvement",
"Zoom to the ISS": "Zoomer sur l'ISS",
"Now: in sunlight": "En ce moment : au soleil",
"Now: in the Earth's shadow": "En ce moment : dans l'ombre de la Terre",
"STATION VIEW · {name}": "VUE DE LA STATION · {name}",
"Previous station view": "Vue précédente de la station",
"Next station view": "Vue suivante de la station",
"OBSERVATION MODULE · ISS": "MODULE D'OBSERVATION · ISS",
"European Space Agency (ESA)": "Agence spatiale européenne (ESA)",
"7 WINDOWS": "7 HUBLOTS",
"LAUNCHED 8 FEB 2010 · STS-130": "LANCÉ LE 8 FÉV. 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · PORT ORIENTÉ VERS LA TERRE",
"LABORATORY MODULE · ISS": "MODULE LABORATOIRE · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Agence japonaise d'exploration aérospatiale (JAXA)",
"2 WINDOWS": "2 HUBLOTS",
"LAUNCHED 31 MAY 2008 · STS-124": "LANCÉ LE 31 MAI 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · CÔTÉ BÂBORD",
"Return to the default view": "Revenir à la vue par défaut",
"{label} · STATION VIEW": "{label} · VUE DE LA STATION",
"ON AIR": "À L’ANTENNE",
"Starting…": "Démarrage…",
"Stream is offline": "Le flux est hors ligne",
"LIVE VIDEO": "VIDÉO EN DIRECT",
"STREAM ATTACHED TO THE SUBJECT": "FLUX ATTACHÉ À L’OBJET",
"Live video": "Vidéo en direct",
"Show Live Video": "Afficher la vidéo en direct",
"This stream cannot play here": "Ce flux ne peut pas être lu ici",
"Expand Live section": "Déplier la section Direct",
"Collapse Live section": "Replier la section Direct",
"Expand Live": "Déplier Direct",
"Collapse Live": "Replier Direct",
"Live streams for the selected object": "Flux en direct de l’objet sélectionné",
"Stream": "Flux",
"Previous stream": "Flux précédent",
"Next stream": "Flux suivant",
"Try again": "Réessayer",
"Exterior cameras": "Caméras extérieures",
"Live video and space-to-ground audio": "Vidéo en direct et audio espace-sol",
"NASA video, via YouTube": "Vidéo de la NASA, via YouTube",
"Controls for the selected space station": "Commandes de la station spatiale sélectionnée",
"Expand Station section": "Déplier la section Station",
"Collapse Station section": "Replier la section Station",
"Expand Station": "Déplier Station",
"Collapse Station": "Replier Station",
"Manual · telemetry paused": "Manuel · télémétrie en pause",
"Telemetry · updated {ago} ago": "Télémétrie · mise à jour il y a {ago}",
"No signal since {time} · computed values": "Pas de signal depuis {time} · valeurs calculées",
"No signal · computed values": "Pas de signal · valeurs calculées",
"Telemetry unavailable · last update {ago} ago · computed values": "Télémétrie indisponible · dernière mise à jour il y a {ago} · valeurs calculées",
"Telemetry unavailable · computed values": "Télémétrie indisponible · valeurs calculées",
"Telemetry not enabled on this server · computed values": "Télémétrie non activée sur ce serveur · valeurs calculées",
"No public telemetry · computed values": "Pas de télémétrie publique · valeurs calculées",
"Zoom to Tiangong": "Zoomer sur Tiangong",
"Tianhe arm (degrees)": "Bras de Tianhe (degrés)",
"Tianhe wings (degrees)": "Ailes de Tianhe (degrés)",
"Lab wings (degrees)": "Ailes des laboratoires (degrés)",
"Port wing": "Aile bâbord",
"Starboard wing": "Aile tribord",
"Wentian forward · alpha": "Wentian avant · alpha",
"Wentian forward · beta": "Wentian avant · bêta",
"Wentian aft · alpha": "Wentian arrière · alpha",
"Wentian aft · beta": "Wentian arrière · bêta",
"Mengtian forward · alpha": "Mengtian avant · alpha",
"Mengtian forward · beta": "Mengtian avant · bêta",
"Mengtian aft · alpha": "Mengtian arrière · alpha",
"Mengtian aft · beta": "Mengtian arrière · bêta",
"Wentian arm (degrees)": "Bras de Wentian (degrés)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Les panneaux suivent le Soleil, l'antenne vise les satellites relais et les bras oscillent à titre d'illustration. Calculé : la Chine ne publie pas de télémétrie en direct.",
"Telemetry reads while the model is on screen": "La télémétrie est lue tant que le modèle est à l'écran",
"Connecting to telemetry…": "Connexion à la télémétrie…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Les panneaux, les radiateurs et une antenne suivent la télémétrie en direct de la NASA. L'autre antenne reste immobile et les bras bougent à titre d'illustration."
}
+107 -1
View File
@@ -4425,5 +4425,111 @@
"Finding it…": "מחפש…",
"No reading at this time": "אין קריאה בזמן הזה",
"Last reading · {age}": "קריאה אחרונה · {age}",
"Find it": "מצא"
"Find it": "מצא",
"Underneath": "מתחת",
"Open on YouTube": "פתיחה ב-YouTube",
"Video plays from YouTube, which sees your IP address.": "הווידאו זורם מ-YouTube, שרואה את כתובת ה-IP שלך.",
"Automatic": "אוטומטי",
"Manual": "ידני",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "הלוחות והרדיאטורים עוקבים אחר השמש, הצלחות מכוונות ללווייני ממסר והזרועות נעות להמחשה בלבד. מחושב, לא טלמטריה חיה.",
"Overhead": "מעל",
"Ahead": "מלפנים",
"Behind": "מאחור",
"Port side": "צד שמאל",
"Starboard side": "צד ימין",
"Night (shadow)": "לילה (צל)",
"Sun position": "מיקום השמש",
"Follow the Sun": "מעקב אחר השמש",
"Fast orbit (40 s)": "הקפה מהירה (40 שנ')",
"Solar arrays": "לוחות סולאריים",
"Demonstration: the real arrays stay extended.": "הדגמה: הלוחות האמיתיים נשארים פרושים.",
"Retract": "קיפול",
"Extend": "פריסה",
"Radiators": "רדיאטורים",
"Demonstration: the real radiators can fold but stay extended.": "הדגמה: הרדיאטורים האמיתיים יכולים להתקפל אך נשארים פרושים.",
"Dishes": "צלחות",
"Relay satellites": "לווייני ממסר",
"Up": "למעלה",
"Forward": "קדימה",
"Sideways": "הצידה",
"Shoulder roll": "גלגול כתף",
"Shoulder yaw": "סבסוב כתף",
"Shoulder pitch": "עלרוד כתף",
"Elbow": "מרפק",
"Wrist pitch": "עלרוד שורש כף היד",
"Wrist yaw": "סבסוב שורש כף היד",
"Wrist roll": "גלגול שורש כף היד",
"Canadarm2 (degrees)": "Canadarm2 (מעלות)",
"Resume sway": "חידוש התנועה",
"Zoom to the ISS": "התקרבות לתחנת החלל",
"Now: in sunlight": "כעת: באור השמש",
"Now: in the Earth's shadow": "כעת: בצל כדור הארץ",
"{label} · STATION VIEW": "{label} · תצוגת התחנה",
"STATION VIEW · {name}": "תצוגת התחנה · {name}",
"Previous station view": "תצוגת התחנה הקודמת",
"Next station view": "תצוגת התחנה הבאה",
"OBSERVATION MODULE · ISS": "מודול תצפית · תחנת החלל",
"European Space Agency (ESA)": "סוכנות החלל האירופית (ESA)",
"7 WINDOWS": "7 חלונות",
"LAUNCHED 8 FEB 2010 · STS-130": "שוגר ב-8 בפברואר 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "טרנקוויליטי · פתח הפונה לכדור הארץ",
"LABORATORY MODULE · ISS": "מודול מעבדה · תחנת החלל",
"Japan Aerospace Exploration Agency (JAXA)": "סוכנות חקר החלל היפנית (JAXA)",
"2 WINDOWS": "2 חלונות",
"LAUNCHED 31 MAY 2008 · STS-124": "שוגר ב-31 במאי 2008 · STS-124",
"HARMONY · PORT SIDE": "הרמוני · צד שמאל",
"Return to the default view": "חזרה לתצוגת ברירת המחדל",
"ON AIR": "בשידור",
"Starting…": "מתחיל…",
"Stream is offline": "השידור אינו פעיל",
"LIVE VIDEO": "וידאו חי",
"STREAM ATTACHED TO THE SUBJECT": "שידור המשויך לפריט",
"Live video": "וידאו חי",
"Show Live Video": "הצגת וידאו חי",
"This stream cannot play here": "לא ניתן להפעיל שידור זה כאן",
"Expand Live section": "הרחבת מקטע השידור החי",
"Collapse Live section": "כיווץ מקטע השידור החי",
"Expand Live": "הרחבת שידור חי",
"Collapse Live": "כיווץ שידור חי",
"Live streams for the selected object": "שידורים חיים של הפריט שנבחר",
"Stream": "שידור",
"Previous stream": "השידור הקודם",
"Next stream": "השידור הבא",
"Try again": "ניסיון חוזר",
"Exterior cameras": "מצלמות חיצוניות",
"Live video and space-to-ground audio": "וידאו חי ושמע חלל–קרקע",
"NASA video, via YouTube": "וידאו של נאס״א, דרך יוטיוב",
"Controls for the selected space station": "בקרות לתחנת החלל שנבחרה",
"Expand Station section": "הרחבת מקטע התחנה",
"Collapse Station section": "כיווץ מקטע התחנה",
"Expand Station": "הרחבת התחנה",
"Collapse Station": "כיווץ התחנה",
"Manual · telemetry paused": "ידני · הטלמטריה מושהית",
"Telemetry · updated {ago} ago": "טלמטריה · עודכנה לפני {ago}",
"No signal since {time} · computed values": "אין אות מאז {time} · ערכים מחושבים",
"No signal · computed values": "אין אות · ערכים מחושבים",
"Telemetry unavailable · last update {ago} ago · computed values": "הטלמטריה אינה זמינה · עדכון אחרון לפני {ago} · ערכים מחושבים",
"Telemetry unavailable · computed values": "הטלמטריה אינה זמינה · ערכים מחושבים",
"Telemetry not enabled on this server · computed values": "הטלמטריה אינה מופעלת בשרת זה · ערכים מחושבים",
"No public telemetry · computed values": "אין טלמטריה ציבורית · ערכים מחושבים",
"Zoom to Tiangong": "התקרבות לטיאנגונג",
"Tianhe arm (degrees)": "זרוע טיאנהה (מעלות)",
"Tianhe wings (degrees)": "כנפי טיאנחה (מעלות)",
"Lab wings (degrees)": "כנפי המעבדות (מעלות)",
"Port wing": "כנף שמאל",
"Starboard wing": "כנף ימין",
"Wentian forward · alpha": "ונטיאן קדמי · אלפא",
"Wentian forward · beta": "ונטיאן קדמי · בטא",
"Wentian aft · alpha": "ונטיאן אחורי · אלפא",
"Wentian aft · beta": "ונטיאן אחורי · בטא",
"Mengtian forward · alpha": "מנגטיאן קדמי · אלפא",
"Mengtian forward · beta": "מנגטיאן קדמי · בטא",
"Mengtian aft · alpha": "מנגטיאן אחורי · אלפא",
"Mengtian aft · beta": "מנגטיאן אחורי · בטא",
"Wentian arm (degrees)": "זרוע ונטיאן (מעלות)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "הלוחות עוקבים אחר השמש, האנטנה מכוונת ללווייני ממסר והזרועות נעות לצורכי הדגמה. מחושב: סין אינה מפרסמת טלמטריה חיה.",
"Telemetry reads while the model is on screen": "הטלמטריה נקראת כל עוד הדגם מוצג על המסך",
"Connecting to telemetry…": "מתחבר לטלמטריה…",
"{seconds} s": "{seconds} שנ׳",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "הלוחות, הרדיאטורים וצלחת אחת עוקבים אחר הטלמטריה החיה של נאס״א. הצלחת השנייה נשארת במקומה והזרועות נעות להמחשה בלבד."
}
+107 -1
View File
@@ -4425,5 +4425,111 @@
"Finding it…": "Ricerca in corso…",
"No reading at this time": "Nessun dato a quest'ora",
"Last reading · {age}": "Ultimo dato · {age}",
"Find it": "Trova"
"Find it": "Trova",
"Underneath": "Sotto",
"Open on YouTube": "Apri su YouTube",
"Video plays from YouTube, which sees your IP address.": "Il video viene riprodotto da YouTube, che vede il tuo indirizzo IP.",
"Automatic": "Automatico",
"Manual": "Manuale",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Pannelli e radiatori seguono il Sole, le antenne puntano ai satelliti di collegamento e i bracci si muovono a scopo illustrativo. Calcolato, non telemetria in diretta.",
"Overhead": "Sopra",
"Ahead": "Davanti",
"Behind": "Dietro",
"Port side": "Babordo",
"Starboard side": "Tribordo",
"Night (shadow)": "Notte (ombra)",
"Sun position": "Posizione del Sole",
"Follow the Sun": "Segui il Sole",
"Fast orbit (40 s)": "Orbita veloce (40 s)",
"Solar arrays": "Pannelli solari",
"Demonstration: the real arrays stay extended.": "Dimostrazione: i pannelli reali restano dispiegati.",
"Retract": "Ritira",
"Extend": "Dispiega",
"Radiators": "Radiatori",
"Demonstration: the real radiators can fold but stay extended.": "Dimostrazione: i radiatori reali possono ripiegarsi ma restano dispiegati.",
"Dishes": "Antenne",
"Relay satellites": "Satelliti di collegamento",
"Up": "In alto",
"Forward": "In avanti",
"Sideways": "Di lato",
"Shoulder roll": "Rollio spalla",
"Shoulder yaw": "Imbardata spalla",
"Shoulder pitch": "Beccheggio spalla",
"Elbow": "Gomito",
"Wrist pitch": "Beccheggio polso",
"Wrist yaw": "Imbardata polso",
"Wrist roll": "Rollio polso",
"Canadarm2 (degrees)": "Canadarm2 (gradi)",
"Resume sway": "Riprendi movimento",
"Zoom to the ISS": "Zoom sulla ISS",
"Now: in sunlight": "Ora: alla luce del Sole",
"Now: in the Earth's shadow": "Ora: nell'ombra della Terra",
"STATION VIEW · {name}": "VISTA DELLA STAZIONE · {name}",
"Previous station view": "Vista precedente della stazione",
"Next station view": "Vista successiva della stazione",
"OBSERVATION MODULE · ISS": "MODULO DI OSSERVAZIONE · ISS",
"European Space Agency (ESA)": "Agenzia Spaziale Europea (ESA)",
"7 WINDOWS": "7 FINESTRINI",
"LAUNCHED 8 FEB 2010 · STS-130": "LANCIATO L’8 FEB 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · PORTELLONE RIVOLTO ALLA TERRA",
"LABORATORY MODULE · ISS": "MODULO LABORATORIO · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Agenzia Giapponese per l’Esplorazione Aerospaziale (JAXA)",
"2 WINDOWS": "2 FINESTRINI",
"LAUNCHED 31 MAY 2008 · STS-124": "LANCIATO IL 31 MAG 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · LATO DI BABORDO",
"Return to the default view": "Torna alla vista predefinita",
"{label} · STATION VIEW": "{label} · VISTA DELLA STAZIONE",
"ON AIR": "IN ONDA",
"Starting…": "Avvio…",
"Stream is offline": "La diretta è offline",
"LIVE VIDEO": "VIDEO LIVE",
"STREAM ATTACHED TO THE SUBJECT": "DIRETTA COLLEGATA ALL’OGGETTO",
"Live video": "Video live",
"Show Live Video": "Mostra Video live",
"This stream cannot play here": "Questa diretta non può essere riprodotta qui",
"Expand Live section": "Espandi la sezione Live",
"Collapse Live section": "Comprimi la sezione Live",
"Expand Live": "Espandi Live",
"Collapse Live": "Comprimi Live",
"Live streams for the selected object": "Dirette dell’oggetto selezionato",
"Stream": "Diretta",
"Previous stream": "Diretta precedente",
"Next stream": "Diretta successiva",
"Try again": "Riprova",
"Exterior cameras": "Telecamere esterne",
"Live video and space-to-ground audio": "Video in diretta e audio spazio-terra",
"NASA video, via YouTube": "Video NASA, tramite YouTube",
"Controls for the selected space station": "Controlli della stazione spaziale selezionata",
"Expand Station section": "Espandi la sezione Stazione",
"Collapse Station section": "Comprimi la sezione Stazione",
"Expand Station": "Espandi Stazione",
"Collapse Station": "Comprimi Stazione",
"Manual · telemetry paused": "Manuale · telemetria in pausa",
"Telemetry · updated {ago} ago": "Telemetria · aggiornata {ago} fa",
"No signal since {time} · computed values": "Nessun segnale dalle {time} · valori calcolati",
"No signal · computed values": "Nessun segnale · valori calcolati",
"Telemetry unavailable · last update {ago} ago · computed values": "Telemetria non disponibile · ultimo aggiornamento {ago} fa · valori calcolati",
"Telemetry unavailable · computed values": "Telemetria non disponibile · valori calcolati",
"Telemetry not enabled on this server · computed values": "Telemetria non attivata su questo server · valori calcolati",
"No public telemetry · computed values": "Nessuna telemetria pubblica · valori calcolati",
"Zoom to Tiangong": "Zoom su Tiangong",
"Tianhe arm (degrees)": "Braccio di Tianhe (gradi)",
"Tianhe wings (degrees)": "Ali di Tianhe (gradi)",
"Lab wings (degrees)": "Ali dei laboratori (gradi)",
"Port wing": "Ala di sinistra",
"Starboard wing": "Ala di dritta",
"Wentian forward · alpha": "Wentian anteriore · alfa",
"Wentian forward · beta": "Wentian anteriore · beta",
"Wentian aft · alpha": "Wentian posteriore · alfa",
"Wentian aft · beta": "Wentian posteriore · beta",
"Mengtian forward · alpha": "Mengtian anteriore · alfa",
"Mengtian forward · beta": "Mengtian anteriore · beta",
"Mengtian aft · alpha": "Mengtian posteriore · alfa",
"Mengtian aft · beta": "Mengtian posteriore · beta",
"Wentian arm (degrees)": "Braccio di Wentian (gradi)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "I pannelli seguono il Sole, l'antenna punta ai satelliti di collegamento e i bracci oscillano a scopo illustrativo. Calcolato: la Cina non pubblica telemetria in tempo reale.",
"Telemetry reads while the model is on screen": "La telemetria viene letta finché il modello è sullo schermo",
"Connecting to telemetry…": "Connessione alla telemetria…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Pannelli, radiatori e un'antenna seguono la telemetria in diretta della NASA. L'altra antenna resta ferma e i bracci si muovono a scopo illustrativo."
}
+107 -1
View File
@@ -4213,5 +4213,111 @@
"Finding it…": "検索中…",
"No reading at this time": "この時刻のデータなし",
"Last reading · {age}": "最終データ・{age}",
"Find it": "探す"
"Find it": "探す",
"Underneath": "真下",
"Open on YouTube": "YouTubeで開く",
"Video plays from YouTube, which sees your IP address.": "動画は YouTube から再生され、YouTube にはあなたの IP アドレスが見えます。",
"Automatic": "自動",
"Manual": "手動",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "太陽電池パネルとラジエーターは太陽を追い、アンテナは中継衛星を向き、アームは説明用にゆっくり動きます。計算による表示で、実際のテレメトリではありません。",
"Overhead": "真上",
"Ahead": "前方",
"Behind": "後方",
"Port side": "左舷",
"Starboard side": "右舷",
"Night (shadow)": "夜(影)",
"Sun position": "太陽の位置",
"Follow the Sun": "太陽を追う",
"Fast orbit (40 s)": "高速周回(40秒)",
"Solar arrays": "太陽電池パネル",
"Demonstration: the real arrays stay extended.": "デモ表示:実際のパネルは展開したままです。",
"Retract": "収納",
"Extend": "展開",
"Radiators": "ラジエーター",
"Demonstration: the real radiators can fold but stay extended.": "デモ表示:実際のラジエーターは折りたためますが、展開したままです。",
"Dishes": "アンテナ",
"Relay satellites": "中継衛星",
"Up": "上",
"Forward": "前",
"Sideways": "横",
"Shoulder roll": "肩ロール",
"Shoulder yaw": "肩ヨー",
"Shoulder pitch": "肩ピッチ",
"Elbow": "肘",
"Wrist pitch": "手首ピッチ",
"Wrist yaw": "手首ヨー",
"Wrist roll": "手首ロール",
"Canadarm2 (degrees)": "Canadarm2(度)",
"Resume sway": "自動の動きに戻す",
"Zoom to the ISS": "ISSにズーム",
"Now: in sunlight": "現在:日なた",
"Now: in the Earth's shadow": "現在:地球の影の中",
"STATION VIEW · {name}": "ステーションビュー · {name}",
"Previous station view": "前のステーションビュー",
"Next station view": "次のステーションビュー",
"OBSERVATION MODULE · ISS": "観測モジュール · ISS",
"European Space Agency (ESA)": "欧州宇宙機関(ESA)",
"7 WINDOWS": "窓 7 枚",
"LAUNCHED 8 FEB 2010 · STS-130": "2010年2月8日打ち上げ · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "トランクウィリティー · 地球側ポート",
"LABORATORY MODULE · ISS": "実験モジュール · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "宇宙航空研究開発機構(JAXA)",
"2 WINDOWS": "窓 2 枚",
"LAUNCHED 31 MAY 2008 · STS-124": "2008年5月31日打ち上げ · STS-124",
"HARMONY · PORT SIDE": "ハーモニー · 左舷側",
"Return to the default view": "既定のビューに戻す",
"{label} · STATION VIEW": "{label} · ステーションビュー",
"ON AIR": "オンエア",
"Starting…": "開始しています…",
"Stream is offline": "ストリームはオフラインです",
"LIVE VIDEO": "ライブ映像",
"STREAM ATTACHED TO THE SUBJECT": "対象に紐づくライブ配信",
"Live video": "ライブ映像",
"Show Live Video": "ライブ映像を表示",
"This stream cannot play here": "このストリームはここでは再生できません",
"Expand Live section": "ライブセクションを展開",
"Collapse Live section": "ライブセクションを折りたたむ",
"Expand Live": "ライブを展開",
"Collapse Live": "ライブを折りたたむ",
"Live streams for the selected object": "選択中のオブジェクトのライブ配信",
"Stream": "ストリーム",
"Previous stream": "前のストリーム",
"Next stream": "次のストリーム",
"Try again": "再試行",
"Exterior cameras": "船外カメラ",
"Live video and space-to-ground audio": "ライブ映像と地上との交信音声",
"NASA video, via YouTube": "NASAの映像、YouTube経由",
"Controls for the selected space station": "選択中の宇宙ステーションの操作",
"Expand Station section": "ステーションセクションを展開",
"Collapse Station section": "ステーションセクションを折りたたむ",
"Expand Station": "ステーションを展開",
"Collapse Station": "ステーションを折りたたむ",
"Manual · telemetry paused": "手動 · テレメトリ一時停止",
"Telemetry · updated {ago} ago": "テレメトリ · {ago}前に更新",
"No signal since {time} · computed values": "{time}から信号なし · 計算値",
"No signal · computed values": "信号なし · 計算値",
"Telemetry unavailable · last update {ago} ago · computed values": "テレメトリ利用不可 · 最終更新は{ago}前 · 計算値",
"Telemetry unavailable · computed values": "テレメトリ利用不可 · 計算値",
"Telemetry not enabled on this server · computed values": "このサーバーではテレメトリが無効 · 計算値",
"No public telemetry · computed values": "公開テレメトリなし · 計算値",
"Zoom to Tiangong": "天宮にズーム",
"Tianhe arm (degrees)": "天和アーム(度)",
"Tianhe wings (degrees)": "天和の翼(度)",
"Lab wings (degrees)": "実験モジュールの翼(度)",
"Port wing": "左舷の翼",
"Starboard wing": "右舷の翼",
"Wentian forward · alpha": "問天 前方 · アルファ",
"Wentian forward · beta": "問天 前方 · ベータ",
"Wentian aft · alpha": "問天 後方 · アルファ",
"Wentian aft · beta": "問天 後方 · ベータ",
"Mengtian forward · alpha": "夢天 前方 · アルファ",
"Mengtian forward · beta": "夢天 前方 · ベータ",
"Mengtian aft · alpha": "夢天 後方 · アルファ",
"Mengtian aft · beta": "夢天 後方 · ベータ",
"Wentian arm (degrees)": "問天アーム(度)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "太陽電池パネルは太陽を追い、アンテナは中継衛星に向き、アームは説明のために揺れます。計算値:中国はライブテレメトリを公開していません。",
"Telemetry reads while the model is on screen": "テレメトリはモデルが画面にある間に読み取られます",
"Connecting to telemetry…": "テレメトリに接続中…",
"{seconds} s": "{seconds} 秒",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "太陽電池パネル、ラジエーター、アンテナの1基はNASAのライブテレメトリに従います。もう1基のアンテナは動かず、アームは説明用にゆっくり動きます。"
}
+107 -1
View File
@@ -4425,5 +4425,111 @@
"Finding it…": "A procurar…",
"No reading at this time": "Sem leitura nesta hora",
"Last reading · {age}": "Última leitura · {age}",
"Find it": "Encontrar"
"Find it": "Encontrar",
"Underneath": "Embaixo",
"Open on YouTube": "Abrir no YouTube",
"Video plays from YouTube, which sees your IP address.": "O vídeo é reproduzido a partir do YouTube, que vê o seu endereço IP.",
"Automatic": "Automático",
"Manual": "Manual",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Painéis e radiadores seguem o Sol, as antenas apontam para os satélites de retransmissão e os braços se movem de forma ilustrativa. Calculado, não é telemetria ao vivo.",
"Overhead": "Em cima",
"Ahead": "À frente",
"Behind": "Atrás",
"Port side": "Bombordo",
"Starboard side": "Estibordo",
"Night (shadow)": "Noite (sombra)",
"Sun position": "Posição do Sol",
"Follow the Sun": "Seguir o Sol",
"Fast orbit (40 s)": "Órbita acelerada (40 s)",
"Solar arrays": "Painéis solares",
"Demonstration: the real arrays stay extended.": "Demonstração: os painéis reais ficam abertos.",
"Retract": "Recolher",
"Extend": "Expandir",
"Radiators": "Radiadores",
"Demonstration: the real radiators can fold but stay extended.": "Demonstração: os radiadores reais podem dobrar, mas ficam abertos.",
"Dishes": "Antenas",
"Relay satellites": "Satélites de retransmissão",
"Up": "Para cima",
"Forward": "Para frente",
"Sideways": "Para o lado",
"Shoulder roll": "Ombro (giro)",
"Shoulder yaw": "Ombro (guinada)",
"Shoulder pitch": "Ombro (arfagem)",
"Elbow": "Cotovelo",
"Wrist pitch": "Pulso (arfagem)",
"Wrist yaw": "Pulso (guinada)",
"Wrist roll": "Pulso (giro)",
"Canadarm2 (degrees)": "Canadarm2 (graus)",
"Resume sway": "Retomar movimento",
"Zoom to the ISS": "Aproximar da ISS",
"Now: in sunlight": "Agora: na luz do Sol",
"Now: in the Earth's shadow": "Agora: na sombra da Terra",
"STATION VIEW · {name}": "VISTA DA ESTAÇÃO · {name}",
"Previous station view": "Vista anterior da estação",
"Next station view": "Próxima vista da estação",
"OBSERVATION MODULE · ISS": "MÓDULO DE OBSERVAÇÃO · ISS",
"European Space Agency (ESA)": "Agência Espacial Europeia (ESA)",
"7 WINDOWS": "7 JANELAS",
"LAUNCHED 8 FEB 2010 · STS-130": "LANÇADO EM 8 FEV 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · PORTA VOLTADA PARA A TERRA",
"LABORATORY MODULE · ISS": "MÓDULO LABORATÓRIO · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Agência de Exploração Aeroespacial do Japão (JAXA)",
"2 WINDOWS": "2 JANELAS",
"LAUNCHED 31 MAY 2008 · STS-124": "LANÇADO EM 31 MAI 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · LADO BOMBORDO",
"Return to the default view": "Voltar à vista padrão",
"{label} · STATION VIEW": "{label} · VISTA DA ESTAÇÃO",
"ON AIR": "NO AR",
"Starting…": "A iniciar…",
"Stream is offline": "A transmissão está offline",
"LIVE VIDEO": "VÍDEO AO VIVO",
"STREAM ATTACHED TO THE SUBJECT": "TRANSMISSÃO VINCULADA AO OBJETO",
"Live video": "Vídeo ao vivo",
"Show Live Video": "Mostrar vídeo ao vivo",
"This stream cannot play here": "Esta transmissão não pode ser reproduzida aqui",
"Expand Live section": "Expandir a secção Ao vivo",
"Collapse Live section": "Recolher a secção Ao vivo",
"Expand Live": "Expandir Ao vivo",
"Collapse Live": "Recolher Ao vivo",
"Live streams for the selected object": "Transmissões ao vivo do objeto selecionado",
"Stream": "Transmissão",
"Previous stream": "Transmissão anterior",
"Next stream": "Próxima transmissão",
"Try again": "Tentar novamente",
"Exterior cameras": "Câmaras exteriores",
"Live video and space-to-ground audio": "Vídeo ao vivo e áudio espaço-terra",
"NASA video, via YouTube": "Vídeo da NASA, via YouTube",
"Controls for the selected space station": "Controlos da estação espacial selecionada",
"Expand Station section": "Expandir a secção Estação",
"Collapse Station section": "Recolher a secção Estação",
"Expand Station": "Expandir Estação",
"Collapse Station": "Recolher Estação",
"Manual · telemetry paused": "Manual · telemetria em pausa",
"Telemetry · updated {ago} ago": "Telemetria · atualizada há {ago}",
"No signal since {time} · computed values": "Sem sinal desde as {time} · valores calculados",
"No signal · computed values": "Sem sinal · valores calculados",
"Telemetry unavailable · last update {ago} ago · computed values": "Telemetria indisponível · última atualização há {ago} · valores calculados",
"Telemetry unavailable · computed values": "Telemetria indisponível · valores calculados",
"Telemetry not enabled on this server · computed values": "Telemetria não ativada neste servidor · valores calculados",
"No public telemetry · computed values": "Sem telemetria pública · valores calculados",
"Zoom to Tiangong": "Aproximar de Tiangong",
"Tianhe arm (degrees)": "Braço de Tianhe (graus)",
"Tianhe wings (degrees)": "Asas de Tianhe (graus)",
"Lab wings (degrees)": "Asas dos laboratórios (graus)",
"Port wing": "Asa de bombordo",
"Starboard wing": "Asa de estibordo",
"Wentian forward · alpha": "Wentian dianteira · alfa",
"Wentian forward · beta": "Wentian dianteira · beta",
"Wentian aft · alpha": "Wentian traseira · alfa",
"Wentian aft · beta": "Wentian traseira · beta",
"Mengtian forward · alpha": "Mengtian dianteira · alfa",
"Mengtian forward · beta": "Mengtian dianteira · beta",
"Mengtian aft · alpha": "Mengtian traseira · alfa",
"Mengtian aft · beta": "Mengtian traseira · beta",
"Wentian arm (degrees)": "Braço de Wentian (graus)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Os painéis seguem o Sol, a antena aponta para os satélites de retransmissão e os braços oscilam a título ilustrativo. Calculado: a China não publica telemetria em direto.",
"Telemetry reads while the model is on screen": "A telemetria é lida enquanto o modelo está no ecrã",
"Connecting to telemetry…": "A ligar à telemetria…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Painéis, radiadores e uma antena seguem a telemetria ao vivo da NASA. A outra antena fica parada e os braços se movem de forma ilustrativa."
}
+107 -1
View File
@@ -4531,5 +4531,111 @@
"Finding it…": "Поиск…",
"No reading at this time": "Нет данных на это время",
"Last reading · {age}": "Последние данные · {age}",
"Find it": "Найти"
"Find it": "Найти",
"Underneath": "Снизу",
"Open on YouTube": "Открыть на YouTube",
"Video plays from YouTube, which sees your IP address.": "Видео воспроизводится с YouTube, который видит ваш IP-адрес.",
"Automatic": "Автоматически",
"Manual": "Вручную",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Панели и радиаторы следят за Солнцем, антенны наводятся на спутники-ретрансляторы, а манипуляторы движутся для иллюстрации. Расчёт, а не телеметрия в реальном времени.",
"Overhead": "Сверху",
"Ahead": "Спереди",
"Behind": "Сзади",
"Port side": "Левый борт",
"Starboard side": "Правый борт",
"Night (shadow)": "Ночь (тень)",
"Sun position": "Положение Солнца",
"Follow the Sun": "Следить за Солнцем",
"Fast orbit (40 s)": "Быстрый виток (40 с)",
"Solar arrays": "Солнечные батареи",
"Demonstration: the real arrays stay extended.": "Демонстрация: настоящие батареи остаются раскрытыми.",
"Retract": "Сложить",
"Extend": "Раскрыть",
"Radiators": "Радиаторы",
"Demonstration: the real radiators can fold but stay extended.": "Демонстрация: настоящие радиаторы складываются, но остаются раскрытыми.",
"Dishes": "Антенны",
"Relay satellites": "Спутники-ретрансляторы",
"Up": "Вверх",
"Forward": "Вперёд",
"Sideways": "В сторону",
"Shoulder roll": "Плечо: крен",
"Shoulder yaw": "Плечо: рыскание",
"Shoulder pitch": "Плечо: тангаж",
"Elbow": "Локоть",
"Wrist pitch": "Запястье: тангаж",
"Wrist yaw": "Запястье: рыскание",
"Wrist roll": "Запястье: крен",
"Canadarm2 (degrees)": "Canadarm2 (градусы)",
"Resume sway": "Возобновить движение",
"Zoom to the ISS": "Приблизить к МКС",
"Now: in sunlight": "Сейчас: на свету",
"Now: in the Earth's shadow": "Сейчас: в тени Земли",
"STATION VIEW · {name}": "ВИД СО СТАНЦИИ · {name}",
"Previous station view": "Предыдущий вид со станции",
"Next station view": "Следующий вид со станции",
"OBSERVATION MODULE · ISS": "МОДУЛЬ НАБЛЮДЕНИЯ · МКС",
"European Space Agency (ESA)": "Европейское космическое агентство (ЕКА)",
"7 WINDOWS": "7 ИЛЛЮМИНАТОРОВ",
"LAUNCHED 8 FEB 2010 · STS-130": "ЗАПУЩЕН 8 ФЕВ 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · ПОРТ, ОБРАЩЁННЫЙ К ЗЕМЛЕ",
"LABORATORY MODULE · ISS": "ЛАБОРАТОРНЫЙ МОДУЛЬ · МКС",
"Japan Aerospace Exploration Agency (JAXA)": "Японское агентство аэрокосмических исследований (JAXA)",
"2 WINDOWS": "2 ИЛЛЮМИНАТОРА",
"LAUNCHED 31 MAY 2008 · STS-124": "ЗАПУЩЕН 31 МАЯ 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · ЛЕВЫЙ БОРТ",
"Return to the default view": "Вернуть вид по умолчанию",
"{label} · STATION VIEW": "{label} · ВИД СО СТАНЦИИ",
"ON AIR": "В ЭФИРЕ",
"Starting…": "Запуск…",
"Stream is offline": "Трансляция не ведётся",
"LIVE VIDEO": "ВИДЕО ОНЛАЙН",
"STREAM ATTACHED TO THE SUBJECT": "ТРАНСЛЯЦИЯ ВЫБРАННОГО ОБЪЕКТА",
"Live video": "Видео онлайн",
"Show Live Video": "Показать видео онлайн",
"This stream cannot play here": "Эту трансляцию нельзя воспроизвести здесь",
"Expand Live section": "Развернуть раздел «Эфир»",
"Collapse Live section": "Свернуть раздел «Эфир»",
"Expand Live": "Развернуть «Эфир»",
"Collapse Live": "Свернуть «Эфир»",
"Live streams for the selected object": "Прямые трансляции выбранного объекта",
"Stream": "Трансляция",
"Previous stream": "Предыдущая трансляция",
"Next stream": "Следующая трансляция",
"Try again": "Повторить",
"Exterior cameras": "Внешние камеры",
"Live video and space-to-ground audio": "Прямое видео и переговоры с Землёй",
"NASA video, via YouTube": "Видео NASA, через YouTube",
"Controls for the selected space station": "Управление выбранной космической станцией",
"Expand Station section": "Развернуть раздел «Станция»",
"Collapse Station section": "Свернуть раздел «Станция»",
"Expand Station": "Развернуть «Станцию»",
"Collapse Station": "Свернуть «Станцию»",
"Manual · telemetry paused": "Вручную · телеметрия приостановлена",
"Telemetry · updated {ago} ago": "Телеметрия · обновлено {ago} назад",
"No signal since {time} · computed values": "Нет сигнала с {time} · расчётные значения",
"No signal · computed values": "Нет сигнала · расчётные значения",
"Telemetry unavailable · last update {ago} ago · computed values": "Телеметрия недоступна · последнее обновление {ago} назад · расчётные значения",
"Telemetry unavailable · computed values": "Телеметрия недоступна · расчётные значения",
"Telemetry not enabled on this server · computed values": "Телеметрия не включена на этом сервере · расчётные значения",
"No public telemetry · computed values": "Открытой телеметрии нет · расчётные значения",
"Zoom to Tiangong": "Приблизить к «Тяньгун»",
"Tianhe arm (degrees)": "Манипулятор «Тяньхэ» (градусы)",
"Tianhe wings (degrees)": "Крылья «Тяньхэ» (градусы)",
"Lab wings (degrees)": "Крылья лабораторий (градусы)",
"Port wing": "Левое крыло",
"Starboard wing": "Правое крыло",
"Wentian forward · alpha": "«Вэньтянь», передняя · альфа",
"Wentian forward · beta": "«Вэньтянь», передняя · бета",
"Wentian aft · alpha": "«Вэньтянь», задняя · альфа",
"Wentian aft · beta": "«Вэньтянь», задняя · бета",
"Mengtian forward · alpha": "«Мэнтянь», передняя · альфа",
"Mengtian forward · beta": "«Мэнтянь», передняя · бета",
"Mengtian aft · alpha": "«Мэнтянь», задняя · альфа",
"Mengtian aft · beta": "«Мэнтянь», задняя · бета",
"Wentian arm (degrees)": "Манипулятор «Вэньтянь» (градусы)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Панели следят за Солнцем, антенна наводится на спутники-ретрансляторы, а манипуляторы покачиваются для наглядности. Расчёт: Китай не публикует телеметрию в реальном времени.",
"Telemetry reads while the model is on screen": "Телеметрия читается, пока модель на экране",
"Connecting to telemetry…": "Подключение к телеметрии…",
"{seconds} s": "{seconds} с",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Панели, радиаторы и одна антенна следуют телеметрии NASA в реальном времени. Вторая антенна неподвижна, а манипуляторы движутся для иллюстрации."
}
+107 -1
View File
@@ -4319,5 +4319,111 @@
"Finding it…": "Söker…",
"No reading at this time": "Ingen avläsning vid den här tiden",
"Last reading · {age}": "Senaste avläsning · {age}",
"Find it": "Hitta"
"Find it": "Hitta",
"Underneath": "Nedanför",
"Open on YouTube": "Öppna på YouTube",
"Video plays from YouTube, which sees your IP address.": "Videon spelas upp från YouTube, som ser din IP-adress.",
"Automatic": "Automatiskt",
"Manual": "Manuellt",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Paneler och radiatorer följer solen, antennerna riktas mot relästationer i rymden och armarna rör sig som illustration. Beräknat, inte telemetri i realtid.",
"Overhead": "Ovanför",
"Ahead": "Framför",
"Behind": "Bakom",
"Port side": "Babord",
"Starboard side": "Styrbord",
"Night (shadow)": "Natt (skugga)",
"Sun position": "Solens läge",
"Follow the Sun": "Följ solen",
"Fast orbit (40 s)": "Snabbt varv (40 s)",
"Solar arrays": "Solpaneler",
"Demonstration: the real arrays stay extended.": "Demonstration: de verkliga panelerna förblir utfällda.",
"Retract": "Fäll in",
"Extend": "Fäll ut",
"Radiators": "Radiatorer",
"Demonstration: the real radiators can fold but stay extended.": "Demonstration: de verkliga radiatorerna kan vikas men förblir utfällda.",
"Dishes": "Antenner",
"Relay satellites": "Reläsatelliter",
"Up": "Uppåt",
"Forward": "Framåt",
"Sideways": "Åt sidan",
"Shoulder roll": "Axel, roll",
"Shoulder yaw": "Axel, gir",
"Shoulder pitch": "Axel, tipp",
"Elbow": "Armbåge",
"Wrist pitch": "Handled, tipp",
"Wrist yaw": "Handled, gir",
"Wrist roll": "Handled, roll",
"Canadarm2 (degrees)": "Canadarm2 (grader)",
"Resume sway": "Återuppta rörelsen",
"Zoom to the ISS": "Zooma in på ISS",
"Now: in sunlight": "Nu: i solljus",
"Now: in the Earth's shadow": "Nu: i jordens skugga",
"{label} · STATION VIEW": "{label} · STATIONSVY",
"STATION VIEW · {name}": "STATIONSVY · {name}",
"Previous station view": "Föregående stationsvy",
"Next station view": "Nästa stationsvy",
"OBSERVATION MODULE · ISS": "OBSERVATIONSMODUL · ISS",
"European Space Agency (ESA)": "Europeiska rymdorganisationen (ESA)",
"7 WINDOWS": "7 FÖNSTER",
"LAUNCHED 8 FEB 2010 · STS-130": "UPPSKJUTEN 8 FEB 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · DOCKNINGSPORT MOT JORDEN",
"LABORATORY MODULE · ISS": "LABORATORIEMODUL · ISS",
"Japan Aerospace Exploration Agency (JAXA)": "Japans rymdorganisation (JAXA)",
"2 WINDOWS": "2 FÖNSTER",
"LAUNCHED 31 MAY 2008 · STS-124": "UPPSKJUTEN 31 MAJ 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · BABORDSSIDAN",
"Return to the default view": "Återgå till standardvyn",
"ON AIR": "PÅ LUFTEN",
"Starting…": "Startar…",
"Stream is offline": "Strömmen är offline",
"LIVE VIDEO": "LIVEVIDEO",
"STREAM ATTACHED TO THE SUBJECT": "STRÖM KNUTEN TILL OBJEKTET",
"Live video": "Livevideo",
"Show Live Video": "Visa livevideo",
"This stream cannot play here": "Den här strömmen kan inte spelas upp här",
"Expand Live section": "Expandera Live-sektionen",
"Collapse Live section": "Fäll ihop Live-sektionen",
"Expand Live": "Expandera Live",
"Collapse Live": "Fäll ihop Live",
"Live streams for the selected object": "Liveströmmar för det valda objektet",
"Stream": "Ström",
"Previous stream": "Föregående ström",
"Next stream": "Nästa ström",
"Try again": "Försök igen",
"Exterior cameras": "Yttre kameror",
"Live video and space-to-ground audio": "Livevideo och ljud rymd–mark",
"NASA video, via YouTube": "NASA-video, via YouTube",
"Controls for the selected space station": "Reglage för den valda rymdstationen",
"Expand Station section": "Expandera Station-sektionen",
"Collapse Station section": "Fäll ihop Station-sektionen",
"Expand Station": "Expandera Station",
"Collapse Station": "Fäll ihop Station",
"Manual · telemetry paused": "Manuellt · telemetri pausad",
"Telemetry · updated {ago} ago": "Telemetri · uppdaterad för {ago} sedan",
"No signal since {time} · computed values": "Ingen signal sedan {time} · beräknade värden",
"No signal · computed values": "Ingen signal · beräknade värden",
"Telemetry unavailable · last update {ago} ago · computed values": "Telemetri otillgänglig · senast uppdaterad för {ago} sedan · beräknade värden",
"Telemetry unavailable · computed values": "Telemetri otillgänglig · beräknade värden",
"Telemetry not enabled on this server · computed values": "Telemetri inte aktiverad på den här servern · beräknade värden",
"No public telemetry · computed values": "Ingen offentlig telemetri · beräknade värden",
"Zoom to Tiangong": "Zooma in på Tiangong",
"Tianhe arm (degrees)": "Tianhe-armen (grader)",
"Tianhe wings (degrees)": "Tianhes vingar (grader)",
"Lab wings (degrees)": "Laboratoriernas vingar (grader)",
"Port wing": "Babordsvinge",
"Starboard wing": "Styrbordsvinge",
"Wentian forward · alpha": "Wentian fram · alfa",
"Wentian forward · beta": "Wentian fram · beta",
"Wentian aft · alpha": "Wentian bak · alfa",
"Wentian aft · beta": "Wentian bak · beta",
"Mengtian forward · alpha": "Mengtian fram · alfa",
"Mengtian forward · beta": "Mengtian fram · beta",
"Mengtian aft · alpha": "Mengtian bak · alfa",
"Mengtian aft · beta": "Mengtian bak · beta",
"Wentian arm (degrees)": "Wentian-armen (grader)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Panelerna följer solen, antennen riktas mot relästationer i rymden och armarna svänger i illustrativt syfte. Beräknat: Kina publicerar ingen live-telemetri.",
"Telemetry reads while the model is on screen": "Telemetri läses medan modellen syns på skärmen",
"Connecting to telemetry…": "Ansluter till telemetri…",
"{seconds} s": "{seconds} s",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Paneler, radiatorer och en antenn följer NASA:s telemetri i realtid. Den andra antennen står stilla och armarna rör sig som illustration."
}
+107 -1
View File
@@ -4531,5 +4531,111 @@
"Finding it…": "Пошук…",
"No reading at this time": "Немає даних на цей час",
"Last reading · {age}": "Останні дані · {age}",
"Find it": "Знайти"
"Find it": "Знайти",
"Underneath": "Знизу",
"Open on YouTube": "Відкрити на YouTube",
"Video plays from YouTube, which sees your IP address.": "Відео відтворюється з YouTube, який бачить вашу IP-адресу.",
"Automatic": "Автоматично",
"Manual": "Вручну",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "Панелі й радіатори стежать за Сонцем, антени наводяться на супутники-ретранслятори, а маніпулятори рухаються для ілюстрації. Розрахунок, а не телеметрія в реальному часі.",
"Overhead": "Згори",
"Ahead": "Спереду",
"Behind": "Позаду",
"Port side": "Лівий борт",
"Starboard side": "Правий борт",
"Night (shadow)": "Ніч (тінь)",
"Sun position": "Положення Сонця",
"Follow the Sun": "Стежити за Сонцем",
"Fast orbit (40 s)": "Швидкий виток (40 с)",
"Solar arrays": "Сонячні батареї",
"Demonstration: the real arrays stay extended.": "Демонстрація: справжні батареї залишаються розкритими.",
"Retract": "Скласти",
"Extend": "Розкрити",
"Radiators": "Радіатори",
"Demonstration: the real radiators can fold but stay extended.": "Демонстрація: справжні радіатори складаються, але залишаються розкритими.",
"Dishes": "Антени",
"Relay satellites": "Супутники-ретранслятори",
"Up": "Вгору",
"Forward": "Вперед",
"Sideways": "Убік",
"Shoulder roll": "Плече: крен",
"Shoulder yaw": "Плече: рискання",
"Shoulder pitch": "Плече: тангаж",
"Elbow": "Лікоть",
"Wrist pitch": "Зап'ястя: тангаж",
"Wrist yaw": "Зап'ястя: рискання",
"Wrist roll": "Зап'ястя: крен",
"Canadarm2 (degrees)": "Canadarm2 (градуси)",
"Resume sway": "Відновити рух",
"Zoom to the ISS": "Наблизити до МКС",
"Now: in sunlight": "Зараз: на світлі",
"Now: in the Earth's shadow": "Зараз: у тіні Землі",
"STATION VIEW · {name}": "ВИГЛЯД ЗІ СТАНЦІЇ · {name}",
"Previous station view": "Попередній вигляд зі станції",
"Next station view": "Наступний вигляд зі станції",
"OBSERVATION MODULE · ISS": "МОДУЛЬ СПОСТЕРЕЖЕННЯ · МКС",
"European Space Agency (ESA)": "Європейське космічне агентство (ЄКА)",
"7 WINDOWS": "7 ІЛЮМІНАТОРІВ",
"LAUNCHED 8 FEB 2010 · STS-130": "ЗАПУЩЕНО 8 ЛЮТ 2010 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "TRANQUILITY · ПОРТ, ЗВЕРНЕНИЙ ДО ЗЕМЛІ",
"LABORATORY MODULE · ISS": "ЛАБОРАТОРНИЙ МОДУЛЬ · МКС",
"Japan Aerospace Exploration Agency (JAXA)": "Японське агентство аерокосмічних досліджень (JAXA)",
"2 WINDOWS": "2 ІЛЮМІНАТОРИ",
"LAUNCHED 31 MAY 2008 · STS-124": "ЗАПУЩЕНО 31 ТРАВ 2008 · STS-124",
"HARMONY · PORT SIDE": "HARMONY · ЛІВИЙ БОРТ",
"Return to the default view": "Повернути типовий вигляд",
"{label} · STATION VIEW": "{label} · ВИГЛЯД ЗІ СТАНЦІЇ",
"ON AIR": "В ЕФІРІ",
"Starting…": "Запуск…",
"Stream is offline": "Трансляція не ведеться",
"LIVE VIDEO": "ВІДЕО ОНЛАЙН",
"STREAM ATTACHED TO THE SUBJECT": "ТРАНСЛЯЦІЯ ВИБРАНОГО ОБ’ЄКТА",
"Live video": "Відео онлайн",
"Show Live Video": "Показати відео онлайн",
"This stream cannot play here": "Цю трансляцію не можна відтворити тут",
"Expand Live section": "Розгорнути розділ «Ефір»",
"Collapse Live section": "Згорнути розділ «Ефір»",
"Expand Live": "Розгорнути «Ефір»",
"Collapse Live": "Згорнути «Ефір»",
"Live streams for the selected object": "Прямі трансляції вибраного об’єкта",
"Stream": "Трансляція",
"Previous stream": "Попередня трансляція",
"Next stream": "Наступна трансляція",
"Try again": "Повторити",
"Exterior cameras": "Зовнішні камери",
"Live video and space-to-ground audio": "Пряме відео та переговори із Землею",
"NASA video, via YouTube": "Відео NASA, через YouTube",
"Controls for the selected space station": "Керування вибраною космічною станцією",
"Expand Station section": "Розгорнути розділ «Станція»",
"Collapse Station section": "Згорнути розділ «Станція»",
"Expand Station": "Розгорнути «Станцію»",
"Collapse Station": "Згорнути «Станцію»",
"Manual · telemetry paused": "Вручну · телеметрію призупинено",
"Telemetry · updated {ago} ago": "Телеметрія · оновлено {ago} тому",
"No signal since {time} · computed values": "Немає сигналу з {time} · розрахункові значення",
"No signal · computed values": "Немає сигналу · розрахункові значення",
"Telemetry unavailable · last update {ago} ago · computed values": "Телеметрія недоступна · останнє оновлення {ago} тому · розрахункові значення",
"Telemetry unavailable · computed values": "Телеметрія недоступна · розрахункові значення",
"Telemetry not enabled on this server · computed values": "Телеметрію не ввімкнено на цьому сервері · розрахункові значення",
"No public telemetry · computed values": "Відкритої телеметрії немає · розрахункові значення",
"Zoom to Tiangong": "Наблизити до «Тяньгун»",
"Tianhe arm (degrees)": "Маніпулятор «Тяньхе» (градуси)",
"Tianhe wings (degrees)": "Крила «Тяньхе» (градуси)",
"Lab wings (degrees)": "Крила лабораторій (градуси)",
"Port wing": "Ліве крило",
"Starboard wing": "Праве крило",
"Wentian forward · alpha": "«Веньтянь», передня · альфа",
"Wentian forward · beta": "«Веньтянь», передня · бета",
"Wentian aft · alpha": "«Веньтянь», задня · альфа",
"Wentian aft · beta": "«Веньтянь», задня · бета",
"Mengtian forward · alpha": "«Ментянь», передня · альфа",
"Mengtian forward · beta": "«Ментянь», передня · бета",
"Mengtian aft · alpha": "«Ментянь», задня · альфа",
"Mengtian aft · beta": "«Ментянь», задня · бета",
"Wentian arm (degrees)": "Маніпулятор «Веньтянь» (градуси)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "Панелі стежать за Сонцем, антена наводиться на супутники-ретранслятори, а маніпулятори похитуються для наочності. Розрахунок: Китай не публікує телеметрію в реальному часі.",
"Telemetry reads while the model is on screen": "Телеметрія читається, поки модель на екрані",
"Connecting to telemetry…": "Підключення до телеметрії…",
"{seconds} s": "{seconds} с",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "Панелі, радіатори й одна антена слідують телеметрії NASA в реальному часі. Друга антена нерухома, а маніпулятори рухаються для ілюстрації."
}
+107 -1
View File
@@ -4213,5 +4213,111 @@
"Finding it…": "正在查找…",
"No reading at this time": "此时无数据",
"Last reading · {age}": "最后数据 · {age}",
"Find it": "查找"
"Find it": "查找",
"Underneath": "正下方",
"Open on YouTube": "在 YouTube 上打开",
"Video plays from YouTube, which sees your IP address.": "视频从 YouTube 播放,YouTube 会看到你的 IP 地址。",
"Automatic": "自动",
"Manual": "手动",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "太阳能板和散热器跟随太阳,天线指向中继卫星,机械臂仅作演示性摆动。均为计算结果,并非实时遥测。",
"Overhead": "正上方",
"Ahead": "前方",
"Behind": "后方",
"Port side": "左舷",
"Starboard side": "右舷",
"Night (shadow)": "夜间(阴影)",
"Sun position": "太阳位置",
"Follow the Sun": "跟随太阳",
"Fast orbit (40 s)": "快速绕行(40 秒)",
"Solar arrays": "太阳能板",
"Demonstration: the real arrays stay extended.": "演示:真实的太阳能板保持展开。",
"Retract": "收起",
"Extend": "展开",
"Radiators": "散热器",
"Demonstration: the real radiators can fold but stay extended.": "演示:真实的散热器可以折叠,但保持展开。",
"Dishes": "天线",
"Relay satellites": "中继卫星",
"Up": "向上",
"Forward": "向前",
"Sideways": "向侧面",
"Shoulder roll": "肩部滚转",
"Shoulder yaw": "肩部偏航",
"Shoulder pitch": "肩部俯仰",
"Elbow": "肘部",
"Wrist pitch": "腕部俯仰",
"Wrist yaw": "腕部偏航",
"Wrist roll": "腕部滚转",
"Canadarm2 (degrees)": "Canadarm2(度)",
"Resume sway": "恢复摆动",
"Zoom to the ISS": "拉近到国际空间站",
"Now: in sunlight": "当前:处于日照中",
"Now: in the Earth's shadow": "当前:处于地球阴影中",
"STATION VIEW · {name}": "空间站视图 · {name}",
"Previous station view": "上一个空间站视图",
"Next station view": "下一个空间站视图",
"OBSERVATION MODULE · ISS": "观测舱 · 国际空间站",
"European Space Agency (ESA)": "欧洲航天局(ESA)",
"7 WINDOWS": "7 扇舷窗",
"LAUNCHED 8 FEB 2010 · STS-130": "2010年2月8日发射 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "宁静号节点舱 · 对地端口",
"LABORATORY MODULE · ISS": "实验舱 · 国际空间站",
"Japan Aerospace Exploration Agency (JAXA)": "日本宇宙航空研究开发机构(JAXA)",
"2 WINDOWS": "2 扇舷窗",
"LAUNCHED 31 MAY 2008 · STS-124": "2008年5月31日发射 · STS-124",
"HARMONY · PORT SIDE": "和谐号节点舱 · 左舷",
"Return to the default view": "恢复默认视图",
"{label} · STATION VIEW": "{label} · 空间站视图",
"ON AIR": "直播中",
"Starting…": "正在启动…",
"Stream is offline": "直播已离线",
"LIVE VIDEO": "实时视频",
"STREAM ATTACHED TO THE SUBJECT": "与所选对象关联的直播",
"Live video": "实时视频",
"Show Live Video": "显示实时视频",
"This stream cannot play here": "此直播无法在此播放",
"Expand Live section": "展开直播区",
"Collapse Live section": "收起直播区",
"Expand Live": "展开直播",
"Collapse Live": "收起直播",
"Live streams for the selected object": "所选对象的直播",
"Stream": "直播",
"Previous stream": "上一个直播",
"Next stream": "下一个直播",
"Try again": "重试",
"Exterior cameras": "外部摄像头",
"Live video and space-to-ground audio": "实时视频与天地通话音频",
"NASA video, via YouTube": "NASA 视频,经由 YouTube",
"Controls for the selected space station": "所选空间站的控制",
"Expand Station section": "展开空间站区",
"Collapse Station section": "收起空间站区",
"Expand Station": "展开空间站",
"Collapse Station": "收起空间站",
"Manual · telemetry paused": "手动 · 遥测已暂停",
"Telemetry · updated {ago} ago": "遥测 · {ago}前更新",
"No signal since {time} · computed values": "自 {time} 起无信号 · 计算值",
"No signal · computed values": "无信号 · 计算值",
"Telemetry unavailable · last update {ago} ago · computed values": "遥测不可用 · 最后更新于{ago}前 · 计算值",
"Telemetry unavailable · computed values": "遥测不可用 · 计算值",
"Telemetry not enabled on this server · computed values": "此服务器未启用遥测 · 计算值",
"No public telemetry · computed values": "无公开遥测 · 计算值",
"Zoom to Tiangong": "拉近到天宫",
"Tianhe arm (degrees)": "天和机械臂(度)",
"Tianhe wings (degrees)": "天和翼板(度)",
"Lab wings (degrees)": "实验舱翼板(度)",
"Port wing": "左侧翼板",
"Starboard wing": "右侧翼板",
"Wentian forward · alpha": "问天前侧 · α",
"Wentian forward · beta": "问天前侧 · β",
"Wentian aft · alpha": "问天后侧 · α",
"Wentian aft · beta": "问天后侧 · β",
"Mengtian forward · alpha": "梦天前侧 · α",
"Mengtian forward · beta": "梦天前侧 · β",
"Mengtian aft · alpha": "梦天后侧 · α",
"Mengtian aft · beta": "梦天后侧 · β",
"Wentian arm (degrees)": "问天机械臂(度)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "太阳能板跟随太阳,天线指向中继卫星,机械臂仅作示意摆动。计算值:中国不公开实时遥测。",
"Telemetry reads while the model is on screen": "模型显示在屏幕上时读取遥测",
"Connecting to telemetry…": "正在连接遥测…",
"{seconds} s": "{seconds} 秒",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "太阳能板、散热器和一副天线依据 NASA 的实时遥测转动。另一副天线保持不动,机械臂仅作演示性摆动。"
}
+107 -1
View File
@@ -4213,5 +4213,111 @@
"Finding it…": "正在查找…",
"No reading at this time": "此時無數據",
"Last reading · {age}": "最後數據 · {age}",
"Find it": "查找"
"Find it": "查找",
"Underneath": "正下方",
"Open on YouTube": "在 YouTube 上打開",
"Video plays from YouTube, which sees your IP address.": "視頻從 YouTube 播放,YouTube 會看到你的 IP 地址。",
"Automatic": "自動",
"Manual": "手動",
"Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.": "太陽能板和散熱器跟隨太陽,天線指向中繼衛星,機械臂僅作演示性擺動。均為計算結果,並非實時遙測。",
"Overhead": "正上方",
"Ahead": "前方",
"Behind": "後方",
"Port side": "左舷",
"Starboard side": "右舷",
"Night (shadow)": "夜間(陰影)",
"Sun position": "太陽位置",
"Follow the Sun": "跟隨太陽",
"Fast orbit (40 s)": "快速繞行(40 秒)",
"Solar arrays": "太陽能板",
"Demonstration: the real arrays stay extended.": "演示:真實的太陽能板保持展開。",
"Retract": "收起",
"Extend": "展開",
"Radiators": "散熱器",
"Demonstration: the real radiators can fold but stay extended.": "演示:真實的散熱器可以摺疊,但保持展開。",
"Dishes": "天線",
"Relay satellites": "中繼衛星",
"Up": "向上",
"Forward": "向前",
"Sideways": "向側面",
"Shoulder roll": "肩部滾轉",
"Shoulder yaw": "肩部偏航",
"Shoulder pitch": "肩部俯仰",
"Elbow": "肘部",
"Wrist pitch": "腕部俯仰",
"Wrist yaw": "腕部偏航",
"Wrist roll": "腕部滾轉",
"Canadarm2 (degrees)": "Canadarm2(度)",
"Resume sway": "恢復擺動",
"Zoom to the ISS": "拉近到國際空間站",
"Now: in sunlight": "當前:處於日照中",
"Now: in the Earth's shadow": "當前:處於地球陰影中",
"STATION VIEW · {name}": "空間站視圖 · {name}",
"Previous station view": "上一個空間站視圖",
"Next station view": "下一個空間站視圖",
"OBSERVATION MODULE · ISS": "觀測艙 · 國際空間站",
"European Space Agency (ESA)": "歐洲航天局(ESA)",
"7 WINDOWS": "7 扇舷窗",
"LAUNCHED 8 FEB 2010 · STS-130": "2010年2月8日發射 · STS-130",
"TRANQUILITY · EARTH-FACING PORT": "寧靜號節點艙 · 對地端口",
"LABORATORY MODULE · ISS": "實驗艙 · 國際空間站",
"Japan Aerospace Exploration Agency (JAXA)": "日本宇宙航空研究開發機構(JAXA)",
"2 WINDOWS": "2 扇舷窗",
"LAUNCHED 31 MAY 2008 · STS-124": "2008年5月31日發射 · STS-124",
"HARMONY · PORT SIDE": "和諧號節點艙 · 左舷",
"Return to the default view": "恢復默認視圖",
"{label} · STATION VIEW": "{label} · 空間站視圖",
"ON AIR": "直播中",
"Starting…": "正在啟動…",
"Stream is offline": "直播已離線",
"LIVE VIDEO": "實時視頻",
"STREAM ATTACHED TO THE SUBJECT": "與所選對象關聯的直播",
"Live video": "實時視頻",
"Show Live Video": "顯示實時視頻",
"This stream cannot play here": "此直播無法在此播放",
"Expand Live section": "展開直播區",
"Collapse Live section": "收起直播區",
"Expand Live": "展開直播",
"Collapse Live": "收起直播",
"Live streams for the selected object": "所選對象的直播",
"Stream": "直播",
"Previous stream": "上一個直播",
"Next stream": "下一個直播",
"Try again": "重試",
"Exterior cameras": "外部攝像頭",
"Live video and space-to-ground audio": "實時視頻與天地通話音頻",
"NASA video, via YouTube": "NASA 視頻,經由 YouTube",
"Controls for the selected space station": "所選空間站的控制",
"Expand Station section": "展開空間站區",
"Collapse Station section": "收起空間站區",
"Expand Station": "展開空間站",
"Collapse Station": "收起空間站",
"Manual · telemetry paused": "手動 · 遙測已暫停",
"Telemetry · updated {ago} ago": "遙測 · {ago}前更新",
"No signal since {time} · computed values": "自 {time} 起無信號 · 計算值",
"No signal · computed values": "無信號 · 計算值",
"Telemetry unavailable · last update {ago} ago · computed values": "遙測不可用 · 最後更新於{ago}前 · 計算值",
"Telemetry unavailable · computed values": "遙測不可用 · 計算值",
"Telemetry not enabled on this server · computed values": "此服務器未啟用遙測 · 計算值",
"No public telemetry · computed values": "無公開遙測 · 計算值",
"Zoom to Tiangong": "拉近到天宮",
"Tianhe arm (degrees)": "天和機械臂(度)",
"Tianhe wings (degrees)": "天和翼板(度)",
"Lab wings (degrees)": "實驗艙翼板(度)",
"Port wing": "左側翼板",
"Starboard wing": "右側翼板",
"Wentian forward · alpha": "問天前側 · α",
"Wentian forward · beta": "問天前側 · β",
"Wentian aft · alpha": "問天後側 · α",
"Wentian aft · beta": "問天後側 · β",
"Mengtian forward · alpha": "夢天前側 · α",
"Mengtian forward · beta": "夢天前側 · β",
"Mengtian aft · alpha": "夢天後側 · α",
"Mengtian aft · beta": "夢天後側 · β",
"Wentian arm (degrees)": "問天機械臂(度)",
"Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.": "太陽能板跟隨太陽,天線指向中繼衛星,機械臂僅作示意擺動。計算值:中國不公開實時遙測。",
"Telemetry reads while the model is on screen": "模型顯示在屏幕上時讀取遙測",
"Connecting to telemetry…": "正在連接遙測…",
"{seconds} s": "{seconds} 秒",
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.": "太陽能板、散熱器和一副天線依據 NASA 的實時遙測轉動。另一副天線保持不動,機械臂僅作演示性擺動。"
}
+17 -6
View File
@@ -295,7 +295,11 @@
"{n} mm",
"Route",
"3D",
"KT"
"KT",
"ON AIR",
"Stream",
"{seconds} s",
"Mode"
],
"es": [
"1 min/s",
@@ -489,7 +493,9 @@
"{n} min",
"{n} mm",
"3D",
"KT"
"KT",
"Manual",
"{seconds} s"
],
"fr": [
"1 min/s",
@@ -746,7 +752,8 @@
"{n} min",
"{n} mm",
"3D",
"KT"
"KT",
"{seconds} s"
],
"it": [
"1 min/s",
@@ -979,7 +986,8 @@
"{n} min",
"{n} mm",
"3D",
"KT"
"KT",
"{seconds} s"
],
"ja": [
"1090 MHz",
@@ -1257,7 +1265,9 @@
"{n} min",
"{n} mm",
"3D",
"KT"
"KT",
"Manual",
"{seconds} s"
],
"ru": [
"1900–1945",
@@ -1494,7 +1504,8 @@
"{n} min",
"{n} mm",
"3D",
"KT"
"KT",
"{seconds} s"
],
"uk": [
"1900–1945",
+31
View File
@@ -139,3 +139,34 @@ test('same pixels at a new aspect redraw at the new fit', () => {
]);
assert.equal(runtime.canvasStamp, 2);
});
test('same pixels at a new resolution with the same fit skip the redraw', () => {
const { runtime, load } = stillHarness();
load(640, 480);
assert.deepEqual(load(1280, 960), []);
assert.equal(runtime.canvasStamp, 1);
assert.equal(runtime.drawnImageStamp, 2);
});
test('changed pixels redraw even when the fitted rectangle is unchanged', () => {
const { runtime, load } = stillHarness();
load(640, 480);
const changedPixels = new Uint8ClampedArray(
FRAME_SIGNATURE_W * FRAME_SIGNATURE_H * 4,
).fill(90);
runtime.signatureCtx.getImageData = () => ({ data: changedPixels });
const calls = load(640, 480);
assert.equal(calls[0][0], 'fillRect');
assert.deepEqual(calls[1], ['drawImage', 240, 0, 1440, 1080]);
assert.equal(runtime.canvasStamp, 2);
});
test('a failed pixel signature redraws rather than assuming equal content', () => {
const { runtime, load } = stillHarness();
load(640, 480);
runtime.signatureCtx.getImageData = () => {
throw new Error('tainted canvas');
};
assert.deepEqual(load(640, 480).at(-1), ['drawImage', 240, 0, 1440, 1080]);
assert.equal(runtime.canvasStamp, 2);
});
+2 -3
View File
@@ -81,9 +81,8 @@ export function createNavigation({
return false;
const nearest = nearestCameraIdToViewer();
if (!nearest || nearest === layerState._activeCameraId) return false;
parts.selection.setActiveCamera(nearest);
// setActiveCamera ends the opening pick; this is still that pick.
layerState._openingCameraProvisional = true;
// Still the opening pick: later settled moves may replace it.
parts.selection.setActiveCamera(nearest, { opening: true });
return true;
}
+74
View File
@@ -428,6 +428,80 @@ test('a pose with no perspective field of view is projected by the renderer', ()
}
});
test('focus release restores video hue and alpha after the style throttle', () => {
const viewer = {};
const camera = fakeCameraPort({
pose: { position: { x: 6378137 + 1000, y: 0, z: 0 } },
});
const { unbind } = bindFakeDraw(viewer, {
camera: camera.port,
query: { project: () => ({ x: 10, y: 20 }) },
});
let target = {};
const records = ['mp4', 'webm'].map((feedType) => ({
camera: { id: feedType, feedType },
position: { x: 6378137, y: 0, z: 0 },
}));
const state = {
_enabled: true,
_viewer: viewer,
_records: records,
_activeCameraId: null,
_activeFocusStyleCount: 0,
_lastFocusStyleAt: -Infinity,
};
const focus = {
focusNowMs: (nowMs) => nowMs,
getFocusTarget: () => target,
focusPassIsNeeded: (value, count) => !!value || count > 0,
advanceSpriteFocus: () => ({
factor: target ? FOCUS_FACTOR : 1,
active: !!target,
transitioning: false,
}),
focusAlphaNeedsWrite: (before, after) => before !== after,
};
const { createCameraIcons, addCameraIcon, refreshCctvFocusStyles } =
createRendering({
state,
services: { focus },
parts: {
model: {
isVideoFeedCamera: (camera) => isVideoFeedType(camera.feedType),
},
},
source: {},
});
try {
createCameraIcons(viewer);
for (const record of records) addCameraIcon(record);
const icons = state._icons;
refreshCctvFocusStyles(1000);
for (const record of records) {
assertKeepsColor(
icons,
record.camera.id,
LIVE_CAMERA_COLOR,
record.camera.id,
);
}
target = null;
refreshCctvFocusStyles(1050);
for (const record of records) {
assert.equal(icons.focus(record.camera.id), FOCUS_FACTOR, 'throttled');
}
refreshCctvFocusStyles(1100);
for (const record of records) {
assert.deepEqual(icons.item(record.camera.id).color, LIVE_CAMERA_COLOR);
assert.equal(icons.focus(record.camera.id), 1);
}
assert.equal(state._activeFocusStyleCount, 0);
} finally {
unbind();
}
});
test('hover picks the underlying camera only outside a painted count', () => {
const viewer = {};
const icon = { set: 'icons', id: 'camera' };
+8 -2
View File
@@ -108,10 +108,13 @@ export function createSelection({
* Sets the active camera by ID, initializes its projection runtime, refreshes
* its frame, and updates styles.
* @param {string} cameraId - ID of the camera to activate.
* @param {Object} [options]
* @param {boolean} [options.opening=false] - The opening camera following
* the view, not someone's pick: settled moves may still replace it.
* @returns {'activated'|'unchanged'|'not-found'} Discriminated activation result.
*/
function setActiveCamera(cameraId) {
function setActiveCamera(cameraId, { opening = false } = {}) {
if (!cameraId || !layerState._recordById.has(cameraId))
return CCTV_ACTIVATION_RESULT.NOT_FOUND;
const record = layerState._recordById.get(cameraId);
@@ -129,6 +132,9 @@ export function createSelection({
record,
)
) {
// Picking the camera a settled move re-opened is still a pick: later
// settled moves must leave it alone.
if (!opening) layerState._openingCameraProvisional = false;
// Browser-only feeds have a separate player; a reselect retries it
// without re-running activation or touching the projection geometry.
if (parts.model.isBrowserOverlayCamera(record.camera)) {
@@ -139,7 +145,7 @@ export function createSelection({
}
layerState._activeCameraId = cameraId;
layerState._autoHopSuspended = false;
layerState._openingCameraProvisional = false;
layerState._openingCameraProvisional = opening;
// A real activation creates projection work — wake the self-stopping loop.
parts.projection.startProjectionLoop();
if (previousActiveRecord && previousActiveRecord !== record) {
+13
View File
@@ -215,3 +215,16 @@ test('a count click is the card on top for every layer, unless the count yields'
picking.unregisterPickOwner('flights');
}
});
test('same-camera selection ends the opening pick without notifying snapshot feeds', () => {
const fixture = makeSelection('tripcheck-odot');
fixture.state._openingCameraProvisional = true;
assert.equal(
fixture.selection.setActiveCamera('same-camera'),
CCTV_ACTIVATION_RESULT.UNCHANGED,
);
assert.equal(fixture.state._openingCameraProvisional, false);
assert.equal(fixture.state._activeCameraReselection, 0);
assert.equal(fixture.notifications(), 0);
});
-2
View File
@@ -22,8 +22,6 @@ function frameUrlFor(camera, refreshMs = ACTIVE_FRAME_REFRESH_MS) {
const params = new URLSearchParams({
label: camera.name,
city: camera.city,
lat: camera.lat.toFixed(6),
lon: camera.lon.toFixed(6),
heading: String(Math.round(camera.headingDeg)),
fov: String(Math.round(camera.fovDeg)),
pitch: String(Math.round(camera.pitchDeg || -10)),
+2 -2
View File
@@ -82,8 +82,8 @@ test('frame and media URLs preserve registered camera identity and encoded metad
);
assert.equal(frame.searchParams.get('label'), camera.name);
assert.equal(frame.searchParams.get('city'), camera.city);
assert.equal(frame.searchParams.get('lat'), '30.267000');
assert.equal(frame.searchParams.get('lon'), '-97.744000');
assert.equal(frame.searchParams.has('lat'), false);
assert.equal(frame.searchParams.has('lon'), false);
assert.equal(frame.searchParams.get('heading'), '45');
assert.equal(frame.searchParams.get('pitch'), '-12');
assert.deepEqual([...media.searchParams.keys()], ['ts']);
+1
View File
@@ -108,6 +108,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
} = {}) {
layerState._viewer = viewer;
layerState._records = Array.isArray(records) ? records : [];
layerState._count = layerState._records.length;
layerState._recordById = new Map(
layerState._records
.filter((record) => record?.camera?.id)
+30 -1
View File
@@ -10,7 +10,13 @@ import { surfaceDistance } from '../../geo/geodesic.js';
import { toDegrees, toRadians } from '../../geo/vector.js';
import { cameraOf } from '../../render/rendererOf.js';
export function createControls({ state: layerState, services, parts, source }) {
export function createControls({
state: layerState,
services,
parts,
source,
overlayHost,
}) {
const methods = {
id: LAYER_ID,
@@ -171,6 +177,29 @@ export function createControls({ state: layerState, services, parts, source }) {
return id ? methods.getById(id) : null;
},
/**
* The mapped installation whose label box the shared overlay paints at a
* canvas position: what a click lands on from far out, where the dot is
* 7 px. Another layer's card or label that takes clicks there wins, so
* this answers null. The dot, outline and fill themselves are query port
* hits, read with {@link findByPick}. Null for anything else.
* @param {{x: number, y: number}|null|undefined} position Canvas CSS px.
* @returns {object|null} As {@link getById}.
*/
findAt(position) {
if (!Number.isFinite(position?.x) || !Number.isFinite(position?.y))
return null;
let top = null;
try {
top = overlayHost?.hitTest?.(position.x, position.y) ?? null;
} catch {
top = null;
}
if (top) return null;
const id = parts.namedMarkers?.labelAt?.(position) ?? null;
return id ? methods.getById(id) : null;
},
/**
* Select and frame a mapped installation from another contextual UI.
* @param {string} id Source-backed installation id.
@@ -0,0 +1,83 @@
// src/layers/installations/labelBoxClick.test.mjs — a click on a mapped
// installation's label box finds the site, read from the box the overlay
// painted for it, unless another layer's card or label that takes clicks is
// painted there.
import assert from 'node:assert/strict';
import test from 'node:test';
import { createControls } from './controls.js';
const RECORD = Object.freeze({
id: 'base',
kind: 'installation',
name: 'Base',
class: 'base',
latitude: 10,
longitude: 20,
});
const inside = (box, { x, y }) =>
x >= box.x && x <= box.x + box.w && y >= box.y && y <= box.y + box.h;
/**
* The installations controls over a fake overlay: `cards` are the hit rects
* of entries that take clicks (other layers'), `labels` the boxes painted
* for this layer's labels, which are not cards.
*/
function controlsWith({ cards = [], labels = {} }) {
const overlayHost = {
// As the world overlay does: the last painted card under the point wins.
hitTest(x, y) {
for (let i = cards.length - 1; i >= 0; i--)
if (inside(cards[i], { x, y }))
return { sourceId: cards[i].sourceId, entryId: cards[i].entryId };
return null;
},
};
const namedMarkers = {
labelAt: (position) =>
Object.keys(labels).find((id) => inside(labels[id], position)) ?? null,
};
const controls = createControls({
state: {
enabled: true,
records: [RECORD],
recordById: new Map([[RECORD.id, RECORD]]),
},
services: {},
parts: {
rendering: { installationSurfaceHeightM: () => 0 },
namedMarkers,
},
source: {},
overlayHost,
});
return controls.methods;
}
const BASE_LABEL = { x: 100, y: 100, w: 80, h: 20 };
test("a click on the site's own label box finds the site", () => {
const methods = controlsWith({ labels: { base: BASE_LABEL } });
assert.equal(methods.findAt({ x: 120, y: 110 })?.id, 'base');
assert.equal(methods.findAt({ x: 10, y: 10 }), null, 'outside every box');
assert.equal(methods.findAt(null), null);
});
test("another layer's card painted over the site's label keeps the click", () => {
const methods = controlsWith({
labels: { base: BASE_LABEL },
cards: [
{ sourceId: 'flights', entryId: 'abc123', x: 110, y: 105, w: 40, h: 12 },
],
});
assert.equal(
methods.findAt({ x: 120, y: 110 }),
null,
'the flight card is on top',
);
assert.equal(
methods.findAt({ x: 170, y: 110 })?.id,
'base',
'past the card, the site is found',
);
});
+31
View File
@@ -221,6 +221,11 @@ export function createNamedMarkers({ state, services, parts, overlayHost }) {
// What `visit` hands out: the marker's id, position and whether
// it is on this side of the horizon.
point: { id: { installationId: record.id }, position, show: false },
// Not an interactive overlay entry: those are cards that take every
// click from what is drawn under them, and an aircraft or vessel
// under a base's label must stay selectable. The label box still
// finds the site through its painted box (labelAt), which the
// layer's click claim reads where nothing else is drawn.
entry: createInfrastructureOverlayEntry({
id: record.id,
source: LAYER_ID,
@@ -274,6 +279,32 @@ export function createNamedMarkers({ state, services, parts, overlayHost }) {
visitor(marker.recordId, marker.point);
}
},
/**
* The site whose label box the shared overlay painted at a canvas
* position in its last frame, or null: what a click lands on from far
* out, where the dot is 7 px.
* @param {{x: number, y: number}|null|undefined} position Canvas CSS px.
* @returns {string|null} The installation id.
*/
labelAt(position) {
if (!state.enabled) return null;
const x = position?.x;
const y = position?.y;
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
for (let i = ordered.length - 1; i >= 0; i--) {
const { recordId } = ordered[i];
const box = overlayHost.paintRect?.(LAYER_ID, recordId);
if (
box &&
x >= box.x &&
x <= box.x + box.w &&
y >= box.y &&
y <= box.y + box.h
)
return recordId;
}
return null;
},
refresh,
enable,
hide,
+111 -23
View File
@@ -9,15 +9,30 @@ import { fakeSceneFrame, fakeSceneQuery } from '../../testSupport/fakeCesiumScen
import { createLocalInfrastructureOverlayEntry } from '../../data/localGeojsonCore.js';
function setup(t) {
let labels = [], options, publications = 0, visible = false;
let labels = [],
options,
publications = 0,
visible = false;
const overlayHost = {
setEntries(id, entries, policy) {
assert.equal(id, 'military-installations');
labels = entries; options = policy; publications++;
labels = entries;
options = policy;
publications++;
},
clearSource() {
labels = [];
},
setVisible(_id, value) {
visible = value;
},
// The boxes the overlay painted last frame, by entry id.
paintRect(id, entryId) {
assert.equal(id, 'military-installations');
return boxes.get(entryId) ?? null;
},
clearSource() { labels = []; },
setVisible(_id, value) { visible = value; },
};
const boxes = new Map();
let x = -100;
t.mock.method(C.SceneTransforms, 'worldToWindowCoordinates', () => new C.Cartesian2(x, 300));
const camera = { changed: new C.Event(), moveEnd: new C.Event(), positionWC: C.Cartesian3.fromDegrees(0, 0, 1e6), directionWC: new C.Cartesian3(0, 0, -1) };
@@ -33,14 +48,16 @@ function setup(t) {
lifecycle.init(state.viewer); lifecycle.enable();
const records = [1, 2].map((n) => ({ id: `osm:military:w${n}`, name: `Site ${n}`, namedArea: true, areaM2: 100 / n, latitude: 0, longitude: 0, pointOnly: true }));
const points = () => [...draw.sets.values()].find((set) => set.kind === 'points' && !set.disposed);
return { state, camera, draw, points, get labels() { return labels; }, get options() { return options; }, get visible() { return visible; }, records, markers: parts.namedMarkers, lifecycle, setX: (value) => { x = value; }, publications: () => publications, loads: () => loads };
return { state, camera, draw, points, get labels() { return labels; }, get options() { return options; }, get visible() { return visible; }, records, markers: parts.namedMarkers, lifecycle, boxes, setX: (value) => { x = value; }, publications: () => publications, loads: () => loads };
}
test('Contacts camera motion reprojects and declutters existing labels without source loads or primitive replacement', (t) => {
const h = setup(t);
h.markers.sync(h.records);
assert.equal(h.markers.stats().pointsOnScreen, 0);
h.setX(600); h.camera.changed.raiseEvent(); h.camera.moveEnd.raiseEvent();
h.setX(600);
h.camera.changed.raiseEvent();
h.camera.moveEnd.raiseEvent();
assert.equal(h.markers.stats().pointsOnScreen, 2);
assert.equal(h.labels.length, 2);
assert.equal(h.options.collisionCapacity, 24);
@@ -61,7 +78,8 @@ test('Contacts camera motion reprojects and declutters existing labels without s
assert.equal(h.labels.length, 0);
assert.equal(h.visible, false);
h.state.records = h.records;
h.setX(600); h.lifecycle.enable();
h.setX(600);
h.lifecycle.enable();
assert.equal(h.labels.length, 2);
assert.equal(h.publications(), 5);
h.lifecycle.destroy(h.state.viewer);
@@ -73,13 +91,25 @@ test('Contacts camera motion reprojects and declutters existing labels without s
test('wide named markers retain primitives until close polygons publish with the same identity', async (t) => {
const { retainNamedHandoff } = await import('./ingestion.js');
const h = setup(t);
h.setX(600); h.markers.sync(h.records);
h.setX(600);
h.markers.sync(h.records);
const first = h.labels[0];
const box = { west: -1, east: 1, south: -1, north: 1 };
h.markers.sync(retainNamedHandoff(h.records, [], box));
assert.equal(h.labels[0], first);
assert.equal(first.title, 'Site 1');
const polygon = { ...h.records[0], namedArea: false, name: 'Military area', pointOnly: false, footprint: [[0, 0], [0.1, 0], [0, 0.1], [0, 0]] };
const polygon = {
...h.records[0],
namedArea: false,
name: 'Military area',
pointOnly: false,
footprint: [
[0, 0],
[0.1, 0],
[0, 0.1],
[0, 0],
],
};
const handed = retainNamedHandoff(h.records, [polygon], box);
assert.equal(handed.length, 2);
assert.equal(handed[0].name, 'Site 1');
@@ -88,7 +118,11 @@ test('wide named markers retain primitives until close polygons publish with the
assert.equal(h.labels[0], first);
assert.equal(first.title, 'Site 1');
assert.equal(h.labels.length, 2, 'no duplicate title at handoff');
assert.equal(retainNamedHandoff(h.records, [], { west: 1, east: 2, south: 1, north: 2 }).length, 0);
assert.equal(
retainNamedHandoff(h.records, [], { west: 1, east: 2, south: 1, north: 2 })
.length,
0,
);
h.lifecycle.destroy(h.state.viewer);
});
@@ -98,7 +132,9 @@ test('canonical aliases transfer named marker ownership without replacing marker
const parent = h.records[1];
h.markers.sync([parent]);
let originalPoint;
h.markers.visit((_id, point) => { originalPoint = point; });
h.markers.visit((_id, point) => {
originalPoint = point;
});
const label = h.labels[0];
for (const record of [
{ ...parent, id: h.records[0].id, aliasIds: [parent.id], pointOnly: false },
@@ -120,17 +156,29 @@ test('canonical aliases transfer named marker ownership without replacing marker
h.lifecycle.destroy(h.state.viewer);
});
test('the bounded host cohort ranks wide points and polygon titles by area', (t) => {
const h = setup(t);
h.markers.sync(Array.from({ length: 600 }, (_, n) => ({
...h.records[0], id: `site:${n}`, name: `Site ${n}`, areaM2: n,
pointOnly: n % 2 === 0,
})));
h.markers.sync(
Array.from({ length: 600 }, (_, n) => ({
...h.records[0],
id: `site:${n}`,
name: `Site ${n}`,
areaM2: n,
pointOnly: n % 2 === 0,
})),
);
assert.equal(h.labels.length, 512);
assert.equal(h.labels[0].id, 'site:599');
assert.equal(h.labels.at(-1).id, 'site:88');
assert.ok(h.labels.every((entry) => !entry.stateless && entry.horizonCull && entry.collisionGroup === 'ambient-card'));
assert.ok(
h.labels.every(
(entry) =>
!entry.stateless &&
entry.horizonCull &&
entry.collisionGroup === 'ambient-card' &&
entry.interactive === false,
),
);
const first = h.labels[0];
const publications = h.publications();
for (let i = 0; i < 100; i++) {
@@ -143,7 +191,6 @@ test('the bounded host cohort ranks wide points and polygon titles by area', (t)
assert.equal(h.labels.length, 0);
});
test('wide and polygon titles use the Data Centers entry contract and persistent shared domain', (t) => {
const h = setup(t);
h.markers.sync([h.records[0], { ...h.records[1], pointOnly: false }]);
@@ -151,12 +198,43 @@ test('wide and polygon titles use the Data Centers entry contract and persistent
assert.equal(h.options.solveIntervalMs, undefined);
assert.equal(h.options.maxVisible, 24);
for (const entry of h.labels) {
const reference = createLocalInfrastructureOverlayEntry({ id: entry.id, layerId: 'military-installations', position: entry.position, properties: { name: entry.title }, priority: entry.priority, accent: entry.accent });
const reference = createLocalInfrastructureOverlayEntry({
id: entry.id,
layerId: 'military-installations',
position: entry.position,
properties: { name: entry.title },
priority: entry.priority,
accent: entry.accent,
});
// Not interactive: an interactive entry is a card that takes the click
// from an aircraft or vessel drawn under it. A click on the label box
// finds the site through its painted box (labelAt).
assert.deepEqual(entry, { ...reference, selected: false });
}
h.lifecycle.destroy(h.state.viewer);
});
test("labelAt finds the site whose label box was painted at a point, in CSS px", (t) => {
const h = setup(t);
h.markers.sync(h.records);
const [first, second] = h.records.map((record) => record.id);
h.boxes.set(first, { x: 100, y: 100, w: 80, h: 20 });
h.boxes.set(second, { x: 300, y: 100, w: 60, h: 20 });
assert.equal(h.markers.labelAt({ x: 120, y: 110 }), first);
assert.equal(h.markers.labelAt({ x: 360, y: 120 }), second, 'edges count');
assert.equal(h.markers.labelAt({ x: 250, y: 110 }), null, 'between boxes');
assert.equal(h.markers.labelAt(null), null);
assert.equal(h.markers.labelAt({ x: Number.NaN, y: 110 }), null);
// A site no longer marked has no label to find, even with a stale box.
h.markers.sync([h.records[1]]);
assert.equal(h.markers.labelAt({ x: 120, y: 110 }), null);
assert.equal(h.markers.labelAt({ x: 320, y: 110 }), second);
// Nor does a layer that is off.
h.state.enabled = false;
assert.equal(h.markers.labelAt({ x: 320, y: 110 }), null);
h.state.enabled = true;
h.lifecycle.destroy(h.state.viewer);
});
test('selection promotes exactly one entry and deselection restores that same label', (t) => {
const h = setup(t);
@@ -167,7 +245,7 @@ test('selection promotes exactly one entry and deselection restores that same la
assert.equal(h.labels.length, 2);
assert.equal(h.labels[0], original);
assert.equal(original.variant, 'selected');
assert.equal(h.labels.filter(e => e.selected).length, 1);
assert.equal(h.labels.filter((e) => e.selected).length, 1);
assert.equal(h.options.maxVisible, 23);
h.state.selectedId = null;
h.markers.sync(h.records);
@@ -180,14 +258,24 @@ test('selection promotes exactly one entry and deselection restores that same la
test('Contacts can select a point outside the normal title cap or an unnamed polygon', (t) => {
const h = setup(t);
const records = Array.from({ length: 520 }, (_, i) => ({ ...h.records[0], id: `site:${i}`, areaM2: 1000 - i }));
records.push({ ...h.records[0], id: 'unnamed', name: 'Military area', namedArea: false, pointOnly: false });
const records = Array.from({ length: 520 }, (_, i) => ({
...h.records[0],
id: `site:${i}`,
areaM2: 1000 - i,
}));
records.push({
...h.records[0],
id: 'unnamed',
name: 'Military area',
namedArea: false,
pointOnly: false,
});
for (const id of ['site:519', 'unnamed']) {
h.state.selectedId = id;
h.markers.sync(records);
assert.equal(h.labels[0].id, id);
assert.equal(h.labels[0].variant, 'selected');
assert.equal(h.labels.filter(e => e.selected).length, 1);
assert.equal(h.labels.filter((e) => e.selected).length, 1);
assert.equal(h.labels.length, 512);
}
h.lifecycle.destroy(h.state.viewer);
+50 -9
View File
@@ -1,5 +1,10 @@
import { inputFor } from '../../input/dispatcher.js';
import { isUnderOtherCard } from '../../data/pickRegistry.js';
import {
clickCard,
isUnderOtherCard,
registerClickClaim,
unregisterClickClaim,
} from '../../data/pickRegistry.js';
import { LAYER_ID } from './policy.js';
export function createSelection({
@@ -37,8 +42,39 @@ export function createSelection({
return layerState.selectedId === id;
}
/** Whether a draw hit is one of this layer's: a dot, outline, fill or named marker. */
function ownsHit(hit) {
return Boolean(
hit &&
(hit.set === parts.namedMarkers?.setId ||
parts.rendering.ownsSet(hit.set)),
);
}
/**
* A site's label box as the card on top of a click, for every layer's
* clickCard (the pick registry's click claim). Only where nothing another
* layer draws is under the click: an aircraft or vessel drawn under a
* base's label keeps its own click, while a label over the map, or over
* this layer's own dots and fills, takes it. Runs only where no card or
* label that takes clicks is painted on top.
* @param {object} event The shared dispatcher click.
* @returns {{sourceId: string, entryId: string}|null}
*/
function labelClickCard(event) {
if (!layerState.enabled || !event) return null;
if (event.topHit && !ownsHit(event.drawHit)) return null;
const id =
parts.namedMarkers?.labelAt?.(event.screenPosition ?? event.position) ??
null;
return id && layerState.recordById.has(id)
? { sourceId: LAYER_ID, entryId: id }
: null;
}
function installInteraction(viewer) {
if (layerState.clickSubscription) return;
registerClickClaim(LAYER_ID, labelClickCard);
const events = [
'gev:entity-selected',
'gev:entity-selection-cleared',
@@ -54,16 +90,20 @@ export function createSelection({
layerState.clickSubscription = input.onClick((event) => {
if (!layerState.enabled) return;
// Another layer's card or label painted on top takes the click: the item
// under it does not act, and the click is not empty space either.
if (isUnderOtherCard(event)) return;
// A site's dot, outline or fill, or a named marker: each draw item
// names its installation in its `meta`.
// under it does not act, and the click is not empty space either. A
// site's own label box is this layer's.
if (isUnderOtherCard(event, [LAYER_ID])) return;
// The site whose label box is at the click takes it where nothing
// another layer draws is under it (labelClickCard): from far out the
// click lands on the label, not the 7 px dot. Else a site's dot,
// outline or fill, or a named marker: each draw item names its
// installation in its `meta`.
const card = clickCard(event);
const hit = event.drawHit;
const id =
hit?.set === parts.namedMarkers?.setId ||
parts.rendering.ownsSet(hit?.set)
? hit.meta?.installationId
: null;
(card?.sourceId === LAYER_ID ? card.entryId : null) ??
(ownsHit(hit) ? hit.meta?.installationId : null) ??
null;
if (id && layerState.recordById.has(id) && id !== layerState.selectedId) {
selectRecord(id);
} else if (layerState.selectedId) {
@@ -82,6 +122,7 @@ export function createSelection({
destroy() {
removeContextListeners?.();
removeContextListeners = null;
unregisterClickClaim(LAYER_ID);
},
};
}
+69 -1
View File
@@ -7,7 +7,8 @@ import { createRendering } from './rendering.js';
import { createNamedMarkers, namedPointId } from './namedMarkers.js';
import { bindFakeCesiumScene } from '../../testSupport/fakeCesiumScene.mjs';
import { fakeInput } from '../../input/testDoubles.mjs';
import { setClickCardHitTest } from '../../data/pickRegistry.js';
import { clickCard, setClickCardHitTest } from '../../data/pickRegistry.js';
import { LAYER_ID } from './policy.js';
function harness(t) {
const previousWindow = globalThis.window;
@@ -60,6 +61,8 @@ function harness(t) {
() => new Cesium.Cartesian2(640, 400),
);
let labels = [];
// The boxes the overlay painted last frame for this layer's labels.
const boxes = new Map();
const services = {
context,
anchors: {},
@@ -82,6 +85,9 @@ function harness(t) {
},
clearSource() {},
setVisible() {},
paintRect(_id, entryId) {
return boxes.get(entryId) ?? null;
},
},
};
parts.rendering = createRendering(ctx);
@@ -116,6 +122,7 @@ function harness(t) {
draw,
input,
parts,
boxes,
/** Click on what `pick` names, as the scene would pick it. */
click(value) {
picked = value;
@@ -258,3 +265,64 @@ test('a click on a site dot or its outline selects the site; another set does no
h.click({ id: { set: 'other:1', id: outline.id, meta: outline.meta } });
assert.equal(selectedNow(), false);
});
test("a click on a site's label box selects it where nothing else is drawn under it", (t) => {
const h = harness(t);
h.state.selectedId = null;
context.clearSelectedEntityContextForLayer('military-installations');
h.parts.rendering.renderRecords();
// The card every layer reads for each click, as Context's bridge reads it.
const cards = [];
const offCards = h.input.input.onClick((event) =>
cards.push(clickCard(event)),
);
t.after(offCards);
// No label at the click and nothing picked: nothing is selected.
h.click(undefined);
h.assertSelected(false);
assert.equal(cards.at(-1), null);
// The site's label box at the click (CSS px) selects it; again releases it.
h.boxes.set('base', { x: 600, y: 390, w: 80, h: 20 });
h.click(undefined);
h.assertSelected(true);
assert.deepEqual(cards.at(-1), { sourceId: LAYER_ID, entryId: 'base' });
h.click(undefined);
h.assertSelected(false);
// Over the site's own named marker, the label still takes the click.
const setId = h.parts.namedMarkers.setId;
const item = h.draw.set(setId).items.get(namedPointId('base'));
h.click({ id: { set: setId, id: item.id, meta: item.meta } });
h.assertSelected(true);
assert.deepEqual(cards.at(-1), { sourceId: LAYER_ID, entryId: 'base' });
// An aircraft drawn under the label keeps its click: the label is no card
// there, so its own layer and Context can select it, and the site lets go.
h.click({ id: 'flight:abc123' });
h.assertSelected(false);
assert.equal(cards.at(-1), null);
// Another layer's card painted over the label takes the click.
setClickCardHitTest(() => ({ sourceId: 'earthquake-card', entryId: 'ak1' }));
t.after(() => setClickCardHitTest(null));
h.click(undefined);
h.assertSelected(false);
setClickCardHitTest(null);
// A layer that is off claims nothing.
h.state.enabled = false;
h.click(undefined);
assert.equal(cards.at(-1), null);
h.state.enabled = true;
});
test('destroy withdraws the label claim', (t) => {
const h = harness(t);
h.boxes.set('base', { x: 600, y: 390, w: 80, h: 20 });
const cards = [];
const offCards = h.input.input.onClick((event) =>
cards.push(clickCard(event)),
);
t.after(offCards);
h.click(undefined);
assert.deepEqual(cards.at(-1), { sourceId: LAYER_ID, entryId: 'base' });
h.selection.destroy();
h.click(undefined);
assert.equal(cards.at(-1), null);
});
+24
View File
@@ -9,6 +9,7 @@ import {
tleEpochMs,
} from './classes.js';
import { ISS_NORAD } from './policy.js';
import { trackedStation } from './stationModels.js';
/** The layer id a satellite subject carries through Cockpit events and state. */
export const SATELLITE_COCKPIT_LAYER_ID = 'satellites';
@@ -261,6 +262,29 @@ export function createCockpitSubject({ state: layerState, parts }) {
return out;
},
/**
* Where the Cockpit camera sits and looks when the subject is the
* station: a view from a point on the ISS model (issMounts.js) in place
* of the straight-down picture. The station offers several (from Nauka,
* from Zarya, from a docked vehicle), whichever of its entries is ridden.
* @param {string|null} [key] The view asked for; the first on offer when
* it is not given or not on offer.
* @returns {{position: object, direction: object, up: object,
* right: object, key: string, label: string,
* views: Array<{key: string, label: string}>}|null} Earth-fixed
* `{x, y, z}` vectors, the view shown and the views on offer; null for
* any other satellite, outside the Cockpit, or until the model has
* loaded.
*/
getCockpitMount(key = null) {
if (!_cockpitHeld()) return null;
// The station the subject belongs to; a station without views on its
// model (Tiangong) answers null, and the Cockpit keeps the nadir picture.
return (
trackedStation(layerState, parts)?.model?._cockpitMount?.(key) ?? null
);
},
/**
* Mark the satellite whose position the Cockpit camera occupies, or
* release it. The hold applies while that satellite is tracked.
@@ -631,3 +631,70 @@ test('the subject says whether its class may be ridden', () => {
])
assert.equal(subject(satelliteClass).enterable, true, satelliteClass);
});
test('the station offers its mount only while the Cockpit rides it', async (t) => {
const f = await fixture(t);
const mount = { label: 'ZARYA' };
// The ISS model part works the mount out (issModel.js, stationModel.js);
// this layer only decides when the Cockpit may have it, asking the part
// whose station the subject is (stationModels.js).
const modelPart = (offered) => ({
key: 'iss',
norad: ISS_NORAD,
_updateStationModel() {},
_destroyStationModel() {},
_standsInFor: () => false,
_cockpitMount: () => offered,
});
f.parts.stationModels = [modelPart(mount)];
assert.equal(f.methods.getCockpitMount(), null, 'nothing tracked');
f.track(ISS_NORAD);
f.nextFrame();
assert.equal(f.methods.getCockpitMount(), null, 'tracked, not ridden');
f.methods.setCockpitSubject(String(ISS_NORAD));
assert.equal(f.methods.getCockpitMount(), mount);
// The view asked for is passed on; none asks for the first on offer.
const asked = [];
f.parts.stationModels = [
{
...modelPart(mount),
_cockpitMount(key) {
asked.push(key);
return mount;
},
},
];
f.methods.getCockpitMount('zarya');
f.methods.getCockpitMount();
assert.deepEqual(asked, ['zarya', null]);
// The model has nothing to offer: not loaded, or not the station.
f.parts.stationModels = [modelPart(null)];
assert.equal(f.methods.getCockpitMount(), null);
delete f.parts.stationModels;
assert.equal(f.methods.getCockpitMount(), null);
// Another station's part is not asked for the ISS.
f.parts.stationModels = [{ ...modelPart(mount), norad: 48274 }];
assert.equal(f.methods.getCockpitMount(), null);
f.parts.stationModels = [modelPart(mount)];
f.methods.setCockpitSubject(null);
assert.equal(f.methods.getCockpitMount(), null, 'released');
});
test('a satellite docked to the ISS draws no ring of its own: the ISS’s shows', async (t) => {
const f = await fixture(t);
f.track(COMPANION);
f.nextFrame();
assert.equal(f.state._trackedDockedToIss, true);
assert.equal(f.ring(COMPANION), undefined, 'no second ring');
assert.equal(f.ring(ISS_NORAD).show, true);
// The ISS's ring stands for it even with the stations class hidden.
f.methods.setParams({ classes: { stations: false } });
assert.equal(f.ring(ISS_NORAD).show, true);
// Another satellite keeps its own ring; the ISS's goes with its class.
f.track(GPS);
f.nextFrame();
assert.equal(f.state._trackedDockedToIss, false);
assert.ok(f.ring(GPS));
assert.equal(f.ring(GPS).show, true);
assert.equal(f.ring(ISS_NORAD).show, false);
});
+21 -2
View File
@@ -9,6 +9,7 @@ import {
mergeClassVisibility,
} from './classes.js';
import { ISS_NORAD, POINT_STYLES, classPointStyle } from './policy.js';
import { modelFor, trackedStation } from './stationModels.js';
export function createControls({ state: layerState, services, parts, source }) {
const { isExplicitLayerStateOrigin } = services.layerState;
@@ -64,7 +65,8 @@ export function createControls({ state: layerState, services, parts, source }) {
/**
* Whether the ISS's ring shows: orbits on, the layer drawing, and its
* class on or the ISS tracked (a tracked satellite keeps its ring).
* class on or the ISS tracked (a tracked satellite keeps its ring), also
* as an object docked to it, which draws no ring of its own.
*/
function _issOrbitVisible() {
return (
@@ -72,7 +74,9 @@ export function createControls({ state: layerState, services, parts, source }) {
layerState._enabled,
layerState._params.showOrbits,
) &&
(_classVisible(ISS_NORAD) || layerState._trackedNorad === ISS_NORAD)
(_classVisible(ISS_NORAD) ||
layerState._trackedNorad === ISS_NORAD ||
Boolean(layerState._trackedDockedToIss))
);
}
@@ -253,6 +257,9 @@ export function createControls({ state: layerState, services, parts, source }) {
// that card instead. Only members of the tracked cluster are affected —
// unrelated nearby satellites are never suppressed.
if (!isTracked && layerState._dockedCompanions.has(noradId)) continue;
// Up close a station is its 3D model: no mark on it, nor on what is
// docked to it.
if (modelFor(parts, noradId)?._visualPosition?.()) continue;
// The Cockpit camera rides a held subject; a bracket on it would sit
// on the lens.
if (isTracked && parts.cockpit?._cockpitHeld()) continue;
@@ -433,6 +440,18 @@ export function createControls({ state: layerState, services, parts, source }) {
return result;
},
/**
* The keys the LIVE section matches streams by for the tracked
* satellite: a station is `station:<key>` (`station:iss`,
* `station:tiangong`) whichever of its entries is tracked (the station,
* a module, a docked vehicle).
* @returns {string[]}
*/
getLiveSubjectKeys() {
const station = trackedStation(layerState, parts);
return station ? [`station:${station.key}`] : [];
},
/**
* Track a satellite by NORAD id (camera follow + orbit path + highlight),
* same path as clicking its point.
+23 -1
View File
@@ -7,13 +7,22 @@ import { createRendering } from './rendering.js';
import { createTracking } from './tracking.js';
import { createTesting } from './testing.js';
import { createInteraction } from './interaction.js';
import { issStationDescription } from './issStation.js';
import { createStationPanel } from './stationPanel.js';
import { createIssModel } from './issModel.js';
import { createTiangongModel } from './tiangongModel.js';
import { tiangongStationDescription } from './tiangongStation.js';
import { createLifecycle } from './lifecycle.js';
import { createIngestion } from './ingestion.js';
import { createRecords } from './records.js';
import { createState } from './state.js';
/** Construct one layer with its own scene state and supplied application services. */
export function createSatellitesLayer({ services, source }) {
export function createSatellitesLayer({
services,
source,
resolveAsset = (url) => url,
}) {
if (typeof source?.readGroup !== 'function')
throw new TypeError('A satellites source is required');
const state = createState({ services });
@@ -25,6 +34,18 @@ export function createSatellitesLayer({ services, source }) {
parts.orbits = createOrbits(context);
parts.records = createRecords(context);
parts.rendering = createRendering(context);
// The stations drawn as models up close; the other parts ask
// stationModels.js which station an entry belongs to.
parts.issModel = createIssModel({ ...context, resolveAsset });
parts.tiangongModel = createTiangongModel({ ...context, resolveAsset });
parts.stationModels = [parts.issModel, parts.tiangongModel];
parts.stationPanel = createStationPanel({
...context,
stations: [
issStationDescription(context),
tiangongStationDescription(context),
],
});
parts.tracking = createTracking(context);
parts.testing = createTesting(context);
parts.interaction = createInteraction(context);
@@ -35,6 +56,7 @@ export function createSatellitesLayer({ services, source }) {
{},
parts.controls.methods,
parts.cockpit.methods,
parts.stationPanel.methods,
parts.lifecycle.methods,
parts.ingestion.methods,
{
+13
View File
@@ -1,4 +1,5 @@
import { inputFor } from '../../input/dispatcher.js';
import { modelHitNorad } from './stationModels.js';
import { onFollowChanged } from '../../data/followed.js';
export function createInteraction({
@@ -67,6 +68,18 @@ export function createInteraction({
parts.tracking._trackSatellite(noradId, { origin: 'user' });
return;
}
// A station's 3D model (stationModel.js) names its station. A click
// on the tracked station's own model is already tracked; on another
// station's model it tracks that one.
const modelNorad = modelHitNorad(parts, hit);
if (modelNorad !== null) {
if (modelNorad === layerState._trackedNorad) return;
if (layerState._catalog.has(modelNorad)) {
parts.tracking._cancelPendingTrackingRestore();
parts.tracking._trackSatellite(modelNorad, { origin: 'user' });
return;
}
}
// A pick that belongs to a sibling layer (plane, vessel, station, CCTV
// camera…) is not "empty space" — leave OUR tracking (and crucially
+834
View File
@@ -0,0 +1,834 @@
import { sunPositionFixed } from '../../geo/celestial.js';
/**
* The ISS model's moving parts. NASA's file names its joints; the build keeps
* each one as a node of its own, with the parts it carries beneath it, all in
* the model's rest frame (glTF axes, meters: X port, Y zenith, Z forward), so
* a joint turns by rotating its node about `pivot`.
*
* By default the angles are computed from where the Sun is: the two alpha
* joints turn the outboard truss about the truss axis, each array's beta
* joint turns it about its mast, and the two radiator joints keep the
* radiators edge-on to the Sun. In the Earth's shadow the arrays feather:
* masts along the flight direction, edge into it.
*
* Where the server relays NASA's public telemetry (issTelemetry.js), the
* arrays, the radiators and one dish take their real angles from it instead,
* and fall back to the computed ones whenever it has nothing to say.
*/
/** Alpha joints (SARJ): rotate about the truss, glTF X. */
export const ISS_ALPHA_JOINTS = Object.freeze([
Object.freeze({ node: 'PORT_ALPHA_ROT', pivot: [19.533, 0, 0] }),
Object.freeze({ node: 'STBD_ALPHA_ROT', pivot: [-19.533, 0, 0] }),
]);
/**
* Beta joints (BGA): rotate about the mast, glTF Z at rest. `face` is the
* sign of the cell side's normal along X at rest (the roll-out arrays sit on
* that side).
*/
export const ISS_BETA_JOINTS = Object.freeze([
Object.freeze({
node: 'PORT_BETA_ROT_2A',
pivot: [36.7319, 0.7256, -3.0077],
face: -1,
}),
Object.freeze({
node: 'PORT_BETA_ROT_4A',
pivot: [36.7319, -0.7258, 2.2332],
face: -1,
}),
Object.freeze({
node: 'PORT_BETA_ROT_2B',
pivot: [53.223, -0.7196, 2.2335],
face: -1,
}),
Object.freeze({
node: 'PORT_BETA_ROT_4B',
pivot: [53.2219, 0.7294, -3.0076],
face: -1,
}),
Object.freeze({
node: 'STBD_BETA_ROT_1A',
pivot: [-36.6608, 0.7257, 3.0224],
face: 1,
}),
Object.freeze({
node: 'STBD_BETA_ROT_3A',
pivot: [-36.6608, -0.7257, -2.2408],
face: 1,
}),
Object.freeze({
node: 'STBD_BETA_ROT_1B',
pivot: [-53.2219, -0.7294, -2.2408],
face: 1,
}),
Object.freeze({
node: 'STBD_BETA_ROT_3B',
pivot: [-53.2232, 0.722, 3.0223],
face: 1,
}),
]);
/** Radiator joints (TRRJ): rotate about glTF Z; the panels face Y at rest. */
export const ISS_RADIATOR_JOINTS = Object.freeze([
Object.freeze({ node: 'PORT_TRRJ_GAMMA_ROT', pivot: [16.1287, 0, -7.4432] }),
Object.freeze({ node: 'STBD_TRRJ_GAMMA_ROT', pivot: [-16.1287, 0, -7.4432] }),
]);
/** How fast a joint may turn on screen, radians per second of wall time. */
export const ISS_JOINT_RATE = (12 * Math.PI) / 180;
/** Below this the Sun is too close to a joint's axis to steer by it. */
const MIN_STEER = 0.05;
const EARTH_RADIUS_M = 6_371_000;
/** The signed difference b - a, wrapped to (-π, π]. */
function wrap(delta) {
let d = delta % (2 * Math.PI);
if (d > Math.PI) d -= 2 * Math.PI;
if (d <= -Math.PI) d += 2 * Math.PI;
return d;
}
/** Of `angle` and `angle + π`, the one nearer to `previous`. */
function nearestHalfTurn(angle, previous) {
const flipped = angle + Math.PI;
return Math.abs(wrap(angle - previous)) <= Math.abs(wrap(flipped - previous))
? angle
: flipped;
}
/**
* Whether a point is in the Earth's shadow, taken as a cylinder.
* @param {number[]} positionEcef Meters.
* @param {number[]} sunEcef Unit vector toward the Sun.
* @returns {boolean}
*/
export function issInShadow(positionEcef, sunEcef) {
const along =
positionEcef[0] * sunEcef[0] +
positionEcef[1] * sunEcef[1] +
positionEcef[2] * sunEcef[2];
if (along >= 0) return false;
const off = Math.hypot(
positionEcef[0] - along * sunEcef[0],
positionEcef[1] - along * sunEcef[1],
positionEcef[2] - along * sunEcef[2],
);
return off < EARTH_RADIUS_M;
}
/**
* The Sun's direction on the model's glTF axes, from the flight axes the
* model is oriented by (x along-track, y orbit normal, z zenith).
* @param {number[]} sunEcef Unit vector toward the Sun, Earth-fixed.
* @param {{x:number[], y:number[], z:number[]}} axes
* @returns {number[]} [port, zenith, forward].
*/
export function issSunInModelFrame(sunEcef, axes) {
const dot = (a) => a[0] * sunEcef[0] + a[1] * sunEcef[1] + a[2] * sunEcef[2];
return [dot(axes.y), dot(axes.z), dot(axes.x)];
}
/**
* The joint angles that point the arrays at the Sun.
* @param {number[]} sun Unit vector toward the Sun on the model's glTF axes.
* @param {boolean} sunlit False in the Earth's shadow: the arrays feather.
* @param {{alpha:number, gamma:number}} [previous] The last targets, so a
* joint with two equivalent answers keeps the nearer one.
* @returns {{alpha:number, beta:number[], gamma:number}} Radians: `alpha`
* about +X for both alpha joints, `beta` about +Z per ISS_BETA_JOINTS entry,
* `gamma` about +Z for both radiator joints.
*/
export function issJointTargets(
sun,
sunlit,
previous = { alpha: 0, gamma: 0 },
) {
const [sx, sy, sz] = sun;
// Radiators: the panel normal, Y at rest, perpendicular to the Sun.
const gamma =
Math.hypot(sx, sy) < MIN_STEER
? previous.gamma
: nearestHalfTurn(Math.atan2(sy, sx), previous.gamma);
if (!sunlit) {
return {
alpha: nearestHalfTurn(0, previous.alpha),
beta: ISS_BETA_JOINTS.map(() => 0),
gamma,
};
}
// Alpha: the masts, ±Z at rest, perpendicular to the Sun.
const alpha =
Math.hypot(sy, sz) < MIN_STEER
? previous.alpha
: nearestHalfTurn(Math.atan2(sz, sy), previous.alpha);
// The Sun as the arrays see it before the alpha turn.
const c = Math.cos(alpha);
const s = Math.sin(alpha);
const lx = sx;
const ly = c * sy + s * sz;
// Beta: the cell side's normal, ±X at rest, onto the Sun.
const beta = ISS_BETA_JOINTS.map(({ face }) =>
Math.atan2(face * ly, face * lx),
);
return { alpha, beta, gamma };
}
/**
* Step `current` toward `target` the short way round, by at most `maxStep`.
* @returns {number}
*/
export function issStepAngle(current, target, maxStep) {
const delta = wrap(target - current);
if (Math.abs(delta) <= maxStep) return current + delta;
return current + Math.sign(delta) * maxStep;
}
/**
* A node's matrix for a turn of `angle` about `axis` ('x' or 'z') through
* `pivot`, column-major.
* @param {'x'|'z'} axis
* @param {number[]} pivot
* @param {number} angle Radians.
* @param {ArrayLike<number>} result Any 16-slot array, column-major.
* @returns {ArrayLike<number>} `result`.
*/
export function issJointMatrix(axis, pivot, angle, result) {
const c = Math.cos(angle);
const s = Math.sin(angle);
const [px, py, pz] = pivot;
// Row-major arguments.
if (axis === 'x')
return set(result, [
1,
0,
0,
0,
0,
c,
-s,
py - (c * py - s * pz),
0,
s,
c,
pz - (s * py + c * pz),
0,
0,
0,
1,
]);
return set(result, [
c,
-s,
0,
px - (c * px - s * py),
s,
c,
0,
py - (s * px + c * py),
0,
0,
1,
0,
0,
0,
0,
1,
]);
}
/**
* Write a row-major 4×4 into `result`, column-major (a renderer's matrix
* layout; `result` is any 16-slot array).
* @param {ArrayLike<number> & {[i: number]: number}} [result] A new one when not given.
* @param {number[]} rowMajor
*/
function set(result, rowMajor) {
result ??= new Float64Array(16);
for (let row = 0; row < 4; row++)
for (let column = 0; column < 4; column++)
result[column * 4 + row] = rowMajor[row * 4 + column];
return result;
}
/**
* Canadarm2's seven joints as NASA's file names them, base to tip: each
* node's pivot and its local Z axis on the model's axes. Where the real arm
* is at any moment is not public, so its motion here is ILLUSTRATIVE: a slow
* sway of `sway` radians about the pose in NASA's file, over `period`
* seconds. Joints with no sway stay as filed.
*/
export const ISS_ARM_JOINTS = Object.freeze(
[
['SHR', [0.6732, -9.3793, 8.3367], [-0.0942, -0.0136, 0.9955], 0, 0],
['SHY', [0.6004, -9.3899, 9.105], [-0.2949, 0.9554, -0.0148], 8, 97],
['SHP_PRIME', [0.7848, -9.9873, 9.1143], [-0.2949, 0.9554, -0.0148], 6, 71],
[
'ELP_PRIME',
[-2.9987, -11.8039, 2.5061],
[-0.2949, 0.9554, -0.0148],
12,
53,
],
['WRP', [-3.8898, -12.6132, 10.249], [-0.2949, 0.9554, -0.0148], 10, 41],
['WRY', [-3.9961, -12.6341, 11.0132], [-0.2949, 0.9554, -0.0148], 0, 0],
['WRR', [-4.2995, -12.7285, 10.9684], [0.2874, -0.5533, -0.7818], 0, 0],
].map(([node, pivot, axis, swayDeg, period]) =>
Object.freeze({
node,
pivot,
axis,
sway: (swayDeg * Math.PI) / 180,
period,
}),
),
);
/**
* The station's smaller arms, swayed the same illustrative way: Dextre's two
* arms (shoulder and elbow pitch each) and the Japanese arm on Kibo
* (shoulder, elbow and wrist pitch). The European arm on Nauka has no joints
* in NASA's file, so it stays as filed.
*/
export const ISS_SMALL_ARM_JOINTS = Object.freeze(
[
[
'SPDM_Arm1_SHP',
[4.3019, -8.7313, 2.9551],
[-0.5183, -0.8218, -0.2366],
5,
61,
],
[
'SPDM_Arm1_ELP',
[4.763, -7.9839, 3.1897],
[0.2256, 0.4303, -0.874],
7,
43,
],
[
'SPDM_Arm2_SHP',
[1.8182, -9.8753, 5.2105],
[-0.27, -0.522, -0.8091],
5,
67,
],
[
'SPDM_Arm2_ELP',
[1.8575, -9.4898, 6.0546],
[-0.3202, -0.5495, -0.7717],
7,
47,
],
['JEM_SP_ROT', [14.2188, -3.6716, 13.394], [-0.001, 0, -1], 5, 83],
['JEM_EP_ROT', [14.2223, 0.6479, 13.394], [-0.0011, 0, -1], 8, 59],
['JEM_WP_ROT', [16.4495, -3.0694, 13.3917], [-0.001, 0, -1], 8, 37],
].map(([node, pivot, axis, swayDeg, period]) =>
Object.freeze({
node,
pivot,
axis,
sway: (swayDeg * Math.PI) / 180,
period,
}),
),
);
/** Every joint that sways. */
const ISS_SWAY_JOINTS = [...ISS_ARM_JOINTS, ...ISS_SMALL_ARM_JOINTS];
/** The arm joints the sway moves; the rest hold NASA's filed pose. */
const ISS_SWAYING_NODES = new Set(
ISS_SWAY_JOINTS.filter((joint) => joint.sway).map((joint) => joint.node),
);
/**
* The arm's illustrative joint angles at a wall-clock time.
* @param {number} seconds
* @returns {number[]} Radians, one per ISS_ARM_JOINTS entry.
*/
export function issArmAngles(seconds, joints = ISS_ARM_JOINTS) {
return joints.map(({ sway, period }) =>
sway ? sway * Math.sin((2 * Math.PI * seconds) / period) : 0,
);
}
/**
* The two Ku-band dishes on the Z1 truss. NASA's file has them welded into
* the truss; the build cuts out everything above each gimbal. At rest a dish
* looks along +Y (zenith).
*/
export const ISS_DISH_JOINTS = Object.freeze([
Object.freeze({ node: 'SGANT_ROT_1', pivot: [-1.105, 4.5, -4.885] }),
Object.freeze({ node: 'SGANT_ROT_2', pivot: [4.56, 4.64, -5.235] }),
]);
/**
* The relay satellites the dishes talk to (NASA's TDRS) sit over the equator
* at fixed longitudes, so each is a fixed point in the Earth-fixed frame.
* These are the fleet's nominal slots (Atlantic, Pacific, Indian Ocean), not
* a live roster: which satellite the station uses at a given moment is not
* public in real time.
*/
export const ISS_RELAY_LONGITUDES_DEG = Object.freeze([-41, -171, 85]);
const GEOSTATIONARY_RADIUS_M = 42_164_000;
/** A dish does not look below this much above the station's horizon plane. */
const DISH_MIN_UP = 0.15;
/**
* Where the relay satellites are from the station, on the model's axes, the
* highest above the station first.
* @param {number[]} positionEcef Meters.
* @param {{x:number[], y:number[], z:number[]}} axes Flight axes.
* @param {readonly number[]} [longitudes] The relays' slots, degrees east;
* NASA's for the ISS, another station passes its own.
* @returns {number[][]} Unit vectors [port, zenith, forward].
*/
export function issRelayDirections(
positionEcef,
axes,
longitudes = ISS_RELAY_LONGITUDES_DEG,
) {
return longitudes
.map((longitude) => {
const lon = (longitude * Math.PI) / 180;
const to = [
GEOSTATIONARY_RADIUS_M * Math.cos(lon) - positionEcef[0],
GEOSTATIONARY_RADIUS_M * Math.sin(lon) - positionEcef[1],
-positionEcef[2],
];
const length = Math.hypot(to[0], to[1], to[2]);
return issSunInModelFrame(
to.map((c) => c / length),
axes,
);
})
.sort((a, b) => b[1] - a[1]);
}
/**
* Turn the unit vector `current` toward `target` by at most `maxStep` radians.
* @returns {number[]}
*/
export function issStepDirection(current, target, maxStep) {
const cos = Math.min(
1,
Math.max(
-1,
current[0] * target[0] + current[1] * target[1] + current[2] * target[2],
),
);
const angle = Math.acos(cos);
if (angle <= maxStep || angle < 1e-6) return target;
const sin = Math.sin(angle);
// Opposite vectors have no single arc between them: nudge off the line.
if (sin < 1e-6)
return issStepDirection(
[current[2], current[0], current[1]],
target,
maxStep,
);
const t = maxStep / angle;
const a = Math.sin((1 - t) * angle) / sin;
const b = Math.sin(t * angle) / sin;
return [0, 1, 2].map((i) => a * current[i] + b * target[i]);
}
/**
* A node's matrix for a turn of `angle` about the unit vector `axis` through
* `pivot`.
* @param {number[]} pivot
* @param {number[]} axis Unit vector.
* @param {number} angle Radians.
* @param {ArrayLike<number>} result Any 16-slot array, column-major.
* @returns {ArrayLike<number>} `result`.
*/
export function issAxisMatrix(pivot, axis, angle, result) {
const [x, y, z] = axis;
const c = Math.cos(angle);
const s = Math.sin(angle);
const t = 1 - c;
const r = [
[t * x * x + c, t * x * y - s * z, t * x * z + s * y],
[t * x * y + s * z, t * y * y + c, t * y * z - s * x],
[t * x * z - s * y, t * y * z + s * x, t * z * z + c],
];
const rows = r.map((row, i) => [
...row,
pivot[i] - (row[0] * pivot[0] + row[1] * pivot[1] + row[2] * pivot[2]),
]);
return set(result, [...rows[0], ...rows[1], ...rows[2], 0, 0, 0, 1]);
}
/**
* A dish node's matrix that turns its rest boresight (+Y) onto `direction`.
* @param {number[]} pivot
* @param {number[]} direction Unit vector on the model's axes.
* @param {ArrayLike<number>} result Any 16-slot array, column-major.
* @returns {ArrayLike<number>} `result`.
*/
export function issAimMatrix(pivot, direction, result) {
// Y × direction
const kx = direction[2];
const kz = -direction[0];
const length = Math.hypot(kx, kz);
if (length < 1e-9)
return issAxisMatrix(
pivot,
[1, 0, 0],
direction[1] > 0 ? 0 : Math.PI,
result,
);
const angle = Math.acos(Math.min(1, Math.max(-1, direction[1])));
return issAxisMatrix(pivot, [kx / length, 0, kz / length], angle, result);
}
/**
* Drives the loaded model's joints. Stateless about the model: `update` looks
* the nodes up once per model and only writes a node whose angle moved.
*/
export function createIssArticulation() {
let boundModel = null;
let nodes = null;
let angles = null;
let targets = { alpha: 0, gamma: 0 };
let lastMs = 0;
let override = null;
let dishOverride = null;
/** Gives the joint angles from telemetry, or null: see setTelemetry. */
let telemetry = null;
/** Command panel state: Manual takes the joints, so telemetry is off. */
let telemetryAllowed = true;
/** Whether the last update took its angles from telemetry; null before one. */
let lastLive = null;
/** Whether the last update had the station in sunlight; null before one. */
let lastSunlit = null;
/** Command panel state: the arm is being posed by hand, so the sway is off. */
/** The arm joints posed by hand (command panel); the rest keep swaying. */
const manualJoints = new Set();
let armNodes = null;
/** Command panel state: how far the arrays are rolled out, 0.05 to 1. */
let deploy = 1;
let deployTarget = 1;
let radiatorDeploy = 1;
let radiatorTarget = 1;
/** The truss face the radiators fold back to, on the model's Z axis. */
const RADIATOR_ROOT_Z = -1.9;
/** The power modules' radiators, cut out by the build, and their root. */
const SMALL_RADIATOR_NODES = [
'PVR_FOLD_P4',
'PVR_FOLD_P6',
'PVR_FOLD_S4',
'PVR_FOLD_S6',
];
const SMALL_RADIATOR_ROOT_Y = -1.6;
/** Where each dish looks now, on the model's axes. */
let dishes = null;
const scratchMatrix = new Float64Array(16);
function bind(model) {
boundModel = model;
const get = (joint) => model.getNode(joint.node) ?? null;
nodes = {
alpha: ISS_ALPHA_JOINTS.map(get),
beta: ISS_BETA_JOINTS.map(get),
gamma: ISS_RADIATOR_JOINTS.map(get),
dish: ISS_DISH_JOINTS.map(get),
};
angles = null;
dishes = null;
armNodes = null;
}
function sunEcef(date) {
const sun = sunPositionFixed(date.getTime());
const length = Math.hypot(sun.x, sun.y, sun.z) || 1;
return [sun.x / length, sun.y / length, sun.z / length];
}
function write(node, axis, pivot, angle) {
if (!node) return;
node.matrix = issJointMatrix(axis, pivot, angle, scratchMatrix);
}
/**
* @param {{ready: boolean, getNode: (name: string) => object|undefined}} model
* A ready model, or any holder of nodes that take a `matrix`.
* @param {Date} date The instant the model is placed at.
* @param {{x:number,y:number,z:number}} position Earth-fixed station position.
* @param {{x:number[], y:number[], z:number[]}} axes Its flight axes.
* @param {number} [nowMs] Wall clock, for the turn rate.
*/
function update(model, date, position, axes, nowMs = Date.now()) {
if (!model.ready) return;
if (model !== boundModel) bind(model);
const forced = override?.(nowMs) ?? null;
if (forced) {
lastSunlit = Boolean(forced.sunlit);
targets = issJointTargets(forced.sun, forced.sunlit, targets);
} else {
const sun = sunEcef(date);
const sunlit = !issInShadow([position.x, position.y, position.z], sun);
lastSunlit = sunlit;
targets = issJointTargets(issSunInModelFrame(sun, axes), sunlit, targets);
}
// Telemetry, when it has a pose, replaces the computed targets; a Sun
// chosen by hand in the command panel is always computed.
const pose = telemetryAllowed && !forced ? (telemetry?.() ?? null) : null;
lastLive = Boolean(pose);
const alphaTargets = pose?.alpha ?? [targets.alpha, targets.alpha];
const betaTargets = pose?.beta ?? targets.beta;
const gammaTargets = pose?.gamma ?? [targets.gamma, targets.gamma];
// A first frame, or one after a pause, goes straight to the pose.
const elapsed = (nowMs - lastMs) / 1000;
lastMs = nowMs;
const maxStep =
!angles || !(elapsed >= 0) || elapsed > 2
? Number.POSITIVE_INFINITY
: ISS_JOINT_RATE * elapsed;
const next = {
alpha: alphaTargets.map((target, i) =>
issStepAngle(angles?.alpha[i] ?? 0, target, maxStep),
),
beta: betaTargets.map((target, i) =>
issStepAngle(angles?.beta[i] ?? 0, target, maxStep),
),
gamma: gammaTargets.map((target, i) =>
issStepAngle(angles?.gamma[i] ?? 0, target, maxStep),
),
};
ISS_ALPHA_JOINTS.forEach((joint, i) => {
if (!angles || next.alpha[i] !== angles.alpha[i])
write(nodes.alpha[i], 'x', joint.pivot, next.alpha[i]);
});
// Command panel: squash the arrays along their masts (see setDeploy).
const deployStep = Number.isFinite(maxStep) ? elapsed / 8 : 1;
const nextDeploy =
deploy +
Math.sign(deployTarget - deploy) *
Math.min(Math.abs(deployTarget - deploy), deployStep);
ISS_BETA_JOINTS.forEach((joint, i) => {
if (
!angles ||
next.beta[i] !== angles.beta[i] ||
nextDeploy !== deploy ||
nextDeploy !== 1
) {
const node = nodes.beta[i];
if (!node) return;
const m = issJointMatrix('z', joint.pivot, next.beta[i], scratchMatrix);
m[10] = nextDeploy;
m[14] = joint.pivot[2] * (1 - nextDeploy);
node.matrix = m;
}
});
deploy = nextDeploy;
// Command panel: fold the radiators toward the truss.
const nextRadiator =
radiatorDeploy +
Math.sign(radiatorTarget - radiatorDeploy) *
Math.min(Math.abs(radiatorTarget - radiatorDeploy), deployStep);
ISS_RADIATOR_JOINTS.forEach((joint, i) => {
if (
angles &&
next.gamma[i] === angles.gamma[i] &&
nextRadiator === radiatorDeploy
)
return;
const node = nodes.gamma[i];
if (!node) return;
const m = issJointMatrix('z', joint.pivot, next.gamma[i], scratchMatrix);
m[10] = nextRadiator;
m[14] = RADIATOR_ROOT_Z * (1 - nextRadiator);
node.matrix = m;
});
// The four small radiators fold up to the truss, along Y.
if (nextRadiator !== radiatorDeploy)
for (const name of SMALL_RADIATOR_NODES) {
const node = model.getNode(name);
if (!node) continue;
node.matrix = set(scratchMatrix, [
1,
0,
0,
0,
0,
nextRadiator,
0,
SMALL_RADIATOR_ROOT_Y * (1 - nextRadiator),
0,
0,
1,
0,
0,
0,
0,
1,
]);
}
radiatorDeploy = nextRadiator;
angles = next;
// Dishes: the highest relay satellite for the first, the next for the
// second; one below the station's horizon plane keeps its last aim.
// Telemetry reports one dish (the station uses one at a time, and does
// not say which): the first takes its real aim, wherever that is, and
// the second holds still.
const liveDish = !dishOverride && pose?.dish ? pose.dish : null;
const relays = dishOverride
? [dishOverride, dishOverride]
: liveDish
? [liveDish, null]
: issRelayDirections([position.x, position.y, position.z], axes);
const nextDishes = ISS_DISH_JOINTS.map((joint, i) => {
const current = dishes?.[i] ?? [0, 1, 0];
const wanted = relays[i];
const target =
wanted && (liveDish || wanted[1] >= DISH_MIN_UP) ? wanted : current;
const stepped = issStepDirection(current, target, maxStep);
const moved =
!dishes || stepped.some((c, k) => Math.abs(c - current[k]) > 1e-9);
if (moved)
if (nodes.dish[i])
nodes.dish[i].matrix = issAimMatrix(
joint.pivot,
stepped,
scratchMatrix,
);
return stepped;
});
dishes = nextDishes;
// Arm: an illustrative sway (see ISS_ARM_JOINTS).
{
const arm = issArmAngles(nowMs / 1000, ISS_SWAY_JOINTS);
ISS_SWAY_JOINTS.forEach((joint, i) => {
if (!joint.sway || manualJoints.has(joint.node)) return;
const node = (armNodes ??= ISS_SWAY_JOINTS.map(
(entry) => model.getNode(entry.node) ?? null,
))[i];
if (node)
node.matrix = issAxisMatrix(
joint.pivot,
joint.axis,
arm[i],
scratchMatrix,
);
});
}
}
/**
* Command panel: turn any named node about an axis through a pivot.
* @param {string} name
* @param {number[]} pivot
* @param {number[]} axis Unit vector.
* @param {number} angle Radians.
*/
function setJoint(name, pivot, axis, angle) {
manualJoints.add(name);
const node = boundModel?.getNode(name);
if (node) node.matrix = issAxisMatrix(pivot, axis, angle, scratchMatrix);
}
/** Forget the model and every manual choice: the next update starts clean. */
function reset() {
boundModel = null;
nodes = null;
angles = null;
dishes = null;
armNodes = null;
targets = { alpha: 0, gamma: 0 };
override = null;
dishOverride = null;
telemetryAllowed = true;
manualJoints.clear();
}
/**
* Command panel: a function giving the Sun on the model's axes (and whether the
* station is lit) in place of the real one, or null for the real one.
* @param {((nowMs:number)=>{sun:number[], sunlit:boolean}|null)|null} fn
*/
function setOverride(fn) {
override = fn;
}
/** Whether the station is in sunlight, as of the last update. */
function isSunlit() {
return lastSunlit;
}
/**
* Where the joint angles come from when telemetry has them: a function
* giving `{alpha, beta, gamma, dish}` (issTelemetryPose) or null.
* @param {(() => {alpha:number[], beta:number[], gamma:number[],
* dish:number[]|null}|null)|null} fn
*/
function setTelemetry(fn) {
telemetry = fn;
}
/** Command panel: Manual switches telemetry off, Automatic back on. */
function setTelemetryAllowed(allowed) {
telemetryAllowed = Boolean(allowed);
}
/** Whether the last update took its angles from telemetry; null before one. */
function isLive() {
return lastLive;
}
/** Command panel: aim both dishes along a unit vector, or null for the relays. */
function setDishOverride(direction) {
dishOverride = direction;
}
/**
* Command panel: squash the arrays toward their bases, or let them
* out again. The real arrays do not retract in service.
* @param {boolean} out
*/
function setDeploy(out) {
deployTarget = out ? 1 : 0.05;
}
/**
* Command panel: fold the radiators toward the truss, or let them
* out. The real ones are accordion panels that can do this, but stay out
* in service.
* @param {boolean} out
*/
function setRadiatorDeploy(out) {
radiatorTarget = out ? 1 : 0.08;
}
/** Command panel: hand the arm back to its sway. */
function resumeArm() {
// A joint the sway does not move would keep its manual angle: it goes
// back to its filed pose. The swaying ones are posed again next update.
for (const name of manualJoints) {
if (ISS_SWAYING_NODES.has(name)) continue;
const node = boundModel?.getNode(name);
if (node) node.matrix = undefined;
}
manualJoints.clear();
}
return {
update,
reset,
setOverride,
setDishOverride,
setJoint,
resumeArm,
setDeploy,
setRadiatorDeploy,
isSunlit,
setTelemetry,
setTelemetryAllowed,
isLive,
};
}
@@ -0,0 +1,231 @@
import assert from 'node:assert/strict';
import fs from 'node:fs';
import test from 'node:test';
import {
ISS_ALPHA_JOINTS,
ISS_BETA_JOINTS,
ISS_RADIATOR_JOINTS,
issInShadow,
issJointMatrix,
issJointTargets,
issStepAngle,
issSunInModelFrame,
} from './issArticulation.js';
const rotX = (a, [x, y, z]) => [
x,
Math.cos(a) * y - Math.sin(a) * z,
Math.sin(a) * y + Math.cos(a) * z,
];
const rotZ = (a, [x, y, z]) => [
Math.cos(a) * x - Math.sin(a) * y,
Math.sin(a) * x + Math.cos(a) * y,
z,
];
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const unit = (v) => v.map((c) => c / Math.hypot(...v));
const SUNS = [
[0, 1, 0],
[0, -1, 0],
[0, 0, 1],
[0.5, 0.5, 0.7],
[-0.6, 0.2, -0.77],
[0.3, -0.9, 0.3],
[0.9, 0.1, -0.4],
].map(unit);
test('in sunlight every array faces the Sun, masts across it', () => {
for (const sun of SUNS) {
const { alpha, beta } = issJointTargets(sun, true);
assert.ok(Math.abs(dot(rotX(alpha, [0, 0, 1]), sun)) < 1e-9);
ISS_BETA_JOINTS.forEach(({ face }, i) => {
// The beta joint hangs from the alpha joint: beta turns first.
const normal = rotX(alpha, rotZ(beta[i], [face, 0, 0]));
assert.ok(dot(normal, sun) > 1 - 1e-9, `${sun} array ${i}`);
});
}
});
test('the radiators stay edge-on to the Sun', () => {
for (const sun of SUNS) {
const { gamma } = issJointTargets(sun, true);
assert.ok(Math.abs(dot(rotZ(gamma, [0, 1, 0]), sun)) < 1e-9);
}
});
test('in the shadow the arrays feather along the flight direction', () => {
const { alpha, beta } = issJointTargets(unit([0.2, -0.9, 0.3]), false, {
alpha: 3,
gamma: 0,
});
assert.ok(Math.abs(Math.sin(alpha)) < 1e-9); // masts back along ±Z
assert.ok(Math.abs(alpha - Math.PI) < 1e-9); // the nearer half turn
assert.deepEqual(
beta,
ISS_BETA_JOINTS.map(() => 0),
);
});
test('a joint keeps the answer nearer its last one, and holds near its axis', () => {
const first = issJointTargets(unit([0, 1, 0.01]), true);
const next = issJointTargets(unit([0, 1, -0.01]), true, first);
assert.ok(Math.abs(next.alpha - first.alpha) < 0.05);
// Sun along the truss: nothing to steer the alpha joint by.
const held = issJointTargets([1, 0, 0], true, { alpha: 1.2, gamma: 0.4 });
assert.equal(held.alpha, 1.2);
});
test('angles step the short way round, capped', () => {
assert.equal(issStepAngle(0, 1, 0.25), 0.25);
assert.ok(issStepAngle(3, -3, 0.1) > 3); // through π, not back through 0
assert.equal(issStepAngle(0.2, 0.3, 1), 0.3);
});
test('a joint matrix leaves its pivot in place', () => {
for (const axis of ['x', 'z']) {
const pivot = [3, -2, 5];
const m = issJointMatrix(axis, pivot, 0.7, undefined);
const moved = [0, 1, 2].map(
(r) =>
m[r] * pivot[0] + m[4 + r] * pivot[1] + m[8 + r] * pivot[2] + m[12 + r],
);
moved.forEach((v, i) => assert.ok(Math.abs(v - pivot[i]) < 1e-12));
}
});
test('the shadow is the cylinder behind the Earth', () => {
const sun = [1, 0, 0];
assert.equal(issInShadow([6_790_000, 0, 0], sun), false);
assert.equal(issInShadow([-6_790_000, 0, 0], sun), true);
assert.equal(issInShadow([-1_000_000, 6_700_000, 0], sun), false);
});
test('the Sun lands on the model axes: port, zenith, forward', () => {
const axes = { x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] };
assert.deepEqual(issSunInModelFrame([0.1, 0.2, 0.3], axes), [0.2, 0.3, 0.1]);
});
test('the model file has every joint node, beta joints under their alpha', () => {
const buf = fs.readFileSync(
new URL('../../../public/models/iss.glb', import.meta.url),
);
const json = JSON.parse(
buf.subarray(20, 20 + buf.readUInt32LE(12)).toString('utf8'),
);
const byName = new Map(json.nodes.map((n) => [n.name, n]));
for (const { node } of [
...ISS_ALPHA_JOINTS,
...ISS_BETA_JOINTS,
...ISS_RADIATOR_JOINTS,
]) {
const n = byName.get(node);
assert.ok(n, node);
// Joints rest at identity: the pivots above are in the model's own frame.
assert.equal(n.rotation, undefined);
assert.equal(n.translation, undefined);
assert.equal(n.matrix, undefined);
}
for (const side of ['PORT', 'STBD']) {
const kids = byName
.get(`${side}_ALPHA_ROT`)
.children.map((i) => json.nodes[i].name);
for (const { node } of ISS_BETA_JOINTS)
if (node.startsWith(side)) assert.ok(kids.includes(node), node);
}
});
test('a dish aims its rest boresight (+Y) at the direction, pivot in place', async () => {
const { issAimMatrix, ISS_DISH_JOINTS } =
await import('./issArticulation.js');
for (const direction of SUNS) {
const m = issAimMatrix(ISS_DISH_JOINTS[0].pivot, direction, undefined);
// Column 1 is where +Y goes.
[m[4], m[5], m[6]].forEach((v, i) =>
assert.ok(Math.abs(v - direction[i]) < 1e-9),
);
const p = ISS_DISH_JOINTS[0].pivot;
[0, 1, 2].forEach((r) =>
assert.ok(
Math.abs(
m[r] * p[0] + m[4 + r] * p[1] + m[8 + r] * p[2] + m[12 + r] - p[r],
) < 1e-9,
),
);
}
});
test('relay directions are unit vectors, highest above the station first', async () => {
const { issRelayDirections } = await import('./issArticulation.js');
// Over the equator at 41°W, flying east: the Atlantic relay is overhead.
const lon = (-41 * Math.PI) / 180;
const r = 6_790_000;
const position = [r * Math.cos(lon), r * Math.sin(lon), 0];
const zenith = [Math.cos(lon), Math.sin(lon), 0];
const east = [-Math.sin(lon), Math.cos(lon), 0];
const axes = { x: east, y: [0, 0, 1], z: zenith };
const relays = issRelayDirections(position, axes);
assert.equal(relays.length, 3);
relays.forEach((d) => assert.ok(Math.abs(Math.hypot(...d) - 1) < 1e-9));
assert.ok(relays[0][1] > 0.999);
assert.ok(relays[0][1] >= relays[1][1] && relays[1][1] >= relays[2][1]);
});
test('a direction steps along the arc, capped, and lands on the target', async () => {
const { issStepDirection } = await import('./issArticulation.js');
const stepped = issStepDirection([0, 1, 0], [1, 0, 0], 0.1);
assert.ok(Math.abs(Math.hypot(...stepped) - 1) < 1e-9);
assert.ok(Math.abs(Math.acos(stepped[1]) - 0.1) < 1e-9);
assert.deepEqual(issStepDirection([0, 1, 0], [1, 0, 0], 2), [1, 0, 0]);
});
test('the model file has both dish nodes', async () => {
const { ISS_DISH_JOINTS } = await import('./issArticulation.js');
const buf = fs.readFileSync(
new URL('../../../public/models/iss.glb', import.meta.url),
);
const json = JSON.parse(
buf.subarray(20, 20 + buf.readUInt32LE(12)).toString('utf8'),
);
for (const { node } of ISS_DISH_JOINTS) {
const n = json.nodes.find((candidate) => candidate.name === node);
assert.ok(n?.children?.length, node);
}
});
test('the arm sways gently about the filed pose, and only where it is set to', async () => {
const { ISS_ARM_JOINTS, issArmAngles } = await import('./issArticulation.js');
assert.equal(ISS_ARM_JOINTS.length, 7);
for (let seconds = 0; seconds < 400; seconds += 7) {
issArmAngles(seconds).forEach((angle, i) => {
assert.ok(Math.abs(angle) <= ISS_ARM_JOINTS[i].sway + 1e-12);
// Illustrative, so kept small.
assert.ok(Math.abs(angle) <= (12 * Math.PI) / 180 + 1e-12);
});
}
assert.deepEqual(issArmAngles(0), [0, 0, 0, 0, 0, 0, 0]);
});
test('the smaller arms sway too, and their joints are in the model file', async () => {
const { ISS_SMALL_ARM_JOINTS, ISS_ARM_JOINTS, issArmAngles } =
await import('./issArticulation.js');
const buf = fs.readFileSync(
new URL('../../../public/models/iss.glb', import.meta.url),
);
const json = JSON.parse(
buf.subarray(20, 20 + buf.readUInt32LE(12)).toString('utf8'),
);
const names = new Set(json.nodes.map((n) => n.name));
for (const { node, sway, axis } of [
...ISS_ARM_JOINTS,
...ISS_SMALL_ARM_JOINTS,
]) {
assert.ok(names.has(node), node);
assert.ok(sway <= (12 * Math.PI) / 180 + 1e-12);
assert.ok(Math.abs(Math.hypot(...axis) - 1) < 1e-3);
}
assert.equal(
issArmAngles(10, ISS_SMALL_ARM_JOINTS).length,
ISS_SMALL_ARM_JOINTS.length,
);
});
+105
View File
@@ -0,0 +1,105 @@
const unit = (v) => {
const n = Math.hypot(...v);
return v.map((c) => c / n);
};
/** Where "Zoom to the ISS" stops: the whole 109 m station fills the view. */
export const ISS_COMMAND_ZOOM_RANGE_M = 260;
/** Beyond this the camera counts as far, and the zoom button is offered. */
export const ISS_COMMAND_FAR_M = 1000;
/**
* Whether "Zoom to the ISS" is offered: only from far away, so it goes once
* the camera is in close (by the button or by hand) and returns on zooming
* back out.
* @param {number} distance Meters from the camera to the station.
* @returns {boolean}
*/
export function issCommandOffersZoom(distance) {
return distance > ISS_COMMAND_FAR_M;
}
/**
* One step of the zoom: how far to move in from `distance`, easing out as
* the target range nears, never past it.
* @param {number} distance Meters from the camera to the station.
* @returns {number} Meters to move in; 0 once close enough.
*/
export function issCommandZoomStep(distance) {
const left = distance - ISS_COMMAND_ZOOM_RANGE_M;
if (!(left > ISS_COMMAND_ZOOM_RANGE_M * 0.02)) return 0;
return left * 0.14;
}
/**
* The follow camera's range after one step of the zoom: the step nearer,
* never past the target range, and unchanged once there. The camera is moved
* by scaling its follow offset from the station (the camera port's
* `followOffset`, the eye in the follow's frame) by
* `issCommandZoomRange(range) / range`, which can only bring it in; a move
* along the view direction is not used, since it ran away when the camera
* was not looking at the station.
* @param {number} range Meters from the camera to the station.
* @returns {number} The range to set; `range` itself when there is no step.
*/
export function issCommandZoomRange(range) {
if (!(range > 0) || !Number.isFinite(range)) return range;
const step = issCommandZoomStep(range);
return step > 0 ? Math.max(ISS_COMMAND_ZOOM_RANGE_M, range - step) : range;
}
/**
* One step of the zoom on the follow offset: the same offset, shortened to
* `issCommandZoomRange` of its length, so the eye keeps its bearing on the
* station and only comes in.
* @param {{x: number, y: number, z: number}|null|undefined} offset The
* eye's offset from the station, metres in the follow's frame.
* @returns {{x: number, y: number, z: number}|null} The offset to set; null
* when there is no step (close enough, or no offset to shorten).
*/
export function issCommandZoomOffset(offset) {
if (!offset) return null;
const range = Math.hypot(offset.x, offset.y, offset.z);
const next = issCommandZoomRange(range);
if (!(next < range)) return null;
const k = next / range;
return { x: offset.x * k, y: offset.y * k, z: offset.z * k };
}
/**
* Whether the zoom may run: only while the camera follows the station's
* follow target and has framed it, so that its follow offset is the eye's
* offset from the station and shortening it brings the camera in. From any
* other camera (still flying to the station, following something else, or
* a follow not yet framed) there is no such offset to shorten.
* @param {{followed?: object|null, followFramed?: boolean}|null|undefined}
* camera What the camera port reports (`cameraOf(viewer)`).
* @param {object|null|undefined} target The layer's follow target for the
* station (`layerState._followTarget`).
* @returns {boolean}
*/
export function issCommandCameraOnStation(camera, target) {
return (
Boolean(target) &&
camera?.followed === target &&
camera.followFramed === true
);
}
/** How long one lap of the "fast orbit" takes, and its share in shadow. */
const FAST_ORBIT_MS = 40_000;
/**
* The Sun over one accelerated orbit: it circles the truss, a third of the
* lap in the Earth's shadow.
* @param {number} elapsedMs
* @returns {{sun: number[], sunlit: boolean}}
*/
export function issCommandFastOrbit(elapsedMs) {
const angle = (elapsedMs / FAST_ORBIT_MS) * 2 * Math.PI;
return {
sun: unit([0.35, Math.cos(angle), Math.sin(angle)]),
sunlit: Math.cos(angle) > -0.5,
};
}
+141
View File
@@ -0,0 +1,141 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {
issCommandCameraOnStation,
issCommandZoomOffset,
issCommandZoomRange,
ISS_COMMAND_ZOOM_RANGE_M,
issCommandFastOrbit,
issCommandZoomStep,
} from './issCommand.js';
import { ISS_NORAD } from './policy.js';
test('the zoom eases in to its range and stops there, never past it', () => {
let distance = 726_000;
let steps = 0;
for (; steps < 400; steps++) {
const step = issCommandZoomStep(distance);
if (!step) break;
assert.ok(step > 0 && step < distance - ISS_COMMAND_ZOOM_RANGE_M);
distance -= step;
}
assert.ok(steps < 120); // under two seconds at 60 frames a second
assert.ok(distance >= ISS_COMMAND_ZOOM_RANGE_M);
assert.ok(distance <= ISS_COMMAND_ZOOM_RANGE_M * 1.02 + 1e-6);
// Already closer: nothing to do, and it never pushes the camera back out.
assert.equal(issCommandZoomStep(180), 0);
});
test('the fast orbit turns the Sun once per lap, part of it in shadow', () => {
const start = issCommandFastOrbit(0);
assert.ok(Math.abs(Math.hypot(...start.sun) - 1) < 1e-9);
assert.equal(start.sunlit, true);
assert.equal(issCommandFastOrbit(20_000).sunlit, false); // half a lap: below
const lap = issCommandFastOrbit(40_000);
lap.sun.forEach((v, i) => assert.ok(Math.abs(v - start.sun[i]) < 1e-9));
});
test('the zoom is offered only from far away', async () => {
const { ISS_COMMAND_FAR_M, issCommandOffersZoom } =
await import('./issCommand.js');
assert.equal(issCommandOffersZoom(726_000), true);
assert.equal(issCommandOffersZoom(ISS_COMMAND_FAR_M + 1), true);
// Where the zoom itself stops, and anywhere closer, it is gone.
assert.equal(issCommandOffersZoom(ISS_COMMAND_ZOOM_RANGE_M * 1.02), false);
assert.equal(issCommandOffersZoom(150), false);
});
test('an object docked to the ISS is the station too', async () => {
const { issTrackedOnStation } = await import('./policy.js');
const NAUKA = 49044;
// Tracking Nauka, the ISS shares its position; tracking the ISS needs nothing.
assert.equal(issTrackedOnStation(ISS_NORAD, new Set()), true);
assert.equal(issTrackedOnStation(ISS_NORAD, null), true);
assert.equal(issTrackedOnStation(NAUKA, new Set([ISS_NORAD, 68837])), true);
// Another satellite, with or without neighbours, is not.
assert.equal(issTrackedOnStation(20580, new Set()), false);
assert.equal(issTrackedOnStation(20580, new Set([20581])), false);
assert.equal(issTrackedOnStation(null, new Set([ISS_NORAD])), false);
assert.equal(issTrackedOnStation(undefined, undefined), false);
});
test('the zoom range only ever shortens, settles at the target range and never runs away', () => {
let range = 1e9;
let steps = 0;
while (steps < 400) {
const next = issCommandZoomRange(range);
assert.ok(next <= range, `step ${steps} moved out: ${range} -> ${next}`);
assert.ok(next >= ISS_COMMAND_ZOOM_RANGE_M, 'never past the target');
if (next === range) break;
range = next;
steps += 1;
}
assert.ok(steps < 400, "settles within the loop's budget");
assert.ok(range <= ISS_COMMAND_ZOOM_RANGE_M * 1.02);
assert.equal(
issCommandZoomRange(ISS_COMMAND_ZOOM_RANGE_M),
ISS_COMMAND_ZOOM_RANGE_M,
);
assert.equal(
issCommandZoomRange(100),
100,
'closer than the range: left alone',
);
for (const bad of [0, -5, NaN, Infinity])
assert.ok(
Object.is(issCommandZoomRange(bad), bad),
`${bad} passes through`,
);
});
test('one zoom step shortens the follow offset on its own bearing, and stops at the range', () => {
const next = issCommandZoomOffset({ x: 3000, y: 4000, z: 0 });
const range = Math.hypot(next.x, next.y, next.z);
assert.ok(Math.abs(range - issCommandZoomRange(5000)) < 1e-9);
assert.ok(Math.abs(next.x / next.y - 3 / 4) < 1e-12, 'the bearing is kept');
assert.equal(next.z, 0);
// Already at the range, or closer: no step.
assert.equal(
issCommandZoomOffset({ x: ISS_COMMAND_ZOOM_RANGE_M, y: 0, z: 0 }),
null,
);
assert.equal(issCommandZoomOffset({ x: 0, y: 100, z: 0 }), null);
// Nothing to shorten: no follow offset yet (the follow has not framed).
assert.equal(issCommandZoomOffset(null), null);
assert.equal(issCommandZoomOffset(undefined), null);
assert.equal(issCommandZoomOffset({ x: 0, y: 0, z: 0 }), null);
});
test("the zoom needs the camera following the station's target, framed", () => {
const target = { key: 'satellites:25544' };
const on = { followed: target, followFramed: true };
assert.equal(issCommandCameraOnStation(on, target), true);
assert.equal(
issCommandCameraOnStation(
{ followed: target, followFramed: false },
target,
),
false,
'not before the follow has framed the eye',
);
assert.equal(
issCommandCameraOnStation({ followed: null, followFramed: false }, target),
false,
);
assert.equal(
issCommandCameraOnStation(
{ followed: { key: 'flights:a' }, followFramed: true },
target,
),
false,
'following something else',
);
assert.equal(issCommandCameraOnStation(null, target), false);
assert.equal(issCommandCameraOnStation(undefined, target), false);
assert.equal(issCommandCameraOnStation(on, null), false);
assert.equal(
issCommandCameraOnStation({ followed: null, followFramed: true }, null),
false,
'nothing followed and no target is not a match',
);
});
+144
View File
@@ -0,0 +1,144 @@
import { createIssArticulation } from './issArticulation.js';
import {
ISS_MOUNTS,
ISS_NAUKA_NORAD,
ISS_POISK_NORAD,
issMountView,
issMountViews,
issMountWorld,
} from './issMounts.js';
import { createIssTelemetryFeed } from './issTelemetry.js';
import {
ISS_COMPANION_COARSE_M,
ISS_COMPANION_RADIUS_M,
ISS_COMPANION_SCAN_MS,
ISS_CARD_CLEAR_M,
ISS_MODEL_LOCAL_AXES,
ISS_MODEL_MAX_DISTANCE_M,
ISS_MODEL_MIN_PX,
ISS_MODEL_NATIVE_SPAN,
ISS_MODEL_URL,
ISS_NORAD,
ISS_ORBIT_HIDE_M,
ISS_SPAN_M,
} from './policy.js';
import {
createStationModel,
stationFlightAxes,
stationModelShouldShow,
temeToEcefAxes,
} from './stationModel.js';
/** The model's scale for the real 109 m truss. */
export const ISS_MODEL_SCALE = ISS_SPAN_M / ISS_MODEL_NATIVE_SPAN;
// The station-independent rules live in stationModel.js; these names are
// kept for the code and tests written against the ISS-only model.
export { temeToEcefAxes };
export const issFlightAxes = stationFlightAxes;
/**
* Whether the ISS model may be drawn (stationModelShouldShow with the ISS's
* `hasIss` wording).
* @param {{enabled: boolean, showPoints: boolean, hasIss: boolean,
* classVisible: boolean, tracked: boolean, cockpitHidden: boolean}} input
* @returns {boolean}
*/
export function issModelShouldShow({ hasIss, ...rest }) {
return stationModelShouldShow({ hasStation: hasIss, ...rest });
}
/**
* Whether a catalog entry at the ISS is one of the station's own modules
* (Zarya, Nauka, Poisk, or any other the catalog lists as "ISS (…)") rather
* than a visiting vehicle. A missing entry counts as a module.
* @param {number} noradId
* @param {{name?: string}|undefined} entry
* @returns {boolean}
*/
export function issIsModule(noradId, entry) {
return (
noradId === ISS_NORAD ||
noradId === ISS_NAUKA_NORAD ||
noradId === ISS_POISK_NORAD ||
/^ISS\s*\(/i.test(entry?.name ?? 'ISS (')
);
}
/**
* The ISS as the station model factory describes it: NASA's model at the
* real 109 m span, its joints on the Sun or NASA's telemetry, the Cockpit's
* views from mounts on the model (so the model stays drawn in the Cockpit),
* and its orbit ring, which has rules of its own (`_syncIssOrbit`).
* @param {{parts: object}} context
* @returns {import('./stationModel.js').StationModelSpec}
*/
export function issModelSpec({ parts }) {
return {
key: 'iss',
label: 'ISS', // i18n-ignore: the station's name, for log lines
norad: ISS_NORAD,
modelUrl: ISS_MODEL_URL,
scale: ISS_MODEL_SCALE,
minPx: ISS_MODEL_MIN_PX,
maxDistanceM: ISS_MODEL_MAX_DISTANCE_M,
orbitHideM: ISS_ORBIT_HIDE_M,
cardClearM: ISS_CARD_CLEAR_M,
companionRadiusM: ISS_COMPANION_RADIUS_M,
companionCoarseM: ISS_COMPANION_COARSE_M,
companionScanMs: ISS_COMPANION_SCAN_MS,
localAxes: ISS_MODEL_LOCAL_AXES,
isModule: issIsModule,
createArticulation: createIssArticulation,
createTelemetry: createIssTelemetryFeed,
/**
* One of the views on the model (issMounts.js), in the world.
* `noradId` on the result is the catalog entry the view belongs to.
*/
cockpitMount: ({ key, centre, axes, name, entry, dockedVehicle }) => {
const views = issMountViews({
naukaName: name(ISS_NAUKA_NORAD),
zaryaName: name(ISS_NORAD),
poiskName: name(ISS_POISK_NORAD),
dockedName: name(dockedVehicle),
naukaNorad: entry(ISS_NAUKA_NORAD),
zaryaNorad: entry(ISS_NORAD),
poiskNorad: entry(ISS_POISK_NORAD),
dockedNorad: entry(dockedVehicle),
});
const view = issMountView(views, key);
return {
...issMountWorld(ISS_MOUNTS[view.key], centre, axes),
key: view.key,
label: view.label,
noradId: view.noradId,
card: view.card,
views,
};
},
// The Cockpit rides the station from a mount on the model, so the model
// stays while it does.
hideInCockpit: false,
syncOrbit: () => parts.controls._syncIssOrbit?.(),
};
}
/**
* The ISS as a 3D model when the camera is close (stationModel.js), with the
* part's methods also under their former ISS-only names.
* @param {{state: object, parts: object, resolveAsset?: (url: string) => string}} context
*/
export function createIssModel(context) {
const model = createStationModel(issModelSpec(context), context);
return {
...model,
_updateIssModel: model._updateStationModel,
_destroyIssModel: model._destroyStationModel,
_issVisualPosition: model._visualPosition,
_issCardClearPx: model._cardClearPx,
_issStandsInFor: model._standsInFor,
_issCockpitMount: model._cockpitMount,
_issTelemetryStatus: model._telemetryStatus,
_issArticulation: model._articulation,
};
}
+153
View File
@@ -0,0 +1,153 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { gstime, propagate, twoline2satrec } from 'satellite.js';
import {
ISS_MODEL_SCALE,
issFlightAxes,
issModelShouldShow,
temeToEcefAxes,
} from './issModel.js';
import {
ISS_MODEL_CENTER_NATIVE,
ISS_MODEL_LOCAL_AXES,
ISS_MODEL_NATIVE_SPAN,
ISS_MODEL_URL,
ISS_NORAD,
ISS_SPAN_M,
} from './policy.js';
const ISS_TLE = [
'1 25544U 98067A 24001.50000000 .00016717 00000-0 10270-3 0 9002',
'2 25544 51.6416 247.4627 0006703 130.5360 325.0288 15.50377579 1234',
];
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const norm = (a) => Math.hypot(a[0], a[1], a[2]);
const shown = {
enabled: true,
showPoints: true,
hasIss: true,
classVisible: true,
tracked: false,
cockpitHidden: false,
};
test('the ISS model shows on the same terms as its dot', () => {
assert.equal(issModelShouldShow(shown), true);
assert.equal(issModelShouldShow({ ...shown, enabled: false }), false);
assert.equal(issModelShouldShow({ ...shown, showPoints: false }), false);
assert.equal(issModelShouldShow({ ...shown, hasIss: false }), false);
assert.equal(issModelShouldShow({ ...shown, classVisible: false }), false);
});
test('a tracked ISS keeps its model with its class hidden', () => {
assert.equal(
issModelShouldShow({ ...shown, classVisible: false, tracked: true }),
true,
);
});
test('the Cockpit hold hides the model', () => {
assert.equal(
issModelShouldShow({ ...shown, tracked: true, cockpitHidden: true }),
false,
);
});
test('the model is the ISS by NORAD number, at its real 109 m span', () => {
assert.equal(ISS_NORAD, 25544);
assert.ok(
Math.abs(ISS_MODEL_SCALE * ISS_MODEL_NATIVE_SPAN - ISS_SPAN_M) < 1e-9,
);
});
test('the native span and centre match the shipped asset', () => {
const glb = readFileSync(
new URL(`../../../public${ISS_MODEL_URL}`, import.meta.url),
);
const jsonLength = glb.readUInt32LE(12);
const gltf = JSON.parse(glb.subarray(20, 20 + jsonLength).toString('utf8'));
const root = gltf.nodes[gltf.scenes[0].nodes[0]];
const min = [Infinity, Infinity, Infinity];
const max = [-Infinity, -Infinity, -Infinity];
// Every node below the root rests untransformed (joint nodes included), so
// each mesh's bounds are already in the root's frame.
const visit = (index) => {
const node = gltf.nodes[index];
assert.equal(node.rotation ?? null, null);
assert.equal(node.scale ?? null, null);
assert.equal(node.translation ?? null, null);
for (const primitive of gltf.meshes[node.mesh]?.primitives ?? []) {
const accessor = gltf.accessors[primitive.attributes.POSITION];
for (let i = 0; i < 3; i++) {
min[i] = Math.min(min[i], accessor.min[i]);
max[i] = Math.max(max[i], accessor.max[i]);
}
}
(node.children ?? []).forEach(visit);
};
root.children.forEach(visit);
// The truss is the longest axis, glTF X.
assert.ok(Math.abs(max[0] - min[0] - ISS_MODEL_NATIVE_SPAN) < 0.01);
assert.ok(max[0] - min[0] > max[1] - min[1]);
assert.ok(max[0] - min[0] > max[2] - min[2]);
ISS_MODEL_CENTER_NATIVE.forEach((value, i) =>
assert.ok(Math.abs((min[i] + max[i]) / 2 - value) < 0.01),
);
// The scene root moves that centre to the origin: minimumPixelSize scales
// the model about its origin, so the far-range model stays centred.
assert.deepEqual(
root.translation.map((value, i) => value + ISS_MODEL_CENTER_NATIVE[i]),
[0, 0, 0],
);
// NASA's own textures ship with it.
assert.ok(gltf.textures.length > 0);
});
test('the model axes are a proper rotation of the flight axes', () => {
// A cyclic order of x, y, z keeps the frame right-handed (no mirroring).
const order = ISS_MODEL_LOCAL_AXES.join('');
assert.ok(['xyz', 'yzx', 'zxy'].includes(order));
});
test('flight axes: orthonormal, z away from the Earth, x along the motion', () => {
const satrec = twoline2satrec(ISS_TLE[0], ISS_TLE[1]);
for (const minutes of [0, 17, 46, 80]) {
const date = new Date(Date.UTC(2024, 0, 1, 12, minutes));
const { position, velocity } = propagate(satrec, date);
const gmst = gstime(date);
const r = temeToEcefAxes(position, gmst);
const v = temeToEcefAxes(velocity, gmst);
const axes = issFlightAxes(r, v);
for (const key of ['x', 'y', 'z'])
assert.ok(Math.abs(norm(axes[key]) - 1) < 1e-9);
assert.ok(Math.abs(dot(axes.x, axes.y)) < 1e-9);
assert.ok(Math.abs(dot(axes.y, axes.z)) < 1e-9);
assert.ok(Math.abs(dot(axes.x, axes.z)) < 1e-9);
const rUnit = [r.x, r.y, r.z].map((c) => c / norm([r.x, r.y, r.z]));
assert.ok(dot(axes.z, rUnit) > 0.999999);
// A near-circular orbit: the along-track axis is almost the velocity.
const vUnit = [v.x, v.y, v.z].map((c) => c / norm([v.x, v.y, v.z]));
assert.ok(dot(axes.x, vUnit) > 0.999);
// Right-handed: x × y = z.
const cross = [
axes.x[1] * axes.y[2] - axes.x[2] * axes.y[1],
axes.x[2] * axes.y[0] - axes.x[0] * axes.y[2],
axes.x[0] * axes.y[1] - axes.x[1] * axes.y[0],
];
assert.ok(dot(cross, axes.z) > 0.999999);
}
});
test('flight axes refuse a degenerate state', () => {
assert.equal(issFlightAxes({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 }), null);
assert.equal(issFlightAxes({ x: 1, y: 0, z: 0 }, { x: 2, y: 0, z: 0 }), null);
});
test('TEME to Earth-fixed axes keeps the position eciToGeodetic uses', () => {
const v = temeToEcefAxes({ x: 1, y: 0, z: 0 }, Math.PI / 2);
assert.ok(Math.abs(v.x) < 1e-12);
assert.ok(Math.abs(v.y + 1) < 1e-12);
});
+257
View File
@@ -0,0 +1,257 @@
import { msg } from '../../i18n/index.js';
/**
* Where the Cockpit camera sits when it rides the station. The ISS has
* several catalog entries that are one body (the ISS itself, listed under
* Zarya, its first module; Nauka; whatever vehicle is docked). Riding any of
* them looks out from a point on its 3D model, away from the station, in
* place of the straight-down picture every other satellite has, and the
* Cockpit steps between the views: from Nauka, from Zarya, from Poisk, from
* the Cupola, from Kibo, from a docked vehicle. Each looks outward, in a direction of its own, and the
* arrows turn the view from there. From this height the Earth's limb is 20°
* below level: a view 30° down has it across its upper part.
*
* The points were chosen by casting rays across the view against the model
* at rest: each is over a meter clear of every surface, and at most a tenth
* of its frame meets the station, none of it nearer than 12 m.
*
* Points and directions are on the model's axes in meters (X port, Y zenith,
* Z forward), from the model's origin: the frame the file's nodes sit in.
*/
/**
* The station's modules that have catalog entries of their own, beside the
* ISS's (ISS_NORAD in policy.js, listed as "ISS (ZARYA)"): Nauka and Poisk.
*/
export const ISS_NAUKA_NORAD = 49044;
export const ISS_POISK_NORAD = 36086;
const mount = (eye, forward, up) =>
Object.freeze({
eye: Object.freeze(eye),
forward: Object.freeze(forward),
up: Object.freeze(up),
});
export const ISS_MOUNTS = Object.freeze({
/**
* Nauka hangs below Zvezda, pointing at the Earth: from the port side of
* its lower end, looking out ahead of the station to port and down.
*/
nauka: mount([3.03, -12, -24.25], [0.75, -0.5, 0.43], [0, 1, 0]),
/**
* Zarya lies along the station's long axis, docked at both ends, so it
* looks out sideways: from its port side, out across the track and down.
*/
zarya: mount([3.38, 2.96, -22], [0.87, -0.5, 0], [0, 1, 0]),
/**
* Poisk stands on top of Zvezda, pointing away from the Earth: from the
* top of it, looking out behind the station to starboard, the limb across
* the middle of the frame.
*/
poisk: mount([-1.27, 12, -27.27], [-0.66, -0.34, -0.66], [0, 1, 0]),
/**
* A docked vehicle (a Progress, a Soyuz, a Dragon): the catalog does not
* say which port it is on, so it takes the place of one on Zvezda's aft
* port, the most used: looking out behind the station and down, the Earth
* falling away.
*/
docked: mount([0, 2.05, -41.5], [0, -0.5, -0.87], [0, 1, 0]),
/**
* The Cupola, on Tranquility's Earth-facing port: from just below it,
* looking aft along the station and down, the Russian segment (Zvezda,
* Nauka, the docked vehicles) in the corner and the Earth beyond.
*/
cupola: mount([8.3, -3.2, -4.9], [0, -0.5, -0.87], [0, 1, 0]),
/**
* Kibo, on Harmony's port side: its two windows are on its port end, above
* the airlock. From just outside them, looking out to port and down over
* the Exposed Facility, the Earth beyond it. The port solar arrays turn
* through this view as they follow the Sun, as they do past the windows.
*/
kibo: mount([15.4, 4.2, 11], [0.81, -0.5, -0.3], [0, 1, 0]),
});
/**
* The card a view shows in place of its catalog entry's, for a module the
* catalog has no entry for. Its texts are marked for translation; the name
* is the module's, as catalog names are.
*/
export const ISS_MOUNT_CARDS = Object.freeze({
cupola: Object.freeze({
name: 'CUPOLA',
classLabel: msg('OBSERVATION MODULE · ISS'),
operator: msg('European Space Agency (ESA)'),
facts: Object.freeze([
msg('7 WINDOWS'),
msg('LAUNCHED 8 FEB 2010 · STS-130'),
msg('TRANQUILITY · EARTH-FACING PORT'),
]),
}),
kibo: Object.freeze({
name: 'KIBO',
classLabel: msg('LABORATORY MODULE · ISS'),
operator: msg('Japan Aerospace Exploration Agency (JAXA)'),
facts: Object.freeze([
msg('2 WINDOWS'),
msg('LAUNCHED 31 MAY 2008 · STS-124'),
msg('HARMONY · PORT SIDE'),
]),
}),
});
/**
* The views in the order the Cockpit steps through them. The first is the
* one it opens on, whichever of the station's entries was selected.
*/
export const ISS_MOUNT_ORDER = Object.freeze([
'nauka',
'zarya',
'poisk',
'cupola',
'kibo',
'docked',
]);
/**
* The views the station offers now, in ISS_MOUNT_ORDER. Nauka, Zarya and
* Poisk are part of the model, so they are always there; the docked-vehicle
* view is offered only while a vehicle is docked, under that vehicle's name.
* Each view names the catalog entry it belongs to (the ISS itself for
* Zarya), so the Cockpit can ride that entry and its card describe it; null
* when the catalog has no entry for it. The Cupola and Kibo have none: they
* ride the ISS's and carry cards of their own (ISS_MOUNT_CARDS).
* @param {{naukaName?: string|null, zaryaName?: string|null,
* poiskName?: string|null, dockedName?: string|null,
* naukaNorad?: number|null, zaryaNorad?: number|null,
* poiskNorad?: number|null, dockedNorad?: number|null}} [entries]
* Catalog names (e.g. "ISS (NAUKA)") and numbers.
* @returns {Array<{key: 'nauka'|'zarya'|'poisk'|'cupola'|'kibo'|'docked',
* label: string, noradId: number|null, card: object|null}>}
*/
export function issMountViews({
naukaName,
zaryaName,
poiskName,
dockedName,
naukaNorad = null,
zaryaNorad = null,
poiskNorad = null,
dockedNorad = null,
} = {}) {
const labels = {
nauka: issMountLabel(naukaName) || 'NAUKA',
zarya: issMountLabel(zaryaName) || 'ZARYA',
poisk: issMountLabel(poiskName) || 'POISK',
cupola: ISS_MOUNT_CARDS.cupola.name,
kibo: ISS_MOUNT_CARDS.kibo.name,
docked: issMountLabel(dockedName),
};
const entries = {
nauka: naukaNorad,
zarya: zaryaNorad,
poisk: poiskNorad,
cupola: zaryaNorad,
kibo: zaryaNorad,
docked: dockedNorad,
};
return ISS_MOUNT_ORDER.filter((key) => labels[key]).map((key) => ({
key,
label: labels[key],
noradId: Number.isFinite(entries[key]) ? entries[key] : null,
card: ISS_MOUNT_CARDS[key] ?? null,
}));
}
/**
* The view to show: the one asked for while it is on offer, else the first.
* @param {Array<{key: string, label: string}>} views From issMountViews.
* @param {string|null|undefined} key
* @returns {{key: string, label: string}}
*/
export function issMountView(views, key) {
return views.find((view) => view.key === key) ?? views[0];
}
/**
* The view after the current one, wrapping round; null with fewer than two.
* @param {Array<{key: string, label: string}>} views
* @param {string|null|undefined} key The current view.
* @returns {{key: string, label: string}|null}
*/
export function issNextMountView(views, key) {
if (!Array.isArray(views) || views.length < 2) return null;
const index = views.findIndex((view) => view.key === key);
return views[(index + 1) % views.length];
}
/**
* The view before the current one, wrapping round; null with fewer than two.
* An unknown current view steps back to the last.
* @param {Array<{key: string, label: string}>} views
* @param {string|null|undefined} key The current view.
* @returns {{key: string, label: string}|null}
*/
export function issPreviousMountView(views, key) {
if (!Array.isArray(views) || views.length < 2) return null;
const index = views.findIndex((view) => view.key === key);
return views[(Math.max(index, 0) - 1 + views.length) % views.length];
}
/**
* The name the Cockpit shows for the view: the entry's own, without the
* "ISS (…)" the catalog wraps the station's modules in.
* @param {string|null|undefined} name Catalog name, e.g. "ISS (ZARYA)".
* @returns {string}
*/
export function issMountLabel(name) {
const text = String(name ?? '').trim();
const inner = /^ISS\s*\((.+)\)$/i.exec(text);
return (inner ? inner[1] : text).trim();
}
const add = (a, b, k) => [a[0] + b[0] * k, a[1] + b[1] * k, a[2] + b[2] * k];
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const unit = (v) => {
const length = Math.hypot(v[0], v[1], v[2]);
return [v[0] / length, v[1] / length, v[2] / length];
};
const cross = (a, b) => [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
const point = (v) => ({ x: v[0], y: v[1], z: v[2] });
/**
* A mount in the world: the eye point and the view's frame, Earth-fixed.
* The model is placed with its forward axis along the flight direction, its
* port axis along the orbit normal and its zenith axis away from the Earth
* (issFlightAxes), so a model vector [port, zenith, forward] is
* port × axes.y + zenith × axes.z + forward × axes.x.
* @param {{eye: number[], forward: number[], up: number[]}} mount
* @param {{x: number, y: number, z: number}} centre The model's origin.
* @param {{x: number[], y: number[], z: number[]}} axes Flight axes.
* @returns {{position: object, direction: object, up: object, right: object}}
* `{x, y, z}` vectors; direction, up and right are unit and perpendicular,
* right = direction × up.
*/
export function issMountWorld(mount, centre, axes) {
const toWorld = ([port, zenith, forward]) =>
add(add(add([0, 0, 0], axes.y, port), axes.z, zenith), axes.x, forward);
const direction = unit(toWorld(mount.forward));
// Up, squared to the direction: the mount's own need not be exact.
const rough = toWorld(mount.up);
const up = unit(add(rough, direction, -dot(rough, direction)));
const offset = toWorld(mount.eye);
return {
position: {
x: centre.x + offset[0],
y: centre.y + offset[1],
z: centre.z + offset[2],
},
direction: point(direction),
up: point(up),
right: point(cross(direction, up)),
};
}
+183
View File
@@ -0,0 +1,183 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {
ISS_MOUNTS,
ISS_MOUNT_CARDS,
ISS_MOUNT_ORDER,
ISS_NAUKA_NORAD,
ISS_POISK_NORAD,
issMountLabel,
issMountView,
issMountViews,
issMountWorld,
issNextMountView,
issPreviousMountView,
} from './issMounts.js';
import { ISS_MODEL_NATIVE_SPAN, ISS_NORAD } from './policy.js';
const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
const length = (a) => Math.hypot(a.x, a.y, a.z);
/** Key, label and entry of each view: what the Cockpit steps through. */
const summary = (views) =>
views.map(({ key, label, noradId }) => ({ key, label, noradId }));
test('the station offers its views in order, Nauka first', () => {
assert.deepEqual(
[...ISS_MOUNT_ORDER],
['nauka', 'zarya', 'poisk', 'cupola', 'kibo', 'docked'],
);
for (const key of ISS_MOUNT_ORDER) assert.ok(ISS_MOUNTS[key]);
assert.equal(new Set([ISS_NORAD, ISS_NAUKA_NORAD, ISS_POISK_NORAD]).size, 3);
// Each view names the entry it belongs to, for the Cockpit to ride. The
// Cupola and Kibo have no entries of their own: they ride the ISS's.
const views = issMountViews({
naukaName: 'ISS (NAUKA)',
zaryaName: 'ISS (ZARYA)',
poiskName: 'POISK',
dockedName: 'PROGRESS-MS 34',
naukaNorad: ISS_NAUKA_NORAD,
zaryaNorad: ISS_NORAD,
poiskNorad: ISS_POISK_NORAD,
dockedNorad: 68837,
});
assert.deepEqual(summary(views), [
{ key: 'nauka', label: 'NAUKA', noradId: ISS_NAUKA_NORAD },
{ key: 'zarya', label: 'ZARYA', noradId: ISS_NORAD },
{ key: 'poisk', label: 'POISK', noradId: ISS_POISK_NORAD },
{ key: 'cupola', label: 'CUPOLA', noradId: ISS_NORAD },
{ key: 'kibo', label: 'KIBO', noradId: ISS_NORAD },
{ key: 'docked', label: 'PROGRESS-MS 34', noradId: 68837 },
]);
// Only the modules without an entry carry cards of their own.
assert.deepEqual(
views.filter((view) => view.card).map((view) => view.key),
['cupola', 'kibo'],
);
// No vehicle docked: no view from one. The modules are part of the model,
// so they are offered even when the catalog has no entry for them; such a
// view has no entry to ride.
assert.deepEqual(summary(issMountViews({ zaryaName: 'ISS (ZARYA)' })), [
{ key: 'nauka', label: 'NAUKA', noradId: null },
{ key: 'zarya', label: 'ZARYA', noradId: null },
{ key: 'poisk', label: 'POISK', noradId: null },
{ key: 'cupola', label: 'CUPOLA', noradId: null },
{ key: 'kibo', label: 'KIBO', noradId: null },
]);
assert.deepEqual(
issMountViews().map(({ key }) => key),
['nauka', 'zarya', 'poisk', 'cupola', 'kibo'],
);
});
test('the Cupola’s card names it and gives its facts, marked for translation', () => {
const card = ISS_MOUNT_CARDS.cupola;
assert.equal(card.name, 'CUPOLA');
assert.equal(card.classLabel, 'OBSERVATION MODULE · ISS');
assert.equal(card.operator, 'European Space Agency (ESA)');
assert.deepEqual(
[...card.facts],
[
'7 WINDOWS',
'LAUNCHED 8 FEB 2010 · STS-130',
'TRANQUILITY · EARTH-FACING PORT',
],
);
});
test('Kibo’s card names it and gives its facts, marked for translation', () => {
const card = ISS_MOUNT_CARDS.kibo;
assert.equal(card.name, 'KIBO');
assert.equal(card.classLabel, 'LABORATORY MODULE · ISS');
assert.equal(card.operator, 'Japan Aerospace Exploration Agency (JAXA)');
assert.deepEqual(
[...card.facts],
['2 WINDOWS', 'LAUNCHED 31 MAY 2008 · STS-124', 'HARMONY · PORT SIDE'],
);
});
test('the view shown is the one asked for, else the first; the next wraps round', () => {
const views = issMountViews({ dockedName: 'SOYUZ-MS 28' });
assert.equal(issMountView(views, null).key, 'nauka');
assert.equal(issMountView(views, undefined).key, 'nauka');
assert.equal(issMountView(views, 'zarya').key, 'zarya');
assert.equal(issMountView(views, 'docked').label, 'SOYUZ-MS 28');
// A view no longer on offer (the vehicle undocked) falls back to the first.
assert.equal(issMountView(issMountViews(), 'docked').key, 'nauka');
assert.equal(issNextMountView(views, 'nauka').key, 'zarya');
assert.equal(issNextMountView(views, 'zarya').key, 'poisk');
assert.equal(issNextMountView(views, 'poisk').key, 'cupola');
assert.equal(issNextMountView(views, 'cupola').key, 'kibo');
assert.equal(issNextMountView(views, 'kibo').key, 'docked');
assert.equal(issNextMountView(views, 'docked').key, 'nauka');
assert.equal(issNextMountView(views, 'unknown').key, 'nauka');
assert.equal(issNextMountView(views.slice(0, 1), 'nauka'), null);
assert.equal(issNextMountView(null, 'nauka'), null);
assert.equal(issPreviousMountView(views, 'nauka').key, 'docked');
assert.equal(issPreviousMountView(views, 'docked').key, 'kibo');
assert.equal(issPreviousMountView(views, 'zarya').key, 'nauka');
assert.equal(issPreviousMountView(views, 'unknown').key, 'docked');
assert.equal(issPreviousMountView(views.slice(0, 1), 'nauka'), null);
assert.equal(issPreviousMountView(null, 'nauka'), null);
});
test('the view is named after the entry, without the catalog’s "ISS (…)"', () => {
assert.equal(issMountLabel('ISS (ZARYA)'), 'ZARYA');
assert.equal(issMountLabel(' ISS (NAUKA) '), 'NAUKA');
assert.equal(issMountLabel('PROGRESS-MS 34'), 'PROGRESS-MS 34');
assert.equal(issMountLabel(null), '');
});
test('every mount is on or beside the model, with a usable view frame', () => {
for (const [key, { eye, forward, up }] of Object.entries(ISS_MOUNTS)) {
// Within the station's own size of its centre: on it or just off its end.
assert.ok(Math.hypot(...eye) < ISS_MODEL_NATIVE_SPAN / 2, key);
assert.ok(Math.hypot(...forward) > 0.5, key);
// Up is not along the view, so the frame can be squared.
const cos =
(forward[0] * up[0] + forward[1] * up[1] + forward[2] * up[2]) /
(Math.hypot(...forward) * Math.hypot(...up));
assert.ok(Math.abs(cos) < 0.9, key);
}
});
test('a mount goes to the world on the axes the model is placed with', () => {
// Flight axes: x along-track, y the orbit normal, z zenith.
const axes = { x: [0, 1, 0], y: [0, 0, 1], z: [1, 0, 0] };
const centre = { x: 6_800_000, y: 0, z: 0 };
// Model axes are [port, zenith, forward]: forward is along-track, zenith
// is away from the Earth, port is the orbit normal.
const world = issMountWorld(
{ eye: [3, 5, -7], forward: [0, 0, 1], up: [0, 1, 0] },
centre,
axes,
);
assert.deepEqual(world.position, { x: 6_800_005, y: -7, z: 3 });
assert.deepEqual(world.direction, { x: 0, y: 1, z: 0 });
assert.deepEqual(world.up, { x: 1, y: 0, z: 0 });
// right = direction × up.
assert.deepEqual(world.right, { x: 0, y: 0, z: -1 });
});
test('the view frame is unit and square whatever the mount says', () => {
const axes = { x: [0, 1, 0], y: [0, 0, 1], z: [1, 0, 0] };
const centre = { x: 1, y: 2, z: 3 };
for (const mount of [
...Object.values(ISS_MOUNTS),
// Lengths off, and an up that leans into the view.
{ eye: [0, 0, 0], forward: [0, -3, 4], up: [0, 2, 1] },
]) {
const { direction, up, right } = issMountWorld(mount, centre, axes);
for (const v of [direction, up, right])
assert.ok(Math.abs(length(v) - 1) < 1e-12);
assert.ok(Math.abs(dot(direction, up)) < 1e-12);
assert.ok(Math.abs(dot(direction, right)) < 1e-12);
assert.ok(Math.abs(dot(up, right)) < 1e-12);
}
// The eye is the mount's distance from the centre.
const { position } = issMountWorld(ISS_MOUNTS.docked, centre, axes);
const offset = Math.hypot(position.x - 1, position.y - 2, position.z - 3);
assert.ok(Math.abs(offset - Math.hypot(...ISS_MOUNTS.docked.eye)) < 1e-9);
});
+227
View File
@@ -0,0 +1,227 @@
import { msg } from '../../i18n/index.js';
import { ISS_ARM_JOINTS } from './issArticulation.js';
import { issCommandFastOrbit } from './issCommand.js';
import { ISS_NORAD } from './policy.js';
import { trackedStation } from './stationModels.js';
const unit = (v) => {
const n = Math.hypot(...v);
return v.map((c) => c / n);
};
/**
* The Sun positions Manual offers, on the model's axes (port, zenith,
* forward), and whether the station is lit there.
*/
export const ISS_SUN_POSES = Object.freeze([
{ id: 'overhead', label: msg('Overhead'), sun: [0, 1, 0], sunlit: true },
{ id: 'ahead', label: msg('Ahead'), sun: unit([0, 0.05, 1]), sunlit: true },
{
id: 'behind',
label: msg('Behind'),
sun: unit([0, 0.05, -1]),
sunlit: true,
},
{
id: 'below',
label: msg('Underneath'),
sun: unit([0, -1, 0.05]),
sunlit: true,
},
{
id: 'port',
label: msg('Port side'),
sun: unit([0.8, 0.5, 0.3]),
sunlit: true,
},
{
id: 'starboard',
label: msg('Starboard side'),
sun: unit([-0.8, 0.5, 0.3]),
sunlit: true,
},
{ id: 'night', label: msg('Night (shadow)'), sun: [0, -1, 0], sunlit: false },
]);
/** A seven-joint arm's slider labels, base to tip (Tiangong's arms share them). */
export const ISS_ARM_LABELS = Object.freeze([
msg('Shoulder roll'),
msg('Shoulder yaw'),
msg('Shoulder pitch'),
msg('Elbow'),
msg('Wrist pitch'),
msg('Wrist yaw'),
msg('Wrist roll'),
]);
/**
* The ISS as the STATION section describes it (stationPanel.js): its joint
* driver and telemetry from the model part, and the Manual controls the
* command panel offered: the Sun's position or a fast orbit, folding the
* arrays and radiators as a demonstration, aiming the dishes, posing
* Canadarm2 by joint.
* @param {{state: object, parts: object}} context
* @returns {import('./stationPanel.js').StationDescription}
*/
export function issStationDescription({ state: layerState, parts }) {
return {
key: 'iss',
title: 'ISS', // i18n-ignore: the station's name
// stationModels.js says which station the tracked entry belongs to.
selected: () => trackedStation(layerState, parts)?.norad === ISS_NORAD,
subjectName: () =>
layerState._catalog.get(layerState._trackedNorad)?.name?.trim() ||
`ISS · NORAD ${ISS_NORAD}`,
articulation: () => parts.issModel?._articulation ?? null,
telemetry: () => {
// The feed is read only while the model is drawn; away from it there
// is no signal to report, and a stale answer would read as lost.
if ((parts.issModel?._visualPosition?.() ?? null) === null)
return { state: 'idle', poseAgeMs: null, liveUntilMs: null };
return parts.issModel?._telemetryStatus?.() ?? null;
},
// The model's centre, else this frame's tracked sample, else the dot as
// the rendering part draws it.
position: () =>
parts.issModel?._visualPosition?.() ??
layerState._trackedFrameCartesian ??
parts.rendering?._pointPosition?.(ISS_NORAD) ??
null,
zoomLabel: msg('Zoom to the ISS'),
notes: {
live: msg(
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.",
),
computed: msg(
'Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.',
),
},
groups: [
{
id: 'sun',
label: msg('Sun position'),
kind: 'choices',
choices: [
{
id: 'follow',
label: msg('Follow the Sun'),
isDefault: true,
apply: (a) => a.setOverride(null),
},
...ISS_SUN_POSES.map(({ id, label, sun, sunlit }) => ({
id,
label,
apply: (a) => {
const fixed = { sun, sunlit };
a.setOverride(() => fixed);
},
})),
{
id: 'orbit',
label: msg('Fast orbit (40 s)'),
apply: (a) => {
const start = Date.now();
a.setOverride((nowMs) => issCommandFastOrbit(nowMs - start));
},
},
],
},
{
id: 'arrays',
label: msg('Solar arrays'),
note: msg('Demonstration: the real arrays stay extended.'),
kind: 'choices',
choices: [
{
id: 'retract',
label: msg('Retract'),
apply: (a) => a.setDeploy(false),
},
{
id: 'extend',
label: msg('Extend'),
isDefault: true,
apply: (a) => a.setDeploy(true),
},
],
},
{
id: 'radiators',
label: msg('Radiators'),
note: msg(
'Demonstration: the real radiators can fold but stay extended.',
),
kind: 'choices',
choices: [
{
id: 'retract',
label: msg('Retract'),
apply: (a) => a.setRadiatorDeploy(false),
},
{
id: 'extend',
label: msg('Extend'),
isDefault: true,
apply: (a) => a.setRadiatorDeploy(true),
},
],
},
{
id: 'dishes',
label: msg('Dishes'),
kind: 'choices',
choices: [
{
id: 'relays',
label: msg('Relay satellites'),
isDefault: true,
apply: (a) => a.setDishOverride(null),
},
{
id: 'up',
label: msg('Up'),
apply: (a) => a.setDishOverride([0, 1, 0]),
},
{
id: 'forward',
label: msg('Forward'),
apply: (a) => a.setDishOverride(unit([0, 0.35, 0.94])),
},
{
id: 'sideways',
label: msg('Sideways'),
apply: (a) => a.setDishOverride(unit([0.94, 0.35, 0])),
},
],
},
{
id: 'arm',
label: msg('Canadarm2 (degrees)'),
kind: 'sliders',
resume: msg('Resume sway'),
sliders: ISS_ARM_JOINTS.map((joint, i) => ({
id: joint.node,
label: ISS_ARM_LABELS[i],
min: -120,
max: 120,
apply: (a, value) =>
a.setJoint(
joint.node,
joint.pivot,
joint.axis,
(value * Math.PI) / 180,
),
})),
resumeApply: (a) => a.resumeArm(),
},
],
automatic: (a) => {
a.setTelemetryAllowed?.(true);
a.setOverride(null);
a.setDishOverride(null);
a.setDeploy(true);
a.setRadiatorDeploy(true);
a.resumeArm();
},
};
}
+301
View File
@@ -0,0 +1,301 @@
/**
* The ISS model's joints from NASA's public telemetry, when the server relays
* it (`/api/iss-telemetry`, off unless the operator sets
* `ISS_TELEMETRY_ENABLED=1`). Without it, or while the station has no signal,
* the joints keep the computed rules in issArticulation.js.
*
* How each telemetry angle maps onto a model joint was fitted against a
* recording of the feed, using the station's own attitude and position from
* the same feed:
* - the dish's two angles give a direction that stayed within 0.3° of a TDRS
* relay satellite across a hand-over between two of them;
* - the alpha joints' sign and zero put the arrays' masts square to the Sun;
* - each beta joint's sign is the one that turns its cell side toward the Sun
* (the other sign faces it about 45° away). The arrays then sat 5° to 9°
* off the Sun, which is where the real station held them.
* The radiator joints did not move during the recording, so their sign is the
* better of the two candidates on a parked joint, not a fit.
*/
/** The route the server relays the feed at. */
export const ISS_TELEMETRY_URL = '/api/iss-telemetry';
const DEG = Math.PI / 180;
/** Alpha joints (SARJ), in ISS_ALPHA_JOINTS order: port, starboard. */
export const ISS_TELEMETRY_ALPHA = Object.freeze([
Object.freeze({ item: 'S0000004', sign: 1 }),
Object.freeze({ item: 'S0000003', sign: -1 }),
]);
/**
* Beta joints (BGA), in ISS_BETA_JOINTS order: 2A, 4A, 2B, 4B, 1A, 3A, 1B,
* 3B. The model's angle is `sign × telemetry + 90°`: at 0° or 180° an array
* stands square to the truss, which is the model's ±90°.
*/
export const ISS_TELEMETRY_BETA = Object.freeze([
Object.freeze({ item: 'P4000007', sign: 1 }),
Object.freeze({ item: 'P4000008', sign: -1 }),
Object.freeze({ item: 'P6000008', sign: -1 }),
Object.freeze({ item: 'P6000007', sign: 1 }),
Object.freeze({ item: 'S4000007', sign: -1 }),
Object.freeze({ item: 'S4000008', sign: 1 }),
Object.freeze({ item: 'S6000008', sign: 1 }),
Object.freeze({ item: 'S6000007', sign: -1 }),
]);
/** Radiator joints (TRRJ), in ISS_RADIATOR_JOINTS order: port, starboard. */
export const ISS_TELEMETRY_GAMMA = Object.freeze([
Object.freeze({ item: 'S0000002', sign: 1 }),
Object.freeze({ item: 'S0000001', sign: 1 }),
]);
/** The Ku-band dish: elevation and cross-elevation. */
export const ISS_TELEMETRY_DISH = Object.freeze({
elevation: 'Z1000014',
crossElevation: 'Z1000015',
});
/**
* Where the dish points, on the model's axes (port, zenith, forward), from
* its two gimbal angles: zenith at rest, cross-elevation leans it to port,
* elevation then tips it aft.
* @param {number} elevationDeg
* @param {number} crossElevationDeg
* @returns {number[]} Unit vector.
*/
export function issTelemetryDishDirection(elevationDeg, crossElevationDeg) {
const el = elevationDeg * DEG;
const xel = crossElevationDeg * DEG;
return [
Math.sin(xel),
Math.cos(el) * Math.cos(xel),
-Math.sin(el) * Math.cos(xel),
];
}
/**
* The joint angles a telemetry snapshot gives, as the model turns them.
* @param {Record<string, [number, number|null]>|null|undefined} items The
* relay's `items`: each item's value and the time it was true at.
* @returns {{alpha: number[], beta: number[], gamma: number[],
* dish: number[]|null}|null} Radians, in the joint lists' order; null
* unless every array and radiator joint is present. `dish` is null when
* its angles are missing.
*/
export function issTelemetryPose(items) {
if (!items) return null;
const read = (item) => {
const value = items[item]?.[0];
return Number.isFinite(value) ? value : null;
};
const turn = (list, offsetDeg) =>
list.map(({ item, sign }) => {
const value = read(item);
return value === null ? null : (sign * value + offsetDeg) * DEG;
});
const alpha = turn(ISS_TELEMETRY_ALPHA, 0);
const beta = turn(ISS_TELEMETRY_BETA, 90);
const gamma = turn(ISS_TELEMETRY_GAMMA, 0);
if ([...alpha, ...beta, ...gamma].includes(null)) return null;
const el = read(ISS_TELEMETRY_DISH.elevation);
const xel = read(ISS_TELEMETRY_DISH.crossElevation);
return {
alpha,
beta,
gamma,
dish:
el === null || xel === null ? null : issTelemetryDishDirection(el, xel),
};
}
/** How often the relay is asked while the model is on screen. */
export const ISS_TELEMETRY_POLL_MS = 5_000;
/** A snapshot older than this is not used: the joints go back to their rules. */
export const ISS_TELEMETRY_FRESH_MS = 20_000;
/**
* The newest moment any of the relay's items was true at: when the feed
* last had data, as far as this answer tells.
* @param {Record<string, [number, number]>|null|undefined} items
* @returns {number|null} Epoch ms, or null without a dated item.
*/
export function issTelemetryLatestEpoch(items) {
let latest = null;
for (const entry of Object.values(items ?? {})) {
const epoch = Array.isArray(entry) ? Number(entry[1]) : NaN;
// An item with no time has 0 there, which is no date.
if (
epoch > 0 &&
Number.isFinite(epoch) &&
(latest === null || epoch > latest)
)
latest = epoch;
}
return latest;
}
/** The feed stops asking this long after the model was last drawn. */
const WANTED_MS = 10_000;
const REQUEST_TIMEOUT_MS = 5_000;
/** After a failed request the next one waits this long. */
const FAILURE_WAIT_MS = 30_000;
/**
* Polls the relay while the model is drawn. `touch()` each frame the model
* shows keeps it asking; it stops by itself when the touches stop, and for
* good once the server says the relay is not switched on.
* @param {{fetchImpl?: typeof fetch, now?: () => number,
* setTimer?: (fn: () => void, ms: number) => unknown,
* clearTimer?: (id: unknown) => void}} [options]
*/
export function createIssTelemetryFeed({
fetchImpl = (...args) => globalThis.fetch(...args),
now = Date.now,
setTimer = (fn, ms) => setTimeout(fn, ms),
clearTimer = (id) => clearTimeout(id),
} = {}) {
/** False once the server answered that the relay is off. */
let configured = null;
let lastTouchAt = null;
let timer = null;
let requesting = false;
/** Bumped by destroy, so a request in flight cannot write after it. */
let generation = 0;
let pose = null;
let poseAt = null;
/** What the relay last said and when, for the station panel's status line. */
let relayStatus = null;
let answeredAt = null;
let failures = 0;
/** When the relay last reported signal; the "no signal since" time. */
let liveUntil = null;
async function request() {
const mine = generation;
requesting = true;
const controller = new AbortController();
const deadline = setTimer(() => controller.abort(), REQUEST_TIMEOUT_MS);
let wait = ISS_TELEMETRY_POLL_MS;
try {
const response = await fetchImpl(ISS_TELEMETRY_URL, {
signal: controller.signal,
cache: 'no-store',
});
if (!response.ok) throw new Error('unavailable');
const body = await response.json();
if (mine !== generation) return;
if (body?.configured !== true) {
configured = false;
pose = null;
return;
}
configured = true;
answeredAt = now();
failures = 0;
relayStatus = typeof body.status === 'string' ? body.status : null;
const next = body.status === 'live' ? issTelemetryPose(body.items) : null;
pose = next;
poseAt = next ? now() : null;
if (next) liveUntil = poseAt;
// A page that opens during a loss of signal still learns when the
// feed last had data: the newest value the relay holds was true then.
else if (body.status === 'no-signal' && liveUntil === null)
liveUntil = issTelemetryLatestEpoch(body.items);
} catch {
if (mine !== generation) return;
failures += 1;
wait = FAILURE_WAIT_MS;
} finally {
clearTimer(deadline);
if (mine === generation) {
requesting = false;
schedule(wait);
}
}
}
function wanted() {
return (
configured !== false &&
lastTouchAt !== null &&
now() - lastTouchAt < WANTED_MS
);
}
function schedule(ms) {
if (timer !== null || requesting || !wanted()) return;
timer = setTimer(() => {
timer = null;
if (wanted()) request();
}, ms);
}
return {
/** The model is on screen: keep the feed asking. */
touch() {
lastTouchAt = now();
schedule(0);
},
/**
* The joint angles to use now, or null: no relay, no signal, or the last
* answer is too old.
* @returns {{alpha: number[], beta: number[], gamma: number[],
* dish: number[]|null}|null}
*/
pose() {
if (!pose || poseAt === null) return null;
return now() - poseAt < ISS_TELEMETRY_FRESH_MS ? pose : null;
},
/** Whether the server relays the feed: null until it has answered. */
configured() {
return configured;
},
/**
* Where the joints' angles stand, for the station panel: `live` with a
* fresh pose; `no-signal` while the relay is up but the station is out
* of contact; `unavailable` when the relay cannot be reached or is not
* connected; `disabled` when this server does not relay the feed;
* `pending` before the first answer. `poseAgeMs` is how old the last
* pose is, `liveUntilMs` when signal was last had (epoch ms), both null
* when there was none.
* @returns {{state: 'live'|'no-signal'|'unavailable'|'disabled'|'pending',
* poseAgeMs: number|null, liveUntilMs: number|null}}
*/
status() {
const at = now();
const poseAgeMs = poseAt === null ? null : at - poseAt;
let state;
if (configured === false) state = 'disabled';
// Never answered: still asking, or the route is not there (a 404, an
// HTML fallback page), which is unavailable rather than pending.
else if (configured === null)
state = failures > 0 ? 'unavailable' : 'pending';
else if (pose && poseAgeMs < ISS_TELEMETRY_FRESH_MS) state = 'live';
else if (failures === 0 && relayStatus === 'no-signal')
state = 'no-signal';
else if (
failures === 0 &&
(relayStatus === 'connecting' || relayStatus === 'reconnecting') &&
answeredAt !== null &&
at - answeredAt < ISS_TELEMETRY_FRESH_MS
)
state = 'pending';
else state = 'unavailable';
return { state, poseAgeMs, liveUntilMs: liveUntil };
},
destroy() {
generation += 1;
if (timer !== null) clearTimer(timer);
timer = null;
requesting = false;
lastTouchAt = null;
pose = null;
poseAt = null;
configured = null;
relayStatus = null;
answeredAt = null;
failures = 0;
liveUntil = null;
},
};
}
+511
View File
@@ -0,0 +1,511 @@
import assert from 'node:assert/strict';
import test, { after, before } from 'node:test';
import * as Cesium from 'cesium';
import {
ISS_ALPHA_JOINTS,
ISS_BETA_JOINTS,
ISS_DISH_JOINTS,
ISS_RADIATOR_JOINTS,
createIssArticulation,
} from './issArticulation.js';
import {
issTelemetryLatestEpoch,
ISS_TELEMETRY_ALPHA,
ISS_TELEMETRY_BETA,
ISS_TELEMETRY_FRESH_MS,
ISS_TELEMETRY_GAMMA,
ISS_TELEMETRY_POLL_MS,
ISS_TELEMETRY_URL,
createIssTelemetryFeed,
issTelemetryDishDirection,
issTelemetryPose,
} from './issTelemetry.js';
// The joint driver asks Cesium for the Earth's orientation, which loads data
// over the network; without it Cesium's own fallback is used, as in the app
// before that data arrives.
const realIcrf = Cesium.Transforms.computeIcrfToFixedMatrix;
before(() => {
Cesium.Transforms.computeIcrfToFixedMatrix = () => undefined;
});
after(() => {
Cesium.Transforms.computeIcrfToFixedMatrix = realIcrf;
});
const DEG = Math.PI / 180;
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const angleDeg = (a, b) =>
Math.acos(Math.min(1, Math.max(-1, dot(a, b)))) / DEG;
/**
* Two moments recorded from the feed on 13 November 2026, eleven minutes
* apart. `sun` and `relayDirection` are on the model's axes (port, zenith,
* forward), worked out from the station's own position and attitude in the
* same feed; the relay is the TDRS satellite the dish was aimed at.
*/
const RECORDED = [
{
items: {
S0000004: [306.2512, 0],
S0000003: [53.7878, 0],
P4000007: [161.5045, 0],
P4000008: [198.4406, 0],
P6000008: [202.9449, 0],
P6000007: [161.0541, 0],
S4000007: [18.7427, 0],
S4000008: [341.3068, 0],
S6000008: [341.7682, 0],
S6000007: [18.8361, 0],
S0000002: [15.1868, 0],
S0000001: [24.8383, 0],
Z1000014: [-8.4924, 0],
Z1000015: [-31.6077, 0],
},
sun: [0.45411, 0.5286, -0.7172],
relayDirection: [-0.5264, 0.84041, 0.12893],
},
{
items: {
S0000004: [262.0807, 0],
S0000003: [97.9968, 0],
P4000007: [161.8451, 0],
P4000008: [198.2867, 0],
P6000008: [202.8131, 0],
P6000007: [161.4166, 0],
S4000007: [18.6932, 0],
S4000008: [341.7902, 0],
S6000008: [341.6089, 0],
S6000007: [18.4076, 0],
S0000002: [15.1923, 0],
S0000001: [24.8383, 0],
Z1000014: [39.5837, 0],
Z1000015: [-30.1135, 0],
},
sun: [0.45807, -0.12024, -0.88075],
relayDirection: [-0.50436, 0.66714, -0.54822],
},
];
/**
* An array's cell-side normal on the model's axes: ±X at rest, turned about
* the mast (Z) by beta, then about the truss (X) by alpha.
*/
function cellNormal(face, alpha, beta) {
const x = face * Math.cos(beta);
const y = face * Math.sin(beta);
return [x, Math.cos(alpha) * y, Math.sin(alpha) * y];
}
test('the joint lists line up with the model joints they drive', () => {
assert.equal(ISS_TELEMETRY_ALPHA.length, ISS_ALPHA_JOINTS.length);
assert.equal(ISS_TELEMETRY_BETA.length, ISS_BETA_JOINTS.length);
assert.equal(ISS_TELEMETRY_GAMMA.length, ISS_RADIATOR_JOINTS.length);
const items = [
...ISS_TELEMETRY_ALPHA,
...ISS_TELEMETRY_BETA,
...ISS_TELEMETRY_GAMMA,
].map(({ item }) => item);
assert.equal(new Set(items).size, items.length, 'no item drives two joints');
});
test('recorded telemetry turns every array toward where the Sun was', () => {
for (const { items, sun } of RECORDED) {
const pose = issTelemetryPose(items);
ISS_BETA_JOINTS.forEach(({ node, face }, i) => {
const alpha = pose.alpha[node.startsWith('PORT') ? 0 : 1];
const off = angleDeg(cellNormal(face, alpha, pose.beta[i]), sun);
// The real arrays were held 5° to 9° off the Sun.
assert.ok(off < 11, `${node} is ${off.toFixed(1)}° off the Sun`);
});
}
});
test('the other sign on any joint turns its arrays away from the Sun', () => {
const { items, sun } = RECORDED[0];
const pose = issTelemetryPose(items);
ISS_BETA_JOINTS.forEach(({ node, face }, i) => {
const alpha = pose.alpha[node.startsWith('PORT') ? 0 : 1];
// Beta with the opposite sign about its 90° zero.
const flipped = Math.PI - pose.beta[i];
assert.ok(angleDeg(cellNormal(face, alpha, flipped), sun) > 35, node);
// Alpha with the opposite sign.
assert.ok(angleDeg(cellNormal(face, -alpha, pose.beta[i]), sun) > 35, node);
});
});
test('the recorded dish angles point at the relay satellite', () => {
for (const { items, relayDirection } of RECORDED) {
const { dish } = issTelemetryPose(items);
assert.ok(Math.abs(Math.hypot(...dish) - 1) < 1e-9);
assert.ok(angleDeg(dish, relayDirection) < 0.5);
}
// At rest it looks at the zenith; cross-elevation leans to port,
// elevation tips aft.
assert.ok(angleDeg(issTelemetryDishDirection(0, 0), [0, 1, 0]) < 1e-6);
assert.ok(issTelemetryDishDirection(0, 30)[0] > 0);
assert.ok(issTelemetryDishDirection(30, 0)[2] < 0);
});
test('a snapshot missing a joint gives no pose; missing dish angles give no dish', () => {
const { items } = RECORDED[0];
assert.equal(issTelemetryPose(null), null);
assert.equal(issTelemetryPose({}), null);
for (const item of ['S0000004', 'P6000007', 'S0000001']) {
const partial = { ...items };
delete partial[item];
assert.equal(issTelemetryPose(partial), null, item);
}
assert.equal(
issTelemetryPose({ ...items, S0000003: ['x', 0] }),
null,
'a value that is not a number',
);
const noDish = { ...items };
delete noDish.Z1000015;
const pose = issTelemetryPose(noDish);
assert.equal(pose.dish, null);
assert.equal(pose.beta.length, 8);
});
/** A hand-moved clock with the timers set on it. */
function fakeTime() {
const time = { ms: 1_000_000 };
let timers = [];
let nextId = 1;
return {
now: () => time.ms,
setTimer(fn, ms) {
const id = nextId++;
timers.push({ id, at: time.ms + ms, fn });
return id;
},
clearTimer(id) {
timers = timers.filter((timer) => timer.id !== id);
},
/** Move the clock on, running timers as they fall due. */
async advance(ms) {
const end = time.ms + ms;
for (;;) {
// Let a finished request schedule its next timer first.
await new Promise((resolve) => setImmediate(resolve));
const due = timers
.filter((timer) => timer.at <= end)
.sort((a, b) => a.at - b.at)[0];
if (!due) break;
timers = timers.filter((timer) => timer !== due);
time.ms = Math.max(time.ms, due.at);
due.fn();
}
time.ms = end;
await new Promise((resolve) => setImmediate(resolve));
},
};
}
/** A fetch that answers from a queue of bodies (or throws for an Error). */
function fakeFetch(answers) {
const calls = [];
const fetchImpl = async (url, init) => {
calls.push({ url, init });
const answer = answers.length > 1 ? answers.shift() : answers[0];
if (answer instanceof Error) throw answer;
return { ok: true, json: async () => answer };
};
return { fetchImpl, calls };
}
const LIVE = { configured: true, status: 'live', items: RECORDED[0].items };
test('the feed asks only while the model is drawn, every five seconds', async () => {
const time = fakeTime();
const { fetchImpl, calls } = fakeFetch([LIVE]);
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
await time.advance(60_000);
assert.equal(calls.length, 0, 'nothing is asked before the model shows');
feed.touch();
await time.advance(0);
assert.equal(calls.length, 1);
assert.equal(calls[0].url, ISS_TELEMETRY_URL);
assert.equal(calls[0].init.cache, 'no-store');
assert.equal(feed.configured(), true);
assert.deepEqual(feed.pose(), issTelemetryPose(RECORDED[0].items));
// Drawn for another 12 s: two more requests.
for (let i = 0; i < 12; i++) {
feed.touch();
await time.advance(1000);
}
assert.equal(calls.length, 1 + Math.floor(12_000 / ISS_TELEMETRY_POLL_MS));
// Not drawn any more: it stops by itself, and the pose goes stale.
const drawn = calls.length;
await time.advance(60_000);
assert.ok(calls.length <= drawn + 2);
assert.equal(feed.pose(), null);
const settled = calls.length;
await time.advance(60_000);
assert.equal(calls.length, settled);
});
test('a relay that is switched off is asked once and never again', async () => {
const time = fakeTime();
const { fetchImpl, calls } = fakeFetch([{ configured: false }]);
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
for (let i = 0; i < 30; i++) {
feed.touch();
await time.advance(1000);
}
assert.equal(calls.length, 1);
assert.equal(feed.configured(), false);
assert.equal(feed.pose(), null);
});
test('no signal, a failed request or an old answer all give no pose', async () => {
const time = fakeTime();
const { fetchImpl, calls } = fakeFetch([
LIVE,
{ configured: true, status: 'no-signal', items: RECORDED[0].items },
LIVE,
new Error('offline'),
]);
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
const drawFor = async (ms) => {
for (let t = 0; t < ms; t += 1000) {
feed.touch();
await time.advance(1000);
}
};
await drawFor(1000);
assert.ok(feed.pose());
await drawFor(ISS_TELEMETRY_POLL_MS);
assert.equal(feed.pose(), null, 'no signal');
await drawFor(ISS_TELEMETRY_POLL_MS);
assert.ok(feed.pose(), 'signal back');
// Requests now fail: the last pose is used until it is 20 s old, and the
// feed asks less often.
const failingFrom = calls.length;
await drawFor(ISS_TELEMETRY_FRESH_MS - ISS_TELEMETRY_POLL_MS - 1000);
assert.ok(feed.pose());
await drawFor(ISS_TELEMETRY_POLL_MS + 2000);
assert.equal(feed.pose(), null, 'too old');
await drawFor(60_000);
assert.ok(calls.length - failingFrom <= 4, 'failures are retried slowly');
});
test('destroy stops the feed, even with a request in flight', async () => {
const time = fakeTime();
let release;
const calls = [];
const fetchImpl = (url) => {
calls.push(url);
return new Promise((resolve) => {
release = () => resolve({ ok: true, json: async () => LIVE });
});
};
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
feed.touch();
await time.advance(0);
assert.equal(calls.length, 1);
feed.destroy();
release();
await time.advance(60_000);
assert.equal(feed.pose(), null);
assert.equal(calls.length, 1);
});
/**
* A stand-in for the loaded model: named nodes that keep a copy of the
* matrix written to them, as a Cesium node does.
*/
function fakeModel() {
const nodes = new Map();
return {
ready: true,
getNode(name) {
if (!nodes.has(name)) {
let copy = null;
nodes.set(name, {
name,
get matrix() {
return copy;
},
set matrix(value) {
copy = Array.from(value);
},
});
}
return nodes.get(name);
},
matrixOf(name) {
return nodes.get(name)?.matrix ?? null;
},
};
}
const AXES = { x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] };
const POSITION = { x: 6_800_000, y: 0, z: 0 };
test('with a telemetry pose the joints take its angles, each side its own', () => {
const articulation = createIssArticulation();
const model = fakeModel();
const pose = issTelemetryPose(RECORDED[0].items);
articulation.setTelemetry(() => pose);
articulation.update(
model,
new Date(Date.UTC(2026, 10, 13, 11, 8)),
POSITION,
AXES,
1000,
);
assert.equal(articulation.isLive(), true);
// The alpha joints turn about X by the pose's angle: port and starboard differ.
ISS_ALPHA_JOINTS.forEach(({ node }, i) => {
const m = model.matrixOf(node);
assert.ok(Math.abs(m[5] - Math.cos(pose.alpha[i])) < 1e-9, node);
assert.ok(Math.abs(m[6] - Math.sin(pose.alpha[i])) < 1e-9, node);
});
assert.notDeepEqual(
model.matrixOf(ISS_ALPHA_JOINTS[0].node),
model.matrixOf(ISS_ALPHA_JOINTS[1].node),
);
ISS_BETA_JOINTS.forEach(({ node }, i) => {
const m = model.matrixOf(node);
assert.ok(Math.abs(m[0] - Math.cos(pose.beta[i])) < 1e-9, node);
assert.ok(Math.abs(m[1] - Math.sin(pose.beta[i])) < 1e-9, node);
});
ISS_RADIATOR_JOINTS.forEach(({ node }, i) => {
const m = model.matrixOf(node);
assert.ok(Math.abs(m[0] - Math.cos(pose.gamma[i])) < 1e-9, node);
});
// The first dish takes the reported aim (its rest boresight, +Y, turned
// onto it); the second is left where it was.
const dish = model.matrixOf(ISS_DISH_JOINTS[0].node);
assert.ok(angleDeg([dish[4], dish[5], dish[6]], pose.dish) < 1e-4);
const second = model.matrixOf(ISS_DISH_JOINTS[1].node);
assert.ok(angleDeg([second[4], second[5], second[6]], [0, 1, 0]) < 1e-4);
});
test('without a pose, or in Manual, the joints keep their computed rules', () => {
const date = new Date(Date.UTC(2026, 10, 13, 11, 8));
const computed = fakeModel();
createIssArticulation().update(computed, date, POSITION, AXES, 1000);
// Telemetry with nothing to say.
const silent = createIssArticulation();
silent.setTelemetry(() => null);
const silentModel = fakeModel();
silent.update(silentModel, date, POSITION, AXES, 1000);
assert.equal(silent.isLive(), false);
// Telemetry with a pose, but the command panel is on Manual.
const manual = createIssArticulation();
manual.setTelemetry(() => issTelemetryPose(RECORDED[0].items));
manual.setTelemetryAllowed(false);
const manualModel = fakeModel();
manual.update(manualModel, date, POSITION, AXES, 1000);
assert.equal(manual.isLive(), false);
// A Sun chosen by hand is computed too.
const forced = createIssArticulation();
forced.setTelemetry(() => issTelemetryPose(RECORDED[0].items));
forced.setOverride(() => ({ sun: [0, 1, 0], sunlit: true }));
forced.update(fakeModel(), date, POSITION, AXES, 1000);
assert.equal(forced.isLive(), false);
for (const { node } of [
...ISS_ALPHA_JOINTS,
...ISS_BETA_JOINTS,
...ISS_RADIATOR_JOINTS,
]) {
assert.deepEqual(silentModel.matrixOf(node), computed.matrixOf(node), node);
assert.deepEqual(manualModel.matrixOf(node), computed.matrixOf(node), node);
}
// Back to Automatic: the pose is used again, gliding at the joint rate.
manual.setTelemetryAllowed(true);
manual.update(manualModel, date, POSITION, AXES, 1100);
assert.equal(manual.isLive(), true);
});
test('a page that opens during a loss of signal learns when the feed last had data', async () => {
const time = fakeTime();
// The recording carries no times; date every item the same.
const dated = Object.fromEntries(
Object.entries(RECORDED[0].items).map(([key, [value]]) => [
key,
[value, 1_700_000_000_000],
]),
);
const noSignal = {
configured: true,
status: 'no-signal',
items: dated,
};
const { fetchImpl } = fakeFetch([noSignal, noSignal]);
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
feed.touch();
await time.advance(1000);
const status = feed.status();
assert.equal(status.state, 'no-signal');
assert.equal(status.poseAgeMs, null);
const latest = issTelemetryLatestEpoch(dated);
assert.ok(Number.isFinite(latest) && latest > 0);
assert.equal(status.liveUntilMs, latest);
feed.destroy();
});
test('the latest epoch is the newest dated item, and nothing without one', () => {
assert.equal(
issTelemetryLatestEpoch({ a: [1, 100], b: [2, 300], c: [3, 200] }),
300,
);
assert.equal(issTelemetryLatestEpoch({ a: [1, 'x'], b: 5, c: [2, 0] }), null);
assert.equal(issTelemetryLatestEpoch({}), null);
assert.equal(issTelemetryLatestEpoch(null), null);
});
test('the status says where the angles stand: pending, live, disabled', async () => {
const time = fakeTime();
const { fetchImpl } = fakeFetch([LIVE]);
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
assert.equal(feed.status().state, 'pending', 'before the first answer');
feed.touch();
await time.advance(0);
const live = feed.status();
assert.equal(live.state, 'live');
assert.ok(live.poseAgeMs >= 0 && live.poseAgeMs < ISS_TELEMETRY_FRESH_MS);
const off = fakeFetch([{ configured: false }]);
const offFeed = createIssTelemetryFeed({ fetchImpl: off.fetchImpl, ...time });
offFeed.touch();
await time.advance(0);
assert.equal(offFeed.status().state, 'disabled');
});
test('a relay route that is not there reads as unavailable, not as connecting forever', async () => {
const time = fakeTime();
// A 404, or a deploy's HTML fallback page: never a relay answer.
const answers = [
{ ok: false, status: 404, json: async () => ({}) },
{
ok: true,
json: async () => {
throw new SyntaxError('Unexpected token <');
},
},
];
let call = 0;
const fetchImpl = async () => answers[Math.min(call++, answers.length - 1)];
const feed = createIssTelemetryFeed({ fetchImpl, ...time });
feed.touch();
await time.advance(0);
assert.equal(feed.configured(), null, 'never answered');
assert.equal(feed.status().state, 'unavailable');
for (let i = 0; i < 30; i++) {
feed.touch();
await time.advance(1000);
}
assert.equal(feed.status().state, 'unavailable');
});
+8
View File
@@ -47,6 +47,8 @@ export function createLifecycle({
const frame = frameOf(viewer);
parts.catalog._abortActiveUpdates();
clearFocusTarget('satellites');
for (const model of parts.stationModels ?? [])
model._destroyStationModel();
layerState._viewer = viewer;
layerState._catalog = new Map();
layerState._points = new Map();
@@ -138,7 +140,10 @@ export function createLifecycle({
releaseContinuousRender('satellites');
parts.rendering._setPointsShown(false);
parts.rendering._setOrbitPathsShown(false);
for (const model of parts.stationModels ?? [])
model._updateStationModel(); // off: releases the model
parts.tracking._clearTracking();
parts.stationPanel?._syncStationPanel(); // off: takes the panel down
parts.labels._syncIssOverlay();
// Remove click handler + keydown listener + preRender propagation while disabled
layerState._clickSubscription?.();
@@ -178,6 +183,9 @@ export function createLifecycle({
}
layerState._overlayHost.clearSource(ISS_OVERLAY_SOURCE_ID);
layerState._overlayHost.setVisible(ISS_OVERLAY_SOURCE_ID, false);
for (const model of parts.stationModels ?? [])
model._destroyStationModel();
parts.stationPanel?._destroyStationPanel();
// The dots', tracked dot's and rings' sets are disposed of
parts.rendering._detach(viewer);
layerState._points.clear();
+92
View File
@@ -321,6 +321,98 @@ test('the rendering part draws the dots, the tracked dot and the rings through t
}
});
test('a dot handed to a station model draws only beyond its range; the tracked dot too', () => {
const viewer = {};
const { draw, unbind } = bindFakeDraw(viewer);
try {
const state = {
now: Date.now,
_points: new Map(),
_orbitPaths: new Map(),
_catalog: new Map(),
_viewer: viewer,
_trackedNorad: null,
_enabled: true,
_params: { showPoints: false, showOrbits: false },
};
const rendering = createRendering({
state,
services: {
focus: {
focusNowMs: (ms) => ms,
getFocusTarget: () => null,
focusPassIsNeeded: () => false,
},
},
parts: { tracking: { _getTrackedFramePosition: () => null } },
});
rendering._attach(viewer);
const points = draw.find('satellites:').spec.id;
const set = draw.set(points);
const range = [1.5e6, Number.MAX_VALUE];
let frame = 0;
const tick = () => rendering._preRenderTick({ frame: ++frame });
rendering._addPoint(25544, { x: 1, y: 2, z: 3 }, POINT_STYLES.iss);
tick();
assert.equal(set.items.get('25544').displayRange, undefined);
assert.equal(rendering._pointDisplayRange(25544), null);
// The range goes to the set with the frame, as the item's own copy.
assert.equal(rendering._setPointDisplayRange(25544, range), true);
assert.equal(rendering._setPointDisplayRange(1, range), false, 'no dot');
let writes = set.writes;
tick();
assert.equal(set.writes, writes + 1, 'sent with the frame');
assert.deepEqual(set.items.get('25544').displayRange, range);
assert.notEqual(set.items.get('25544').displayRange, range);
assert.deepEqual(rendering._pointDisplayRange(25544), range);
assert.equal(set.items.get('25544').show, true, 'shown, within its range');
// The same range again sends nothing (asked every frame).
writes = set.writes;
rendering._setPointDisplayRange(25544, [1.5e6, Number.MAX_VALUE]);
tick();
assert.equal(set.writes, writes);
// None again: every distance.
rendering._setPointDisplayRange(25544, null);
tick();
assert.equal(set.items.get('25544').displayRange, undefined);
assert.equal(rendering._pointDisplayRange(25544), null);
// A dot added again (a catalog rebuild) arrives with no range.
rendering._setPointDisplayRange(25544, range);
rendering._addPoint(25544, { x: 1, y: 2, z: 3 }, POINT_STYLES.iss);
tick();
assert.equal(set.items.get('25544').displayRange, undefined);
// The tracked dot: redrawn at once while drawn, fresh for each tracking.
const tracked = draw.set(points.replace(':points', ':tracked'));
state._trackedNorad = 25544;
assert.equal(rendering._trackedDotDisplayRange(), null, 'no tracked dot');
rendering._setTrackedDotDisplayRange(range); // nothing to put it on
rendering._addTrackedEntity({ position: () => ({ x: 1, y: 2, z: 3 }) });
assert.equal(rendering._trackedDotDisplayRange(), null);
tick();
assert.equal(tracked.items.get('25544').displayRange, undefined);
writes = tracked.writes;
rendering._setTrackedDotDisplayRange(range);
assert.equal(tracked.writes, writes + 1, 'redrawn at once');
assert.deepEqual(tracked.items.get('25544').displayRange, range);
assert.deepEqual(rendering._trackedDotDisplayRange(), range);
rendering._setTrackedDotDisplayRange([1.5e6, Number.MAX_VALUE]);
assert.equal(tracked.writes, writes + 1, 'the same range sends nothing');
rendering._setTrackedDotDisplayRange(null);
assert.equal(tracked.items.get('25544').displayRange, undefined);
assert.equal(rendering._trackedDotDisplayRange(), null);
rendering._setTrackedDotDisplayRange(range);
rendering._removeTrackedEntity();
assert.equal(rendering._trackedDotDisplayRange(), null);
rendering._addTrackedEntity({ position: () => ({ x: 1, y: 2, z: 3 }) });
tick();
assert.equal(tracked.items.get('25544').displayRange, undefined);
rendering._detach(viewer);
} finally {
unbind();
}
});
test('the orbit frame matrix turns ECEF about Z by minus the GMST elapsed', () => {
const rendering = createRendering({
state: {},
+150
View File
@@ -19,6 +19,156 @@ import { SATELLITE_CLASS_DISPLAY, SATELLITE_CLASS_IDS } from './classes.js';
export const ISS_NORAD = 25544;
/**
* Tiangong's catalog entry: CelesTrak lists the core module as "CSS (TIANHE)"
* and the labs as "CSS (WENTIAN)" and "CSS (MENGTIAN)" under entries of their
* own, with the docked Shenzhou and Tianzhou ships beside them.
*/
export const TIANGONG_NORAD = 48274;
/**
* Whether the tracked satellite is a station: the station's own entry, or an
* object docked to it (a module, a cargo ship…), which is the same body under
* a catalog entry of its own. A click on the station's dot lands on any of
* them.
* @param {number} stationNorad The station's entry (ISS_NORAD, TIANGONG_NORAD).
* @param {number|null|undefined} trackedNorad
* @param {{has(noradId: number): boolean}|null|undefined} dockedCompanions
* What shares the tracked satellite's position (`_dockedCompanions`).
* @returns {boolean}
*/
export function stationTrackedOn(stationNorad, trackedNorad, dockedCompanions) {
if (trackedNorad === stationNorad) return true;
return (
trackedNorad !== null &&
trackedNorad !== undefined &&
Boolean(dockedCompanions?.has(stationNorad))
);
}
/** `stationTrackedOn` for the ISS. */
export function issTrackedOnStation(trackedNorad, dockedCompanions) {
return stationTrackedOn(ISS_NORAD, trackedNorad, dockedCompanions);
}
/**
* The ISS drawn as a 3D model up close (issModel.js): NASA's "International
* Space Station (ISS) (D) (IGOAL)" from NASA 3D Resources, the station's
* current configuration (Nauka, Prichal, Bishop, the roll-out solar arrays),
* with NASA's own textures. The shipped file is that model reduced for the
* web and put in one frame, in meters (public/models/README.md says how).
*/
export const ISS_MODEL_URL = '/models/iss.glb';
/** The real station across its main truss, end to end, in meters. */
export const ISS_SPAN_M = 109;
/**
* The asset's span along its truss (glTF X, solar array to solar array) in
* its own units, read from the file's accessors. The file is in meters.
*/
export const ISS_MODEL_NATIVE_SPAN = 109;
/**
* The station's bounding-box centre in the file's coordinates, whose origin is
* NASA's (the middle of the S0 truss). The scene root is translated by minus
* this, so the model's origin is the station's centre. That is what
* minimumPixelSize scales about, so the enlarged far-range model stays
* centred on the orbital position (and on the tracked card's leader).
*/
export const ISS_MODEL_CENTER_NATIVE = Object.freeze([0, -7.38, 0.001]);
/**
* Which flight axis each of the model's local axes (Cesium's, after its glTF
* axis correction: local X = glTF Z, Y = glTF X, Z = glTF Y) points along.
* The file has the U.S. segment at +Z (forward), Kibo at +X (port) and the Z1
* truss at +Y (zenith; the Cupola faces -Y), so: local X → along-track, local
* Y → orbit normal, local Z → zenith.
*/
export const ISS_MODEL_LOCAL_AXES = Object.freeze(['x', 'y', 'z']);
/**
* Within this camera distance the model replaces the dot; farther out the dot
* stays. Covers the tracked view (~726 km back for LEO) with room to spare.
*/
export const ISS_MODEL_MAX_DISTANCE_M = 1_500_000;
/**
* The model is never drawn smaller than this, in pixels. At true size the
* station is under a pixel from the tracked view, so the floor is what makes
* it readable there; within a few kilometres the true size takes over.
*/
export const ISS_MODEL_MIN_PX = 72;
/**
* Objects within this distance of the ISS are docked to it (their element
* sets put them within a few hundred meters); while the model shows, their
* dots give way to it inside its range (issModel.js).
*/
export const ISS_COMPANION_RADIUS_M = 5_000;
/**
* Dots are moved at different moments, so with the clock sped up a docked
* object's dot can trail the ISS's by a long way. Only objects whose dots are
* within this distance are checked orbit against orbit (issModel.js).
*/
export const ISS_COMPANION_COARSE_M = 3_000_000;
/** How often the docked set is rescanned, ms. */
export const ISS_COMPANION_SCAN_MS = 1_000;
/**
* Within this camera distance of the ISS its orbit ring is hidden. The ring is
* drawn as ~230 km chords and turned with the Earth once a second, so up close
* it runs metres to kilometres off the model and jumps; at the tracked view
* (~726 km) and beyond it stays.
*/
export const ISS_ORBIT_HIDE_M = 50_000;
/**
* The tracked card keeps clear of the model: its gap from the anchor is this
* many meters of the station as drawn on screen (about its reach from its
* centre in an oblique view), so up close the card sits beside the station, not on it.
*/
export const ISS_CARD_CLEAR_M = 40;
/**
* Tiangong drawn as a 3D model up close (tiangongModel.js): the project's own
* model of the station's T configuration (Tianhe, Wentian, Mengtian, with a
* Shenzhou forward and nadir and a Tianzhou aft), built from primitives with
* procedural textures, in meters, same frame as the ISS file (glTF +X port,
* +Y zenith, +Z forward), the scene root at the station's bounding-box
* centre (public/models/README.md).
*/
export const TIANGONG_MODEL_URL = '/models/tiangong.glb';
/**
* The tracked card's clearance from Tiangong (ISS_CARD_CLEAR_M for the ISS):
* the station reaches ~29 m from its centre along the lab wings.
*/
export const TIANGONG_CARD_CLEAR_M = 30;
/**
* The stations the layer treats as one body with their docked entries
* (stationModels.js): `key` is the STATION description's and the LIVE
* section's (`station:<key>`); objects within `companionRadiusM` of the
* station, orbit against orbit, are docked to it. Each is also drawn as a 3D
* model up close (issModel.js, tiangongModel.js), but these rules hold
* whether or not a model part exists.
*/
export const STATIONS = Object.freeze([
Object.freeze({
key: 'iss',
norad: ISS_NORAD,
companionRadiusM: ISS_COMPANION_RADIUS_M,
}),
Object.freeze({
key: 'tiangong',
norad: TIANGONG_NORAD,
companionRadiusM: ISS_COMPANION_RADIUS_M,
}),
]);
export const ISS_OVERLAY_SOURCE_ID = 'satellites-iss';
export const ISS_OVERLAY_SOURCE_OPTIONS = Object.freeze({
+60 -1
View File
@@ -54,6 +54,13 @@ const RING_BEHIND_ALPHA = 0.35;
/** An RGBA colour with another alpha. */
const withAlpha = (color, alpha) => [color[0], color[1], color[2], alpha];
/** Whether two display ranges are the same: both none, or the same bounds. */
const sameRange = (a, b) =>
a && b ? a[0] === b[0] && a[1] === b[1] : !a && !b;
/** A display range as the item's own copy, or undefined for none. */
const rangeOf = (range) => (range ? [range[0], range[1]] : undefined);
/** Layer instances so far: set ids unique to each. */
let instances = 0;
@@ -206,7 +213,7 @@ export function createRendering({
function _setOrbitPathShown(noradId, show) {
const path = layerState._orbitPaths.get(noradId);
if (!path) return;
if (!path || path.item.show === show) return;
path.item.show = show;
sets?.rings.upsert([path.item]);
}
@@ -258,6 +265,46 @@ export function createRendering({
if (trackedDot.drawn) sets?.tracked.upsert([trackedDot.item]);
}
/**
* Draw one satellite's dot only at eye distances in `range` (`[near, far)`,
* metres), or at every distance for null, apart from whether it is shown:
* a station's model stands in for its dot, and for the dots of the objects
* docked to it, within the model's range (stationModel.js). A dot added
* again (a catalog rebuild) arrives with no range.
* @param {number} noradId
* @param {readonly [number, number]|null} range
* @returns {boolean} Whether the satellite has a dot.
*/
function _setPointDisplayRange(noradId, range) {
const point = layerState._points.get(noradId);
if (!point) return false;
if (sameRange(point.displayRange, range)) return true;
point.displayRange = rangeOf(range);
_markDirty(noradId);
return true;
}
/** The eye distances a dot is drawn at, or null for every distance. */
function _pointDisplayRange(noradId) {
return layerState._points.get(noradId)?.displayRange ?? null;
}
/**
* The tracked satellite's dot likewise; a dot drawn is redrawn at once. A
* new tracked dot (tracking another satellite) arrives with no range.
* @param {readonly [number, number]|null} range
*/
function _setTrackedDotDisplayRange(range) {
if (!trackedDot || sameRange(trackedDot.item.displayRange, range)) return;
trackedDot.item.displayRange = rangeOf(range);
if (trackedDot.drawn) sets?.tracked.upsert([trackedDot.item]);
}
/** The eye distances the tracked dot is drawn at, or null for every distance. */
function _trackedDotDisplayRange() {
return trackedDot?.item.displayRange ?? null;
}
/** Remove every orbit ring. */
function _clearOrbitPaths() {
const ids = [...layerState._orbitPaths.values()].map(
@@ -666,6 +713,11 @@ export function createRendering({
function _tickAfterFrame() {
const now = focusNowMs(Date.now());
// The stations as 3D models up close. First, before the tracked sample
// below is refreshed: the follow camera and the tracked dot were placed
// this frame from the sample still cached, and a model must sit on it too.
for (const model of parts.stationModels ?? []) model._updateStationModel();
const interval = layerState._trackedNorad ? 200 : POSITION_UPDATE_MS;
// Space Missions keeps this layer enabled for TLE lookup while deliberately
// hiding its standalone fleet. Do not rebuild hidden point buffers on the
@@ -700,6 +752,9 @@ export function createRendering({
if (layerState._cockpitSubjectNorad !== null)
parts.cockpit?._syncCockpitSubjectVisuals();
// NASA's live video beside the card while the ISS is selected.
parts.stationPanel?._syncStationPanel();
_updatePointFocus(now);
// Hidden standalone orbit rings do not need turning while Space Missions
@@ -861,6 +916,10 @@ export function createRendering({
_setPointStyle,
_pointShown,
_setTrackedDotShown,
_setPointDisplayRange,
_pointDisplayRange,
_setTrackedDotDisplayRange,
_trackedDotDisplayRange,
_clearOrbitPaths,
_addPoint,
_movePoint,
+7
View File
@@ -80,6 +80,13 @@ export function createState({ services }) {
// Click-to-track state
state._trackedNorad = null;
/**
* The station the tracked satellite is docked to, by both orbits compared
* when tracking began (tracking.js): its NORAD number, or null.
*/
state._trackedDockedToStation = null;
/** Whether that station is the ISS, whose ring stands for the entry's. */
state._trackedDockedToIss = false;
state._pendingTrackingRestore = null;
+850
View File
@@ -0,0 +1,850 @@
import { eciToGeodetic, gstime, propagate } from 'satellite.js';
import { fromRadians } from '../../geo/ellipsoid.js';
import { headingPitchRollOfAxes } from '../../geo/frames.js';
import { copyInto, distance, vec } from '../../geo/vector.js';
import { canvasOf, drawOf, findCamera } from '../../render/rendererOf.js';
import { stationTrackedOn } from './policy.js';
/**
* A space station as a 3D model when the camera is close, driven by a
* description of the station (`StationModelSpec`): the ISS (issModel.js) and
* Tiangong (tiangongModel.js) are two instances of this one factory. Far out
* the dot stays: the model and the dot (ambient and tracked) split the
* distance range, so exactly one of them draws (the model by the display
* range on its draw item, the dots by the display range the rendering part
* puts on theirs). The model is one item of a `models` set on the
* renderer's draw port, asked for on first need and only if the station is
* shown, and posed every frame from its own SGP4 sample (the dot moves once
* a second, which at model range would show as a jump).
*
* The moving parts (the joint driver, `createArticulation`) write node
* matrices into this part's node poses, as they would into a model's nodes;
* those poses are the draw item's `nodes`, which the renderer applies to the
* model's named glTF nodes.
*
* @typedef {object} StationModelSpec
* @property {string} key Short id ('iss', 'tiangong'): the STATION
* description's key and the LIVE section's `station:<key>` subject key.
* @property {string} label The station's name, for log lines.
* @property {number} norad The catalog entry the model stands at.
* @property {string} modelUrl Asset path, resolved with `resolveAsset`.
* @property {number} scale The file's units to meters.
* @property {number} minPx The model is never drawn smaller than this.
* @property {number} maxDistanceM Within this camera distance the model
* replaces the dot.
* @property {number} orbitHideM Within this camera distance the station's
* orbit ring is hidden.
* @property {number} cardClearM How many meters of the station the tracked
* card keeps clear of.
* @property {number} companionRadiusM Objects within this of the station,
* orbit against orbit, are docked to it.
* @property {number} companionCoarseM Only dots within this are checked.
* @property {number} companionScanMs How often the docked set is rescanned.
* @property {readonly string[]} localAxes Which flight axis each of the
* model's local axes points along (see ISS_MODEL_LOCAL_AXES).
* @property {(noradId: number, entry: object|undefined) => boolean} isModule
* Whether a catalog entry at the station is one of its own modules (the
* ISS's Nauka, Tiangong's labs) rather than a visiting vehicle.
* @property {() => object} createArticulation The joint driver
* (`update(nodes, date, position, axes)`, `reset()`, and what the STATION
* section calls). `nodes` has a model's `ready` and `getNode(name)`, each
* node taking a `matrix`.
* @property {(() => {pose: () => object|null, touch: () => void,
* status: () => object, destroy: () => void})|null} createTelemetry A
* telemetry feed for the joints, or null for computed angles only.
* @property {((input: {key: string|null, centre: {x: number, y: number, z: number},
* axes: {x: number[], y: number[], z: number[]},
* name: (noradId: number|null) => string|null,
* entry: (noradId: number|null) => number|null,
* dockedVehicle: number|null}) => object|null)|null} cockpitMount The
* Cockpit camera's views on the model, or null when the station has none.
* @property {boolean} hideInCockpit Hide the model while the Cockpit rides
* the station: true where its camera would sit inside the hull, false
* where it rides a mount on the model.
* @property {(() => void)|null} syncOrbit Puts the station's ring back to
* its own rules on leaving the close-up; null for the layer's orbit toggle
* (a ring that exists only while the station is tracked).
* @property {number} [unloadAfterMs] How long the model may go undrawn (out
* of range, or hidden) before its draw set is released and its GPU memory
* with it; asked for again on the next approach. Default one minute.
* @property {number} [retryAfterMs] How long after a failed load the model
* is released and asked for again. Default 30 s.
*/
/** Default `unloadAfterMs`: a minute undrawn releases the model. */
export const STATION_MODEL_UNLOAD_AFTER_MS = 60_000;
/**
* A model that failed to load is released after this and asked for again
* on the next frame in range (the renderer retries a load only on an
* update, and a model that is not ready is not sent).
*/
export const STATION_MODEL_RETRY_AFTER_MS = 30_000;
/**
* Whether a station model may be drawn: the dot's own rules (layer on, points
* on, the station loaded and its class shown or the station tracked), and
* not while the Cockpit hides it.
* @param {{enabled: boolean, showPoints: boolean, hasStation: boolean,
* classVisible: boolean, tracked: boolean, cockpitHidden: boolean}} input
* @returns {boolean}
*/
export function stationModelShouldShow({
enabled,
showPoints,
hasStation,
classVisible,
tracked,
cockpitHidden,
}) {
return (
Boolean(enabled) &&
Boolean(showPoints) &&
Boolean(hasStation) &&
(Boolean(classVisible) || Boolean(tracked)) &&
!cockpitHidden
);
}
/**
* A station's flight axes in the Earth-fixed frame, from one SGP4 state: a
* station normally flies "+XVV", its modules along the velocity, the truss or
* labs across the orbit plane, the same side always to the Earth. Returned
* as the model's local axes: x along-track, y the orbit normal, z zenith
* (away from the Earth's centre).
* @param {{x:number,y:number,z:number}} positionEcef Earth-fixed position.
* @param {{x:number,y:number,z:number}} velocityEcefAxes Inertial velocity,
* turned onto the Earth-fixed axes (direction only matters).
* @returns {{x:number[], y:number[], z:number[]}|null} Unit vectors, or null
* for a degenerate state (zero position or velocity along it).
*/
export function stationFlightAxes(positionEcef, velocityEcefAxes) {
const r = [positionEcef.x, positionEcef.y, positionEcef.z];
const v = [velocityEcefAxes.x, velocityEcefAxes.y, velocityEcefAxes.z];
const z = unit(r);
const y = unit(cross(r, v));
if (!z || !y) return null;
const x = cross(y, z);
return { x, y, z };
}
/**
* Turn an inertial (TEME) vector onto the Earth-fixed axes at `gmst`: the same
* rotation `eciToGeodetic` applies to the position.
* @param {{x:number,y:number,z:number}} v
* @param {number} gmst Radians.
* @returns {{x:number,y:number,z:number}}
*/
export function temeToEcefAxes(v, gmst) {
const c = Math.cos(gmst);
const s = Math.sin(gmst);
return { x: c * v.x + s * v.y, y: -s * v.x + c * v.y, z: v.z };
}
/**
* The model's orientation for the renderer, `{heading, pitch, roll}` at
* `position`, from the station's flight axes and which of them each model
* axis points along (`localAxes`).
* @param {{x:number,y:number,z:number}} position Earth-fixed.
* @param {{x:number[], y:number[], z:number[]}} axes Flight axes.
* @param {readonly string[]} localAxes
* @returns {{heading: number, pitch: number, roll: number}}
*/
export function stationModelOrientation(position, axes, localAxes) {
const as = (key) => vec(axes[key][0], axes[key][1], axes[key][2]);
return headingPitchRollOfAxes(position, {
x: as(localAxes[0]),
y: as(localAxes[1]),
z: as(localAxes[2]),
});
}
/**
* Node poses as a joint driver writes them: `getNode(name)` hands a node
* whose `matrix` it sets (a column-major 4×4, copied on write, as a model's
* node copies), and `poses` keeps every matrix written, by node name: the
* draw item's `nodes` (`ModelItem.nodes`), one object for the item's life.
* @returns {{ready: boolean, getNode: (name: string) => {matrix: Float64Array},
* poses: Record<string, Float64Array>, clear: () => void}}
*/
export function createNodePoses() {
/** @type {Record<string, Float64Array>} */
const poses = {};
const nodes = new Map();
return {
ready: true,
poses,
getNode(name) {
let node = nodes.get(name);
if (!node) {
node = {
get matrix() {
return poses[name];
},
set matrix(value) {
// None: the node goes back to its authored pose (its name leaves
// the map), as a model's node does.
if (value === undefined || value === null) {
delete poses[name];
return;
}
const kept = (poses[name] ??= new Float64Array(16));
for (let i = 0; i < 16; i++) kept[i] = value[i];
},
};
nodes.set(name, node);
}
return node;
},
/** Every node back to its authored pose (its name leaves the map). */
clear() {
for (const name of Object.keys(poses)) delete poses[name];
},
};
}
function cross(a, b) {
return [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
}
function unit(a) {
const n = Math.hypot(a[0], a[1], a[2]);
if (!(n > 0)) return null;
return [a[0] / n, a[1] / n, a[2] / n];
}
/**
* One station's model part.
* @param {StationModelSpec} spec
* @param {{state: object, parts: object, resolveAsset?: (url: string) => string}} context
*/
export function createStationModel(
spec,
{ state: layerState, parts, resolveAsset },
) {
const { norad } = spec;
/** The `models` draw set the station is an item of, once asked for. */
let set = null;
let offReady = null;
let offFailed = null;
/** The station's draw item, sent again each frame it is posed. */
const itemId = `station:${spec.key}`;
let item = null;
/** Whether the renderer has the model loaded and posed. */
let ready = false;
let loading = false;
let failed = false;
/** When the renderer said the load failed (wall-clock ms), or null. */
let failedAt = null;
/** Turns the moving parts by where the Sun (and the relays) are. */
const articulation = spec.createArticulation();
/** Where the joint driver writes; kept for a renderer that poses nodes. */
const nodePoses = createNodePoses();
/**
* Telemetry for the same joints, where the station has any: asked for only
* while the model is drawn, and used in place of the computed angles
* whenever it has a pose.
*/
const telemetry = spec.createTelemetry?.() ?? null;
if (telemetry) articulation.setTelemetry?.(() => telemetry.pose());
/** The eye distances the model draws at. */
const nearRange = Object.freeze([0, spec.maxDistanceM]);
/** The eye distances the dots the model stands in for are drawn at. */
const farRange = Object.freeze([spec.maxDistanceM, Number.MAX_VALUE]);
/** Whether the station's own dot is left to the model within its range. */
let dotHanded = false;
/** Whether the tracked dot is, the tracked satellite being the station. */
let trackedDotHanded = false;
/**
* @type {Set<number>} Objects docked to the station, orbit against orbit,
* at the last scan: the same body as the model whether or not it draws.
*/
const dockedByOrbit = new Set();
/** @type {Set<number>} Docked objects whose dots the model stands in for. */
const handedCompanions = new Set();
/** Whether the model draws and the docked dots are left to it. */
let handingOver = false;
/** Wall-clock ms since when the model has not been drawn, or null. */
let undrawnSince = null;
let lastCompanionScanMs = Number.NEGATIVE_INFINITY;
/** Whether the station's orbit ring is hidden for the close-up. */
let orbitHidden = false;
/** The tracked docked object whose ring is hidden for the close-up, or null. */
let companionRingHidden = null;
const scratchPosition = vec();
const scratchMountCentre = vec();
/** The station centre the model last rendered at (for the tracked card). */
const visualPosition = vec();
let visualValid = false;
function _shouldShow() {
const tracked = layerState._trackedNorad === norad;
return stationModelShouldShow({
enabled: layerState._enabled,
showPoints: layerState._params.showPoints,
hasStation: layerState._catalog.has(norad),
classVisible: parts.controls._classVisible(norad),
tracked,
// With no mounts on the model the Cockpit camera would sit inside the
// hull, so the model goes while the Cockpit rides the station.
cockpitHidden:
spec.hideInCockpit &&
Boolean(parts.cockpit?._cockpitHeld?.()) &&
_trackedOnStation(),
});
}
/** The eye, from the camera port, or null without one. */
function _eye() {
return findCamera(layerState._viewer)?.pose?.()?.position ?? null;
}
/**
* Ask the renderer for the model: a `models` set of its own with the
* station as its one item, hidden until posed. On a renderer that draws
* no models the dot keeps drawing at every distance.
* @param {{x:number,y:number,z:number}} at Where the station is now.
*/
function _load(at) {
const draw = drawOf(layerState._viewer);
if (typeof draw?.models !== 'function') {
failed = true;
return;
}
loading = true;
set = draw.models({ id: `satellites:${itemId}`, show: true });
offReady = set.on('ready', (id) => {
if (id !== itemId) return;
ready = true;
loading = false;
failed = false;
});
offFailed = set.on('loadFailed', (id, message) => {
if (id !== itemId) return;
// The dots keep drawing at every distance (the model is never ready);
// after `retryAfterMs` the model is released and asked for again.
failed = true;
failedAt = Date.now();
loading = false;
console.warn(
`[Data:Satellites] ${spec.label} model failed to load:`,
message,
);
});
item = {
id: itemId,
pos: { x: at.x, y: at.y, z: at.z },
url: resolveAsset(spec.modelUrl),
orientation: { heading: 0, pitch: 0, roll: 0 },
scale: spec.scale,
minPixelSize: spec.minPx,
displayRange: nearRange,
// So a click on the model tracks the station, as a click on its dot does.
meta: { norad },
// The joint driver's poses, applied to the model's named nodes.
nodes: nodePoses.poses,
show: false,
};
set.upsert([item]);
}
/** Send the item as it stands. */
function _send() {
if (set && item) set.upsert([item]);
}
/** Hide the model (nothing sent when it is hidden already). */
function _hide() {
if (item && item.show) {
item.show = false;
_send();
}
}
/** An object's inertial position at `date`, km, or null. */
function _temeKm(satrec, date) {
if (!satrec) return null;
try {
const position = propagate(satrec, date)?.position;
return position && typeof position !== 'boolean' ? position : null;
} catch {
return null;
}
}
/**
* Whether the tracked satellite is the station itself: its own entry, or
* an object docked to it (a module, a cargo ship…), which has a catalog
* entry and a dot of its own but is the same body as the model. Read from
* the layer's docked set (dots sharing a position) and from this part's
* own scan (orbit against orbit), which stands whether or not the model
* draws: the answer must not depend on what it decides.
*/
function _trackedOnStation() {
const tracked = layerState._trackedNorad;
return (
stationTrackedOn(norad, tracked, layerState._dockedCompanions) ||
(tracked !== null && dockedByOrbit.has(tracked))
);
}
/**
* Leave the near range to the model: the station's dot, and the tracked
* dot while the tracked satellite is the station, draw only beyond it.
* Asked every frame (the calls cost nothing when nothing changes): a
* catalog rebuild or a change of tracked satellite brings new dots that
* arrive with no range, and a tracked satellite that leaves the station
* (a vehicle undocking) gets its tracked dot back.
*/
function _handOverDots() {
dotHanded = parts.rendering._setPointDisplayRange(norad, farRange);
const trackedHere = _trackedOnStation();
if (trackedHere) parts.rendering._setTrackedDotDisplayRange(farRange);
else if (trackedDotHanded) parts.rendering._setTrackedDotDisplayRange(null);
trackedDotHanded = trackedHere;
}
/** Give the station's dot and the tracked dot back at every distance. */
function _releaseDots() {
if (dotHanded) parts.rendering._setPointDisplayRange(norad, null);
dotHanded = false;
if (trackedDotHanded) parts.rendering._setTrackedDotDisplayRange(null);
trackedDotHanded = false;
}
/**
* Objects docked to the station (a module, a crew or cargo ship) have dots
* of their own at the station's position. Near the model they are part of
* it, and their dots, moved only a few times a second, jump across the
* model at 7.6 km/s. While the model shows, their dots draw only beyond its
* range too. Rescanned once a second: a vehicle that undocks gets its dot
* back, and a catalog rebuild's new dots are picked up.
* @param {number} nowMs
* @param {boolean} handOver Whether the docked dots are left to the model
* (it draws); otherwise the scan only keeps the docked set current.
*/
function _scanCompanions(nowMs, handOver) {
if (nowMs - lastCompanionScanMs < spec.companionScanMs) return;
lastCompanionScanMs = nowMs;
const stationPosition = parts.rendering._pointPosition(norad);
// The dots are placed at different moments (far apart with the clock sped
// up), so their spacing only rules out what is nowhere near. Whether an
// object is docked is read from both orbits at one instant.
const date = new Date(layerState.now());
const stationTeme = _temeKm(layerState._catalog.get(norad)?.satrec, date);
if (!stationPosition || !stationTeme) return;
for (const [noradId, point] of layerState._points) {
if (noradId === norad || !point?.pos) continue;
const entry = layerState._catalog.get(noradId);
if (entry?.group === 'dense') continue;
let docked = false;
if (distance(point.pos, stationPosition) <= spec.companionCoarseM) {
const teme = _temeKm(entry?.satrec, date);
docked =
Boolean(teme) &&
Math.hypot(
teme.x - stationTeme.x,
teme.y - stationTeme.y,
teme.z - stationTeme.z,
) *
1000 <=
spec.companionRadiusM;
}
if (docked) dockedByOrbit.add(noradId);
else dockedByOrbit.delete(noradId);
if (docked && handOver) {
parts.rendering._setPointDisplayRange(noradId, farRange); // no-op when equal
handedCompanions.add(noradId);
} else if (handedCompanions.has(noradId)) {
parts.rendering._setPointDisplayRange(noradId, null);
handedCompanions.delete(noradId);
}
}
for (const noradId of dockedByOrbit)
if (!layerState._points.has(noradId)) dockedByOrbit.delete(noradId);
}
/** Give docked objects their dots back at every distance. */
function _releaseCompanions() {
for (const noradId of handedCompanions)
parts.rendering._setPointDisplayRange(noradId, null);
handedCompanions.clear();
}
/** The station's ring back to its own rules (see `syncOrbit`). */
function _restoreOrbit() {
if (spec.syncOrbit) {
spec.syncOrbit();
return;
}
parts.rendering._setOrbitPathShown(
norad,
parts.controls.satelliteVisualsVisible(
layerState._enabled,
layerState._params.showOrbits,
),
);
}
/**
* Up close the orbit ring (polyline chords, turned once a second) runs off
* the model and jumps across it, so it is hidden there.
* @param {boolean} near Camera within `orbitHideM` of the station.
*/
function _syncOrbitCloseUp(near) {
if (near) {
// Kept hidden every frame: the ring may be built after this.
parts.rendering._setOrbitPathShown(norad, false);
orbitHidden = true;
} else if (orbitHidden) {
orbitHidden = false;
// Back to the ring's own rules, unless the Cockpit holds it hidden.
if (layerState._cockpitHiddenPath !== norad) _restoreOrbit();
}
// A tracked docked object draws a ring of its own through the model.
const tracked = layerState._trackedNorad;
const companion =
near && tracked !== norad && _trackedOnStation() ? tracked : null;
if (companionRingHidden !== null && companionRingHidden !== companion) {
// A tracked satellite's ring shows; untracking has already hidden it.
if (
tracked === companionRingHidden &&
layerState._cockpitHiddenPath !== companionRingHidden
)
parts.rendering._setOrbitPathShown(companionRingHidden, true);
companionRingHidden = null;
}
if (companion !== null) {
parts.rendering._setOrbitPathShown(companion, false);
companionRingHidden = companion;
}
}
/**
* Where the station is this frame, and how it is turned: its centre and
* its flight axes.
*
* The follow camera and the Cockpit camera sit on the tracked satellite's
* per-frame sample. While the tracked satellite is the station (its own
* entry, or an object docked to it, which has a sample of its own) the
* model sits on that same sample, or it would be drawn a frame of orbital
* motion (over 100 m) away from where the camera looks. Otherwise it is
* placed from the station's own orbit now.
* @param {{x:number,y:number,z:number}} result Receives the centre.
* @returns {{date: Date, axes: {x:number[], y:number[], z:number[]}}|null}
* Null when the orbit cannot be propagated.
*/
function _stationFrame(result) {
const sat = layerState._catalog.get(norad);
if (!sat) return null;
const trackedSample =
_trackedOnStation() && Number.isFinite(layerState._trackedFrameGeo?.atMs)
? layerState._trackedFrameGeo
: null;
const date = new Date(
trackedSample ? trackedSample.atMs : layerState.now(),
);
let posVel;
try {
posVel = propagate(sat.satrec, date);
} catch {
posVel = null;
}
if (
!posVel?.position ||
typeof posVel.position === 'boolean' ||
!posVel.velocity ||
typeof posVel.velocity === 'boolean'
)
return null;
const gmst = gstime(date);
if (trackedSample) {
// The sample the camera and the tracked dot were placed from.
copyInto(layerState._trackedFrameCartesian, result);
} else {
const geo = eciToGeodetic(posVel.position, gmst);
copyInto(
fromRadians(geo.longitude, geo.latitude, geo.height * 1000),
result,
);
}
const axes = stationFlightAxes(
result,
temeToEcefAxes(posVel.velocity, gmst),
);
return axes ? { date, axes } : null;
}
/**
* The Cockpit camera's place on the station: one of the views on the
* model, in the world, worked out from the same sample the model is about
* to be placed on, so the camera stays on the model however fast the orbit
* moves it. The spec's `cockpitMount` chooses the view; null for a station
* without views.
* @param {string|null} [key] The view asked for; the first on offer when
* it is not given or not on offer.
* @returns {object|null} Null unless the tracked satellite is the station
* and the model is loaded and may show.
*/
function _cockpitMount(key = null) {
if (!spec.cockpitMount) return null;
if (!ready || !_trackedOnStation() || !_shouldShow()) return null;
const frame = _stationFrame(scratchMountCentre);
if (!frame) return null;
return spec.cockpitMount({
key,
centre: scratchMountCentre,
axes: frame.axes,
name: (noradId) => layerState._catalog.get(noradId)?.name ?? null,
// An entry is offered to ride only when it has a dot to track.
entry: (noradId) =>
noradId !== null && layerState._points.has(noradId) ? noradId : null,
dockedVehicle: _dockedVehicle(),
});
}
/**
* A vehicle docked to the station (a Progress, a Shenzhou, a Dragon): the
* tracked one when that is what is tracked, else the lowest catalog number
* among those docked. The station's own modules have entries too (Zarya,
* Nauka; Tianhe, Wentian): they are the station, not a vehicle. Null when
* no vehicle is docked.
* @returns {number|null}
*/
function _dockedVehicle() {
const vehicle = (noradId) =>
noradId !== norad &&
!spec.isModule(noradId, layerState._catalog.get(noradId));
const tracked = layerState._trackedNorad;
if (tracked !== null && vehicle(tracked)) return tracked;
let lowest = null;
for (const group of [dockedByOrbit, layerState._dockedCompanions ?? []])
for (const noradId of group)
if (vehicle(noradId) && (lowest === null || noradId < lowest))
lowest = noradId;
return lowest;
}
/**
* Per-frame update from the layer's preRender tick.
* @returns {void}
*/
function _updateStationModel() {
visualValid = false;
// The docked set first: whether the model may show (the Cockpit riding
// the station) is read from it, so it is kept current before that. Once
// a second; the dots are handed over or given back with the scan.
if (item) _scanCompanions(Date.now(), handingOver);
const show = _shouldShow();
if (!show) {
_hide();
// The dots draw at every distance while the model may not.
_releaseDots();
if (handedCompanions.size) _releaseCompanions();
handingOver = false;
_syncOrbitCloseUp(false);
// Off, the layer gives the model's memory back at once; hidden, after
// a while.
if (!layerState._enabled) _unload();
else _undrawn();
return;
}
const dotPosition = parts.rendering._pointPosition(norad);
const eye = _eye();
const cameraDistance =
dotPosition && eye
? distance(eye, dotPosition)
: Number.POSITIVE_INFINITY;
if (!item) {
// The file is fetched only once the camera nears the model's range, so
// a globe-wide view of the layer never downloads it.
if (
!loading &&
!failed &&
dotPosition &&
cameraDistance <= spec.maxDistanceM * 1.5
)
_load(dotPosition);
return;
}
// Until the renderer has the model loaded and posed, the dots stand at
// every distance: the station never goes dark while the file loads, nor
// for good when it fails to.
if (!ready) {
_hide();
_releaseDots();
if (handedCompanions.size) _releaseCompanions();
handingOver = false;
_syncOrbitCloseUp(false);
if (
failedAt !== null &&
Date.now() - failedAt >=
(spec.retryAfterMs ?? STATION_MODEL_RETRY_AFTER_MS)
)
_unload(); // asked for again on the next frame in range
else if (cameraDistance > spec.maxDistanceM * 1.5) _undrawn();
else undrawnSince = null;
return;
}
// The docked dots are the model's within its range: handed over at
// once when the model starts drawing, then with each scan.
if (!handingOver) {
handingOver = true;
lastCompanionScanMs = Number.NEGATIVE_INFINITY;
_scanCompanions(Date.now(), true);
}
_handOverDots();
_syncOrbitCloseUp(cameraDistance < spec.orbitHideM);
// Out of range the model would not draw anyway: skip the SGP4 sample.
if (cameraDistance > spec.maxDistanceM * 1.5) {
_hide();
_undrawn();
return;
}
undrawnSince = null;
const frame = _stationFrame(scratchPosition);
if (!frame) {
// Nowhere to draw the model (the orbit would not propagate): the dots
// draw at every distance rather than nothing at all.
_hide();
_releaseDots();
return;
}
const { date, axes } = frame;
copyInto(scratchPosition, visualPosition);
copyInto(scratchPosition, item.pos);
item.orientation = stationModelOrientation(
scratchPosition,
axes,
spec.localAxes,
);
telemetry?.touch();
articulation.update(nodePoses, date, scratchPosition, axes);
item.show = true;
_send();
visualValid = ready;
}
/**
* Where the tracked card should anchor: the station centre the model is
* rendering at this frame, or null while the model is not drawn (the card
* then keeps the dot's position). Up close the dot's cache can be a frame
* ahead of the rendered model, ~130 m of orbit, which shook the card.
* @returns {{x:number,y:number,z:number}|null}
*/
function _visualPosition() {
if (!visualValid || !item?.show) return null;
const eye = _eye();
if (eye && distance(eye, visualPosition) > spec.maxDistanceM) return null;
return visualPosition;
}
/**
* How far the tracked card must stay from its anchor to clear the model, in
* pixels, or null while the dot shows.
*/
function _cardClearPx() {
const position = _visualPosition();
const pose = findCamera(layerState._viewer)?.pose?.() ?? null;
const height = canvasOf(layerState._viewer)?.clientHeight;
const fovy = pose?.fovy;
if (!position || !height || !fovy) return null;
const cameraDistance = distance(pose.position, position);
if (!(cameraDistance > 0)) return null;
const pixelsPerMeter = height / (2 * Math.tan(fovy / 2)) / cameraDistance;
return Math.min(
height * 0.45,
Math.max(spec.minPx * 0.35, spec.cardClearM * pixelsPerMeter),
);
}
/**
* The model has not been drawn this frame: once that has lasted
* `unloadAfterMs`, release it.
*/
function _undrawn() {
if (!item) return;
const nowMs = Date.now();
undrawnSince ??= nowMs;
if (
nowMs - undrawnSince >=
(spec.unloadAfterMs ?? STATION_MODEL_UNLOAD_AFTER_MS)
)
_unload();
}
/**
* Release the model's draw set, and the renderer's model and GPU memory
* with it; the dots stand at every distance. The next approach loads it
* again (a failed load is tried again then too).
*/
function _unload() {
_releaseDots();
_releaseCompanions();
handingOver = false;
loading = false;
failed = false;
failedAt = null;
ready = false;
visualValid = false;
undrawnSince = null;
offReady?.();
offFailed?.();
offReady = null;
offFailed = null;
set?.dispose();
set = null;
item = null;
}
function _destroyStationModel() {
_unload();
articulation.reset();
nodePoses.clear();
telemetry?.destroy();
dockedByOrbit.clear();
lastCompanionScanMs = Number.NEGATIVE_INFINITY;
_syncOrbitCloseUp(false);
}
/** Whether the model is standing in for this docked object's dot. */
function _standsInFor(noradId) {
return handedCompanions.has(noradId) && _visualPosition() !== null;
}
/**
* The station's NORAD number when a draw hit landed on its model, so a
* click on the model tracks the station as a click on its dot does; null
* for any other hit.
* @param {{set?: string, id?: string}|null|undefined} hit The click's
* `drawHit`.
* @returns {number|null}
*/
function _hitNorad(hit) {
return set && hit?.set === set.id && hit.id === itemId ? norad : null;
}
return {
key: spec.key,
norad,
spec,
_updateStationModel,
_destroyStationModel,
_visualPosition,
_cardClearPx,
_standsInFor,
_hitNorad,
_cockpitMount,
_trackedOnStation,
/** Where the joints' angles come from, or null for a station without telemetry. */
_telemetryStatus: () => telemetry?.status() ?? null,
/** The joint driver, for the STATION section. */
_articulation: articulation,
/** The node matrices the joint driver last wrote, by node name (the item's `nodes`). */
_nodePoses: nodePoses.poses,
};
}
+481
View File
@@ -0,0 +1,481 @@
// src/layers/satellites/stationModel.test.mjs — a station's model over the
// rendering part's draw items: it loads once the camera nears its range,
// stands in for the station's dot, the docked companions' dots and the
// tracked dot within that range (a display range on the dots, the model's
// own display condition the other side of it), hides the ring up close, and
// gives everything back when it may not show or is destroyed.
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { eciToGeodetic, gstime, propagate, twoline2satrec } from 'satellite.js';
import { createOrbits } from './orbits.js';
import { createRendering } from './rendering.js';
import { createStationModel } from './stationModel.js';
import {
ISS_MODEL_LOCAL_AXES,
POINT_STYLES,
TRACKED_ORBIT_COLOR,
} from './policy.js';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs';
const STATION = 25544;
const COMPANION = 49044;
const STRANGER = 32711;
const ISS = twoline2satrec(
'1 25544U 98067A 08264.51782528 -.00002182 00000-0 -11606-4 0 2927',
'2 25544 51.6416 247.4627 0006703 130.5360 325.0288 15.72125391563537',
);
const AT_MS = Date.UTC(2008, 8, 20, 12, 30, 0);
const MAX_M = 1_000_000;
/** The dots the model stands in for draw only beyond the model's range. */
const FAR_RANGE = [MAX_M, Number.MAX_VALUE];
/** A satellite's ECEF position at `atMs`, as a plain `{x, y, z}`. */
function ecef(satrec, atMs) {
const date = new Date(atMs);
const geo = eciToGeodetic(propagate(satrec, date).position, gstime(date));
const c = Cesium.Cartesian3.fromRadians(
geo.longitude,
geo.latitude,
geo.height * 1000,
);
return { x: c.x, y: c.y, z: c.z };
}
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
const MODEL_SET = 'satellites:station:test';
const MODEL_ITEM = 'station:test';
/**
* A station model over the real rendering part, a fake draw port (the
* model is an item of a `models` set on it) and a fake camera port. The
* station and a companion share an orbit (docked); a stranger's dot sits
* 500 km off.
*/
function fixture(t) {
const stationPos = ecef(ISS, AT_MS);
const strangerPos = { ...stationPos, x: stationPos.x + 500_000 };
const camera = fakeCameraPort({
pose: { position: { ...stationPos }, fovy: Math.PI / 3 },
});
const viewer = { canvas: { clientHeight: 1000 } };
const { draw, unbind } = bindFakeDraw(viewer, { camera: camera.port });
const state = {
now: () => AT_MS,
_enabled: true,
_params: { showPoints: true, showOrbits: true },
_points: new Map(),
_orbitPaths: new Map(),
_catalog: new Map([
[STATION, { satrec: ISS, group: 'core', name: 'ISS (ZARYA)' }],
[COMPANION, { satrec: ISS, group: 'core', name: 'ISS (NAUKA)' }],
]),
_viewer: viewer,
_trackedNorad: null,
_trackedFrameGeo: null,
_trackedFrameNumber: -1,
_dockedCompanions: new Set(),
_cockpitHiddenPath: null,
_cockpitSubjectNorad: null,
_lastPropagation: -Infinity,
_lastReckonMs: AT_MS,
_lastRingRotation: -Infinity,
_lastFocusUpdate: -Infinity,
_activeFocusCount: 0,
};
const parts = {
orbits: createOrbits({ state: {}, services: {}, parts: {} }),
tracking: { _getTrackedFramePosition: () => null },
catalog: { _propagateDenseChunk() {} },
controls: {
_classVisible: () => true,
satelliteVisualsVisible: (enabled, requested) =>
Boolean(enabled) && Boolean(requested),
},
};
parts.rendering = createRendering({
state,
services: {
focus: {
focusNowMs: (ms) => ms,
getFocusTarget: () => null,
focusPassIsNeeded: () => false,
},
},
parts,
});
const updates = [];
const spec = {
key: 'test',
label: 'TEST',
norad: STATION,
modelUrl: '/models/test.glb',
scale: 2,
minPx: 64,
maxDistanceM: MAX_M,
orbitHideM: 50_000,
cardClearM: 60,
companionRadiusM: 5_000,
companionCoarseM: 200_000,
companionScanMs: 0,
localAxes: ISS_MODEL_LOCAL_AXES,
isModule: () => true,
createArticulation: () => ({
update: (...args) => updates.push(args),
reset() {},
}),
createTelemetry: null,
cockpitMount: null,
hideInCockpit: true,
syncOrbit: null,
};
const model = createStationModel(spec, {
state,
parts,
resolveAsset: (url) => `/assets${url}`,
});
parts.stationModels = [model];
parts.rendering._attach(viewer);
parts.rendering._addPoint(STATION, stationPos, POINT_STYLES.iss);
parts.rendering._addPoint(COMPANION, stationPos, POINT_STYLES.iss);
parts.rendering._addPoint(STRANGER, strangerPos, POINT_STYLES.iss);
const points = [...draw.sets.keys()].find((id) => id.endsWith(':points'));
const set = (suffix) => draw.set(points.replace(':points', suffix));
let frame = 0;
t.after(() => unbind());
const f = {
state,
parts,
model,
updates,
stationPos,
strangerPos,
/** The model's draw set, while it is live. */
modelSet: () => draw.set(MODEL_SET),
/** The model's draw item, once asked for. */
modelItem: () => draw.set(MODEL_SET)?.items.get(MODEL_ITEM),
cameraAt(metres) {
camera.setPose({
position: { ...stationPos, x: stationPos.x + metres },
});
},
tick() {
parts.rendering._preRenderTick({ frame: ++frame });
},
/** Bring the camera into loading range and let the renderer load it. */
async load() {
f.cameraAt(MAX_M * 1.4);
f.tick();
draw.ready(MODEL_SET, MODEL_ITEM);
await settle();
},
/** The renderer reports the model loaded, or failed to. */
readyModel: () => draw.ready(MODEL_SET, MODEL_ITEM),
failModel: () => draw.loadFailed(MODEL_SET, MODEL_ITEM),
/** Track `noradId`, placing the tracked sample on the station. */
track(noradId, at) {
state._trackedNorad = noradId;
state._trackedFrameGeo = { atMs: AT_MS };
Object.assign(state._trackedFrameCartesian, at);
parts.rendering._removeTrackedEntity();
parts.rendering._addTrackedEntity({ position: () => at });
},
drawn: (id) => set(':points').items.get(String(id)),
trackedDot: () => set(':tracked').items.get(String(state._trackedNorad)),
ring: (id) => set(':rings').items.get(String(id)),
};
return f;
}
test('the model loads once the camera nears its range, measured from the dot as drawn', async (t) => {
const f = fixture(t);
f.cameraAt(MAX_M * 5);
f.tick();
assert.equal(f.modelSet(), undefined, 'a globe-wide view never asks for it');
f.cameraAt(MAX_M * 1.4);
f.tick();
const item = f.modelItem();
assert.ok(item, 'one item of a models set of its own');
assert.equal(item.url, '/assets/models/test.glb');
assert.deepEqual(
item.meta,
{ norad: STATION },
'a click on the model tracks the station',
);
assert.equal(item.scale, 2);
assert.equal(item.minPixelSize, 64);
assert.deepEqual(item.displayRange, [0, MAX_M], 'drawn within its range');
assert.equal(item.show, false, 'hidden until posed');
const writes = f.modelSet().writes;
f.cameraAt(MAX_M * 5);
f.tick();
assert.equal(f.modelSet().writes, writes, 'out of range nothing is sent');
assert.equal(f.model._hitNorad({ set: MODEL_SET, id: MODEL_ITEM }), STATION);
assert.equal(f.model._hitNorad({ set: 'other', id: MODEL_ITEM }), null);
assert.equal(f.model._hitNorad(null), null);
assert.equal(
f.model._visualPosition(),
null,
'the card keeps the dot until the renderer has the model',
);
});
test('posed, the model sits on the station with its flight axes as heading, pitch and roll', async (t) => {
const f = fixture(t);
await f.load();
f.cameraAt(20_000);
f.tick();
const item = f.modelItem();
assert.equal(item.show, true);
assert.ok(Math.abs(item.pos.x - f.stationPos.x) < 1, 'on the station');
// The renderer places a model by heading, pitch and roll at its position
// (Cesium's headingPitchRollToFixedFrame): the frame that gives must have
// the model's local axes where ISS_MODEL_LOCAL_AXES says, zenith away from
// the Earth and along-track horizontal.
const { heading, pitch, roll } = item.orientation;
const at = new Cesium.Cartesian3(item.pos.x, item.pos.y, item.pos.z);
const m = Cesium.Transforms.headingPitchRollToFixedFrame(
at,
new Cesium.HeadingPitchRoll(heading, pitch, roll),
);
const column = (c) => [m[c * 4], m[c * 4 + 1], m[c * 4 + 2]];
const up = Cesium.Cartesian3.normalize(at, new Cesium.Cartesian3());
const along = (v) => v[0] * up.x + v[1] * up.y + v[2] * up.z;
const zenith = column(ISS_MODEL_LOCAL_AXES.indexOf('z'));
assert.ok(
Math.abs(along(zenith) - 1) < 1e-6,
'the zenith axis points away from the Earth',
);
const track = column(ISS_MODEL_LOCAL_AXES.indexOf('x'));
assert.ok(Math.abs(along(track)) < 1e-6, 'the along-track axis is level');
assert.equal(f.updates.length, 1, 'the joints are driven');
const nodes = f.updates[0][0];
assert.equal(nodes.ready, true, 'into node poses');
// What the driver writes to a node is the item's `nodes`, by name, as a
// column-major matrix the renderer applies to the model's glTF node.
const turned = new Float64Array(16);
turned[0] = turned[5] = turned[10] = turned[15] = 1;
turned[14] = 2.5;
nodes.getNode('SOLAR_JOINT').matrix = turned;
f.tick();
assert.equal(item.nodes, f.model._nodePoses, 'one object for the item');
assert.deepEqual(Array.from(item.nodes.SOLAR_JOINT), Array.from(turned));
f.model._destroyStationModel();
assert.equal(
Object.keys(f.model._nodePoses).length,
0,
'destroyed, every node goes back to its authored pose',
);
});
test('a station without views on its model hides it while the Cockpit rides the station, its own entry or a docked one', async (t) => {
const f = fixture(t);
let held = false;
f.parts.cockpit = { _cockpitHeld: () => held };
await f.load();
f.cameraAt(20);
// Riding a docked object (the companion shares the orbit).
f.track(COMPANION, f.stationPos);
f.tick();
assert.equal(f.modelItem().show, true, 'outside the Cockpit it draws');
held = true;
// Frame after frame: hiding the model gives the docked dots back, and
// that must not make the layer forget the companion is docked (which
// showed the model again, and so on, every other frame).
for (let i = 0; i < 4; i++) {
f.tick();
assert.equal(
f.modelItem().show,
false,
`the Cockpit camera would sit inside the hull (tick ${i})`,
);
assert.equal(f.model._trackedOnStation(), true, `docked (tick ${i})`);
}
assert.equal(f.model._visualPosition(), null);
// Riding the station itself.
held = false;
f.track(STATION, f.stationPos);
f.tick();
assert.equal(f.modelItem().show, true);
held = true;
f.tick();
assert.equal(f.modelItem().show, false);
// A station that mounts the Cockpit camera on its model keeps drawing.
f.model.spec.hideInCockpit = false;
f.tick();
assert.equal(f.modelItem().show, true);
});
test('until the renderer has the model the dots stand at every distance, and stay so when it fails to load', async (t) => {
const f = fixture(t);
f.parts.rendering._showOrbitPath(STATION, TRACKED_ORBIT_COLOR);
f.track(COMPANION, f.stationPos);
f.cameraAt(MAX_M * 1.4);
f.tick(); // asks for the model
f.cameraAt(20_000);
f.tick();
f.tick();
// Loading: nothing is handed over, so the station never goes dark.
assert.equal(f.modelItem().show, false);
assert.equal(f.drawn(STATION).displayRange, undefined);
assert.equal(f.drawn(COMPANION).displayRange, undefined);
assert.equal(f.trackedDot().displayRange, undefined);
assert.equal(
f.ring(STATION).show,
true,
'the ring is not hidden for a model not drawn',
);
assert.equal(f.model._visualPosition(), null, 'the card keeps the dot');
assert.equal(f.model._cockpitMount(), null);
// The load fails: the dots stay at every distance, frame after frame.
f.failModel();
for (let i = 0; i < 3; i++) f.tick();
assert.equal(f.modelItem().show, false);
assert.equal(f.drawn(STATION).displayRange, undefined);
assert.equal(f.drawn(COMPANION).displayRange, undefined);
assert.equal(f.trackedDot().displayRange, undefined);
// After the retry delay the model is released, and the next frame asks
// for it again: one transient failure does not cost the session.
f.model.spec.retryAfterMs = 0;
f.tick();
assert.equal(f.modelSet(), undefined, 'released after a failure');
f.tick();
assert.ok(f.modelItem(), 'asked for again');
// That load finishes: the dots are handed over.
f.readyModel();
f.tick();
assert.equal(f.modelItem().show, true);
assert.deepEqual(f.drawn(STATION).displayRange, FAR_RANGE);
assert.deepEqual(f.trackedDot().displayRange, FAR_RANGE);
});
test('a model still loading counts as undrawn out of range and is released', (t) => {
const f = fixture(t);
f.cameraAt(MAX_M * 1.4);
f.tick(); // asks for the model, which never answers
f.cameraAt(MAX_M * 5);
f.tick();
assert.ok(f.modelSet(), 'kept for a while');
f.model.spec.unloadAfterMs = 0;
f.tick();
assert.equal(f.modelSet(), undefined);
});
test('turning the layer off, or a while undrawn, releases the model; the next approach asks for it again', async (t) => {
const f = fixture(t);
await f.load();
f.cameraAt(20_000);
f.tick();
assert.equal(f.modelItem().show, true);
// Out of range, within the grace: kept.
f.cameraAt(MAX_M * 5);
f.tick();
assert.ok(f.modelSet(), 'kept for a while');
// Past it: released, and the dots stand everywhere.
f.model.spec.unloadAfterMs = 0;
f.tick();
assert.equal(f.modelSet(), undefined, 'its set is disposed');
assert.equal(f.drawn(STATION).displayRange, undefined);
// The next approach asks for it again.
f.cameraAt(MAX_M * 1.4);
f.tick();
assert.ok(f.modelItem(), 'asked for again');
f.readyModel();
f.cameraAt(20_000);
f.tick();
assert.equal(f.modelItem().show, true);
// Turning the layer off releases it at once.
f.model.spec.unloadAfterMs = 60_000;
// (The layer's disable asks the model once, as here: no frame runs then.)
f.state._enabled = false;
f.model._updateStationModel();
assert.equal(f.modelSet(), undefined);
assert.equal(f.drawn(STATION).displayRange, undefined);
});
test('within its range the model stands in for the dots and hides the ring; beyond it the dots draw', async (t) => {
const f = fixture(t);
await f.load();
f.parts.rendering._showOrbitPath(STATION, TRACKED_ORBIT_COLOR);
f.cameraAt(20_000);
f.tick();
assert.equal(f.modelItem().show, true);
assert.equal(f.updates.length, 1, 'the joints are driven');
assert.deepEqual(f.drawn(STATION).displayRange, FAR_RANGE);
assert.deepEqual(
f.drawn(COMPANION).displayRange,
FAR_RANGE,
'docked, by orbit against orbit',
);
assert.equal(f.drawn(STRANGER).displayRange, undefined, 'not docked');
assert.equal(
f.drawn(STATION).show,
true,
'the range alone splits the distances',
);
assert.equal(f.model._standsInFor(COMPANION), true);
assert.equal(f.model._standsInFor(STRANGER), false);
assert.equal(
f.ring(STATION).show,
false,
'the ring runs off the model up close',
);
assert.ok(f.model._visualPosition(), 'the card anchors on the model');
assert.ok(f.model._cardClearPx() > 0);
// The tracked dot too, while the tracked satellite is the station (here
// an object docked to it)…
f.track(COMPANION, f.stationPos);
f.tick();
assert.deepEqual(f.trackedDot().displayRange, FAR_RANGE);
// …and not once another satellite is tracked.
f.track(STRANGER, f.strangerPos);
f.tick();
assert.equal(f.trackedDot().displayRange, undefined);
// Beyond its range the model is not drawn and the dots are, by their range.
f.cameraAt(MAX_M * 2.5);
f.tick();
assert.equal(f.modelItem().show, false);
assert.equal(f.model._visualPosition(), null);
assert.deepEqual(f.drawn(STATION).displayRange, FAR_RANGE);
assert.equal(f.ring(STATION).show, true, "back to the layer's orbit toggle");
});
test('the dots and the ring come back when the model may not show, and on destroy', async (t) => {
const f = fixture(t);
await f.load();
f.parts.rendering._showOrbitPath(STATION, TRACKED_ORBIT_COLOR);
f.track(COMPANION, f.stationPos);
f.cameraAt(20_000);
f.tick();
assert.deepEqual(f.drawn(STATION).displayRange, FAR_RANGE);
assert.deepEqual(f.trackedDot().displayRange, FAR_RANGE);
assert.equal(f.ring(STATION).show, false);
// Points off: the model may not show, so every dot draws at any distance.
f.state._params.showPoints = false;
f.tick();
assert.equal(f.modelItem().show, false);
assert.equal(f.drawn(STATION).displayRange, undefined);
assert.equal(f.drawn(COMPANION).displayRange, undefined);
assert.equal(f.trackedDot().displayRange, undefined);
assert.equal(f.model._standsInFor(COMPANION), false);
assert.equal(f.ring(STATION).show, true);
// Points on again: handed over again.
f.state._params.showPoints = true;
f.tick();
assert.equal(f.modelItem().show, true);
assert.deepEqual(f.drawn(STATION).displayRange, FAR_RANGE);
assert.deepEqual(f.drawn(COMPANION).displayRange, FAR_RANGE);
assert.deepEqual(f.trackedDot().displayRange, FAR_RANGE);
assert.equal(f.ring(STATION).show, false);
// Destroyed: the model leaves the scene and the dots are given back.
f.model._destroyStationModel();
f.parts.rendering._flushPoints();
assert.equal(f.modelSet(), undefined, 'its set is disposed');
assert.equal(f.drawn(STATION).displayRange, undefined);
assert.equal(f.drawn(COMPANION).displayRange, undefined);
assert.equal(f.trackedDot().displayRange, undefined);
assert.equal(f.ring(STATION).show, true);
assert.equal(f.model._visualPosition(), null);
});
+92
View File
@@ -0,0 +1,92 @@
import { STATIONS, stationTrackedOn } from './policy.js';
/**
* Which station a catalog entry belongs to. The layer knows more than one
* station (STATIONS in policy.js: the ISS, Tiangong), each drawn as a model
* part (stationModel.js) at its own catalog entry and standing in for the
* entries docked to it; the parts that key behaviour to "the station" (card
* anchor and clearance, detection marks, the LIVE and STATION sections, the
* Cockpit's mounts) ask here instead of naming the ISS. The model parts are
* read from `parts.stationModels` each time, so a layer built without them
* (tests, a part replaced) still answers.
*/
/**
* The model whose station `noradId` is drawn as: the station's own entry,
* or a docked object whose dot the model stands in for right now.
* @param {Array<{norad: number, _standsInFor?: (noradId: number) => boolean}>} models
* @param {number|null|undefined} noradId
* @returns {object|null}
*/
export function stationModelFor(models, noradId) {
if (noradId === null || noradId === undefined) return null;
for (const model of models)
if (model.norad === noradId || model._standsInFor?.(noradId)) return model;
return null;
}
/**
* The station that is selected: the tracked satellite is the station
* itself, or an object docked to it, judged by the dots sharing a position
* (`dockedCompanions`), by both orbits compared when tracking began
* (`trackedDockedToStation`, the station's NORAD or null), or by the
* station's model standing in for its dot.
* @param {ReadonlyArray<{key: string, norad: number}>} stations
* @param {Array<{norad: number, _standsInFor?: (noradId: number) => boolean}>} models
* @param {{trackedNorad: number|null, dockedCompanions?: {has(id: number): boolean}|null,
* trackedDockedToStation?: number|null}} selection
* @returns {{key: string, norad: number, model: object|null}|null} The
* station and its model part (null when none is built).
*/
export function trackedStationOf(
stations,
models,
{ trackedNorad, dockedCompanions, trackedDockedToStation },
) {
if (trackedNorad === null || trackedNorad === undefined) return null;
for (const station of stations) {
const model = models.find((m) => m.norad === station.norad) ?? null;
if (
stationTrackedOn(station.norad, trackedNorad, dockedCompanions) ||
trackedDockedToStation === station.norad ||
Boolean(model?._standsInFor?.(trackedNorad))
)
return { ...station, model };
}
return null;
}
/** The layer's station model parts, as built (index.js). */
export function stationModels(parts) {
return parts.stationModels ?? [];
}
/** See stationModelFor, over the layer's model parts. */
export function modelFor(parts, noradId) {
return stationModelFor(stationModels(parts), noradId);
}
/** See trackedStationOf, over the layer's stations, model parts and state. */
export function trackedStation(layerState, parts) {
return trackedStationOf(STATIONS, stationModels(parts), {
trackedNorad: layerState._trackedNorad,
dockedCompanions: layerState._dockedCompanions,
trackedDockedToStation: layerState._trackedDockedToStation ?? null,
});
}
/**
* The station whose model a click's draw hit landed on, over the layer's
* model parts: its NORAD number, or null for any other hit.
* @param {object} parts
* @param {{set?: string, id?: string}|null|undefined} hit
* @returns {number|null}
*/
export function modelHitNorad(parts, hit) {
if (!hit) return null;
for (const model of stationModels(parts)) {
const norad = model._hitNorad?.(hit) ?? null;
if (norad !== null) return norad;
}
return null;
}
@@ -0,0 +1,91 @@
// src/layers/satellites/stationModels.test.mjs — which station a catalog
// entry belongs to, over stand-in model parts.
import test from 'node:test';
import assert from 'node:assert/strict';
import { ISS_NORAD, STATIONS, TIANGONG_NORAD } from './policy.js';
import {
modelFor,
stationModelFor,
trackedStation,
trackedStationOf,
} from './stationModels.js';
const NAUKA = 49044;
const SHENZHOU = 60000;
const GPS = 32711;
const part = (norad, standsIn = []) => ({
norad,
_standsInFor: (id) => standsIn.includes(id),
});
test('the layer knows the ISS and Tiangong, each with a LIVE key', () => {
assert.deepEqual(
STATIONS.map((s) => [s.key, s.norad]),
[
['iss', ISS_NORAD],
['tiangong', TIANGONG_NORAD],
],
);
for (const station of STATIONS) assert.ok(station.companionRadiusM > 0);
});
test('an entry is drawn by the model at its own number, or one standing in for it', () => {
const iss = part(ISS_NORAD, [NAUKA]);
const tiangong = part(TIANGONG_NORAD, [SHENZHOU]);
const models = [iss, tiangong];
assert.equal(stationModelFor(models, ISS_NORAD), iss);
assert.equal(stationModelFor(models, NAUKA), iss);
assert.equal(stationModelFor(models, TIANGONG_NORAD), tiangong);
assert.equal(stationModelFor(models, SHENZHOU), tiangong);
assert.equal(stationModelFor(models, GPS), null);
assert.equal(stationModelFor(models, null), null);
assert.equal(stationModelFor([], ISS_NORAD), null);
});
test('the selected station: itself, a docked companion by position, by orbit, or by stand-in', () => {
const models = [part(ISS_NORAD), part(TIANGONG_NORAD, [SHENZHOU])];
const select = (selection) => trackedStationOf(STATIONS, models, selection);
assert.equal(select({ trackedNorad: null }), null);
assert.equal(select({ trackedNorad: GPS }), null);
assert.equal(select({ trackedNorad: ISS_NORAD })?.key, 'iss');
assert.equal(select({ trackedNorad: TIANGONG_NORAD })?.key, 'tiangong');
// Nauka's dot shares the ISS's position.
assert.equal(
select({ trackedNorad: NAUKA, dockedCompanions: new Set([ISS_NORAD]) })
?.key,
'iss',
);
// A Tianzhou judged docked by orbit when tracking began.
assert.equal(
select({ trackedNorad: 60001, trackedDockedToStation: TIANGONG_NORAD })
?.key,
'tiangong',
);
// A Shenzhou whose dot the Tiangong model stands in for.
assert.equal(select({ trackedNorad: SHENZHOU })?.key, 'tiangong');
// The answer carries the station's model part, or null without one.
assert.equal(select({ trackedNorad: ISS_NORAD })?.model, models[0]);
assert.equal(
trackedStationOf(STATIONS, [], { trackedNorad: TIANGONG_NORAD })?.model,
null,
);
});
test('the layer-state readers take the parts as built, or none', () => {
const parts = {};
const layerState = {
_trackedNorad: SHENZHOU,
_dockedCompanions: new Set(),
_trackedDockedToStation: TIANGONG_NORAD,
};
assert.equal(modelFor(parts, ISS_NORAD), null);
assert.equal(trackedStation(layerState, parts)?.key, 'tiangong');
assert.equal(trackedStation(layerState, parts)?.model, null);
parts.stationModels = [part(TIANGONG_NORAD)];
assert.equal(
trackedStation(layerState, parts)?.model,
parts.stationModels[0],
);
assert.equal(modelFor(parts, TIANGONG_NORAD), parts.stationModels[0]);
});
+376
View File
@@ -0,0 +1,376 @@
import { distance } from '../../geo/index.js';
import { findCamera, findFrame } from '../../render/rendererOf.js';
import {
issCommandCameraOnStation,
issCommandOffersZoom,
issCommandZoomOffset,
} from './issCommand.js';
/**
* The STATION section in Context, for whichever station is selected. A
* station is described once (`issStation.js` describes the ISS) and this
* presents it: Automatic, where the joints follow their rules and the panel
* says where the angles come from (telemetry, or computed when there is
* none); Manual, where the person moves them with the controls the
* description lists; and a zoom to the station from far away. Another
* station plugs in with a description of its own.
*
* @typedef {object} StationDescription
* @property {string} key Short id, e.g. 'iss'.
* @property {string} title The station's name, as a badge.
* @property {() => boolean} selected Whether this station is the tracked
* subject (also as one of its docked entries).
* @property {() => string} subjectName The tracked entry's name.
* @property {() => object|null} articulation The joint driver.
* @property {() => {state: string, poseAgeMs: number|null,
* liveUntilMs: number|null}|null} telemetry Where the angles come from.
* @property {() => {x: number, y: number, z: number}|null} position The
* station's drawn centre (ECEF metres), for the zoom.
* @property {string} zoomLabel The zoom button's text (a msg key).
* @property {{live?: string, computed: string}} notes Automatic's note on
* what moves the joints (msg keys): `live` while the articulation reports
* telemetry, `computed` otherwise (and always, for a station without a
* feed).
* @property {Array<{id: string, label: string, note?: string|null,
* kind: 'choices', choices: Array<{id: string, label: string,
* isDefault?: boolean, apply: (articulation: object) => void}>}|
* {id: string, label: string, kind: 'sliders', resume?: string,
* sliders: Array<{id: string, label: string, min: number, max: number,
* apply: (articulation: object, value: number) => void}>,
* resumeApply?: (articulation: object) => void}>} groups Manual controls.
* @property {(articulation: object) => void} automatic Hand every joint
* back to its rule.
*/
/** How often the status line's age is refreshed while the panel shows. */
export const STATION_PANEL_TICK_MS = 1000;
/**
* @param {{state: object, parts: object, stations: StationDescription[],
* now?: () => number}} context
*/
export function createStationPanel({
state: layerState,
parts,
stations,
now = Date.now,
}) {
const listeners = new Set();
let view = null;
/** The station shown, its mode, its Manual choices and slider values. */
let current = null;
let mode = 'automatic';
let choices = new Map();
let sliders = new Map();
let ticker = null;
let zoomTimer = null;
/** The frame pump while a joint glides, and when it stops. */
let pump = null;
let pumpUntil = 0;
/** The last view published, as text: an unchanged view is not republished. */
let publishedKey = null;
function _stationShown() {
if (!layerState._enabled) return null;
// The right rail is hidden while the Cockpit rides; nothing to show.
if (parts.cockpit?._cockpitHeld()) return null;
return stations.find((station) => station.selected()) ?? null;
}
function _resetManual(station) {
choices = new Map();
sliders = new Map();
for (const group of station?.groups ?? []) {
if (group.kind === 'choices') {
const chosen = group.choices.find((choice) => choice.isDefault);
if (chosen) choices.set(group.id, chosen.id);
} else for (const slider of group.sliders) sliders.set(slider.id, 0);
}
}
/**
* The telemetry status with its ages in whole seconds: the section words
* them so, and an age in ms would make every frame a change.
*/
function wholeSeconds(status) {
if (!status) return status;
const second = (ms) =>
Number.isFinite(ms) ? Math.floor(ms / 1000) * 1000 : ms;
return { ...status, poseAgeMs: second(status.poseAgeMs) };
}
function _publish() {
const station = current;
if (!station) {
if (view !== null) {
view = null;
publishedKey = null;
for (const listener of listeners) listener(null);
}
return;
}
const articulation = station.articulation();
const position = station.position();
const eye = position
? (findCamera(layerState._viewer)?.pose?.()?.position ?? null)
: null;
const range = position && eye ? distance(eye, position) : null;
const next = {
key: station.key,
title: station.title,
subject: station.subjectName(),
mode,
telemetry: wholeSeconds(station.telemetry()),
sunlit: mode === 'manual' ? null : (articulation?.isSunlit?.() ?? null),
note:
(articulation?.isLive?.() ? station.notes?.live : null) ??
station.notes?.computed ??
'',
groups: station.groups.map((group) =>
group.kind === 'choices'
? {
id: group.id,
label: group.label,
note: group.note ?? null,
kind: 'choices',
choices: group.choices.map((choice) => ({
id: choice.id,
label: choice.label,
active: choices.get(group.id) === choice.id,
})),
}
: {
id: group.id,
label: group.label,
note: group.note ?? null,
kind: 'sliders',
resume: group.resume ?? null,
sliders: group.sliders.map((slider) => ({
id: slider.id,
label: slider.label,
min: slider.min,
max: slider.max,
value: sliders.get(slider.id) ?? 0,
})),
},
),
zoom: {
offered:
range !== null && issCommandOffersZoom(range) && _cameraOnStation(),
label: station.zoomLabel,
},
};
// Called every frame from the tick: the section re-renders only on a
// change (the age line moves once a second, the rest on an action).
const key = JSON.stringify(next);
if (key === publishedKey) return;
publishedKey = key;
view = next;
for (const listener of listeners) listener(view);
}
function _tick() {
if (ticker) return;
ticker = setInterval(() => {
if (!current) {
clearInterval(ticker);
ticker = null;
return;
}
_publish();
_requestRender();
}, STATION_PANEL_TICK_MS);
ticker.unref?.();
}
/** Ask the renderer for a frame, through the frame port. */
function _requestRender() {
findFrame(layerState._viewer)?.requestRender('station-panel');
}
/**
* Keep frames coming while a joint glides to a new pose: one pump, run
* until the latest ask (a slider drag asks many times a second).
*/
function _renderFor(ms) {
if (!findFrame(layerState._viewer)) return;
pumpUntil = Math.max(pumpUntil, now() + ms);
if (pump) return;
pump = setInterval(() => {
_requestRender();
if (now() > pumpUntil) _stopPump();
}, 33);
pump.unref?.();
}
function _stopPump() {
if (pump) clearInterval(pump);
pump = null;
pumpUntil = 0;
}
function _stopZoom() {
if (zoomTimer) clearInterval(zoomTimer);
zoomTimer = null;
}
/**
* Whether the camera follows the layer's follow target, framed (see
* issCommand.js): the tracked satellite is the station, or docked to it.
*/
function _cameraOnStation() {
return issCommandCameraOnStation(
findCamera(layerState._viewer),
layerState._followTarget,
);
}
/**
* Bring the follow camera in to the station, a step per frame. Only while
* the follow camera is on it: from any other camera the steps would lead
* away, and a zoom pressed during the flight to the station would do so.
*/
function _zoom() {
_stopZoom();
if (!_cameraOnStation()) return false;
let steps = 0;
zoomTimer = setInterval(() => {
const camera = findCamera(layerState._viewer);
steps += 1;
if (
!camera ||
!current?.position() ||
!current?.selected() ||
!_cameraOnStation() ||
steps > 400
) {
_stopZoom();
return;
}
// While the camera follows the station, its follow offset is the eye's
// offset from it: shorten that, never move along the view. The port
// asks for the frame itself.
const next = issCommandZoomOffset(camera.followOffset.get());
if (!next) {
_stopZoom();
return;
}
camera.followOffset.set(next);
}, 16);
return true;
}
const actions = {
setStationMode(next) {
const articulation = current?.articulation();
if (!current || !articulation) return false;
const wanted = next === 'manual' ? 'manual' : 'automatic';
if (wanted === mode) return true;
mode = wanted;
if (mode === 'manual') articulation.setTelemetryAllowed?.(false);
else {
_resetManual(current);
current.automatic(articulation);
}
_renderFor(20_000);
_publish();
return true;
},
chooseStation(groupId, choiceId) {
const articulation = current?.articulation();
const group = current?.groups.find((g) => g.id === groupId);
const choice = group?.choices?.find((c) => c.id === choiceId);
if (!articulation || !choice) return false;
choices.set(groupId, choiceId);
choice.apply(articulation);
_renderFor(20_000);
_publish();
return true;
},
slideStation(sliderId, value) {
const articulation = current?.articulation();
const group = current?.groups.find((g) =>
g.sliders?.some((s) => s.id === sliderId),
);
const slider = group?.sliders.find((s) => s.id === sliderId);
const number = Number(value);
if (!articulation || !slider || !Number.isFinite(number)) return false;
const clamped = Math.min(slider.max, Math.max(slider.min, number));
sliders.set(sliderId, clamped);
slider.apply(articulation, clamped);
_renderFor(2000);
_publish();
return true;
},
resumeStationArm(groupId) {
const articulation = current?.articulation();
const group = current?.groups.find((g) => g.id === groupId);
if (!articulation || !group?.resumeApply) return false;
for (const slider of group.sliders) sliders.set(slider.id, 0);
group.resumeApply(articulation);
_renderFor(20_000);
_publish();
return true;
},
zoomStation() {
if (!current) return false;
return _zoom();
},
};
/**
* Per tick and on tracking changes: show the selected station's panel,
* or take it down. Leaving a station hands its joints back to Automatic,
* so no manual pose lingers.
*/
function _syncStationPanel() {
const station = _stationShown();
if (station !== current) {
if (current && mode === 'manual') {
const articulation = current.articulation();
if (articulation) current.automatic(articulation);
}
_stopZoom();
current = station;
mode = 'automatic';
_resetManual(station);
if (station) _tick();
}
_publish();
}
function _destroyStationPanel() {
// The joints go back to Automatic with the panel, as on leaving a station.
if (current && mode === 'manual') {
const articulation = current.articulation();
if (articulation) current.automatic(articulation);
}
_stopZoom();
_stopPump();
if (ticker) clearInterval(ticker);
ticker = null;
current = null;
mode = 'automatic';
_publish();
}
const methods = {
/**
* Receive the STATION section's view: the current one at once, then
* each change; null while no station is selected.
* @param {(view: object|null) => void} listener
* @returns {() => void} Stops listening.
*/
subscribeStationPanel(listener) {
listeners.add(listener);
listener(view);
return () => listeners.delete(listener);
},
/** The actions the section's controls call (the store's owners). */
getStationActions() {
return actions;
},
};
return { _syncStationPanel, _destroyStationPanel, methods };
}
+370
View File
@@ -0,0 +1,370 @@
// src/layers/satellites/stationPanel.test.mjs — the STATION section's
// presenter, over a stand-in station description.
import test from 'node:test';
import assert from 'node:assert/strict';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import { ISS_COMMAND_ZOOM_RANGE_M } from './issCommand.js';
import { createStationPanel } from './stationPanel.js';
/**
* A camera port that follows what it is told to and keeps a follow offset,
* as the renderer's does once the follow has framed the eye.
*/
function fakeFollowCamera({ eye, offset }) {
const camera = {
eye,
offset,
followed: null,
followFramed: false,
offsetsSet: [],
pose: () => ({ position: { ...camera.eye } }),
followOffset: {
get: () => (camera.followFramed ? { ...camera.offset } : null),
set(next) {
camera.offset = { ...next };
camera.offsetsSet.push({ ...next });
},
},
};
return camera;
}
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function fixture() {
const calls = [];
const articulation = {
isSunlit: () => true,
isLive: () => false,
setTelemetryAllowed: (allowed) => calls.push(['telemetry', allowed]),
};
let selected = false;
let held = false;
let position = null;
let telemetry = { state: 'live', poseAgeMs: 3000, liveUntilMs: null };
const station = {
key: 'test',
title: 'TEST',
selected: () => selected,
subjectName: () => 'TEST STATION',
articulation: () => articulation,
telemetry: () => telemetry,
position: () => position,
zoomLabel: 'Zoom to the station',
notes: {
live: 'Joints on live telemetry.',
computed: 'Computed, not live telemetry.',
},
groups: [
{
id: 'sun',
label: 'Sun position',
kind: 'choices',
choices: [
{
id: 'follow',
label: 'Follow',
isDefault: true,
apply: () => calls.push(['sun', 'follow']),
},
{
id: 'ahead',
label: 'Ahead',
apply: () => calls.push(['sun', 'ahead']),
},
],
},
{
id: 'arm',
label: 'Arm',
kind: 'sliders',
resume: 'Resume',
sliders: [
{
id: 'shoulder',
label: 'Shoulder',
min: -120,
max: 120,
apply: (a, v) => calls.push(['shoulder', v]),
},
{
id: 'elbow',
label: 'Elbow',
min: -90,
max: 90,
apply: (a, v) => calls.push(['elbow', v]),
},
],
resumeApply: () => calls.push(['resume']),
},
],
automatic: () => calls.push(['automatic']),
};
const layerState = { _enabled: true, _viewer: null };
const parts = { cockpit: { _cockpitHeld: () => held } };
const panel = createStationPanel({
state: layerState,
parts,
stations: [station],
});
const views = [];
panel.methods.subscribeStationPanel((view) => views.push(view));
const actions = panel.methods.getStationActions();
return {
panel,
actions,
calls,
views,
view: () => views.at(-1),
layerState,
select: (on) => (selected = on),
hold: (on) => (held = on),
setTelemetry: (next) => (telemetry = next),
setPosition: (next) => (position = next),
};
}
test('the zoom is offered, and runs, only while the follow camera is on the station', async (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
const viewer = {};
const camera = fakeFollowCamera({
eye: { x: 5000, y: 0, z: 0 },
offset: { x: 3000, y: 4000, z: 0 },
});
const frames = [];
const { unbind } = bindFakeDraw(viewer, {
camera,
frame: { requestRender: (reason) => frames.push(reason) },
});
t.after(unbind);
const target = { key: 'satellites:25544' };
f.layerState._viewer = viewer;
f.layerState._followTarget = target;
f.setPosition({ x: 0, y: 0, z: 0 });
f.select(true);
f.panel._syncStationPanel();
assert.equal(f.view().zoom.offered, false, 'still flying to the station');
assert.equal(f.actions.zoomStation(), false);
camera.followed = { key: 'flights:other' };
camera.followFramed = true;
f.panel._syncStationPanel();
assert.equal(f.view().zoom.offered, false, 'following something else');
camera.followed = target;
camera.followFramed = false;
f.panel._syncStationPanel();
assert.equal(f.view().zoom.offered, false, 'the follow has not framed yet');
camera.followFramed = true;
f.panel._syncStationPanel();
assert.equal(f.view().zoom.offered, true);
assert.equal(f.actions.zoomStation(), true);
await sleep(120);
const ranges = camera.offsetsSet.map((o) => Math.hypot(o.x, o.y, o.z));
assert.ok(ranges.length >= 3, 'the zoom stepped the follow offset');
for (let i = 0; i < ranges.length; i++) {
const before = i === 0 ? 5000 : ranges[i - 1];
assert.ok(
ranges[i] < before,
`step ${i} came in: ${before} -> ${ranges[i]}`,
);
assert.ok(ranges[i] >= ISS_COMMAND_ZOOM_RANGE_M, 'never past the range');
}
// The bearing is kept: the offset only shortens.
const last = camera.offsetsSet.at(-1);
assert.ok(Math.abs(last.x / last.y - 3 / 4) < 1e-9);
assert.equal(last.z, 0);
// The follow ending stops the zoom where it is.
camera.followed = null;
const steps = camera.offsetsSet.length;
await sleep(50);
assert.equal(camera.offsetsSet.length, steps);
camera.followed = target;
camera.eye = { x: 300, y: 0, z: 0 };
f.panel._syncStationPanel();
assert.equal(f.view().zoom.offered, false, 'close in, the zoom goes');
assert.ok(frames.length === 0 || frames.every((r) => r === 'station-panel'));
});
test('a new subscriber gets the current view at once: nothing while no station is selected', () => {
const f = fixture();
assert.deepEqual(f.views, [null]);
f.panel._syncStationPanel();
assert.deepEqual(f.views, [null], 'unchanged nothing is not re-published');
f.panel._destroyStationPanel();
});
test('selecting the station publishes it in Automatic with its defaults', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
const view = f.view();
assert.equal(view.key, 'test');
assert.equal(view.title, 'TEST');
assert.equal(view.subject, 'TEST STATION');
assert.equal(view.mode, 'automatic');
assert.deepEqual(view.telemetry, {
state: 'live',
poseAgeMs: 3000,
liveUntilMs: null,
});
assert.equal(view.sunlit, true);
assert.match(view.note, /Computed, not live telemetry/);
assert.deepEqual(
view.groups[0].choices.map((c) => [c.id, c.active]),
[
['follow', true],
['ahead', false],
],
);
assert.deepEqual(
view.groups[1].sliders.map((s) => s.value),
[0, 0],
);
assert.equal(view.groups[1].resume, 'Resume');
assert.deepEqual(view.zoom, { offered: false, label: 'Zoom to the station' });
assert.deepEqual(f.calls, [], 'Automatic touches nothing on entry');
});
test('Manual pauses telemetry and offers the controls; Automatic hands the joints back', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
assert.equal(f.actions.setStationMode('manual'), true);
assert.equal(f.view().mode, 'manual');
assert.equal(f.view().sunlit, null, "the Sun line is Automatic's");
assert.deepEqual(f.calls, [['telemetry', false]]);
assert.equal(f.actions.setStationMode('manual'), true, 'again is a no-op');
assert.equal(f.calls.length, 1);
assert.equal(f.actions.chooseStation('sun', 'ahead'), true);
assert.equal(f.view().groups[0].choices[1].active, true);
assert.equal(f.actions.setStationMode('automatic'), true);
assert.equal(f.view().mode, 'automatic');
assert.deepEqual(f.calls.at(-1), ['automatic']);
assert.equal(f.view().groups[0].choices[0].active, true, 'choices reset');
});
test('choices apply to the articulation; an unknown choice is refused', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
assert.equal(f.actions.chooseStation('sun', 'ahead'), true);
assert.deepEqual(f.calls, [['sun', 'ahead']]);
assert.equal(f.actions.chooseStation('sun', 'nowhere'), false);
assert.equal(f.actions.chooseStation('arm', 'ahead'), false);
});
test('sliders clamp to their range and refuse non-numbers', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
assert.equal(f.actions.slideStation('shoulder', '45'), true);
assert.equal(f.actions.slideStation('elbow', 500), true);
assert.equal(f.actions.slideStation('elbow', 'abc'), false);
assert.equal(f.actions.slideStation('wrist', 10), false);
assert.deepEqual(f.calls, [
['shoulder', 45],
['elbow', 90],
]);
assert.deepEqual(
f.view().groups[1].sliders.map((s) => s.value),
[45, 90],
);
assert.equal(f.actions.resumeStationArm('arm'), true);
assert.deepEqual(f.calls.at(-1), ['resume']);
assert.deepEqual(
f.view().groups[1].sliders.map((s) => s.value),
[0, 0],
);
assert.equal(
f.actions.resumeStationArm('sun'),
false,
'choices have no resume',
);
});
test('leaving the station in Manual hands its joints back and takes the section down', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
f.actions.setStationMode('manual');
f.actions.slideStation('shoulder', 30);
f.select(false);
f.panel._syncStationPanel();
assert.equal(f.view(), null);
assert.deepEqual(f.calls.at(-1), ['automatic']);
f.select(true);
f.panel._syncStationPanel();
assert.equal(f.view().mode, 'automatic');
assert.deepEqual(
f.view().groups[1].sliders.map((s) => s.value),
[0, 0],
);
});
test('the section is away while the Cockpit holds the rail, and while the layer is off', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.hold(true);
f.panel._syncStationPanel();
assert.equal(f.view(), null);
f.hold(false);
f.panel._syncStationPanel();
assert.equal(f.view().key, 'test');
f.layerState._enabled = false;
f.panel._syncStationPanel();
assert.equal(f.view(), null);
});
test('every sync re-reads the telemetry status for the status line', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.panel._syncStationPanel();
f.setTelemetry({
state: 'unavailable',
poseAgeMs: 61_000,
liveUntilMs: null,
});
f.panel._syncStationPanel();
assert.equal(f.view().telemetry.state, 'unavailable');
});
test('actions without a station are refused; destroy publishes nothing', () => {
const f = fixture();
assert.equal(f.actions.setStationMode('manual'), false);
assert.equal(f.actions.chooseStation('sun', 'ahead'), false);
assert.equal(f.actions.slideStation('shoulder', 1), false);
assert.equal(f.actions.resumeStationArm('arm'), false);
assert.equal(f.actions.zoomStation(), false);
f.select(true);
f.panel._syncStationPanel();
assert.ok(f.view());
f.panel._destroyStationPanel();
assert.equal(f.view(), null);
});
test('frame after frame, the section is republished only when the age crosses a whole second', (t) => {
const f = fixture();
t.after(() => f.panel._destroyStationPanel());
f.select(true);
f.setTelemetry({ state: 'live', poseAgeMs: 3010, liveUntilMs: null });
f.panel._syncStationPanel();
const published = f.views.length;
assert.equal(f.view().telemetry.poseAgeMs, 3000, 'in whole seconds');
// The tick runs every frame; the age moves by milliseconds.
for (const age of [3020, 3150, 3600, 3999]) {
f.setTelemetry({ state: 'live', poseAgeMs: age, liveUntilMs: null });
f.panel._syncStationPanel();
}
assert.equal(f.views.length, published, 'nothing new to show');
f.setTelemetry({ state: 'live', poseAgeMs: 4001, liveUntilMs: null });
f.panel._syncStationPanel();
assert.equal(f.views.length, published + 1);
assert.equal(f.view().telemetry.poseAgeMs, 4000);
});
@@ -0,0 +1,97 @@
// src/layers/satellites/stationResume.test.mjs — handing a station's moving
// parts back from the STATION section's Manual: every joint posed by hand
// leaves its manual angle, the ones the illustrative sway does not move
// included, and the ISS's Automatic lets telemetry back in.
import assert from 'node:assert/strict';
import test from 'node:test';
import { createIssArticulation, ISS_ARM_JOINTS } from './issArticulation.js';
import { issStationDescription } from './issStation.js';
import { createNodePoses } from './stationModel.js';
import {
createTiangongArticulation,
TIANGONG_ARMS,
} from './tiangongArticulation.js';
/** A station on its usual axes, in sunlight, as the model part places it. */
const AT = { x: 6_780_000, y: 0, z: 0 };
const AXES = { x: [0, 1, 0], y: [0, 0, 1], z: [1, 0, 0] };
const DATE = new Date(Date.UTC(2026, 10, 16, 12, 0, 0));
test('ISS: Resume gives the Canadarm2 joints the sway does not move their filed pose back', () => {
const articulation = createIssArticulation();
const nodes = createNodePoses();
articulation.update(nodes, DATE, AT, AXES, 1_000);
const held = ISS_ARM_JOINTS.filter((joint) => !joint.sway);
const swaying = ISS_ARM_JOINTS.find((joint) => joint.sway);
assert.ok(held.length > 0 && swaying);
for (const joint of [...held, swaying])
articulation.setJoint(joint.node, joint.pivot, joint.axis, Math.PI / 2);
for (const joint of held) assert.ok(nodes.poses[joint.node], joint.node);
articulation.resumeArm();
for (const joint of held)
assert.equal(
nodes.poses[joint.node],
undefined,
`${joint.node} back to its filed pose`,
);
// A swaying joint is posed by the sway again on the next update.
articulation.update(nodes, DATE, AT, AXES, 2_000);
assert.ok(nodes.poses[swaying.node]);
});
test('Tiangong: resuming an arm gives its held joints their folded pose back, and only that arm', () => {
const articulation = createTiangongArticulation();
const nodes = createNodePoses();
articulation.update(nodes, DATE, AT, AXES, 1_000);
const heldOf = (key) =>
TIANGONG_ARMS[key].filter((joint) => !joint.sway && !joint.centre);
for (const key of ['cmm', 'emm'])
for (const joint of heldOf(key))
articulation.setJoint(joint.node, joint.pivot, joint.axis, 1);
articulation.resumeArm('cmm');
for (const joint of heldOf('cmm'))
assert.equal(nodes.poses[joint.node], undefined, joint.node);
for (const joint of heldOf('emm'))
assert.ok(nodes.poses[joint.node], `${joint.node} still by hand`);
articulation.resumeArm();
for (const joint of heldOf('emm'))
assert.equal(nodes.poses[joint.node], undefined, joint.node);
});
test('a node given no matrix leaves the item’s nodes, as a model node goes back to its authored pose', () => {
const nodes = createNodePoses();
const identity = new Float64Array(16);
identity[0] = identity[5] = identity[10] = identity[15] = 1;
nodes.getNode('JOINT').matrix = identity;
assert.ok(nodes.poses.JOINT);
nodes.getNode('JOINT').matrix = undefined;
assert.equal('JOINT' in nodes.poses, false);
});
test("the ISS's Automatic lets telemetry back in and hands every part back", () => {
const calls = [];
const recorder = new Proxy(
{},
{
get:
(_, name) =>
(...args) =>
calls.push([name, ...args]),
},
);
const station = issStationDescription({ state: {}, parts: {} });
station.automatic(recorder);
const names = calls.map(([name]) => name);
assert.deepEqual(
calls.find(([name]) => name === 'setTelemetryAllowed'),
['setTelemetryAllowed', true],
);
for (const name of [
'setOverride',
'setDishOverride',
'setDeploy',
'setRadiatorDeploy',
'resumeArm',
])
assert.ok(names.includes(name), name);
});
@@ -0,0 +1,484 @@
import { sunPositionFixed } from '../../geo/celestial.js';
import {
ISS_JOINT_RATE,
issAimMatrix,
issArmAngles,
issAxisMatrix,
issInShadow,
issRelayDirections,
issStepAngle,
issStepDirection,
issSunInModelFrame,
} from './issArticulation.js';
import { tiangongJoint } from './tiangongJoints.js';
/**
* Tiangong's moving parts, driven from the joint table (tiangongJoints.js):
* every angle is computed, since China publishes no live telemetry for the
* station. The rules are the ISS's (issArticulation.js), written for joints
* whose axes and rest normals come from the table instead of being fixed:
*
* - a wing on one joint (Tianhe's two, each visiting vehicle's two) turns
* about its boom so its cell side faces the Sun;
* - a lab wing (Wentian's and Mengtian's two each) turns first about the
* lab's axis (alpha), so the wing's own axis is across the Sun, then about
* that axis (beta), so the cells face it, the ISS's SARJ/BGA pair;
* - in the Earth's shadow the wings turn flat to the Earth (cell side to
* zenith), which puts them edge-on to the flight direction, the ISS's
* feathering;
* - the high-gain antenna aims at the highest of China's Tianlian relay
* satellites over the equator;
* - the two arms sway slowly for illustration (their real pose is not public).
*
* Joints turn at most ISS_JOINT_RATE on screen.
*/
/** Below this the Sun is too close to a joint's axis to steer by it. */
const MIN_STEER = 0.05;
/** The dish does not look below this much above the station's horizon plane. */
const DISH_MIN_UP = 0.15;
/** Where the wings turn in shadow: cell side to zenith, on the model's axes. */
const ZENITH = Object.freeze([0, 1, 0]);
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const cross = (a, b) => [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
/** `v` turned by `angle` about the unit vector `axis` (Rodrigues). */
function rotate(v, axis, angle) {
const c = Math.cos(angle);
const s = Math.sin(angle);
const k = cross(axis, v);
const d = dot(axis, v) * (1 - c);
return [0, 1, 2].map((i) => v[i] * c + k[i] * s + axis[i] * d);
}
/** The signed difference wrapped to (-π, π]. */
function wrap(delta) {
let d = delta % (2 * Math.PI);
if (d > Math.PI) d -= 2 * Math.PI;
if (d <= -Math.PI) d += 2 * Math.PI;
return d;
}
/** Of `angle` and `angle + π`, the one nearer to `previous`. */
function nearestHalfTurn(angle, previous) {
const flipped = angle + Math.PI;
return Math.abs(wrap(angle - previous)) <= Math.abs(wrap(flipped - previous))
? angle
: flipped;
}
const wing = (node, normal) =>
Object.freeze({ ...tiangongJoint(node), normal: Object.freeze(normal) });
/**
* Wings turned by one joint, with the cell side's normal at rest. The
* station's and the forward and aft vehicles' wings lie flat (cells up); the
* nadir Shenzhou hangs below the node, so its wings' cells face forward.
*/
export const TIANGONG_ONE_AXIS_WINGS = Object.freeze([
wing('TIANHE_ARRAY_PORT_ALPHA', ZENITH),
wing('TIANHE_ARRAY_STBD_ALPHA', ZENITH),
wing('SHENZHOU_FORWARD_ARRAY_PORT_ALPHA', ZENITH),
wing('SHENZHOU_FORWARD_ARRAY_STBD_ALPHA', ZENITH),
wing('SHENZHOU_NADIR_ARRAY_PORT_ALPHA', [0, 0, 1]),
wing('SHENZHOU_NADIR_ARRAY_STBD_ALPHA', [0, 0, 1]),
wing('TIANZHOU_AFT_ARRAY_PORT_ALPHA', ZENITH),
wing('TIANZHOU_AFT_ARRAY_STBD_ALPHA', ZENITH),
]);
/** The lab wings: an alpha joint about the lab's axis, a beta joint under it. */
export const TIANGONG_TWO_AXIS_WINGS = Object.freeze(
[
'WENTIAN_ARRAY_FWD',
'WENTIAN_ARRAY_AFT',
'MENGTIAN_ARRAY_FWD',
'MENGTIAN_ARRAY_AFT',
].map((stem) =>
Object.freeze({
alpha: tiangongJoint(`${stem}_ALPHA`),
beta: tiangongJoint(`${stem}_BETA`),
normal: ZENITH,
}),
),
);
/**
* The arms' joints, base to tip, with the illustrative sway: `centre` and
* `sway` radians over `period` seconds, about the folded pose in the file.
* The joints that lift the booms sway on one side of rest only, so the arms
* rise off the hull and never swing into it.
*/
const arm = (prefix, sway) =>
Object.freeze(
['SHR', 'SHY', 'SHP', 'EP', 'WP', 'WY', 'WR'].map((name) => {
const [centreDeg = 0, swayDeg = 0, period = 0] = sway[name] ?? [];
return Object.freeze({
...tiangongJoint(`${prefix}_${name}`),
centre: (centreDeg * Math.PI) / 180,
sway: (swayDeg * Math.PI) / 180,
period,
});
}),
);
export const TIANGONG_ARMS = Object.freeze({
/** The Tianhe arm (CMM), its booms folded along the core module. */
cmm: arm('CMM', { SHP: [12, 6, 71], EP: [-14, 8, 53], WP: [0, 5, 41] }),
/** The Wentian arm (EMM), folded along the lab. */
emm: arm('EMM', { SHP: [-12, 6, 67], EP: [14, 8, 47], WP: [0, 5, 37] }),
});
/** The high-gain antenna's gimbal; rest boresight +Y. */
export const TIANGONG_HGA = tiangongJoint('TIANHE_HGA');
/**
* China's Tianlian II relay satellites over the equator, degrees east, the
* station's counterparts to NASA's TDRS: II-01 at 79.9°E, II-02 at 171.04°E,
* II-03 at 10.5°E (Wikipedia, "Tianlian", and satcat.com's definitive orbit
* for 53100 at 10.56°E; II-03's slot is not stated by the launch reports, which
* say only that the three form a global network). Nominal slots, not a live
* roster: which satellite the station uses at a given moment is not public.
*/
export const TIANGONG_RELAY_LONGITUDES_DEG = Object.freeze([
79.9, 171.04, 10.5,
]);
/**
* The angle that turns a wing's cell side onto the Sun about one axis.
* @param {number[]} sun Unit vector on the model's axes.
* @param {{axis: readonly number[], normal: readonly number[]}} joint The
* turn axis and the cell side's normal at rest (perpendicular to it).
* @param {number} [previous] Held when the Sun is along the axis.
* @returns {number} Radians.
*/
export function tiangongOneAxisAngle(sun, { axis, normal }, previous = 0) {
const across = cross(axis, normal);
const u = dot(sun, normal);
const v = dot(sun, across);
if (Math.hypot(u, v) < MIN_STEER) return previous;
return Math.atan2(v, u);
}
/**
* The two angles that face a lab wing to the Sun: `alpha` about the lab's
* axis puts the wing's own axis across the Sun, `beta` about that axis turns
* the cell side onto it.
* @param {number[]} sun Unit vector on the model's axes.
* @param {{alphaAxis: readonly number[], betaAxis: readonly number[],
* normal: readonly number[]}} joint Axes at rest; the normal is
* perpendicular to both.
* @param {number} [previousAlpha] Alpha has two answers half a turn apart
* (beta makes up the difference); the nearer to this is kept, and it is
* held when the Sun is along the alpha axis.
* @returns {{alpha: number, beta: number}} Radians.
*/
export function tiangongTwoAxisAngles(
sun,
{ alphaAxis, betaAxis, normal },
previousAlpha = 0,
) {
const across = cross(alphaAxis, betaAxis);
const u = dot(sun, betaAxis);
const v = dot(sun, across);
const alpha =
Math.hypot(u, v) < MIN_STEER
? previousAlpha
: nearestHalfTurn(Math.atan2(-u, v), previousAlpha);
// The Sun as the wing sees it after the alpha turn.
const local = rotate(sun, alphaAxis, -alpha);
const beta = Math.atan2(
dot(local, cross(betaAxis, normal)),
dot(local, normal),
);
return { alpha, beta };
}
/**
* Every wing's target angles.
* @param {number[]} sun Unit vector toward the Sun on the model's axes.
* @param {boolean} sunlit False in the Earth's shadow: the wings turn flat.
* @param {{one: number[], alpha: number[]}} [previous] The last targets.
* @returns {{one: number[], alpha: number[], beta: number[]}} Radians, per
* TIANGONG_ONE_AXIS_WINGS and TIANGONG_TWO_AXIS_WINGS entry.
*/
export function tiangongWingTargets(sun, sunlit, previous = null) {
const toward = sunlit ? sun : ZENITH;
const one = TIANGONG_ONE_AXIS_WINGS.map((joint, i) =>
tiangongOneAxisAngle(toward, joint, previous?.one[i] ?? 0),
);
const two = TIANGONG_TWO_AXIS_WINGS.map((pair, i) =>
tiangongTwoAxisAngles(
toward,
{
alphaAxis: pair.alpha.axis,
betaAxis: pair.beta.axis,
normal: pair.normal,
},
previous?.alpha[i] ?? 0,
),
);
return {
one,
alpha: two.map((t) => t.alpha),
beta: two.map((t) => t.beta),
};
}
/**
* Where the Tianlian satellites are from the station, on the model's axes,
* the highest above the station first.
* @param {number[]} positionEcef Meters.
* @param {{x:number[], y:number[], z:number[]}} axes Flight axes.
* @returns {number[][]} Unit vectors [port, zenith, forward].
*/
export function tiangongRelayDirections(positionEcef, axes) {
return issRelayDirections(positionEcef, axes, TIANGONG_RELAY_LONGITUDES_DEG);
}
/**
* Drives the loaded model's joints. Same contract as the ISS driver
* (`update`, `reset`, the STATION section's `setOverride`, `setJoint`,
* `resumeArm`, `isSunlit`), minus telemetry: `isLive` is always false.
*/
export function createTiangongArticulation() {
let boundModel = null;
let nodes = null;
let angles = null;
let targets = null;
let lastMs = 0;
let override = null;
let lastSunlit = null;
/** Where the dish looks now, on the model's axes. */
let dish = null;
/** STATION section: arms being posed by hand, so their sway is off. */
const armManual = new Set();
/**
* STATION section: wings set by hand, node name → radians. A wing with an
* entry here holds that angle (reached at the joint rate) instead of
* following the Sun; the others keep following.
*/
const wingManual = new Map();
const scratchMatrix = new Float64Array(16);
function bind(model) {
boundModel = model;
const get = (joint) => model.getNode(joint.node) ?? null;
nodes = {
one: TIANGONG_ONE_AXIS_WINGS.map(get),
alpha: TIANGONG_TWO_AXIS_WINGS.map((pair) => get(pair.alpha)),
beta: TIANGONG_TWO_AXIS_WINGS.map((pair) => get(pair.beta)),
dish: get(TIANGONG_HGA),
arms: Object.fromEntries(
Object.entries(TIANGONG_ARMS).map(([key, joints]) => [
key,
joints.map(get),
]),
),
};
angles = null;
dish = null;
}
function sunEcef(date) {
const sun = sunPositionFixed(date.getTime());
const length = Math.hypot(sun.x, sun.y, sun.z) || 1;
return [sun.x / length, sun.y / length, sun.z / length];
}
function write(node, joint, angle) {
if (!node) return;
node.matrix = issAxisMatrix(joint.pivot, joint.axis, angle, scratchMatrix);
}
/**
* @param {{ready: boolean, getNode: (name: string) => object|undefined}} model
* A ready model, or any holder of nodes that take a `matrix`.
* @param {Date} date The instant the model is placed at.
* @param {{x:number,y:number,z:number}} position Earth-fixed station position.
* @param {{x:number[], y:number[], z:number[]}} axes Its flight axes.
* @param {number} [nowMs] Wall clock, for the turn rate.
*/
function update(model, date, position, axes, nowMs = Date.now()) {
if (!model.ready) return;
if (model !== boundModel) bind(model);
const forced = override?.(nowMs) ?? null;
if (forced) {
lastSunlit = Boolean(forced.sunlit);
targets = tiangongWingTargets(forced.sun, forced.sunlit, targets);
} else {
const sun = sunEcef(date);
const sunlit = !issInShadow([position.x, position.y, position.z], sun);
lastSunlit = sunlit;
targets = tiangongWingTargets(
issSunInModelFrame(sun, axes),
sunlit,
targets,
);
}
// A first frame, or one after a pause, goes straight to the pose.
const elapsed = (nowMs - lastMs) / 1000;
lastMs = nowMs;
const maxStep =
!angles || !(elapsed >= 0) || elapsed > 2
? Number.POSITIVE_INFINITY
: ISS_JOINT_RATE * elapsed;
// A wing set by hand aims for its set angle; the rest for the Sun's.
const goalFor = (group, joints) =>
targets[group].map((target, i) =>
wingManual.has(joints[i].node)
? wingManual.get(joints[i].node)
: target,
);
const goals = {
one: goalFor('one', TIANGONG_ONE_AXIS_WINGS),
alpha: goalFor(
'alpha',
TIANGONG_TWO_AXIS_WINGS.map((pair) => pair.alpha),
),
beta: goalFor(
'beta',
TIANGONG_TWO_AXIS_WINGS.map((pair) => pair.beta),
),
};
const step = (group) =>
goals[group].map((target, i) =>
issStepAngle(angles?.[group][i] ?? 0, target, maxStep),
);
const next = { one: step('one'), alpha: step('alpha'), beta: step('beta') };
TIANGONG_ONE_AXIS_WINGS.forEach((joint, i) => {
if (!angles || next.one[i] !== angles.one[i])
write(nodes.one[i], joint, next.one[i]);
});
TIANGONG_TWO_AXIS_WINGS.forEach((pair, i) => {
if (!angles || next.alpha[i] !== angles.alpha[i])
write(nodes.alpha[i], pair.alpha, next.alpha[i]);
if (!angles || next.beta[i] !== angles.beta[i])
write(nodes.beta[i], pair.beta, next.beta[i]);
});
angles = next;
// The dish: the highest relay satellite; one below the station's horizon
// plane keeps its last aim.
const current = dish ?? [0, 1, 0];
const wanted = tiangongRelayDirections(
[position.x, position.y, position.z],
axes,
)[0];
const target = wanted && wanted[1] >= DISH_MIN_UP ? wanted : current;
const stepped = issStepDirection(current, target, maxStep);
if (!dish || stepped.some((c, k) => Math.abs(c - current[k]) > 1e-9))
if (nodes.dish)
nodes.dish.matrix = issAimMatrix(
TIANGONG_HGA.pivot,
stepped,
scratchMatrix,
);
dish = stepped;
// Arms: an illustrative sway about the folded pose (see TIANGONG_ARMS).
for (const [key, joints] of Object.entries(TIANGONG_ARMS)) {
if (armManual.has(key)) continue;
const sway = issArmAngles(nowMs / 1000, joints);
joints.forEach((joint, i) => {
if (!joint.sway && !joint.centre) return;
write(nodes.arms[key][i], joint, joint.centre + sway[i]);
});
}
}
/**
* STATION section: turn any named node about an axis through a pivot. A
* node of either arm takes that arm off its sway.
* @param {string} name
* @param {number[]} pivot
* @param {number[]} axis Unit vector.
* @param {number} angle Radians.
*/
function setJoint(name, pivot, axis, angle) {
for (const [key, joints] of Object.entries(TIANGONG_ARMS))
if (joints.some((joint) => joint.node === name)) armManual.add(key);
const node = boundModel?.getNode(name);
if (node) node.matrix = issAxisMatrix(pivot, axis, angle, scratchMatrix);
}
/** Forget the model and every manual choice: the next update starts clean. */
function reset() {
boundModel = null;
nodes = null;
angles = null;
targets = null;
dish = null;
override = null;
wingManual.clear();
armManual.clear();
}
/**
* STATION section: a function giving the Sun on the model's axes (and
* whether the station is lit) in place of the real one, or null for the
* real one.
* @param {((nowMs:number)=>{sun:number[], sunlit:boolean}|null)|null} fn
*/
function setOverride(fn) {
override = fn;
}
/** Whether the station is in sunlight, as of the last update. */
function isSunlit() {
return lastSunlit;
}
/**
* STATION section: hand an arm back to its sway; both when no arm is named.
* @param {'cmm'|'emm'} [key]
*/
function resumeArm(key) {
for (const arm of key ? [key] : [...armManual]) {
if (!armManual.delete(arm)) continue;
// Joints the sway does not move would keep their manual angle: they go
// back to the folded pose. The swaying ones are posed again next update.
for (const joint of TIANGONG_ARMS[arm] ?? []) {
if (joint.sway || joint.centre) continue;
const node = boundModel?.getNode(joint.node);
if (node) node.matrix = undefined;
}
}
}
/**
* STATION section: hold one wing joint at an angle, by its node name
* (a TIANGONG_ONE_AXIS_WINGS entry, or a lab wing's alpha or beta node).
* The joint turns there at the joint rate on the next updates. Null lets
* the wing follow the Sun again.
* @param {string} name
* @param {number|null} angle Radians.
*/
function setWingAngle(name, angle) {
if (angle === null || !Number.isFinite(angle)) wingManual.delete(name);
else wingManual.set(name, angle);
}
/** STATION section: every wing back to the Sun. */
function resumeWings() {
wingManual.clear();
}
return {
update,
reset,
setOverride,
setJoint,
resumeArm,
setWingAngle,
resumeWings,
isSunlit,
/** No telemetry exists for Tiangong: the angles are always computed. */
isLive: () => false,
setTelemetryAllowed() {},
};
}
@@ -0,0 +1,238 @@
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import test from 'node:test';
import { ISS_RELAY_LONGITUDES_DEG } from './issArticulation.js';
import { TIANGONG_MODEL_URL } from './policy.js';
import {
TIANGONG_ARMS,
TIANGONG_HGA,
TIANGONG_ONE_AXIS_WINGS,
TIANGONG_RELAY_LONGITUDES_DEG,
TIANGONG_TWO_AXIS_WINGS,
tiangongOneAxisAngle,
tiangongRelayDirections,
tiangongTwoAxisAngles,
tiangongWingTargets,
} from './tiangongArticulation.js';
import { TIANGONG_JOINTS, tiangongJoint } from './tiangongJoints.js';
const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
const cross = (a, b) => [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
const unit = (v) => v.map((c) => c / Math.hypot(...v));
/** `v` turned by `angle` about `axis` (Rodrigues), the turn the matrix makes. */
const rotate = (v, axis, angle) => {
const c = Math.cos(angle);
const s = Math.sin(angle);
const k = cross(axis, v);
const d = dot(axis, v) * (1 - c);
return [0, 1, 2].map((i) => v[i] * c + k[i] * s + axis[i] * d);
};
const SUNS = [
[0, 1, 0],
[0, -1, 0],
[0, 0, 1],
[1, 0, 0],
[0.5, 0.5, 0.7],
[-0.6, 0.2, -0.77],
[0.3, -0.9, 0.3],
[0.9, 0.1, -0.4],
].map(unit);
test("the joint table is the model build's: 37 nodes, every kind, frozen", () => {
assert.equal(TIANGONG_JOINTS.length, 37);
const kinds = new Map();
for (const joint of TIANGONG_JOINTS) {
kinds.set(joint.kind, (kinds.get(joint.kind) ?? 0) + 1);
assert.ok(Object.isFrozen(joint) && Object.isFrozen(joint.pivot));
assert.equal(joint.pivot.length, 3);
assert.ok(Math.abs(Math.hypot(...joint.axis) - 1) < 1e-9, joint.node);
if (joint.kind === 'dock') assert.equal(joint.rangeDeg, null);
else assert.equal(joint.rangeDeg.length, 2);
}
// 2 Tianhe wings, 4 lab wings and 6 vehicle wings turn on alpha joints.
assert.deepEqual(Object.fromEntries(kinds), {
alpha: 12,
beta: 4,
antenna: 1,
dock: 6,
arm: 14,
});
assert.equal(tiangongJoint('CMM_EP').parent, 'CMM_SHP');
assert.throws(() => tiangongJoint('NOT_A_JOINT'));
});
test('a one-axis wing turns its cell side onto the Sun, as far as its axis allows', () => {
for (const wing of TIANGONG_ONE_AXIS_WINGS) {
assert.ok(Math.abs(dot(wing.axis, wing.normal)) < 1e-9, wing.node);
for (const sun of SUNS) {
const angle = tiangongOneAxisAngle(sun, wing);
const normal = rotate(wing.normal, wing.axis, angle);
// The best the wing can do: the Sun's part across its axis.
const reachable = Math.hypot(
dot(sun, wing.normal),
dot(sun, cross(wing.axis, wing.normal)),
);
if (reachable < 0.05) continue;
assert.ok(
Math.abs(dot(normal, sun) - reachable) < 1e-6,
`${wing.node} ${sun}`,
);
}
}
// The Sun along the axis: nothing to steer by, the last angle holds.
const tianhe = TIANGONG_ONE_AXIS_WINGS[0];
assert.equal(tiangongOneAxisAngle([1, 0, 0], tianhe, 0.7), 0.7);
});
test('a lab wing faces the Sun exactly: alpha across it, beta onto it', () => {
for (const pair of TIANGONG_TWO_AXIS_WINGS) {
const joint = {
alphaAxis: pair.alpha.axis,
betaAxis: pair.beta.axis,
normal: pair.normal,
};
for (const sun of SUNS) {
if (Math.abs(dot(sun, pair.alpha.axis)) > 0.95) continue;
const { alpha, beta } = tiangongTwoAxisAngles(sun, joint);
// The beta joint hangs from the alpha joint: beta turns first.
const normal = rotate(
rotate(pair.normal, pair.beta.axis, beta),
pair.alpha.axis,
alpha,
);
assert.ok(dot(normal, sun) > 1 - 1e-6, `${pair.alpha.node} ${sun}`);
const wingAxis = rotate(pair.beta.axis, pair.alpha.axis, alpha);
assert.ok(
Math.abs(dot(wingAxis, sun)) < 1e-6,
'wing axis across the Sun',
);
}
// Alpha keeps the half turn nearer its last answer.
const first = tiangongTwoAxisAngles(unit([0.2, 1, 0.3]), joint, 0);
const flipped = tiangongTwoAxisAngles(
unit([0.2, 1, 0.3]),
joint,
first.alpha + Math.PI,
);
assert.ok(Math.abs(Math.abs(flipped.alpha - first.alpha) - Math.PI) < 1e-9);
// Sun along the lab: alpha holds.
assert.equal(tiangongTwoAxisAngles([1, 0, 0], joint, 0.4).alpha, 0.4);
}
});
test("in the Earth's shadow every wing turns flat to the Earth, edge into the flight", () => {
const targets = tiangongWingTargets(unit([0.3, -0.9, 0.3]), false, {
one: TIANGONG_ONE_AXIS_WINGS.map(() => 3),
alpha: TIANGONG_TWO_AXIS_WINGS.map(() => 3),
});
TIANGONG_ONE_AXIS_WINGS.forEach((wing, i) => {
const normal = rotate(wing.normal, wing.axis, targets.one[i]);
assert.ok(Math.abs(normal[1] - 1) < 1e-9, wing.node);
});
TIANGONG_TWO_AXIS_WINGS.forEach((pair, i) => {
// The nearer half turn to 3 rad is ±π, with beta making up the rest.
assert.ok(Math.abs(Math.cos(targets.alpha[i]) + 1) < 1e-9, pair.alpha.node);
const normal = rotate(
rotate(pair.normal, pair.beta.axis, targets.beta[i]),
pair.alpha.axis,
targets.alpha[i],
);
assert.ok(Math.abs(normal[1] - 1) < 1e-9);
});
// Lit, the targets face the Sun instead.
const lit = tiangongWingTargets([0, 0, 1], true);
assert.ok(Math.abs(Math.abs(lit.one[0]) - Math.PI / 2) < 1e-9);
});
test('the antenna aims at Tianlian, not TDRS: unit vectors, highest first', () => {
assert.deepEqual([...TIANGONG_RELAY_LONGITUDES_DEG], [79.9, 171.04, 10.5]);
assert.notDeepEqual(
[...TIANGONG_RELAY_LONGITUDES_DEG],
[...ISS_RELAY_LONGITUDES_DEG],
);
// Over 80°E at 400 km: Tianlian II-01 is nearly overhead.
const lon = (79.9 * Math.PI) / 180;
const r = 6_771_000;
const position = [r * Math.cos(lon), r * Math.sin(lon), 0];
const axes = {
x: [-Math.sin(lon), Math.cos(lon), 0],
y: [0, 0, 1],
z: unit(position),
};
const directions = tiangongRelayDirections(position, axes);
assert.equal(directions.length, 3);
for (const d of directions) assert.ok(Math.abs(Math.hypot(...d) - 1) < 1e-9);
assert.ok(directions[0][1] > 0.999, 'II-01 overhead');
assert.ok(
directions[0][1] >= directions[1][1] &&
directions[1][1] >= directions[2][1],
);
assert.deepEqual(TIANGONG_HGA.axis, [0, 1, 0]);
});
test('the arms sway on one side of rest only, so they lift off the hull', () => {
for (const joints of Object.values(TIANGONG_ARMS)) {
assert.equal(joints.length, 7);
for (const joint of joints) {
if (!joint.sway) {
assert.equal(joint.centre, 0);
continue;
}
// The sway never crosses rest unless it is centred on it (wrist pitch).
assert.ok(
joint.centre === 0 || Math.abs(joint.centre) > joint.sway,
joint.node,
);
assert.ok(joint.period > 0);
}
}
});
test('the model file has every joint node, under its parent, with an identity rest', () => {
const glb = readFileSync(
new URL(`../../../public${TIANGONG_MODEL_URL}`, import.meta.url),
);
const jsonLength = glb.readUInt32LE(12);
const gltf = JSON.parse(glb.subarray(20, 20 + jsonLength).toString('utf8'));
const byName = new Map(gltf.nodes.map((node, index) => [node.name, index]));
const parentOf = new Map();
gltf.nodes.forEach((node, index) =>
(node.children ?? []).forEach((child) => parentOf.set(child, index)),
);
for (const joint of TIANGONG_JOINTS) {
const index = byName.get(joint.node);
assert.ok(index !== undefined, joint.node);
const node = gltf.nodes[index];
assert.equal(
gltf.nodes[parentOf.get(index)].name,
joint.parent,
joint.node,
);
if (joint.kind !== 'dock') {
assert.equal(node.translation ?? null, null, joint.node);
assert.equal(node.rotation ?? null, null, joint.node);
assert.equal(node.matrix ?? null, null, joint.node);
}
}
// Each wing's mesh is thin along the cell normal the rules assume.
const thin = (meshNode, normal) => {
const node = gltf.nodes[byName.get(meshNode)];
const accessor =
gltf.accessors[gltf.meshes[node.mesh].primitives[0].attributes.POSITION];
const size = [0, 1, 2].map((i) => accessor.max[i] - accessor.min[i]);
const along = normal.findIndex((c) => c !== 0);
assert.ok(
size[along] < Math.min(...size.filter((_, i) => i !== along)) / 3,
meshNode,
);
};
for (const wing of TIANGONG_ONE_AXIS_WINGS)
thin(wing.node.replace(/_ALPHA$/, ''), wing.normal);
for (const pair of TIANGONG_TWO_AXIS_WINGS)
thin(pair.beta.node.replace(/_BETA$/, ''), pair.normal);
});
+280
View File
@@ -0,0 +1,280 @@
/**
* Tiangong's joint and dock-marker nodes, as the model file carries them in
* each node's glTF `extras` (the model build's joints.json, copied here; the
* app reads this table, never the file's extras). Root frame, meters: glTF +X
* port, +Y zenith, +Z forward. Every driven joint is a node with an identity
* rest transform whose moving mesh hangs beneath it, so a turn of `angle` about
* `axis` through `pivot` is `issAxisMatrix(pivot, axis, angle)`, as for the ISS.
* `kind`: alpha (a wing's drive about its boom), beta (a lab wing's turn about
* its own axis, under its alpha), arm (the two robotic arms, seven joints
* each, base to tip), antenna (the high-gain dish, rest boresight +Y), dock (a
* docking port's outer face, not driven: `axis` is a docked vehicle's
* direction, `rangeDeg` null). `approximate` marks the model author's
* estimates against published dimensions.
* @type {ReadonlyArray<Readonly<{node: string, pivot: number[], axis: number[],
* kind: 'alpha'|'beta'|'arm'|'antenna'|'dock', rangeDeg: number[]|null,
* approximate: boolean, parent: string}>>}
*/
export const TIANGONG_JOINTS = Object.freeze(
[
[
'TIANHE_ARRAY_PORT_ALPHA',
[1.4, 0, -6.7],
[1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'TIANHE_ARRAY_STBD_ALPHA',
[-1.4, 0, -6.7],
[-1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'TIANHE_HGA',
[0, 2.4, -6],
[0, 1, 0],
'antenna',
[-90, 90],
true,
'tiangong',
],
['DOCK_FORWARD', [0, 0, 8.3], [0, 0, 1], 'dock', null, false, 'tiangong'],
['DOCK_AFT', [0, 0, -8.3], [0, 0, -1], 'dock', null, false, 'tiangong'],
['DOCK_NADIR', [0, -2, 6.4], [0, -1, 0], 'dock', null, true, 'tiangong'],
['DOCK_ZENITH', [0, 2, 6.4], [0, 1, 0], 'dock', null, true, 'tiangong'],
['BERTH_PORT', [2.1, 0, 6.4], [1, 0, 0], 'dock', null, true, 'tiangong'],
['BERTH_STBD', [-2.1, 0, 6.4], [-1, 0, 0], 'dock', null, true, 'tiangong'],
[
'WENTIAN_ARRAY_FWD_ALPHA',
[-18.9, 0, 6.9],
[-1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'WENTIAN_ARRAY_FWD_BETA',
[-18.9, 0, 7.7],
[0, 0, 1],
'beta',
[-180, 180],
false,
'WENTIAN_ARRAY_FWD_ALPHA',
],
[
'WENTIAN_ARRAY_AFT_ALPHA',
[-18.9, 0, 5.9],
[-1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'WENTIAN_ARRAY_AFT_BETA',
[-18.9, 0, 5.1],
[0, 0, -1],
'beta',
[-180, 180],
false,
'WENTIAN_ARRAY_AFT_ALPHA',
],
[
'MENGTIAN_ARRAY_FWD_ALPHA',
[18.9, 0, 6.9],
[1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'MENGTIAN_ARRAY_FWD_BETA',
[18.9, 0, 7.7],
[0, 0, 1],
'beta',
[-180, 180],
false,
'MENGTIAN_ARRAY_FWD_ALPHA',
],
[
'MENGTIAN_ARRAY_AFT_ALPHA',
[18.9, 0, 5.9],
[1, 0, 0],
'alpha',
[-180, 180],
false,
'tiangong',
],
[
'MENGTIAN_ARRAY_AFT_BETA',
[18.9, 0, 5.1],
[0, 0, -1],
'beta',
[-180, 180],
false,
'MENGTIAN_ARRAY_AFT_ALPHA',
],
[
'CMM_SHR',
[0.5, 1.9, 3.6],
[0, 1, 0],
'arm',
[-270, 270],
true,
'tiangong',
],
[
'CMM_SHY',
[0.5, 2.3, 3.6],
[0, 0, 1],
'arm',
[-270, 270],
true,
'CMM_SHR',
],
[
'CMM_SHP',
[0.5, 2.7, 3.6],
[1, 0, 0],
'arm',
[-270, 270],
true,
'CMM_SHY',
],
[
'CMM_EP',
[0.5, 2.7, -0.9],
[1, 0, 0],
'arm',
[-270, 270],
true,
'CMM_SHP',
],
['CMM_WP', [0.5, 3.3, 3.6], [1, 0, 0], 'arm', [-270, 270], true, 'CMM_EP'],
['CMM_WY', [0.5, 3.3, 4.1], [0, 1, 0], 'arm', [-270, 270], true, 'CMM_WP'],
['CMM_WR', [0.5, 3.3, 4.6], [0, 0, 1], 'arm', [-270, 270], true, 'CMM_WY'],
[
'EMM_SHR',
[-6, 2.3, 6.4],
[0, 1, 0],
'arm',
[-270, 270],
true,
'tiangong',
],
[
'EMM_SHY',
[-6, 2.55, 6.4],
[1, 0, 0],
'arm',
[-270, 270],
true,
'EMM_SHR',
],
[
'EMM_SHP',
[-6, 2.85, 6.4],
[0, 0, 1],
'arm',
[-270, 270],
true,
'EMM_SHY',
],
['EMM_EP', [-8, 2.85, 6.4], [0, 0, 1], 'arm', [-270, 270], true, 'EMM_SHP'],
['EMM_WP', [-6, 3.2, 6.4], [0, 0, 1], 'arm', [-270, 270], true, 'EMM_EP'],
['EMM_WY', [-5.7, 3.2, 6.4], [0, 1, 0], 'arm', [-270, 270], true, 'EMM_WP'],
['EMM_WR', [-5.4, 3.2, 6.4], [1, 0, 0], 'arm', [-270, 270], true, 'EMM_WY'],
[
'SHENZHOU_FORWARD_ARRAY_PORT_ALPHA',
[1.4, 0, 15.1],
[1, 0, 0],
'alpha',
[-180, 180],
true,
'SHENZHOU_FORWARD',
],
[
'SHENZHOU_FORWARD_ARRAY_STBD_ALPHA',
[-1.4, 0, 15.1],
[-1, -0, -0],
'alpha',
[-180, 180],
true,
'SHENZHOU_FORWARD',
],
[
'SHENZHOU_NADIR_ARRAY_PORT_ALPHA',
[1.4, -8.8, 6.4],
[1, 0, 0],
'alpha',
[-180, 180],
true,
'SHENZHOU_NADIR',
],
[
'SHENZHOU_NADIR_ARRAY_STBD_ALPHA',
[-1.4, -8.8, 6.4],
[-1, -0, -0],
'alpha',
[-180, 180],
true,
'SHENZHOU_NADIR',
],
[
'TIANZHOU_AFT_ARRAY_PORT_ALPHA',
[1.4, 0, -16.6],
[1, 0, 0],
'alpha',
[-180, 180],
true,
'TIANZHOU_AFT',
],
[
'TIANZHOU_AFT_ARRAY_STBD_ALPHA',
[-1.4, 0, -16.6],
[-1, -0, -0],
'alpha',
[-180, 180],
true,
'TIANZHOU_AFT',
],
].map(([node, pivot, axis, kind, rangeDeg, approximate, parent]) =>
Object.freeze({
node,
pivot: Object.freeze(pivot),
axis: Object.freeze(axis),
kind,
rangeDeg: rangeDeg && Object.freeze(rangeDeg),
approximate,
parent,
}),
),
);
const BY_NODE = new Map(TIANGONG_JOINTS.map((joint) => [joint.node, joint]));
/**
* One joint by node name.
* @param {string} node
* @returns {(typeof TIANGONG_JOINTS)[number]}
*/
export function tiangongJoint(node) {
const joint = BY_NODE.get(node);
if (!joint) throw new Error(`Tiangong has no joint ${node}`);
return joint;
}
/** The visiting vehicles' mesh nodes; hiding one hides its arrays with it. */
export const TIANGONG_VEHICLE_NODES = Object.freeze([
'SHENZHOU_FORWARD',
'SHENZHOU_NADIR',
'TIANZHOU_AFT',
]);
+74
View File
@@ -0,0 +1,74 @@
import {
ISS_COMPANION_COARSE_M,
ISS_COMPANION_RADIUS_M,
ISS_COMPANION_SCAN_MS,
ISS_MODEL_LOCAL_AXES,
ISS_MODEL_MAX_DISTANCE_M,
ISS_MODEL_MIN_PX,
ISS_ORBIT_HIDE_M,
TIANGONG_CARD_CLEAR_M,
TIANGONG_MODEL_URL,
TIANGONG_NORAD,
} from './policy.js';
import { createStationModel } from './stationModel.js';
import { createTiangongArticulation } from './tiangongArticulation.js';
import { tiangongCockpitMount } from './tiangongMounts.js';
/**
* Whether a catalog entry at Tiangong is one of the station's own modules
* (CelesTrak lists them as "CSS (TIANHE)", "CSS (WENTIAN)", "CSS (MENGTIAN)")
* rather than a visiting Shenzhou or Tianzhou. A missing entry counts as a
* module.
* @param {number} noradId
* @param {{name?: string}|undefined} entry
* @returns {boolean}
*/
export function tiangongIsModule(noradId, entry) {
return (
noradId === TIANGONG_NORAD || /^CSS\s*\(/i.test(entry?.name ?? 'CSS (')
);
}
/**
* Tiangong as the station model factory describes it. The file is in meters
* (scale 1) and in the ISS file's frame, so it takes the ISS's local-axes
* mapping: the station is assumed to fly like the ISS, Tianhe along the
* velocity with the node (forward port) forward, the labs across the orbit,
* nadir to the Earth. Its joints are computed only; there is no telemetry.
* The Cockpit rides it from views on the model (`tiangongMounts.js`), and
* its ring follows the layer's orbit toggle like any tracked satellite's.
* @returns {import('./stationModel.js').StationModelSpec}
*/
export function tiangongModelSpec() {
return {
key: 'tiangong',
label: 'Tiangong', // i18n-ignore: the station's name, for log lines
norad: TIANGONG_NORAD,
modelUrl: TIANGONG_MODEL_URL,
scale: 1,
minPx: ISS_MODEL_MIN_PX,
maxDistanceM: ISS_MODEL_MAX_DISTANCE_M,
orbitHideM: ISS_ORBIT_HIDE_M,
cardClearM: TIANGONG_CARD_CLEAR_M,
companionRadiusM: ISS_COMPANION_RADIUS_M,
companionCoarseM: ISS_COMPANION_COARSE_M,
companionScanMs: ISS_COMPANION_SCAN_MS,
localAxes: ISS_MODEL_LOCAL_AXES,
isModule: tiangongIsModule,
createArticulation: createTiangongArticulation,
createTelemetry: null,
cockpitMount: tiangongCockpitMount,
// The Cockpit rides the station from a mount on the model, so the model
// stays while it does.
hideInCockpit: false,
syncOrbit: null,
};
}
/**
* Tiangong as a 3D model when the camera is close (stationModel.js).
* @param {{state: object, parts: object, resolveAsset?: (url: string) => string}} context
*/
export function createTiangongModel(context) {
return createStationModel(tiangongModelSpec(), context);
}
@@ -0,0 +1,125 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { issModelSpec } from './issModel.js';
import {
ISS_MODEL_LOCAL_AXES,
ISS_NORAD,
TIANGONG_MODEL_URL,
TIANGONG_NORAD,
} from './policy.js';
import { stationModelShouldShow } from './stationModel.js';
import { tiangongIsModule, tiangongModelSpec } from './tiangongModel.js';
test("Tiangong is CSS (TIANHE) by NORAD number, drawn at the file's meters", () => {
const spec = tiangongModelSpec();
assert.equal(TIANGONG_NORAD, 48274);
assert.equal(spec.norad, TIANGONG_NORAD);
assert.equal(spec.key, 'tiangong');
assert.equal(spec.scale, 1);
assert.equal(spec.modelUrl, TIANGONG_MODEL_URL);
// The same frame as the ISS file, so the same flight-axes mapping.
assert.equal(spec.localAxes, ISS_MODEL_LOCAL_AXES);
// No telemetry; Cockpit views on the model, so the model stays while the
// Cockpit rides it.
assert.equal(spec.createTelemetry, null);
assert.equal(typeof spec.cockpitMount, 'function');
assert.equal(spec.hideInCockpit, false);
assert.equal(spec.syncOrbit, null);
assert.equal(typeof spec.createArticulation().update, 'function');
});
test("the ISS spec keeps the ISS's own rules", () => {
const spec = issModelSpec({ parts: {} });
assert.equal(spec.norad, ISS_NORAD);
assert.equal(spec.key, 'iss');
assert.equal(spec.hideInCockpit, false);
assert.equal(typeof spec.cockpitMount, 'function');
assert.equal(typeof spec.createTelemetry, 'function');
assert.equal(typeof spec.syncOrbit, 'function');
});
test("the station's modules are CSS (…) entries; ships are vehicles", () => {
assert.equal(
tiangongIsModule(TIANGONG_NORAD, { name: 'CSS (TIANHE)' }),
true,
);
assert.equal(tiangongIsModule(53239, { name: 'CSS (WENTIAN)' }), true);
assert.equal(tiangongIsModule(54216, { name: 'CSS (MENGTIAN)' }), true);
assert.equal(tiangongIsModule(60000, { name: 'SHENZHOU-23 (SZ-23)' }), false);
assert.equal(tiangongIsModule(60001, { name: 'TIANZHOU-10' }), false);
assert.equal(
tiangongIsModule(60002, undefined),
true,
'unknown: not a vehicle',
);
});
test("a station hidden for the Cockpit stays hidden; the dot's rules otherwise", () => {
const shown = {
enabled: true,
showPoints: true,
hasStation: true,
classVisible: true,
tracked: false,
cockpitHidden: false,
};
assert.equal(stationModelShouldShow(shown), true);
assert.equal(
stationModelShouldShow({ ...shown, cockpitHidden: true }),
false,
);
assert.equal(stationModelShouldShow({ ...shown, hasStation: false }), false);
assert.equal(
stationModelShouldShow({ ...shown, classVisible: false, tracked: true }),
true,
);
});
test('the shipped asset is centred on the station, in meters, with its own textures', () => {
const glb = readFileSync(
new URL(`../../../public${TIANGONG_MODEL_URL}`, import.meta.url),
);
assert.equal(glb.toString('latin1', 0, 4), 'glTF');
const jsonLength = glb.readUInt32LE(12);
const gltf = JSON.parse(glb.subarray(20, 20 + jsonLength).toString('utf8'));
assert.deepEqual(gltf.scenes[0].nodes.length, 1);
const root = gltf.nodes[gltf.scenes[0].nodes[0]];
assert.equal(root.name, 'tiangong');
// The same compression and texture format as the ISS file.
assert.ok(gltf.extensionsUsed.includes('KHR_draco_mesh_compression'));
assert.ok(gltf.extensionsUsed.includes('EXT_texture_webp'));
assert.ok(gltf.textures.length > 0);
assert.equal(gltf.animations ?? undefined, undefined);
// Station extents (without the vehicles): 41.9 m across the lab wings,
// 57.2 m along the flight direction. The root puts their centre at the
// origin, so minimumPixelSize scales about the orbital position.
const vehicles = new Set([
'SHENZHOU_FORWARD',
'SHENZHOU_NADIR',
'TIANZHOU_AFT',
]);
const min = [Infinity, Infinity, Infinity];
const max = [-Infinity, -Infinity, -Infinity];
const visit = (index) => {
const node = gltf.nodes[index];
if (vehicles.has(node.name)) return;
const offset = node.translation ?? [0, 0, 0];
for (const primitive of gltf.meshes[node.mesh]?.primitives ?? []) {
const accessor = gltf.accessors[primitive.attributes.POSITION];
for (let i = 0; i < 3; i++) {
min[i] = Math.min(min[i], accessor.min[i] + offset[i]);
max[i] = Math.max(max[i], accessor.max[i] + offset[i]);
}
}
(node.children ?? []).forEach(visit);
};
root.children.forEach(visit);
assert.ok(Math.abs(max[0] - min[0] - 41.9) < 0.1, `X ${max[0] - min[0]}`);
assert.ok(Math.abs(max[2] - min[2] - 57.2) < 0.1, `Z ${max[2] - min[2]}`);
for (let i = 0; i < 3; i++)
assert.ok(
Math.abs((min[i] + max[i]) / 2 + root.translation[i]) < 0.05,
`centre ${i}`,
);
});
+156
View File
@@ -0,0 +1,156 @@
import { TIANGONG_NORAD } from './policy.js';
import {
issMountView,
issMountWorld,
issNextMountView,
issPreviousMountView,
} from './issMounts.js';
/**
* The Cockpit's views from Tiangong, as `issMounts.js` gives the ISS's: a
* place on the model (`eye`, metres on the model's axes: port, zenith,
* forward) and where it looks (`forward`, `up`). The model is the layer's
* own build (`public/models/README.md`): Tianhe along the forward axis with
* the node at its forward end, Wentian and Mengtian out to either side of
* the node, a Shenzhou on the forward and nadir ports and a Tianzhou aft.
* The views are from the modules the catalog lists (CSS (TIANHE), CSS
* (WENTIAN), CSS (MENGTIAN)) and from the docked vehicle, so each rides an
* entry of its own; Tiangong needs no cards.
*/
export const TIANGONG_WENTIAN_NORAD = 53239;
export const TIANGONG_MENGTIAN_NORAD = 54216;
const mount = (eye, forward, up) =>
Object.freeze({
eye: Object.freeze(eye),
forward: Object.freeze(forward),
up: Object.freeze(up),
});
export const TIANGONG_MOUNTS = Object.freeze({
/**
* Tianhe lies along the station's long axis, its wings at the aft end:
* from the top of the hull just forward of the wing roots, looking ahead
* along the station to the node and the two labs across it, the Earth
* below.
*/
tianhe: mount([0, 3.0, -3], [0, -0.4, 0.92], [0, 1, 0]),
/**
* Wentian reaches out from the node on the model's starboard side: from
* the top of its outer end, looking out past its wings and down, the
* arrays turning through the view as they follow the Sun.
*/
wentian: mount([-14, 2.9, 6.4], [-0.8, -0.5, 0.3], [0, 1, 0]),
/** Mengtian, the same on the port side. */
mengtian: mount([14, 2.9, 6.4], [0.8, -0.5, 0.3], [0, 1, 0]),
/**
* A docked vehicle (a Shenzhou, a Tianzhou): the catalog does not say
* which port it is on, so it takes the place of the Tianzhou on the aft
* port: looking out behind the station and down, the Earth falling away.
*/
docked: mount([2.4, 0.5, -13], [0, -0.5, -0.87], [0, 1, 0]),
});
export const TIANGONG_MOUNT_ORDER = Object.freeze([
'tianhe',
'wentian',
'mengtian',
'docked',
]);
/**
* The views on offer, in order, each with the name it is shown under and
* the catalog entry it rides: the modules whenever the station is drawn
* (with no entry to ride when the catalog lacks one), the docked vehicle
* only when there is one.
* @param {{tianheName?: string|null, wentianName?: string|null,
* mengtianName?: string|null, dockedName?: string|null,
* tianheNorad?: number|null, wentianNorad?: number|null,
* mengtianNorad?: number|null, dockedNorad?: number|null}} [input]
* @returns {Array<{key: 'tianhe'|'wentian'|'mengtian'|'docked',
* label: string, noradId: number|null, card: null}>}
*/
export function tiangongMountViews({
tianheName,
wentianName,
mengtianName,
dockedName,
tianheNorad = null,
wentianNorad = null,
mengtianNorad = null,
dockedNorad = null,
} = {}) {
const labels = {
tianhe: tiangongMountLabel(tianheName) || 'TIANHE',
wentian: tiangongMountLabel(wentianName) || 'WENTIAN',
mengtian: tiangongMountLabel(mengtianName) || 'MENGTIAN',
docked: tiangongMountLabel(dockedName),
};
const entries = {
tianhe: tianheNorad,
wentian: wentianNorad,
mengtian: mengtianNorad,
docked: dockedNorad,
};
return TIANGONG_MOUNT_ORDER.filter((key) => labels[key]).map((key) => ({
key,
label: labels[key],
noradId: Number.isFinite(entries[key]) ? entries[key] : null,
card: null,
}));
}
/**
* A view's name from its entry's catalog name, without the "CSS (…)" the
* catalog wraps the station's modules in.
* @param {string|null|undefined} name
* @returns {string}
*/
export function tiangongMountLabel(name) {
const text = String(name ?? '').trim();
const inner = /^CSS\s*\((.+)\)$/i.exec(text);
return (inner ? inner[1] : text).trim();
}
/**
* The station model spec's `cockpitMount` for Tiangong: the view asked for
* (the first when none is, or it is not on offer), in the world.
* @param {{key: string|null, centre: {x:number,y:number,z:number},
* axes: {x:number[], y:number[], z:number[]},
* name: (noradId: number|null) => string|null,
* entry: (noradId: number|null) => number|null,
* dockedVehicle: number|null}} input
* @returns {object}
*/
export function tiangongCockpitMount({
key,
centre,
axes,
name,
entry,
dockedVehicle,
}) {
const views = tiangongMountViews({
tianheName: name(TIANGONG_NORAD),
wentianName: name(TIANGONG_WENTIAN_NORAD),
mengtianName: name(TIANGONG_MENGTIAN_NORAD),
dockedName: name(dockedVehicle),
tianheNorad: entry(TIANGONG_NORAD),
wentianNorad: entry(TIANGONG_WENTIAN_NORAD),
mengtianNorad: entry(TIANGONG_MENGTIAN_NORAD),
dockedNorad: entry(dockedVehicle),
});
const view = issMountView(views, key);
return {
...issMountWorld(TIANGONG_MOUNTS[view.key], centre, axes),
key: view.key,
label: view.label,
noradId: view.noradId,
card: view.card,
views,
};
}
export { issNextMountView as tiangongNextMountView };
export { issPreviousMountView as tiangongPreviousMountView };
@@ -0,0 +1,127 @@
// src/layers/satellites/tiangongMounts.test.mjs — the Cockpit's views from
// Tiangong: offered in order from the modules the catalog lists and the
// docked vehicle, each riding its own entry, placed on the model's axes.
import assert from 'node:assert/strict';
import test from 'node:test';
import { TIANGONG_NORAD } from './policy.js';
import {
TIANGONG_MENGTIAN_NORAD,
TIANGONG_MOUNT_ORDER,
TIANGONG_MOUNTS,
TIANGONG_WENTIAN_NORAD,
tiangongCockpitMount,
tiangongMountLabel,
tiangongMountViews,
} from './tiangongMounts.js';
const summary = (views) =>
views.map(({ key, label, noradId }) => ({ key, label, noradId }));
test('the station offers its views in order, Tianhe first', () => {
assert.deepEqual(
[...TIANGONG_MOUNT_ORDER],
['tianhe', 'wentian', 'mengtian', 'docked'],
);
for (const key of TIANGONG_MOUNT_ORDER) assert.ok(TIANGONG_MOUNTS[key]);
assert.equal(
new Set([TIANGONG_NORAD, TIANGONG_WENTIAN_NORAD, TIANGONG_MENGTIAN_NORAD])
.size,
3,
);
const views = tiangongMountViews({
tianheName: 'CSS (TIANHE)',
wentianName: 'CSS (WENTIAN)',
mengtianName: 'CSS (MENGTIAN)',
dockedName: 'SHENZHOU-23 (SZ-23)',
tianheNorad: TIANGONG_NORAD,
wentianNorad: TIANGONG_WENTIAN_NORAD,
mengtianNorad: TIANGONG_MENGTIAN_NORAD,
dockedNorad: 69180,
});
assert.deepEqual(summary(views), [
{ key: 'tianhe', label: 'TIANHE', noradId: TIANGONG_NORAD },
{ key: 'wentian', label: 'WENTIAN', noradId: TIANGONG_WENTIAN_NORAD },
{ key: 'mengtian', label: 'MENGTIAN', noradId: TIANGONG_MENGTIAN_NORAD },
{ key: 'docked', label: 'SHENZHOU-23 (SZ-23)', noradId: 69180 },
]);
// Every view rides a catalog entry: no cards.
assert.ok(views.every((view) => view.card === null));
// No vehicle docked: no view from one. The modules are part of the model,
// so they are offered even when the catalog has no entry for them.
assert.deepEqual(summary(tiangongMountViews()), [
{ key: 'tianhe', label: 'TIANHE', noradId: null },
{ key: 'wentian', label: 'WENTIAN', noradId: null },
{ key: 'mengtian', label: 'MENGTIAN', noradId: null },
]);
});
test('the view is named after the entry, without the catalog’s "CSS (…)"', () => {
assert.equal(tiangongMountLabel('CSS (WENTIAN)'), 'WENTIAN');
assert.equal(tiangongMountLabel('TIANZHOU-10'), 'TIANZHOU-10');
assert.equal(tiangongMountLabel(null), '');
});
test('every mount is outside the hull, with a usable view frame', () => {
for (const key of TIANGONG_MOUNT_ORDER) {
const { eye, forward, up } = TIANGONG_MOUNTS[key];
// Tianhe and the labs are 4.2 m across: no eye inside them (2.1 m of an
// axis), and none far from the station (the labs reach ~20 m out).
const offAxis = Math.hypot(eye[0], eye[1]);
const offLab = Math.hypot(eye[1], eye[2] - 6.4);
assert.ok(offAxis > 2.1 || offLab > 2.1, `${key} sits inside a module`);
assert.ok(Math.hypot(...eye) < 40, `${key} is off the station`);
assert.ok(Math.hypot(...forward) > 0.9, `${key} looks somewhere`);
assert.ok(Math.hypot(...up) > 0.9, `${key} has an up`);
assert.ok(forward[1] < 0, `${key} looks down at the Earth`);
}
});
test('the spec’s mount gives the view asked for in the world, else the first', () => {
const centre = { x: 6_780_000, y: 0, z: 0 };
// The model's axes in the world: port = +y, zenith = +x (away from the
// Earth), forward = +z.
const axes = { x: [0, 0, 1], y: [0, 1, 0], z: [1, 0, 0] };
const names = new Map([
[TIANGONG_NORAD, 'CSS (TIANHE)'],
[TIANGONG_WENTIAN_NORAD, 'CSS (WENTIAN)'],
[69180, 'SHENZHOU-23 (SZ-23)'],
]);
const input = {
centre,
axes,
name: (id) => names.get(id) ?? null,
entry: (id) => (names.has(id) ? id : null),
dockedVehicle: 69180,
};
const first = tiangongCockpitMount({ ...input, key: null });
assert.equal(first.key, 'tianhe');
// The modules are 4.2 m across: no eye inside Tianhe (2.1 m of its axis).
assert.ok(
Math.hypot(TIANGONG_MOUNTS.tianhe.eye[0], TIANGONG_MOUNTS.tianhe.eye[1]) >
2.1,
);
assert.equal(first.noradId, TIANGONG_NORAD);
assert.deepEqual(
first.views.map((view) => view.key),
['tianhe', 'wentian', 'mengtian', 'docked'],
);
// Tianhe's eye is 3 m above the hull (+x in the world), 3 m aft (−z).
assert.ok(Math.abs(first.position.y) < 1e-9);
assert.ok(Math.abs(first.position.x - (6_780_000 + 3.0)) < 1e-9);
assert.ok(Math.abs(first.position.z + 3) < 1e-9);
assert.ok(first.direction.z > 0.9, 'looks ahead along the station');
assert.ok(first.direction.x < 0, 'and down');
const docked = tiangongCockpitMount({ ...input, key: 'docked' });
assert.equal(docked.key, 'docked');
assert.equal(docked.noradId, 69180);
assert.equal(docked.label, 'SHENZHOU-23 (SZ-23)');
assert.ok(docked.direction.z < -0.8, 'looks behind the station');
const unknown = tiangongCockpitMount({ ...input, key: 'cupola' });
assert.equal(unknown.key, 'tianhe', 'a view not on offer gives the first');
// The frame is unit and square.
const d = docked.direction;
const u = docked.up;
assert.ok(Math.abs(Math.hypot(d.x, d.y, d.z) - 1) < 1e-9);
assert.ok(Math.abs(Math.hypot(u.x, u.y, u.z) - 1) < 1e-9);
assert.ok(Math.abs(d.x * u.x + d.y * u.y + d.z * u.z) < 1e-9);
});
+141
View File
@@ -0,0 +1,141 @@
import { msg } from '../../i18n/index.js';
import { issCommandFastOrbit } from './issCommand.js';
import { ISS_ARM_LABELS, ISS_SUN_POSES } from './issStation.js';
import { TIANGONG_NORAD } from './policy.js';
import { trackedStation } from './stationModels.js';
import {
TIANGONG_ARMS,
TIANGONG_ONE_AXIS_WINGS,
TIANGONG_TWO_AXIS_WINGS,
} from './tiangongArticulation.js';
/** The lab wings' slider labels, per TIANGONG_TWO_AXIS_WINGS entry. */
const LAB_WING_LABELS = [
[msg('Wentian forward · alpha'), msg('Wentian forward · beta')],
[msg('Wentian aft · alpha'), msg('Wentian aft · beta')],
[msg('Mengtian forward · alpha'), msg('Mengtian forward · beta')],
[msg('Mengtian aft · alpha'), msg('Mengtian aft · beta')],
];
/**
* Tiangong as the STATION section describes it (stationPanel.js): its joint
* driver from the model part, computed values only (China publishes no
* telemetry), and the Manual controls: the Sun's position or a fast orbit,
* and the two arms posed by joint.
* @param {{state: object, parts: object}} context
* @returns {import('./stationPanel.js').StationDescription}
*/
export function tiangongStationDescription({ state: layerState, parts }) {
const model = () => parts.tiangongModel ?? null;
const armGroup = (id, label, joints) => ({
id,
label,
kind: 'sliders',
resume: msg('Resume sway'),
sliders: joints.map((joint, i) => ({
id: joint.node,
label: ISS_ARM_LABELS[i],
min: -120,
max: 120,
apply: (a, value) =>
a.setJoint(
joint.node,
joint.pivot,
joint.axis,
(value * Math.PI) / 180,
),
})),
resumeApply: (a) => a.resumeArm(id),
});
// Every wing has a joint of its own, so each can be set apart from the
// others; a wing not touched keeps following the Sun.
const wingSlider = (joint, label) => ({
id: joint.node,
label,
min: -180,
max: 180,
apply: (a, value) => a.setWingAngle(joint.node, (value * Math.PI) / 180),
});
const wingGroup = (id, label, sliders) => ({
id,
label,
kind: 'sliders',
resume: msg('Follow the Sun'),
sliders,
resumeApply: (a) => a.resumeWings(),
});
const tianheWings = wingGroup('tianhe-wings', msg('Tianhe wings (degrees)'), [
wingSlider(TIANGONG_ONE_AXIS_WINGS[0], msg('Port wing')),
wingSlider(TIANGONG_ONE_AXIS_WINGS[1], msg('Starboard wing')),
]);
const labWings = wingGroup(
'lab-wings',
msg('Lab wings (degrees)'),
TIANGONG_TWO_AXIS_WINGS.flatMap((pair, i) => [
wingSlider(pair.alpha, LAB_WING_LABELS[i][0]),
wingSlider(pair.beta, LAB_WING_LABELS[i][1]),
]),
);
return {
key: 'tiangong',
title: 'Tiangong', // i18n-ignore: the station's name
selected: () => trackedStation(layerState, parts)?.norad === TIANGONG_NORAD,
subjectName: () =>
layerState._catalog.get(layerState._trackedNorad)?.name?.trim() ||
`Tiangong · NORAD ${TIANGONG_NORAD}`,
articulation: () => model()?._articulation ?? null,
// No feed exists: the status line says so instead of waiting for one.
telemetry: () => ({ state: 'none', poseAgeMs: null, liveUntilMs: null }),
position: () =>
model()?._visualPosition?.() ??
layerState._trackedFrameCartesian ??
parts.rendering?._pointPosition?.(TIANGONG_NORAD) ??
null,
zoomLabel: msg('Zoom to Tiangong'),
notes: {
computed: msg(
'Arrays follow the Sun, the antenna aims at relay satellites and the arms sway for illustration. Computed: China publishes no live telemetry.',
),
},
groups: [
{
id: 'sun',
label: msg('Sun position'),
kind: 'choices',
choices: [
{
id: 'follow',
label: msg('Follow the Sun'),
isDefault: true,
apply: (a) => a.setOverride(null),
},
...ISS_SUN_POSES.map(({ id, label, sun, sunlit }) => ({
id,
label,
apply: (a) => {
const fixed = { sun, sunlit };
a.setOverride(() => fixed);
},
})),
{
id: 'orbit',
label: msg('Fast orbit (40 s)'),
apply: (a) => {
const start = Date.now();
a.setOverride((nowMs) => issCommandFastOrbit(nowMs - start));
},
},
],
},
tianheWings,
labWings,
armGroup('cmm', msg('Tianhe arm (degrees)'), TIANGONG_ARMS.cmm),
armGroup('emm', msg('Wentian arm (degrees)'), TIANGONG_ARMS.emm),
],
automatic: (a) => {
a.setOverride(null);
a.resumeWings();
a.resumeArm();
},
};
}
@@ -0,0 +1,179 @@
// src/layers/satellites/tiangongStation.test.mjs — Tiangong's STATION
// description: every wing can be set apart from the others, and Automatic
// hands them all back to the Sun.
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
createTiangongArticulation,
TIANGONG_ONE_AXIS_WINGS,
TIANGONG_TWO_AXIS_WINGS,
} from './tiangongArticulation.js';
import { issAxisMatrix } from './issArticulation.js';
import { tiangongStationDescription } from './tiangongStation.js';
import { TIANGONG_NORAD } from './policy.js';
function recordingArticulation() {
const calls = [];
return {
calls,
setOverride: (fn) => calls.push(['override', fn === null ? null : 'fn']),
setJoint: (node, pivot, axis, angle) => calls.push(['joint', node, angle]),
resumeArm: (key) => calls.push(['resumeArm', key ?? null]),
setWingAngle: (node, angle) => calls.push(['wing', node, angle]),
resumeWings: () => calls.push(['resumeWings']),
};
}
function description() {
const layerState = {
_trackedNorad: TIANGONG_NORAD,
_catalog: new Map([[TIANGONG_NORAD, { name: 'CSS (TIANHE)' }]]),
_points: new Map(),
_trackedFrameCartesian: null,
};
const parts = { tiangongModel: { _articulation: null } };
return tiangongStationDescription({ state: layerState, parts });
}
test('the description offers one slider per wing joint: two on Tianhe, eight on the labs', () => {
const d = description();
const tianhe = d.groups.find((g) => g.id === 'tianhe-wings');
const labs = d.groups.find((g) => g.id === 'lab-wings');
assert.equal(tianhe.kind, 'sliders');
assert.deepEqual(
tianhe.sliders.map((s) => s.id),
TIANGONG_ONE_AXIS_WINGS.slice(0, 2).map((w) => w.node),
);
assert.equal(labs.sliders.length, 8);
assert.deepEqual(
labs.sliders.map((s) => s.id),
TIANGONG_TWO_AXIS_WINGS.flatMap((p) => [p.alpha.node, p.beta.node]),
);
const labels = new Set(labs.sliders.map((s) => s.label));
assert.equal(labels.size, 8, 'every lab slider has a label of its own');
for (const slider of [...tianhe.sliders, ...labs.sliders]) {
assert.equal(slider.min, -180);
assert.equal(slider.max, 180);
}
// The arms are still there, after the wings.
assert.deepEqual(
d.groups.map((g) => g.id),
['sun', 'tianhe-wings', 'lab-wings', 'cmm', 'emm'],
);
});
test('a wing slider sets that wing alone, in radians; the group resume frees them all', () => {
const d = description();
const a = recordingArticulation();
const labs = d.groups.find((g) => g.id === 'lab-wings');
labs.sliders[3].apply(a, 90);
assert.deepEqual(a.calls, [['wing', labs.sliders[3].id, Math.PI / 2]]);
labs.resumeApply(a);
assert.deepEqual(a.calls.at(-1), ['resumeWings']);
assert.equal(labs.resume, 'Follow the Sun');
});
test('Automatic hands the Sun, the wings and the arms back', () => {
const d = description();
const a = recordingArticulation();
d.automatic(a);
assert.deepEqual(a.calls, [
['override', null],
['resumeWings'],
['resumeArm', null],
]);
});
/** A stand-in model whose nodes keep the last matrix written. */
function fakeModel() {
const nodes = new Map();
return {
ready: true,
nodes,
getNode(name) {
// Cesium's node clones the matrix it is given; the driver writes a
// shared scratch matrix, so the stand-in must clone too.
if (!nodes.has(name))
nodes.set(name, {
_matrix: null,
get matrix() {
return this._matrix;
},
set matrix(value) {
this._matrix = Cesium.Matrix4.clone(value);
},
});
return nodes.get(name);
},
};
}
test('the driver holds a wing set by hand at its angle while the others follow the Sun', () => {
const driver = createTiangongArticulation();
const model = fakeModel();
const date = new Date('2026-11-13T12:00:00Z');
const position = new Cesium.Cartesian3(6_780_000, 0, 0);
const axes = { x: [0, 1, 0], y: [0, 0, 1], z: [1, 0, 0] };
// A fixed Sun: the real one would fetch Cesium's Earth-orientation data.
const fixed = { sun: [0, 0.6, 0.8], sunlit: true };
driver.setOverride(() => fixed);
driver.update(model, date, position, axes, 1000);
const port = TIANGONG_ONE_AXIS_WINGS[0];
const starboard = TIANGONG_ONE_AXIS_WINGS[1];
const portBefore = Cesium.Matrix4.clone(model.getNode(port.node).matrix);
const starboardBefore = Cesium.Matrix4.clone(
model.getNode(starboard.node).matrix,
);
driver.setWingAngle(port.node, 1.2);
// Long after the last frame: the step is not rate-limited.
driver.update(model, date, position, axes, 11_000);
const expected = issAxisMatrix(
port.pivot,
port.axis,
1.2,
new Cesium.Matrix4(),
);
assert.ok(
Cesium.Matrix4.equalsEpsilon(
model.getNode(port.node).matrix,
expected,
1e-9,
),
'the port wing is at the set angle',
);
assert.ok(
Cesium.Matrix4.equalsEpsilon(
model.getNode(starboard.node).matrix,
starboardBefore,
1e-9,
),
'the starboard wing kept its Sun angle (same Sun, same date)',
);
assert.equal(
Cesium.Matrix4.equals(model.getNode(port.node).matrix, portBefore),
false,
'the set angle differs from the Sun angle',
);
driver.resumeWings();
driver.update(model, date, position, axes, 21_000);
assert.ok(
Cesium.Matrix4.equalsEpsilon(
model.getNode(port.node).matrix,
portBefore,
1e-9,
),
'back to the Sun once freed',
);
// Null frees one wing on its own.
driver.setWingAngle(port.node, 0.3);
driver.setWingAngle(port.node, null);
driver.update(model, date, position, axes, 31_000);
assert.ok(
Cesium.Matrix4.equalsEpsilon(
model.getNode(port.node).matrix,
portBefore,
1e-9,
),
);
});
+68 -6
View File
@@ -1,19 +1,21 @@
import { cameraOf } from '../../render/rendererOf.js';
import { entityFollowTarget, stopFollowing } from '../../data/followed.js';
import { satelliteClassText } from '../../data/satelliteClass.js';
import { fromDegreesInto } from '../../geo/ellipsoid.js';
import { clone, scale } from '../../geo/vector.js';
import { fromDegrees, fromDegreesInto } from '../../geo/ellipsoid.js';
import { clone, distance, scale } from '../../geo/vector.js';
import { t } from '../../i18n/index.js';
import { formatQuantity, unitLabel } from '../../ui/unitLabels.js';
import {
ISS_NORAD,
CONTEXT_REFRESH_INTERVAL_MS,
HIGH_ORBIT_ALTITUDE_M,
ISS_NORAD,
STATIONS,
TRACK_VIEW_FROM_HIGH_SCALE,
TRACK_VIEW_FROM_LEO,
TRACKED_ORBIT_COLOR,
} from './policy.js';
import { entityRecord, readEntityRecord } from '../../data/entityRecords.js';
import { modelFor } from './stationModels.js';
export function createTracking({ state: layerState, services, parts, source }) {
const { clearFocusTarget } = services.focus;
@@ -118,6 +120,8 @@ export function createTracking({ state: layerState, services, parts, source }) {
layerState._trackedEntity = null;
}
layerState._trackedNorad = null;
layerState._trackedDockedToStation = null;
layerState._trackedDockedToIss = false;
parts.controls._syncIssOrbit?.();
// A held Cockpit subject that stops being tracked gets its marks back.
if (layerState._cockpitSubjectNorad !== null)
@@ -384,11 +388,27 @@ export function createTracking({ state: layerState, services, parts, source }) {
: t('DOCKED · {name}', { name: companions[0] }),
);
}
// While a station's model shows, the card keeps clear of it: the gap
// follows the station's size on screen, in steps so the card is not
// republished every frame.
const clearPx =
modelFor(parts, layerState._trackedNorad)?._cardClearPx?.() ?? null;
const current = readEntityRecord(layerState._trackedEntity)?.labelModel;
// The overlay's gap is twice the anchor radius, so half the clearance,
// in 4 px steps. The step kept stands until the clearance has moved a
// pixel past the step's edge: at an edge, sub-pixel jitter in the range
// would otherwise flip it, and republish the card, every frame.
const kept = current?.anchorRadiusPx ?? null;
const anchorRadiusPx = !clearPx
? null
: kept !== null && Math.abs(clearPx / 2 - kept) < 3
? kept
: Math.round(clearPx / 8) * 4;
// Compare the WHOLE detail array: comparing only `details[0]` swallowed any
// change confined to the companions line, so the card would never republish.
const unchanged =
current?.title === title &&
(current?.anchorRadiusPx ?? null) === anchorRadiusPx &&
current?.details?.length === details.length &&
details.every((line, index) => current.details[index] === line);
if (unchanged) return;
@@ -396,10 +416,38 @@ export function createTracking({ state: layerState, services, parts, source }) {
title,
details,
accent: '#ffd84d',
...(anchorRadiusPx ? { anchorRadiusPx, anchorRadiusScale: null } : {}),
};
refreshTrackedReadout(layerState._trackedEntity);
}
/**
* The station a satellite is docked to: both orbits, propagated to one
* instant, within the station's companion radius (dots are moved at
* different moments, so their spacing cannot say). A station is docked to
* nothing, and the dense group never is.
* @param {number} noradId
* @returns {number|null} The station's NORAD number, or null.
*/
function _dockedToStation(noradId) {
if (STATIONS.some((station) => station.norad === noradId)) return null;
const sat = layerState._catalog.get(noradId);
if (!sat?.satrec || sat.group === 'dense') return null;
const date = new Date(layerState.now());
const at = (p) => fromDegrees(p.longitude, p.latitude, p.altitude);
let own = null;
for (const station of STATIONS) {
const entry = layerState._catalog.get(station.norad);
if (!entry?.satrec) continue;
own ??= parts.orbits.propagatePosition(sat.satrec, date);
if (!own) return null;
const there = parts.orbits.propagatePosition(entry.satrec, date);
if (there && distance(at(own), at(there)) <= station.companionRadiusM)
return station.norad;
}
return null;
}
function _trackSatellite(noradId, { origin = 'programmatic' } = {}) {
_clearTracking(false, { origin });
@@ -414,9 +462,18 @@ export function createTracking({ state: layerState, services, parts, source }) {
// Hide the dot — the tracked dot draws it, larger and over everything.
parts.rendering._hidePoint(noradId);
// Show orbital path
parts.rendering._showOrbitPath(noradId, TRACKED_ORBIT_COLOR);
if (noradId === ISS_NORAD) parts.controls._syncIssOrbit?.();
// Show orbital path. An object docked to the ISS (Nauka, a Progress…)
// flies the station's orbit under elements of its own: its ring would
// run beside the ISS's, a second line through the same station. The
// ISS's ring stands for it instead. Another station's ring is drawn only
// while that station is tracked, so its docked objects keep their own.
layerState._trackedDockedToStation = _dockedToStation(noradId);
layerState._trackedDockedToIss =
layerState._trackedDockedToStation === ISS_NORAD;
if (!layerState._trackedDockedToIss)
parts.rendering._showOrbitPath(noradId, TRACKED_ORBIT_COLOR);
if (noradId === ISS_NORAD || layerState._trackedDockedToIss)
parts.controls._syncIssOrbit?.();
// The tracked position propagates per evaluation through the per-frame
// cache (WS-D2) — dot, host readout, and camera share one SGP4 epoch per frame.
@@ -453,6 +510,11 @@ export function createTracking({ state: layerState, services, parts, source }) {
entityRecord(layerState._trackedEntity).trackedId = `satellites:${noradId}`;
entityRecord(layerState._trackedEntity).displayPosition =
_trackedDisplayCached;
// Up close a station is a 3D model: the card welds to where it is drawn.
// So does the card of an object docked to it, which the model stands in
// for.
entityRecord(layerState._trackedEntity).visualPosition = () =>
modelFor(parts, noradId)?._visualPosition?.() ?? null;
_updateTrackedSatelliteLabelModel(initialPos?.altitude ?? null);
const dotPosition = parts.rendering._pointPosition(noradId);
+57
View File
@@ -7103,6 +7103,63 @@ test('models moved every frame keep their shader and pick ids: only a new look o
}
});
test('a model poses its named nodes once ready, writes only what changed, and gives a dropped one its own pose back', async () => {
const { loads, restore } = fakeModelLoads();
try {
const part = createCesiumDraw({
scene: fakeScene(),
report: (error) => assert.fail(error),
});
const set = part.port.models({ id: 'station' });
const turn = (x) => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, 0, 0, 1];
const item = (nodes) => ({
id: 'iss',
pos: { lon: 0, lat: 0, height: 400e3 },
url: 'iss.glb',
orientation: { heading: 0, pitch: 0, roll: 0 },
nodes,
});
set.upsert([item({ joint: turn(1), other: turn(2), missing: turn(3) })]);
loads[0].resolve();
await settle();
const model = loads[0].model;
const writes = [];
const nodes = {};
for (const name of ['joint', 'other'])
nodes[name] = {
originalMatrix: Cesium.Matrix4.fromTranslation(
new Cesium.Cartesian3(9, 9, 9),
),
set matrix(m) {
writes.push(name);
// As Cesium's runtime node does: a copy, not the matrix handed in.
this.current = Cesium.Matrix4.clone(m);
},
};
model.getNode = (name) => {
assert.equal(model.ready, true, 'nodes are asked for once ready');
return nodes[name];
};
loads[0].ready();
assert.deepEqual(writes.sort(), ['joint', 'other'], 'posed when ready');
assert.equal(nodes.joint.current[12], 1);
assert.equal(nodes.other.current[12], 2);
writes.length = 0;
set.upsert([item({ joint: turn(1), other: turn(5), missing: turn(3) })]);
assert.deepEqual(writes, ['other'], 'only the node that moved');
assert.equal(nodes.other.current[12], 5);
writes.length = 0;
set.upsert([item({ other: turn(5) })]);
assert.deepEqual(writes, ['joint'], 'the dropped node, back to its pose');
assert.equal(nodes.joint.current[12], 9);
set.dispose();
} finally {
restore();
}
});
test('a model set that recedes fades its models toward the limb with their focus; focus alone dims', async () => {
const { recedeFactors, recedeFrame, recedeParams, recededAlpha } =
await import('../recession.js');
+58 -1
View File
@@ -5,7 +5,7 @@
* item's `url` re-poses and restyles its model in place (position,
* orientation, scale, `axisScale` and pixel bounds, `shading`, `tint`,
* `colorBlend`, `maskColor`, `clip`, `environmentMap`, `displayRange`,
* `show`); only a new `url` loads again, and the old model keeps drawing
* `nodes`, `show`); only a new `url` loads again, and the old model keeps drawing
* until the new one is ready, so a swap never blinks. `ready` fires once per
* load, when the model has loaded and is posed. An item with its `gltf`
* bytes is built from them; its url is then not fetched.
@@ -78,6 +78,62 @@ export const MODEL_RETRY_MS = 5000;
*/
export const RECEDE_WRITE_EPSILON = 0.005;
/**
* Each model's posed nodes (`ModelItem.nodes`): name → the 16 numbers last
* written, so an update that keeps a node's matrix writes nothing.
*/
const posedNodes = new WeakMap();
/** A posed name the model has no node for: looked up once, then skipped. */
const NO_NODE = Symbol('no such node');
const scratchNodeMatrix = new Cesium.Matrix4();
/**
* Write the item's node transforms to `model` once it is ready: changed
* ones only, and a node whose name left the map back to its authored pose.
* Names the model lacks are skipped.
*/
function poseNodes(item, model) {
if (model.ready !== true) return;
const wanted = item.nodes;
let posed = posedNodes.get(model);
if (!wanted && !posed) return;
if (!posed) posedNodes.set(model, (posed = new Map()));
for (const [name, last] of posed) {
if (wanted && Object.hasOwn(wanted, name)) continue;
posed.delete(name);
if (last === NO_NODE) continue;
const node = model.getNode(name);
if (node) node.matrix = Cesium.Matrix4.clone(node.originalMatrix);
}
if (!wanted) return;
for (const name of Object.keys(wanted)) {
const matrix = wanted[name];
if (!matrix || matrix.length < 16) continue;
const last = posed.get(name);
if (last === NO_NODE) continue;
if (last && sameMatrix(last, matrix)) continue;
const node = model.getNode(name);
if (!node) {
posed.set(name, NO_NODE);
continue;
}
// The last matrix written, kept in one array per node, copied in place.
let kept = last;
if (!(kept instanceof Float64Array)) {
kept = new Float64Array(16);
posed.set(name, kept);
}
for (let i = 0; i < 16; i++) kept[i] = matrix[i];
// The node copies the matrix it is given.
node.matrix = Cesium.Matrix4.fromArray(matrix, 0, scratchNodeMatrix);
}
}
function sameMatrix(a, b) {
for (let i = 0; i < 16; i++) if (a[i] !== b[i]) return false;
return true;
}
/** Cesium's own blend amount, for a `mix` that names none. */
const DEFAULT_MIX = 0.5;
@@ -1057,6 +1113,7 @@ export function createModelSets({
const hidden = range && !(range[1] > range[0]);
if (entry.styled?.range !== rangeKey) entry.styled = { range: rangeKey };
entry.dynamic = needsFrame(item, record.spec);
poseNodes(item, model);
apply(entry, model, entry.frame ?? STILL, hidden);
}
+3
View File
@@ -82,6 +82,7 @@ export const CESIUM_CHECKS = new Set([
'draw.models',
'draw.shapes.lit',
'draw.models.loadFailed',
'draw.models.nodes',
'draw.models.tint',
'draw.models.blend',
'draw.models.paint',
@@ -197,6 +198,7 @@ function nextFrame() {
export function createCesiumHarness({
name = 'cesium',
model,
modelNode,
missingModel,
cameraController,
} = {}) {
@@ -269,6 +271,7 @@ export function createCesiumHarness({
? {
assets: {
model,
...(modelNode ? { modelNode } : {}),
missingModel,
// The model's bytes, for the check that a model drawn from them
// never fetches its url.
+2
View File
@@ -77,6 +77,8 @@ export function cesiumCapabilities(scene, only) {
// Cesium scatters drawn models through the atmosphere wherever the
// scene draws fog (its models' atmosphere stage).
'modelAtmosphere',
// A model item's nodes, written to the model's runtime nodes.
'modelNodes',
'quads',
'meshes',
// Raster shells; other field kinds are refused.
+1
View File
@@ -38,6 +38,7 @@ test('capabilities follow what the scene supports', () => {
'models',
'modelParts',
'modelAtmosphere',
'modelNodes',
'quads',
'meshes',
'fields',
+65
View File
@@ -3769,6 +3769,71 @@ export function portChecks() {
},
{ capability: 'models' },
),
check(
'draw.models.nodes',
"a model item's nodes pose its named glTF nodes, live, and a node that leaves the map goes back to its authored pose",
async (h, r) => {
if (!h.assets?.model || !h.assets?.modelNode)
return { skip: 'no model with a named node in this harness' };
const NODE = h.assets.modelNode;
await overAustin(h, r);
const set = r.draw.models({ id: 'conf:models.nodes' });
const ready = [];
set.on('ready', (id) => ready.push(id));
const pos = h.toEcef({ ...AUSTIN, height: 0 });
// Far off along the node's own x axis: off the screen's centre.
const away = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5000, 0, 0, 1];
const model = (nodes) => ({
id: 'm',
pos,
url: h.assets.model,
orientation: { heading: 0, pitch: 0, roll: 0 },
minPixelSize: 160,
environmentMap: false,
shading: 'unlit',
tint: '#ff0000',
colorBlend: { mode: 'replace' },
...(nodes ? { nodes } : {}),
});
try {
set.set([model(null)]);
for (let i = 0; i < 600 && !ready.length; i++) await drawn(h, r, 1);
deepEqual(ready, ['m'], 'ready');
const s = r.query.project(pos);
// How many pixels of a patch at the model's centre are red.
const red = async () => {
await drawn(h, r, 3);
await settled(r);
r.frame.renderNow();
const image = r.readPixels({
crop: {
x: Math.round(s.x) - 4,
y: Math.round(s.y) - 4,
width: 9,
height: 9,
},
});
let n = 0;
for (let i = 0; i < image.data.length; i += 4) {
const [r0, g, b] = image.data.subarray(i, i + 3);
if (r0 > 180 && g < 70 && b < 70) n++;
}
return n;
};
ok((await red()) >= 40, 'authored pose: at the centre');
set.upsert([model({ [NODE]: away })]);
ok((await red()) < 10, 'the node moved away, live');
set.upsert([model({ [NODE]: away, NO_SUCH_NODE: away })]);
ok((await red()) < 10, 'a name the model lacks changes nothing');
set.upsert([model(null)]);
ok((await red()) >= 40, 'the node left the map: authored pose');
deepEqual(ready, ['m'], 'without loading again');
} finally {
set.dispose();
}
},
{ capability: 'modelNodes', bareSky: true },
),
check(
'draw.models.loadFailed',
'a model set says when a model fails to load, and loads it when added again',
+2
View File
@@ -68,6 +68,8 @@ export interface ConformanceHarness {
): void | Promise<void>;
assets?: {
model?: string;
/** The name of a node `model` has, for the `nodes` check. */
modelNode?: string;
missingModel?: string;
modelBytes?: () => Promise<Uint8Array>;
};
+2
View File
@@ -157,6 +157,8 @@ export type Capability =
| 'terrain'
/** Atmosphere scattering applied to drawn models. */
| 'modelAtmosphere'
/** A model item's `nodes` pose the model's named glTF nodes. */
| 'modelNodes'
/** Clouds, fog, haze, rain and snow around the view (`globe.weather`). */
| 'weather'
/** Imagery draped onto 3D tiles as well as the globe. */
Loaded 100 of 178 files, more files were not shown because too many files have changed in this diff. Show more