mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Flights and military now add their billboards through addBillboard and write show, position, scale, rotation, size and distance scaling through setBillboard, which keeps the app's copy in src/data/billboardMirror.js. Their reads go to billboardState instead of the Cesium billboard, so the layers no longer read back what they pushed to the renderer. A mirrored billboard needs an explicit width and height, because unset Cesium reports the loaded image's size. Colour is not mirrored yet: the cyber-sonar theme writes it too and tells the writers apart by the live value, so it moves with the effects port.
178 lines
6.1 KiB
JavaScript
178 lines
6.1 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import { routePlausible } from './routePlausible.js';
|
|
import { createTracking } from '../layers/flights/tracking.js';
|
|
import { addBillboard } from './billboardMirror.js';
|
|
|
|
const SFO = { lat: 37.6188, lon: -122.3754, code: 'SFO' };
|
|
const LAX = { lat: 33.9416, lon: -118.4085, code: 'LAX' };
|
|
const beyond = { lat: -35.818227816411174, lon: -66.16647396367095 };
|
|
const behind = { lat: 35.818227816411174, lon: 113.83352603632906 };
|
|
const antipode = { lat: -SFO.lat, lon: SFO.lon + 180 };
|
|
const midpoint = { lat: 35.8, lon: -120.4 };
|
|
|
|
const plausible = (position, origin = SFO, destination = LAX) =>
|
|
routePlausible({
|
|
latDeg: position.lat,
|
|
lonDeg: position.lon,
|
|
altitudeM: 10000,
|
|
verticalRateMps: 0,
|
|
origin,
|
|
destination,
|
|
});
|
|
|
|
// Independent spherical oracle: native unit-vector angular distances, without
|
|
// the production bearing/cross-track/along-track calculations.
|
|
const unit = ({ lat, lon }) => {
|
|
const latitude = Cesium.Math.toRadians(lat);
|
|
const longitude = Cesium.Math.toRadians(lon);
|
|
return new Cesium.Cartesian3(
|
|
Math.cos(latitude) * Math.cos(longitude),
|
|
Math.cos(latitude) * Math.sin(longitude),
|
|
Math.sin(latitude),
|
|
);
|
|
};
|
|
const angle = (a, b) => Cesium.Cartesian3.angleBetween(unit(a), unit(b));
|
|
const excess = (position, origin, destination) =>
|
|
angle(origin, position) +
|
|
angle(position, destination) -
|
|
angle(origin, destination);
|
|
|
|
test('a short airport route cannot describe a plane thousands of kilometres beyond its destination', () => {
|
|
assert.ok(excess(beyond, SFO, LAX) > 2.9);
|
|
assert.equal(plausible(beyond), false);
|
|
});
|
|
|
|
test('backwards and antipodal extensions are not the scheduled airport leg', () => {
|
|
for (const position of [behind, antipode]) {
|
|
assert.ok(excess(position, SFO, LAX) > 3);
|
|
assert.equal(plausible(position), false);
|
|
}
|
|
});
|
|
|
|
test('ordinary route offsets and generous endpoint extensions stay plausible', () => {
|
|
assert.ok(excess(midpoint, SFO, LAX) < 0.001);
|
|
for (const position of [midpoint, SFO, LAX, { lat: 36.5, lon: -119.5 }]) {
|
|
assert.equal(plausible(position), true);
|
|
}
|
|
// ~167 km past either endpoint is outside the 130 km endpoint circle,
|
|
// but remains inside the 200 km coarse-route tolerance.
|
|
const origin = { lat: 0, lon: 0 };
|
|
const destination = { lat: 0, lon: 10 };
|
|
assert.equal(plausible({ lat: 0, lon: -1.5 }, origin, destination), true);
|
|
assert.equal(plausible({ lat: 0, lon: 11.5 }, origin, destination), true);
|
|
});
|
|
|
|
test('the generous endpoint tolerance still excludes a clearly different leg', () => {
|
|
const origin = { lat: 0, lon: 0 };
|
|
const destination = { lat: 0, lon: 10 };
|
|
assert.equal(plausible({ lat: 0, lon: -2.5 }, origin, destination), false);
|
|
assert.equal(plausible({ lat: 0, lon: 12.5 }, origin, destination), false);
|
|
});
|
|
|
|
test('minor-arc admission works across the antimeridian and near the pole', () => {
|
|
const dateline = [
|
|
{ lat: 10, lon: 170 },
|
|
{ lat: 10, lon: -170 },
|
|
];
|
|
assert.equal(plausible({ lat: 10.15, lon: 180 }, ...dateline), true);
|
|
assert.equal(plausible({ lat: -10.15, lon: 0 }, ...dateline), false);
|
|
const polar = [
|
|
{ lat: 80, lon: -60 },
|
|
{ lat: 80, lon: 60 },
|
|
];
|
|
const top = { lat: 84.96163122670251, lon: 0 };
|
|
assert.ok(excess(top, ...polar) < 1e-8);
|
|
assert.equal(plausible(top, ...polar), true);
|
|
assert.equal(plausible({ lat: -top.lat, lon: 180 }, ...polar), false);
|
|
});
|
|
|
|
test('the forward tolerance survives the signed-angle branch cut in both directions', () => {
|
|
const origin = { lat: 0, lon: 0 };
|
|
for (const direction of [-1, 1]) {
|
|
const destination = { lat: 0, lon: direction * 179.9 };
|
|
const within = { lat: 0, lon: direction * -178.8 };
|
|
const endpointGapKm = angle(destination, within) * 6371.0088;
|
|
assert.ok(endpointGapKm > 130 && endpointGapKm < 200);
|
|
assert.equal(plausible(within, origin, destination), true);
|
|
assert.equal(
|
|
plausible({ lat: 0, lon: direction * -178 }, origin, destination),
|
|
false,
|
|
);
|
|
}
|
|
});
|
|
|
|
test('unjudgeable endpoint geometry and missing coordinates keep the loose contract', () => {
|
|
assert.equal(
|
|
plausible({ lat: 0, lon: -90 }, { lat: 0, lon: 0 }, { lat: 0, lon: 180 }),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
plausible({ lat: 45, lon: 0 }, { lat: 0, lon: 0 }, { lat: 0, lon: 0 }),
|
|
true,
|
|
);
|
|
assert.equal(plausible(beyond, SFO, null), true);
|
|
assert.equal(plausible(beyond, null, null), true);
|
|
});
|
|
|
|
test('the actual native tracked label hides the wrong leg and keeps a healthy route', (t) => {
|
|
const collection = new Cesium.BillboardCollection();
|
|
t.after(() => collection.destroy());
|
|
const flightState = {
|
|
records: { data: new Map(), missingPolls: new Map() },
|
|
feed: { _backoff: false },
|
|
_billboards: new Map(),
|
|
_scratchCarto: new Cesium.Cartographic(),
|
|
};
|
|
// Only application host services are supplied. Route admission, WGS84
|
|
// billboard conversion and tracked-label formatting are the actual owners.
|
|
const services = Object.fromEntries(
|
|
[
|
|
'context',
|
|
'trails',
|
|
'geoid',
|
|
'groundFloor',
|
|
'focus',
|
|
'militaryRegistry',
|
|
'readout',
|
|
'camera',
|
|
'picking',
|
|
].map((name) => [name, {}]),
|
|
);
|
|
services.aircraftPresentation = { isTr3b: () => false };
|
|
const parts = { queries: { _contactLabel: (_, info) => info.callsign } };
|
|
const tracking = createTracking({ flightState, services, parts });
|
|
for (const [position, expected] of [
|
|
[beyond, false],
|
|
[midpoint, true],
|
|
]) {
|
|
const id = 'abc001';
|
|
const route = { origin: SFO, destination: LAX };
|
|
flightState.records.data.set(id, {
|
|
callsign: 'OWNED001',
|
|
altitude: 10000,
|
|
verticalRate: 0,
|
|
route,
|
|
});
|
|
flightState._billboards.set(
|
|
id,
|
|
addBillboard(collection, {
|
|
id,
|
|
width: 20,
|
|
height: 20,
|
|
position: Cesium.Cartesian3.fromDegrees(
|
|
position.lon,
|
|
position.lat,
|
|
10000,
|
|
),
|
|
}),
|
|
);
|
|
assert.equal(
|
|
tracking._trackedLabelText(id).includes('SFO → LAX'),
|
|
expected,
|
|
);
|
|
assert.equal(tracking._routeIsPlausible(id, route), expected);
|
|
}
|
|
});
|