Files
gods-eye-view/src/layers/transit/qaMetrics.js
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

404 lines
12 KiB
JavaScript

/** Acceptance reducers. Missing, non-finite or unexercised evidence never passes. */
export function percentile(values, fraction = 0.95) {
if (!values.length || values.some((v) => !Number.isFinite(v)))
return Infinity;
const sorted = [...values].sort((a, b) => a - b);
return sorted[Math.max(0, Math.ceil(sorted.length * fraction) - 1)];
}
export function reduceMotion(rows, tolerance = 0.02) {
let tested = 0,
moving = 0,
worstRelativeError = 0,
distance = 0,
worstFrame = null;
for (let i = 1; i < rows.length; i++) {
const a = rows[i - 1],
b = rows[i];
if (
!(a.expectedMps > 0) ||
a.segment !== b.segment ||
a.toSeq !== b.toSeq ||
(a.phase && a.phase !== 'playing') ||
(b.phase && b.phase !== 'playing')
)
continue;
const seconds =
(Number.isFinite(a.monoMs) && Number.isFinite(b.monoMs)
? b.monoMs - a.monoMs
: b.displayT - a.displayT) / 1000;
if (!(seconds > 0)) {
tested++;
worstRelativeError = Infinity;
continue;
}
const metres = Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
const error = Math.abs(metres / seconds / a.expectedMps - 1);
tested++;
if (error > worstRelativeError || !Number.isFinite(error))
worstFrame = {
key: b.key,
fromIndex: i - 1,
toIndex: i,
from: a,
to: b,
seconds,
metres,
error,
};
if (metres > 0.00001) moving++;
distance += metres;
worstRelativeError = Math.max(
worstRelativeError,
Number.isFinite(error) ? error : Infinity,
);
}
return {
pass:
tested > 30 &&
moving === tested &&
distance > 1 &&
worstRelativeError <= tolerance,
tested,
moving,
distance,
worstRelativeError,
worstFrame,
tolerance,
};
}
export function reduceAnchor(rows) {
const hiddenFrames = rows.filter((r) => r.markerVisible === false).length;
const invalidWorld = rows.filter((r) => r.worldFinite === false);
rows = rows.filter((r) => r.markerVisible !== false);
// The host acquires its first card asynchronously. Only its leading acquisition
// frames are outside the anchor test; any later missing anchor is a failure.
const acquired = rows.findIndex((r) =>
[r.mx, r.my, r.ax, r.ay].every(Number.isFinite),
);
const acquisitionFrames = acquired < 0 ? rows.length : acquired;
rows = rows.slice(acquisitionFrames);
let samples = 0,
moving = 0,
maxErrorPx = 0;
for (let i = 0; i < rows.length; i++) {
const r = rows[i];
if (![r.mx, r.my, r.ax, r.ay].every(Number.isFinite)) continue;
samples++;
maxErrorPx = Math.max(maxErrorPx, Math.hypot(r.mx - r.ax, r.my - r.ay));
const a = rows[i - 1];
if (a && Math.hypot(r.mx - a.mx, r.my - a.my) > 0.0001) moving++;
}
const polls = new Set(rows.map((r) => r.poll).filter(Number.isFinite)).size;
const conditions = {
enoughSamples: samples > 30,
allFinite: samples === rows.length && invalidWorld.length === 0,
moving: moving > 30,
withinOnePixel: maxErrorPx <= 1,
pollTransition: polls >= 2,
};
return {
pass: Object.values(conditions).every(Boolean),
conditions,
hiddenFrames,
invalidSamples: rows
.filter((r) => ![r.mx, r.my, r.ax, r.ay].every(Number.isFinite))
.slice(0, 8),
invalidWorld: invalidWorld.slice(0, 8),
acquisitionFrames,
inputFrames: rows.length + acquisitionFrames + hiddenFrames,
polls,
samples,
moving,
maxErrorPx,
};
}
export function reduceFleet(
rows,
count,
allocationBytesPerFrame,
retainedBytes,
fixBytes,
) {
const street = count === 800;
const limits = {
cpuMs: street ? 1 : 4,
intervalMs: street ? 20 : 25,
uploadBytes: street ? 262144 : 1048576,
allocationBytes: 8192,
retainedBytes: (street ? 24 : 48) * 1048576,
fixBytes: count * 128 * 48,
};
const metrics = {
frames: rows.length,
cpuP95: percentile(rows.map((r) => r.cpuMs)),
intervalP95: percentile(rows.map((r) => r.intervalMs)),
uploadMax: rows.length
? Math.max(...rows.map((r) => r.uploadBytes))
: Infinity,
movingMin: rows.length ? Math.min(...rows.map((r) => r.moving)) : 0,
allocationBytesPerFrame,
retainedBytes,
fixBytes,
};
const motion = reduceMotion(rows);
return {
pass:
rows.length >= 300 &&
motion.pass &&
metrics.movingMin === count &&
metrics.cpuP95 <= limits.cpuMs &&
metrics.intervalP95 <= limits.intervalMs &&
metrics.uploadMax > 0 &&
metrics.uploadMax <= limits.uploadBytes &&
Number.isFinite(allocationBytesPerFrame) &&
allocationBytesPerFrame <= limits.allocationBytes &&
Number.isFinite(retainedBytes) &&
retainedBytes > 0 &&
retainedBytes <= limits.retainedBytes &&
fixBytes > 0 &&
fixBytes <= limits.fixBytes,
limits,
metrics,
motion,
};
}
export function reduceScenario(trace, key) {
const keys = key.startsWith('mbta:') ? key : `mbta:sim-${key}`;
const rows = trace.out[keys] || [];
let moved = 0;
let total = 0;
let worstJump = 0;
let speedWorst = 0;
let wallFaster = 0;
let lagMax = 0;
let lagMin = Infinity;
const initialResets = (rows.find((r) => r[5] === 1) || rows[0])?.[4] || 0;
let resets = 0;
let backwards = 0;
for (let i = 1; i < rows.length; i += 1) {
const a = rows[i - 1];
const b = rows[i];
const d = Math.hypot(
(b[1] - a[1]) * 111320,
(b[2] - a[2]) * 111320 * Math.cos((a[1] * Math.PI) / 180),
);
// Position and playback time were sampled in preRender; GPU completion
// jitter in column zero must not masquerade as acceleration or catch-up.
const dWall =
(Number.isFinite(a[16]) && Number.isFinite(b[16])
? b[16] - a[16]
: b[0] - a[0]) / 1000;
const dPlay = (b[3] - a[3]) / 1000;
total += d;
if (d > 0.05) moved += 1;
worstJump = Math.max(worstJump, d / Math.max(dWall, 1 / 120));
if (dPlay > dWall * 1.02 + 0.002) wallFaster += 1;
if (dPlay > 0 && d > 0.001) speedWorst = Math.max(speedWorst, d / dPlay);
if (b[1] < a[1] - 0.5 / 111320) backwards += 1;
resets = Math.max(resets, b[4] - initialResets);
const lag = (b[7] - b[3]) / 1000;
lagMax = Math.max(lagMax, lag);
lagMin = Math.min(lagMin, lag);
}
return {
keys,
lagValid:
rows.length > 1 && Number.isFinite(lagMin) && Number.isFinite(lagMax),
rows: rows.length,
moved,
total,
worstJump,
speedWorst,
wallFaster,
lagMax,
lagMin,
resets,
initialResets,
backwards,
last: rows.at(-1),
first: rows[0],
};
}
/** Choose actual sampled backgrounds, never infer brightness from a place name. */
export function reduceBackground(name, pixels) {
const values = pixels.map((p) => p.background);
const luma = values.length
? values.reduce((a, b) => a + b, 0) / values.length
: NaN;
const threshold = name === 'bright' ? 0.55 : 0.35;
return {
pass:
values.length >= 4 &&
values.every(Number.isFinite) &&
(name === 'bright' ? luma >= threshold : luma <= threshold),
luma,
samples: values.length,
threshold,
comparison: name === 'bright' ? '>=' : '<=',
};
}
/** Convert captured tuples without confusing paint completion with the playback clock. */
export function reduceScriptedMotion(key, rows) {
return reduceMotion(
rows.map((r) => ({
key,
monoMs: r[16],
x: r[11],
y: r[12],
z: r[13],
displayT: r[3],
expectedMps: r[9],
segment: r[10],
toSeq: r[14],
phase: r[15],
})),
);
}
/**
* In-scene sensor signatures retain the active shader. Surveillance peak white
* is P43 phosphor (0.16, 1, 0.22): Rec.601 luma 0.65992. D1 requires 90% of
* that peak and a ring <= 0.25. Local background delta is diagnostic.
* White-hot, Ironbow and noir require 0.85; black-hot keeps the inverse.
* Six verified, unobscured sprites are required; absence is UNEXERCISED.
*/
export function reduceSensorContrast(pixels, polarity = 'white', preset = '') {
const limits =
polarity === 'black'
? { centreMax: 0.15, ringMin: 0.75 }
: {
centreMin:
preset === 'surveillance'
? 0.9 * (0.299 * 0.16 + 0.587 + 0.114 * 0.22)
: 0.85,
ringMax: 0.25,
backgroundDeltaMin: null,
};
const judged = pixels
.filter((p) => p.verified === true)
.map((p) => ({
key: p.key,
centre: p.centre,
background: p.background,
backgroundDelta: p.centre - p.background,
ring: polarity === 'black' ? p.ringMax : p.ringMin,
pass:
polarity === 'black'
? p.centre <= limits.centreMax && p.ringMax >= limits.ringMin
: p.centre >= limits.centreMin &&
p.ringMin <= limits.ringMax &&
(limits.backgroundDeltaMin === null ||
p.centre - p.background >= limits.backgroundDeltaMin),
}));
return {
pass: judged.length >= 6 && judged.every((p) => p.pass),
unexercised: judged.length < 6,
reason:
judged.length < 6
? `Only ${judged.length} verified unobscured sprites; need 6`
: null,
limits,
judged,
};
}
/** Selected trail evidence stays inspectable even when the click failed. */
export function reduceTrailHead(anchor, target) {
const conditions = {
selected: anchor?.selected === true,
enoughHeadSamples:
Number.isFinite(anchor?.headSamples) && anchor.headSamples > 30,
aligned: Number.isFinite(anchor?.headErrorPx) && anchor.headErrorPx <= 1,
stableBody: anchor?.bodyMutation === 0,
stableEntityCount:
Number.isFinite(anchor?.entityCount) &&
anchor.entityCount === target?.entityCount,
};
return {
pass: Object.values(conditions).every(Boolean),
conditions,
headSamples: anchor?.headSamples ?? null,
errorPx: anchor?.headErrorPx ?? null,
bodyMutation: anchor?.bodyMutation ?? null,
selection: anchor?.selection ?? null,
};
}
/** Repeated off/on patches isolate stable, trail-correlated framebuffer changes. */
export function reduceTrailPixels(on, off, evidence = {}) {
const { onAgain, offAgain, samples = [], sprite, tilesReady } = evidence;
const finitePoint = (p) =>
p && [p.x, p.y, p.radius].every(Number.isFinite) && p.radius > 0;
const stable = [],
eligible = [];
const hits = Array.from({ length: 8 }, (_, i) => {
const point = samples[i];
eligible[i] = !!(
tilesReady === true &&
finitePoint(point) &&
point.inFront === true &&
finitePoint(sprite) &&
Math.hypot(point.x - sprite.x, point.y - sprite.y) >
point.radius + sprite.radius &&
samples
.slice(0, i)
.every(
(prior) =>
!finitePoint(prior) ||
Math.hypot(point.x - prior.x, point.y - prior.y) >
point.radius + prior.radius,
)
);
const a = on?.[i],
b = off?.[i],
c = onAgain?.[i],
d = offAgain?.[i];
stable[i] = false;
if (
!eligible[i] ||
!a?.length ||
a.length % 4 ||
[b, c, d].some((p) => !p || p.length !== a.length)
)
return false;
let matches = 0;
const contrast = (lit, baseline, k) => {
const delta = Math.hypot(
lit[k] - baseline[k],
lit[k + 1] - baseline[k + 1],
lit[k + 2] - baseline[k + 2],
);
const green = lit[k + 1] > lit[k] + 30 && lit[k + 1] > lit[k + 2] + 18;
const dark =
lit[k] + lit[k + 1] + lit[k + 2] <
0.6 * (baseline[k] + baseline[k + 1] + baseline[k + 2]);
return delta >= 40 && (green || dark);
};
for (let k = 0; k < a.length; k += 4) {
for (let channel = 0; channel < 3; channel++) {
const j = k + channel;
if (
![a[j], b[j], c[j], d[j]].every(
(v) => Number.isFinite(v) && v >= 0 && v <= 255,
) ||
Math.abs(b[j] - d[j]) > 8 ||
Math.abs(a[j] - c[j]) > 8 ||
Math.abs(a[j] - b[j] - (c[j] - d[j])) > 8
)
return false;
}
if (contrast(a, b, k) && contrast(c, d, k)) matches++;
}
stable[i] = true;
return matches >= 2;
});
const present = hits.filter(Boolean).length;
return { hits, stable, eligible, present, total: 8, pass: present >= 6 };
}