Files
gods-eye-view/src/data/iconSegment.test.mjs
T
Sameh Khamis 2c4c66c710 Draw civil flights from an icon set moved on the GPU
Every flight is now a row in the layer's icon set. Its motion segment
follows the same regime `_deadReckon` picks (interpolate between fixes,
warm up backward from the oldest, coast forward from the newest), and
one shared `_motionRegime` makes that choice for both. The shader moves
every untracked contact between polls, so the 12 Hz fleet tick no
longer touches each billboard. It now only re-plans expired rows,
floors grounded contacts, advances focus while needed, and runs the 3D
model regime.

Grounded contacts the floor lifts are pinned to a hold at the floored
position. Their nose glides on the GPU. Contacts within 50 km re-floor
every tick, and farther ones take turns about once a second. Low
contacts are judged for the horizon at no lower than 12 m above the
ellipsoid, as before. Below hover speed a contact's nose holds. A row
whose fleet model is drawn keeps its focus updated, because the model
reads it. Untracking re-plans and re-floors the icon from the tracked
course.

On the same views with about 6,700 OpenSky flights, frame gaps at p95
drop from 28-40 ms to 17 ms, and the fleet tick from 16-37 ms to about
2 ms at most.
2026-11-03 19:40:39 -08:00

248 lines
6.9 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
SEGMENT_STRIDE,
segmentCourse,
segmentPosition,
writeArcSegment,
writeCourseGlide,
writeHoldSegment,
writeLerpSegment,
} from './iconSegment.js';
import {
arcOffsetEnu,
lerpAngleDeg,
limitCourseStep,
norm180,
} from './motionModel.js';
const fix = Cesium.Cartesian3.fromDegrees(-97.04, 32.9, 10_500);
/** What the flights layer's _extrapolateFix draws for the same fix and dt. */
function productionArc(position, speed, trackDeg, turnRateDps, dt) {
const arc = arcOffsetEnu(speed, trackDeg, turnRateDps, dt, {});
const enu = Cesium.Transforms.eastNorthUpToFixedFrame(position);
const offset = new Cesium.Cartesian3(arc.east, arc.north, 0);
return {
position: Cesium.Matrix4.multiplyByPoint(
enu,
offset,
new Cesium.Cartesian3(),
),
course: arc.endCourseDeg,
};
}
function courseGap(a, b) {
return Math.abs(norm180(a - b));
}
test('a hold stays put to float32 encoding precision', () => {
const seg = new Float32Array(SEGMENT_STRIDE * 2);
writeHoldSegment(seg, 1, fix, 271);
const at = segmentPosition(seg, 1, 1234);
assert.ok(Cesium.Cartesian3.distance(at, fix) < 0.005);
assert.equal(segmentCourse(seg, 1, 99), 271);
});
test('a lerp matches Cesium.Cartesian3.lerp between two fixes and holds at both ends', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
const to = Cesium.Cartesian3.fromDegrees(-97.0, 32.93, 10_650);
writeLerpSegment(seg, 0, {
from: fix,
to,
t0: 100,
t1: 110,
course0Deg: 40,
courseSlopeDeg: 6,
});
for (const tau of [100, 102.5, 107, 110]) {
const want = Cesium.Cartesian3.lerp(
fix,
to,
(tau - 100) / 10,
new Cesium.Cartesian3(),
);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, tau), want) < 0.01,
`τ=${tau}`,
);
}
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 50), fix) < 0.01,
);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 500), to) < 0.01,
);
assert.ok(courseGap(segmentCourse(seg, 0, 105), 43) < 1e-4);
});
test('a lerp course reproduces the blended track-and-chord course across the segment', () => {
// _deadReckon: lerpAngle(lerpAngle(trackFrom, trackTo, t), chord, w).
const trackFrom = 350;
const trackTo = 20;
const chord = 10;
const w = 0.6;
const at = (t) => lerpAngleDeg(lerpAngleDeg(trackFrom, trackTo, t), chord, w);
const course0 = at(0);
const slope = norm180(trackTo - trackFrom) * (1 - w);
const seg = new Float32Array(SEGMENT_STRIDE);
const to = Cesium.Cartesian3.fromDegrees(-97.0, 32.93, 10_650);
writeLerpSegment(seg, 0, {
from: fix,
to,
t0: 0,
t1: 10,
course0Deg: course0,
courseSlopeDeg: slope,
});
for (const t of [0, 0.25, 0.5, 0.9, 1])
assert.ok(courseGap(segmentCourse(seg, 0, t * 10), at(t)) < 1e-3, `t=${t}`);
});
test('an arc matches the production turn for straight, slow, standard and tight turns', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
for (const turnRateDps of [0, 0.004, 0.01, 0.5, 3, -3, 12]) {
for (const dt of [0.08, 1, 30, 120, 300]) {
writeArcSegment(seg, 0, {
fix,
t0: 1000,
minDt: -60,
maxDt: 300,
speedMps: 240,
trackDeg: 305,
turnRateDps,
});
const want = productionArc(fix, 240, 305, turnRateDps, dt);
const got = segmentPosition(seg, 0, 1000 + dt);
assert.ok(
Cesium.Cartesian3.distance(got, want.position) < 0.05,
`ω=${turnRateDps}°/s dt=${dt}s off by ${Cesium.Cartesian3.distance(got, want.position)} m`,
);
assert.ok(
courseGap(segmentCourse(seg, 0, 1000 + dt), want.course) < 1e-3,
);
}
}
});
test('an arc extrapolates backward for warm-up and clamps both ends', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
writeArcSegment(seg, 0, {
fix,
t0: 500,
minDt: -60,
maxDt: 0,
speedMps: 200,
trackDeg: 90,
turnRateDps: 1.5,
});
const back = productionArc(fix, 200, 90, 1.5, -20);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 480), back.position) <
0.05,
);
const earliest = productionArc(fix, 200, 90, 1.5, -60);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 0), earliest.position) <
0.05,
);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 900), fix) < 0.01,
);
});
test('the course glide follows limitCourseStep onto a steady target', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
writeHoldSegment(seg, 0, fix, 10);
writeCourseGlide(seg, 0, 300, 50, 24);
let prev = 300;
for (let tau = 50; tau <= 56; tau += 0.08) {
assert.ok(courseGap(segmentCourse(seg, 0, tau), prev) < 1e-3, `τ=${tau}`);
prev = limitCourseStep(prev, 10, 24, 0.08);
}
assert.equal(segmentCourse(seg, 0, 80), 10);
});
test('writing a segment clears the previous one', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
writeArcSegment(seg, 0, {
fix,
t0: 0,
minDt: 0,
maxDt: 300,
speedMps: 250,
trackDeg: 0,
turnRateDps: 3,
});
writeCourseGlide(seg, 0, 90, 0, 30);
writeHoldSegment(seg, 0, fix, 5);
assert.ok(
Cesium.Cartesian3.distance(segmentPosition(seg, 0, 100), fix) < 0.005,
);
assert.equal(segmentCourse(seg, 0, 0), 5);
});
test('the course glide never outruns the rate while its target turns', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
writeArcSegment(seg, 0, {
fix,
t0: 0,
minDt: 0,
maxDt: 300,
speedMps: 200,
trackDeg: 90,
turnRateDps: 3,
});
writeCourseGlide(seg, 0, 60, 0, 24);
let prev = 60;
for (let tau = 0; tau <= 4; tau += 0.01) {
assert.ok(
courseGap(segmentCourse(seg, 0, tau), prev) < 0.05,
`τ=${tau.toFixed(2)}`,
);
prev = limitCourseStep(prev, 90 + 3 * (tau + 0.01), 24, 0.01);
}
assert.ok(
courseGap(segmentCourse(seg, 0, 1), 84) < 0.05,
'24° in the first second, not 27°',
);
assert.ok(
courseGap(segmentCourse(seg, 0, 10), 120) < 1e-3,
'then it follows the turn',
);
});
test('a zero-rate glide holds the course however the segment turns', () => {
const seg = new Float32Array(SEGMENT_STRIDE);
const to = Cesium.Cartesian3.fromDegrees(-97.04, 32.90001, 10_500);
for (const from of [0, 30]) {
writeLerpSegment(seg, 0, {
from: fix,
to,
t0: 0,
t1: 30,
course0Deg: 0,
courseSlopeDeg: 90,
});
writeCourseGlide(seg, 0, from, 0, 0);
for (const tau of [0, 10, 20, 30, 60])
assert.ok(
courseGap(segmentCourse(seg, 0, tau), from) < 1e-4,
`from ${from}° at τ=${tau}`,
);
}
writeArcSegment(seg, 0, {
fix,
t0: 0,
minDt: 0,
maxDt: 300,
speedMps: 1,
trackDeg: 90,
turnRateDps: 3,
});
writeCourseGlide(seg, 0, 90, 0, 0);
assert.ok(courseGap(segmentCourse(seg, 0, 20), 90) < 1e-4, 'arc turn held');
});