mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The trail no longer joins a day of history into one line. It lifts the pen across a gap of more than 48 minutes, an implied speed over 1,500 kt, or a report without altitude (a parked aircraft within 0.1 nm for under 3 h stays joined), and every history point is kept as its own segment. History never gets an invented altitude. The live end is the path the aircraft was drawn along, thinned to its shape, so it no longer cuts corners through turns; a late report trims what was drawn after it. Old segments are frozen in chunks, so a 2,000-point trail costs about 0.1 ms a frame. A tracked aircraft that misses an update shows STALE and is dimmed. It keeps flying on its last speed and heading for five minutes (at most 1,500 kt), then stops, dimmed, labelled SIGNAL LOST with the time since its last report, and is kept for ten minutes after that report so the camera keeps its target. Aircraft on or near known ground hold at their last report instead of coasting. Military flights follow the same rules.
178 lines
6.0 KiB
JavaScript
178 lines
6.0 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';
|
|
|
|
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 },
|
|
motion: { _signalLost: () => null },
|
|
};
|
|
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,
|
|
collection.add({
|
|
id,
|
|
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);
|
|
}
|
|
});
|