mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
## 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.
404 lines
12 KiB
JavaScript
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 };
|
|
}
|