Files
gods-eye-view/src/layers/transit/qaMetrics.test.mjs
T
Bilawal Sidhu 0bb61f53c6 fix(transit): keep the real silhouettes under sensor presets, make the selected trail visible, put Transit in Movement (#596)
## Changes

Follow-up to #587 after the owner's first look at the merged transit layer on Google 3D tiles.

- **Sensor presets keep the real silhouettes.** Under NVG, thermal (white-hot, black-hot, Ironbow) and noir, vehicles are the same silhouettes as in normal view, filled opaque white with a 2 px dark halo, at the CRT display sizes (26 px fleet, 39 px selected). The solid rounded "signature" bodies are gone.
- **The selected vehicle's trail is visible.** The retained history is now draped onto 3D tiles and terrain (`GroundPolylinePrimitive`, `ClassificationType.BOTH`, the way the traffic heat-lines are drawn), 3 px core over a 5 px dark backing, per-segment age colour, a short draped head clipped to the sprite. Two defects kept it off screen before: Cesium's per-instance attribute getters return copies, so the renderer's show/colour edits were discarded, and a marker did not recover after the camera jumped to it, which hid the trail with it. Trail geometry is now prepared on selection independent of floor resolution and marker visibility; sparse long intervals (rail) keep a bounded marker corridor instead of dropping the interval; classification survives map-source changes.
- **Transit sits in the Movement panel group** between Street Traffic and Bike Share (the panel orders by `PANEL_GROUPS`, not by catalog order; the catalog is moved too).

## How it was verified

- `npm run format:check` (854 files), `npm run check:boundaries`, `npm test` (4,062 passing), `npm run build` clean; tracking regression 109/109 in a real browser on Google 3D tiles.
- Browser harness (`scripts/qa-transit.mjs`), keyed on Google 3D tiles and keyless: keyed 194 pass, with the trail pixel check passing at 300, 600 and 900 m; the remaining keyed failures are the per-frame allocation gate already recorded as a follow-up from #587 (CPU and frame time within budget), four readability lines at threshold edges, and the card-anchor check now counting frames where the selected marker is legitimately off screen; keyless 193 pass with the remaining misses being threshold edges on the thin tram silhouette (centre 0.83–0.88 against 0.85) and one bus ring 0.28 against 0.25 on a pure-white roof.
- New harness checks: `Google 3D selected trail visible at 6 of 8 projected samples` (repeated off/on framebuffer captures at 300/600/900 m, samples outside the sprite footprint, a background-change negative control; fails on main, passes here), a camera-arrival check (select a moving vehicle, `setView` onto it, marker shown and trail body drawn within 2 s), `PANEL_ORDER` pinned, raster tests comparing every sensor raster's mask and aspect ratio to the normal silhouette.
- Direct look on a keyed build: a live CapMetro bus at 30 m/s selected through the layer API draws its draped trail along the highway lane (harness capture `keyed-600m-trail-visible.jpg`).
- Adversarial review by Codex Astra before the last two fix passes (stack-switch classification, marker corridor under the vertex cap, pixel-gate loophole), all three fixed with regressions.

Docs: `docs/CURRENT-STATE.md` and `CHANGELOG.md` updated in this PR. No data-source changes.
2026-09-15 13:26:41 -05:00

434 lines
12 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import {
reduceMotion,
reduceAnchor,
reduceFleet,
percentile,
} from './qaMetrics.js';
const rows = () =>
Array.from({ length: 400 }, (_, i) => ({
x: i / 6,
y: 0,
z: 0,
displayT: (i * 1000) / 60,
expectedMps: 10,
segment: 1,
mx: i,
my: 20,
ax: i,
ay: 20,
cpuMs: 0.5,
intervalMs: 1000 / 60,
uploadBytes: 128000,
moving: 800,
poll: Math.floor(i / 200),
}));
test('ordinary 60 Hz motion passes; frozen motion, time and overspeed fail', () => {
assert.equal(reduceMotion(rows()).pass, true);
assert.equal(reduceMotion(rows().map((r) => ({ ...r, x: 0 }))).pass, false);
assert.equal(
reduceMotion(rows().map((r) => ({ ...r, displayT: 0 }))).pass,
false,
);
assert.equal(
reduceMotion(rows().map((r) => ({ ...r, x: r.x * 1.03 }))).pass,
false,
);
});
test('actual anchor agreement passes; equal travel with a fixed offset fails', () => {
assert.equal(reduceAnchor(rows()).pass, true);
assert.equal(
reduceAnchor(rows().map((r) => ({ ...r, ax: r.ax + 2 }))).pass,
false,
);
assert.equal(
reduceAnchor(rows().map((r) => ({ ...r, ax: null }))).pass,
false,
);
});
test('empty samples and unmeasured allocation never pass acceptance', () => {
assert.equal(percentile([]), Infinity);
assert.equal(reduceMotion([]).pass, false);
assert.equal(reduceAnchor([]).pass, false);
assert.equal(reduceFleet([], 800, 0, 1, 1).pass, false);
assert.equal(reduceFleet(rows(), 800, undefined, 1, 1).pass, false);
assert.equal(reduceFleet(rows(), 800, 100, 10000, 800 * 128 * 48).pass, true);
assert.equal(
reduceFleet(
rows().map((r) => ({ ...r, moving: 1 })),
800,
100,
10000,
10000,
).pass,
false,
);
});
test('ordinary frames judge drawn speed against elapsed time and name the offending pair', () => {
const slow = rows().map((r, i) => ({
...r,
key: 'mbta:sim-dup',
monoMs: (i * 1000) / 60,
displayT: r.displayT * 0.8858664517,
x: r.x * 0.8858664517,
}));
const result = reduceMotion(slow);
assert.equal(result.pass, false);
assert.equal(result.worstFrame.key, 'mbta:sim-dup');
assert.ok(result.worstRelativeError > 0.114);
});
test('per-scenario reducer resolves full vehicle keys and cannot pass empty lag', async () => {
const { reduceScenario } = await import('./qaMetrics.js');
const trace = {
out: {
'mbta:sim-straight': Array.from({ length: 5645 }, (_, i) => [
i * 17,
42 + i / 111320,
-71,
i * 17,
0,
1,
0,
i * 17 + 25000,
]),
},
};
const result = reduceScenario(trace, 'straight');
assert.equal(result.rows, 5645);
assert.equal(result.keys, 'mbta:sim-straight');
assert.equal(result.lagMin, 25);
assert.equal(reduceScenario({ out: {} }, 'gap').lagValid, false);
});
test('anchor names its judged conditions and accepts 1128 aligned frames across two polls', () => {
const fixture = Array.from({ length: 1128 }, (_, i) => ({
mx: i,
my: 0,
ax: i + 4e-9,
ay: 0,
poll: i < 564 ? 1 : 2,
}));
const result = reduceAnchor([
{ mx: 0, my: 0, ax: null, ay: null },
...fixture,
]);
assert.equal(result.pass, true);
assert.equal(result.conditions.pollTransition, true);
assert.equal(result.polls, 2);
assert.equal(
reduceAnchor(fixture.map((r) => ({ ...r, poll: 1 }))).pass,
false,
);
});
test('Boston mid-luma fixtures cannot qualify as bright or dark', async () => {
const { reduceBackground } = await import('./qaMetrics.js');
assert.equal(
reduceBackground('bright', Array(4).fill({ background: 0.423 })).pass,
false,
);
assert.equal(
reduceBackground('dark', Array(4).fill({ background: 0.403 })).pass,
false,
);
assert.equal(
reduceBackground('bright', Array(4).fill({ background: 0.65 })).pass,
true,
);
assert.equal(
reduceBackground('dark', Array(4).fill({ background: 0.2 })).pass,
true,
);
});
test('variable GPU work after sampling cannot change the judged playback speed', async () => {
const { reduceScriptedMotion } = await import('./qaMetrics.js');
const frames = Array.from({ length: 400 }, (_, i) => {
const r = Array(17).fill(0),
stamp = (i * 1000) / 60;
r[0] = stamp + (i % 2 ? 4 : 0);
r[3] = stamp;
r[9] = 10;
r[10] = 1;
r[11] = i / 6;
r[14] = 2;
r[15] = 'playing';
r[16] = stamp;
return r;
});
assert.equal(reduceScriptedMotion('mbta:sim-straight', frames).pass, true);
});
test('sensor thresholds retain in-scene NVG peak, halo and six-sprite minimum', async () => {
const { reduceSensorContrast } = await import('./qaMetrics.js');
const pixels = (p, n = 6) =>
Array.from({ length: n }, (_, i) => ({
key: `bus-${i}`,
verified: true,
...p,
}));
assert.equal(
reduceSensorContrast(
pixels({ centre: 0.64, ringMin: 0.03, background: 0.3 }),
'white',
'surveillance',
).pass,
true,
);
assert.equal(
reduceSensorContrast(
pixels({ centre: 0.64, ringMin: 0.03, background: 0.9 }),
'white',
'surveillance',
).pass,
true,
);
assert.equal(
reduceSensorContrast(
pixels({ centre: 0.59, ringMin: 0.03, background: 0.1 }),
'white',
'surveillance',
).pass,
false,
);
assert.equal(
reduceSensorContrast(pixels({ centre: 0.64, ringMin: 0.03 })).pass,
false,
);
assert.equal(
reduceSensorContrast(pixels({ centre: 0.86, ringMin: 0.2 })).pass,
true,
);
assert.equal(
reduceSensorContrast(pixels({ centre: 0.14, ringMax: 0.8 }), 'black').pass,
true,
);
assert.equal(
reduceSensorContrast(pixels({ centre: 1, ringMin: 0.1 }, 5)).unexercised,
true,
);
});
test('initial scripted synchronization is disclosed but subsequent resets fail', async () => {
const { reduceScenario } = await import('./qaMetrics.js');
const trace = {
out: {
'mbta:sim-straight': Array.from({ length: 100 }, (_, i) => [
i * 17,
42 + i / 111320,
-71,
i * 17,
i < 2 ? 0 : 1,
i < 2 ? 0 : 1,
0,
i * 17 + 25000,
]),
},
};
assert.equal(reduceScenario(trace, 'straight').resets, 0);
assert.equal(reduceScenario(trace, 'straight').initialResets, 1);
trace.out['mbta:sim-straight'][50][4] = 2;
assert.equal(reduceScenario(trace, 'straight').resets, 1);
});
test('D2 and D3 gate authored allocation inclusively and metro CPU at four milliseconds', () => {
const fleet = rows().map((r) => ({ ...r, moving: 3000, cpuMs: 3.4 }));
assert.equal(
reduceFleet(fleet, 3000, 8192, 10000, 3000 * 128 * 48).pass,
true,
);
assert.equal(
reduceFleet(fleet, 3000, 8193, 10000, 3000 * 128 * 48).pass,
false,
);
assert.equal(
reduceFleet(
fleet.map((r) => ({ ...r, cpuMs: 4.1 })),
3000,
0,
10000,
10000,
).pass,
false,
);
});
test('anchor ignores explicitly hidden markers but exposes missing painted cards and nonfinite world positions', () => {
const samples = rows();
samples.splice(100, 0, {
markerVisible: false,
mx: 0,
my: 0,
ax: null,
ay: null,
worldFinite: true,
});
assert.equal(reduceAnchor(samples).pass, true);
assert.equal(reduceAnchor(samples).hiddenFrames, 1);
samples[100].markerVisible = true;
assert.equal(reduceAnchor(samples).pass, false);
assert.equal(reduceAnchor(samples).invalidSamples.length, 1);
samples[100].markerVisible = false;
samples[100].worldFinite = false;
assert.equal(reduceAnchor(samples).pass, false);
});
test('scenario speed and catch-up use sampling time, not variable GPU completion time', async () => {
const { reduceScenario } = await import('./qaMetrics.js');
const rows = Array.from({ length: 100 }, (_, i) => {
const r = Array(17).fill(0);
r[0] = i * 17 + (i % 2 ? 4 : 0);
r[1] = 42 + (i * 0.17) / 111320;
r[2] = -71;
r[3] = i * 17;
r[5] = 1;
r[7] = r[3] + 25000;
r[16] = i * 17;
return r;
});
const result = reduceScenario(
{ out: { 'mbta:sim-straight': rows } },
'straight',
);
assert.ok(Math.abs(result.worstJump - 10) < 1e-6);
assert.equal(result.wallFaster, 0);
for (const r of rows) r[16] *= 0.8;
const fast = reduceScenario(
{ out: { 'mbta:sim-straight': rows } },
'straight',
);
assert.ok(fast.worstJump > 12);
assert.ok(fast.wallFaster > 0);
});
test('trail-head acceptance names every missing and failed condition', async () => {
const { reduceTrailHead } = await import('./qaMetrics.js');
const missing = reduceTrailHead({ selected: false }, { entityCount: 0 });
assert.equal(missing.pass, false);
assert.deepEqual(missing.conditions, {
selected: false,
enoughHeadSamples: false,
aligned: false,
stableBody: false,
stableEntityCount: false,
});
const good = {
selected: true,
headSamples: 100,
headErrorPx: 0,
bodyMutation: 0,
entityCount: 0,
};
assert.equal(reduceTrailHead(good, { entityCount: 0 }).pass, true);
assert.equal(
reduceTrailHead({ ...good, headErrorPx: 2 }, { entityCount: 0 }).pass,
false,
);
});
const trailPatch = (rgb) =>
Array.from({ length: 49 }, () => [...rgb, 255]).flat();
const trailEvidence = (on, off) => ({
onAgain: on,
offAgain: off,
tilesReady: true,
samples: Array.from({ length: 8 }, (_, i) => ({
x: i * 20 + 20,
y: 20,
radius: 3,
inFront: true,
})),
sprite: { x: 300, y: 20, radius: 24 },
});
test('trail pixels require repeatable contrast at six distinct samples outside the sprite', async () => {
const { reduceTrailPixels } = await import('./qaMetrics.js');
const off = Array.from({ length: 8 }, () => trailPatch([150, 150, 150]));
const on = off.map((p, i) => (i < 6 ? trailPatch([94, 240, 138]) : p));
const evidence = trailEvidence(on, off);
assert.equal(reduceTrailPixels(on, off, evidence).pass, true);
const five = on.map((p, i) => (i === 5 ? off[i] : p));
assert.equal(
reduceTrailPixels(five, off, trailEvidence(five, off)).pass,
false,
);
for (const rgb of [
[5, 8, 12],
[126, 126, 126],
]) {
const patches = off.map(() => trailPatch(rgb));
assert.equal(
reduceTrailPixels(patches, off, trailEvidence(patches, off)).present,
rgb[0] === 5 ? 8 : 0,
);
assert.equal(
reduceTrailPixels(patches, patches, trailEvidence(patches, patches))
.present,
0,
);
}
assert.equal(
reduceTrailPixels(on, off).pass,
false,
'two reads are insufficient',
);
assert.equal(
reduceTrailPixels(on, off, { ...evidence, tilesReady: false }).pass,
false,
);
assert.equal(
reduceTrailPixels(on, off, {
...evidence,
samples: Array(8).fill(evidence.samples[0]),
}).pass,
false,
);
assert.equal(
reduceTrailPixels(on, off, {
...evidence,
sprite: { x: 80, y: 20, radius: 200 },
}).pass,
false,
);
assert.equal(reduceTrailPixels([], [], trailEvidence([], [])).pass, false);
});
test('background refinement without a trail cannot pass repeated off/on acceptance', async () => {
const { reduceTrailPixels } = await import('./qaMetrics.js');
const grey = (n) => Array.from({ length: 8 }, () => trailPatch([n, n, n]));
const off = grey(100),
on = grey(30);
const evidence = trailEvidence(on, off);
assert.equal(
reduceTrailPixels(on, off, { ...evidence, offAgain: grey(30) }).pass,
false,
'one background transition is not a trail',
);
assert.equal(
reduceTrailPixels(on, off, {
...evidence,
offAgain: grey(170),
onAgain: grey(100),
}).pass,
false,
'equal deltas on a drifting baseline are not a trail',
);
assert.equal(
reduceTrailPixels(on, off, { ...evidence, onAgain: off }).pass,
false,
'contrast must repeat',
);
const first = off.map((p) => p.map((v, i) => (i < 8 ? on[0][i] : v)));
const second = off.map((p) =>
p.map((v, i) => (i >= 8 && i < 16 ? on[0][i] : v)),
);
assert.equal(
reduceTrailPixels(first, off, { ...evidence, onAgain: second }).pass,
false,
'the same pixels must change twice',
);
});