mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 18:34:02 +00:00
1051 lines
35 KiB
JavaScript
1051 lines
35 KiB
JavaScript
import { captureQaScreenshot } from './qa-chrome.mjs';
|
||
import { getRegisteredTransitFeed } from '../src/data/transitFeeds.js';
|
||
|
||
// Not registered or active: camera discovery and live polls never own this feed.
|
||
/** CapMetro metadata under a private QA identity for selected-trail pixels. */
|
||
export const TRAIL_VISIBILITY_FEED = Object.freeze({
|
||
...getRegisteredTransitFeed('capmetro-austin'),
|
||
id: 'qa-trail-capmetro',
|
||
});
|
||
|
||
import { reportTransitVisibility } from './qa-transit-browser.mjs';
|
||
import { writeFile } from 'node:fs/promises';
|
||
import {
|
||
reduceFleet,
|
||
reduceMotion,
|
||
reduceBackground,
|
||
reduceSensorContrast,
|
||
reduceTrailPixels,
|
||
} from '../src/layers/transit/qaMetrics.js';
|
||
|
||
/** CDP includes objects collected during the sample, not just surviving objects. */
|
||
export function allocationTotals(profile) {
|
||
let frameBytes = 0,
|
||
layerFrameBytes = 0,
|
||
sharedOverlayBytes = 0,
|
||
qaBytes = 0;
|
||
const allocators = new Map();
|
||
function visit(node, inFrame = false, inQa = false, inOverlay = false) {
|
||
const frame = node.callFrame || {},
|
||
name = frame.functionName || '',
|
||
url = frame.url || '';
|
||
const nested =
|
||
inFrame ||
|
||
name === 'onPreRender' ||
|
||
/^render\d*$/.test(name) ||
|
||
/^Scene\d*\.render$/.test(name);
|
||
// QA wraps the real frame callback: re-enter production attribution at its
|
||
// onPreRender boundary, but exclude QA's own Math/Cesium helper descendants.
|
||
const qa =
|
||
name === 'onPreRender'
|
||
? false
|
||
: inQa || /\/transit\/testing\.js(?:\?|$)/.test(url);
|
||
const overlay = inOverlay || name === '_drawOverlay';
|
||
const bytes = node.selfSize || 0;
|
||
if (nested) {
|
||
if (qa) qaBytes += bytes;
|
||
else {
|
||
frameBytes += bytes;
|
||
const allocator = `${name || '(anonymous)'} ${url.split('?')[0]}:${(frame.lineNumber ?? -1) + 1}`;
|
||
allocators.set(allocator, (allocators.get(allocator) || 0) + bytes);
|
||
if (overlay) sharedOverlayBytes += bytes;
|
||
if (
|
||
/\/layers\/transit\/|\/data\/(?:contactPlayback|contactTrailRenderer|transit[^/]*)\.js/.test(
|
||
url,
|
||
)
|
||
)
|
||
layerFrameBytes += bytes;
|
||
}
|
||
}
|
||
for (const child of node.children || []) visit(child, nested, qa, overlay);
|
||
}
|
||
visit(profile.head);
|
||
return {
|
||
frameBytes,
|
||
layerFrameBytes,
|
||
sharedOverlayBytes,
|
||
qaBytes,
|
||
topAllocators: [...allocators]
|
||
.sort((a, b) => b[1] - a[1])
|
||
.slice(0, 3)
|
||
.map(([allocator, bytes]) => ({ allocator, bytes })),
|
||
};
|
||
}
|
||
|
||
export async function runFleetBudgets({
|
||
page,
|
||
check,
|
||
wait,
|
||
shots,
|
||
tag,
|
||
detectOn,
|
||
selectStyle,
|
||
}) {
|
||
console.log(
|
||
'\n== moving fleet budgets: 1920×1080 CSS, warmed view, DETECT dense ==',
|
||
);
|
||
await selectStyle(page, 'normal');
|
||
await detectOn(page);
|
||
const cdp = await page.createCDPSession();
|
||
await cdp.send('HeapProfiler.enable');
|
||
for (const count of [800, 3000]) {
|
||
await page.evaluate(async (count) => {
|
||
const app = window.__godsEyeView;
|
||
await app.dataManager.setEnabled('transit', true, { source: 'qa' });
|
||
const camera = app.viewer.camera,
|
||
C = camera.positionCartographic.constructor;
|
||
camera.setView({
|
||
destination: C.toCartesian(
|
||
C.fromDegrees(-71.0605, 42.3554, count === 800 ? 600 : 30000),
|
||
),
|
||
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
|
||
});
|
||
const layer = app.dataManager.layers.get('transit').module;
|
||
layer._transitPartsForTest().ingestion.abortAllInFlight();
|
||
layer._transitStateForTest()._activeFeeds.clear();
|
||
for (const key of layer._transitStateForTest()._vehicles.keys())
|
||
layer._transitPartsForTest().ingestion.removeVehicle(key);
|
||
}, count);
|
||
await wait(8000);
|
||
// Camera proximity can finish a live poll during tile warm-up. Remove it
|
||
// before the heap baseline, or its memory would discount the fixture fleet.
|
||
await page.evaluate(() => {
|
||
const layer =
|
||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||
const state = layer._transitStateForTest(),
|
||
parts = layer._transitPartsForTest();
|
||
parts.ingestion.abortAllInFlight();
|
||
state._activeFeeds.clear();
|
||
clearTimeout(state._cameraDebounceTimer);
|
||
state._cameraDebounceTimer = null;
|
||
for (const key of state._vehicles.keys())
|
||
parts.ingestion.removeVehicle(key);
|
||
parts.rendering.syncRenderHold();
|
||
window.__godsEyeView.viewer.scene.requestRender();
|
||
});
|
||
await wait(500);
|
||
await cdp.send('HeapProfiler.collectGarbage');
|
||
const before = await cdp.send('Runtime.getHeapUsage');
|
||
const loaded = await page.evaluate(
|
||
(count) =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._loadTransitFleetForTest(
|
||
count,
|
||
{ lat: 42.3554, lon: -71.0605 },
|
||
count === 800 ? 5 : 120,
|
||
),
|
||
count,
|
||
);
|
||
await reportTransitVisibility(
|
||
page,
|
||
`${count} budget visibility after load`,
|
||
);
|
||
await wait(2000);
|
||
await cdp.send('HeapProfiler.collectGarbage');
|
||
// The retained delta is conservative: it includes concurrent page growth.
|
||
const retained = await cdp.send('Runtime.getHeapUsage');
|
||
// Timing/upload acceptance runs without the allocation profiler attached.
|
||
const trace = await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._measureTransitFramesForTest(8000),
|
||
);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._resetTransitFixtureClockForTest(),
|
||
);
|
||
await wait(1500);
|
||
await cdp.send('HeapProfiler.startSampling', {
|
||
samplingInterval: 128,
|
||
includeObjectsCollectedByMajorGC: true,
|
||
includeObjectsCollectedByMinorGC: true,
|
||
});
|
||
await reportTransitVisibility(
|
||
page,
|
||
`${count} budget visibility before allocation trace`,
|
||
);
|
||
const allocationTrace = await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._measureTransitFramesForTest(6000),
|
||
);
|
||
const { profile } = await cdp.send('HeapProfiler.stopSampling');
|
||
const allocations = allocationTotals(profile);
|
||
const retainedBytes = retained.usedSize - before.usedSize;
|
||
const evidence = reduceFleet(
|
||
trace.rows,
|
||
count,
|
||
allocations.layerFrameBytes / allocationTrace.rows.length,
|
||
retainedBytes,
|
||
loaded.fixBytes,
|
||
);
|
||
const details = {
|
||
...evidence,
|
||
...allocations,
|
||
wholeFrameBytesPerFrame:
|
||
allocations.frameBytes / allocationTrace.rows.length,
|
||
topAllocatorsPerFrame: allocations.topAllocators.map((a) => ({
|
||
...a,
|
||
bytesPerFrame: a.bytes / allocationTrace.rows.length,
|
||
})),
|
||
allocationFrames: allocationTrace.rows.length,
|
||
loaded,
|
||
dpr: trace.dpr,
|
||
viewport: [trace.width, trace.height],
|
||
heapMethod:
|
||
'GC-bracketed whole-page growth after fleet load (conservative)',
|
||
allocationMethod:
|
||
'CDP 128-byte sampling including collected objects; transit source self allocation gates, whole render stacks reported, QA scaffolding excluded',
|
||
};
|
||
await writeFile(
|
||
`${shots}/${tag}-fleet-${count}.json`,
|
||
JSON.stringify(details, null, 2),
|
||
);
|
||
await writeFile(
|
||
`${shots}/${tag}-fleet-${count}-allocations.json`,
|
||
JSON.stringify(profile),
|
||
);
|
||
check(
|
||
`${count} moving vehicles meet CPU, frame interval, billboard upload, heap and allocation budgets`,
|
||
evidence.pass && trace.width === 1920 && trace.height === 1080,
|
||
JSON.stringify(details),
|
||
);
|
||
check(
|
||
`${count}: transit-authored frame allocation <= 8 KiB`,
|
||
allocationTrace.rows.length >= 100 &&
|
||
reduceMotion(allocationTrace.rows).pass &&
|
||
allocationTrace.rows.every((r) => r.moving === count) &&
|
||
allocations.layerFrameBytes / allocationTrace.rows.length <= 8192,
|
||
`${allocations.layerFrameBytes / allocationTrace.rows.length} transit-authored bytes/frame; whole frame ${allocations.frameBytes / allocationTrace.rows.length}; top three ${JSON.stringify(details.topAllocatorsPerFrame)}; collected objects included. Full profile saved.`,
|
||
);
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-fleet-${count}.jpg`,
|
||
type: 'jpeg',
|
||
quality: 85,
|
||
});
|
||
const settled = await page.evaluate(async () => {
|
||
const layer =
|
||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||
const state = layer._transitStateForTest();
|
||
const { seek } = await import('/src/data/contactPlayback.js');
|
||
const { updatePlayback } =
|
||
await import('/src/layers/transit/movement.js');
|
||
for (const entry of state._vehicles.values()) {
|
||
entry.clocks.wallNowMs = Date.now();
|
||
entry.clocks.monoNowMs = performance.now();
|
||
seek(entry.track, entry.fixes.at(-1).t, entry.clocks);
|
||
updatePlayback(entry, Date.now(), performance.now());
|
||
layer._transitPartsForTest().rendering.schedulePlayback(entry);
|
||
}
|
||
layer._transitPartsForTest().rendering.syncRenderHold();
|
||
return { moving: state._moving.size, held: state._renderHeld };
|
||
});
|
||
check(
|
||
`${count}: settling releases the transit hold`,
|
||
settled.moving === 0 && !settled.held,
|
||
JSON.stringify(settled),
|
||
);
|
||
}
|
||
await cdp.detach();
|
||
}
|
||
|
||
export async function runBostonMatrix({
|
||
page,
|
||
check,
|
||
wait,
|
||
shots,
|
||
tag,
|
||
selectStyle,
|
||
sampleRendered,
|
||
detectOn,
|
||
}) {
|
||
console.log(
|
||
'\n== Boston matrix: scripted Red, 741, 742, Green-E; actual map backgrounds ==',
|
||
);
|
||
await detectOn(page);
|
||
const routes = ['Red', '741', '742', 'Green-E'];
|
||
const looks = [
|
||
{ name: 'normal', style: 'normal', params: {} },
|
||
{ name: 'nvg', style: 'surveillance', params: {} },
|
||
{ name: 'noir', style: 'noir', params: {} },
|
||
{
|
||
name: 'white-hot',
|
||
style: 'thermal',
|
||
params: { 'WHOT/BHOT': 0, Ironbow: 0 },
|
||
},
|
||
{
|
||
name: 'black-hot',
|
||
style: 'thermal',
|
||
params: { 'WHOT/BHOT': 1, Ironbow: 0 },
|
||
},
|
||
{
|
||
name: 'ironbow',
|
||
style: 'thermal',
|
||
params: { 'WHOT/BHOT': 0, Ironbow: 1 },
|
||
},
|
||
];
|
||
// Actual Boston views. Acceptance checks the measured background; a tile/key
|
||
// failure or an unsuitable view is explicitly unexercised, never assumed bright/dark.
|
||
const backgrounds = [
|
||
{
|
||
name: 'bright',
|
||
candidates: [
|
||
{ lat: 42.3458, lon: -71.0464 },
|
||
{ lat: 42.3659, lon: -71.018 },
|
||
{ lat: 42.3526, lon: -71.0461 },
|
||
{ lat: 42.3486, lon: -71.0825 },
|
||
],
|
||
},
|
||
{
|
||
name: 'dark',
|
||
candidates: [
|
||
{ lat: 42.3574, lon: -71.0375 },
|
||
{ lat: 42.3554, lon: -71.0655 },
|
||
{ lat: 42.3588, lon: -71.0738 },
|
||
{ lat: 42.348, lon: -71.032 },
|
||
],
|
||
},
|
||
];
|
||
const evidence = [];
|
||
for (const group of backgrounds) {
|
||
let background, backgroundResult;
|
||
const attempts = [];
|
||
await selectStyle(page, 'normal');
|
||
for (const candidate of group.candidates) {
|
||
background = { ...candidate, name: group.name };
|
||
await page.evaluate((b) => {
|
||
const camera = window.__godsEyeView.viewer.camera,
|
||
C = camera.positionCartographic.constructor;
|
||
camera.setView({
|
||
destination: C.toCartesian(C.fromDegrees(b.lon, b.lat, 600)),
|
||
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
|
||
});
|
||
}, background);
|
||
await wait(8000);
|
||
await page.evaluate(
|
||
({ background, routes }) => {
|
||
const layer =
|
||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||
layer._loadTransitFleetForTest(8, background, 45, routes);
|
||
for (const entry of layer._transitStateForTest()._vehicles.values()) {
|
||
entry.track.rate = 0;
|
||
layer._transitPartsForTest().rendering.schedulePlayback(entry);
|
||
}
|
||
},
|
||
{ background, routes },
|
||
);
|
||
await wait(1000);
|
||
backgroundResult = reduceBackground(
|
||
group.name,
|
||
await sampleRendered(page),
|
||
);
|
||
attempts.push({ background, ...backgroundResult });
|
||
if (backgroundResult.pass) break;
|
||
}
|
||
check(
|
||
`Boston ${background.name}: all four routes over measured ${background.name} background`,
|
||
backgroundResult.pass,
|
||
JSON.stringify({ attempts, chosen: background }),
|
||
{ unexercised: !backgroundResult.pass },
|
||
);
|
||
for (const look of looks) {
|
||
await selectStyle(page, look.style, look.params);
|
||
await wait(1200);
|
||
await reportTransitVisibility(
|
||
page,
|
||
`Boston ${background.name}/${look.name} visibility`,
|
||
);
|
||
const pixels = await sampleRendered(page);
|
||
const modes = await page.evaluate(() => {
|
||
const layer =
|
||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||
return [...layer._transitStateForTest()._vehicles.values()].map(
|
||
(e) => ({
|
||
key: e.key,
|
||
route: e.record.routeId,
|
||
image: e.marker.image,
|
||
width: e.marker.width,
|
||
color: e.marker.color.toCssHexString(),
|
||
}),
|
||
);
|
||
});
|
||
const contrast =
|
||
look.name === 'normal'
|
||
? null
|
||
: reduceSensorContrast(
|
||
pixels,
|
||
look.name === 'black-hot' ? 'black' : 'white',
|
||
look.style,
|
||
);
|
||
check(
|
||
`Boston ${background.name}/${look.name}: all four silhouettes and mode brackets readable`,
|
||
pixels.length >= 6 &&
|
||
pixels.every(
|
||
(p) =>
|
||
p.bracket &&
|
||
p.bracketExpected &&
|
||
Math.hypot(...p.bracket.map((v, i) => v - p.bracketExpected[i])) <
|
||
48,
|
||
) &&
|
||
(!contrast || contrast.pass),
|
||
JSON.stringify({ pixels, contrast }),
|
||
{ unexercised: pixels.length < 6 },
|
||
);
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-matrix-${background.name}-${look.name}-fleet.jpg`,
|
||
type: 'jpeg',
|
||
quality: 90,
|
||
});
|
||
for (const target of modes) {
|
||
await page.evaluate(
|
||
(key) =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._transitPartsForTest()
|
||
.selection.selectVehicle(key),
|
||
target.key,
|
||
);
|
||
await wait(500);
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-matrix-${background.name}-${look.name}-${target.route}-selected.jpg`,
|
||
type: 'jpeg',
|
||
quality: 90,
|
||
});
|
||
const restored = await page.evaluate((key) => {
|
||
const layer =
|
||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||
layer._transitPartsForTest().selection.clearSelection();
|
||
const e = layer._transitStateForTest()._vehicles.get(key);
|
||
return {
|
||
image: e.marker.image,
|
||
width: e.marker.width,
|
||
color: e.marker.color.toCssHexString(),
|
||
};
|
||
}, target.key);
|
||
check(
|
||
`Boston ${background.name}/${look.name}/${target.route}: deselect restores fleet styling`,
|
||
restored.image === target.image &&
|
||
restored.width === target.width &&
|
||
restored.color === target.color,
|
||
);
|
||
}
|
||
await wait(300);
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-matrix-${background.name}-${look.name}-restored.jpg`,
|
||
type: 'jpeg',
|
||
quality: 90,
|
||
});
|
||
evidence.push({
|
||
background,
|
||
look,
|
||
pixels,
|
||
routes: modes.map((m) => m.route),
|
||
});
|
||
}
|
||
}
|
||
await selectStyle(page, 'normal');
|
||
await writeFile(
|
||
`${shots}/${tag}-boston-matrix.json`,
|
||
JSON.stringify(evidence, null, 2),
|
||
);
|
||
}
|
||
|
||
/** Real MBTA observations at oblique street views, separate from matrix fixtures. */
|
||
export async function runBostonLive({
|
||
page,
|
||
check,
|
||
wait,
|
||
shots,
|
||
tag,
|
||
detectOn,
|
||
selectStyle,
|
||
sampleRendered,
|
||
}) {
|
||
console.log('\n== Boston live oblique streets ==');
|
||
await page.evaluate(async () => {
|
||
const app = window.__godsEyeView;
|
||
await app.dataManager.setEnabled('transit', false, { source: 'qa' });
|
||
const camera = app.viewer.camera,
|
||
C = camera.positionCartographic.constructor;
|
||
camera.setView({
|
||
destination: C.toCartesian(C.fromDegrees(-71.0605, 42.3554, 600)),
|
||
orientation: { heading: 0, pitch: -Math.PI / 4, roll: 0 },
|
||
});
|
||
await app.dataManager.setEnabled('transit', true, { source: 'qa' });
|
||
const layer = app.dataManager.layers.get('transit').module;
|
||
layer._setTransitFixtureFloorsForTest([], 0);
|
||
await layer.update();
|
||
});
|
||
await wait(20000);
|
||
await detectOn(page);
|
||
const evidence = [];
|
||
for (const view of [
|
||
{
|
||
name: 'white-hot',
|
||
style: 'thermal',
|
||
altitude: 120,
|
||
heading: 0,
|
||
pitch: -20,
|
||
params: { 'WHOT/BHOT': 0, Ironbow: 0 },
|
||
},
|
||
{
|
||
name: 'nvg',
|
||
style: 'surveillance',
|
||
altitude: 600,
|
||
heading: 30,
|
||
pitch: -45,
|
||
params: {},
|
||
},
|
||
{
|
||
name: 'noir',
|
||
style: 'noir',
|
||
altitude: 400,
|
||
heading: 60,
|
||
pitch: -35,
|
||
params: {},
|
||
},
|
||
]) {
|
||
await page.evaluate((view) => {
|
||
const app = window.__godsEyeView,
|
||
camera = app.viewer.camera,
|
||
C = camera.positionCartographic.constructor;
|
||
app.dataManager.layers
|
||
.get('transit')
|
||
.module._transitPartsForTest()
|
||
.selection.clearSelection();
|
||
camera.setView({
|
||
destination: C.toCartesian(
|
||
C.fromDegrees(-71.0605, 42.3554, view.altitude),
|
||
),
|
||
orientation: {
|
||
heading: (view.heading * Math.PI) / 180,
|
||
pitch: (view.pitch * Math.PI) / 180,
|
||
roll: 0,
|
||
},
|
||
});
|
||
}, view);
|
||
await selectStyle(page, view.style, view.params);
|
||
await wait(8000);
|
||
const fleet = await page.evaluate(() => {
|
||
const state = window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._transitStateForTest();
|
||
const entries = [...state._vehicles.values()];
|
||
return {
|
||
total: entries.length,
|
||
visible: entries.filter((e) => e.marker?.show).length,
|
||
fixtures: entries.filter((e) => e.qaFixture).length,
|
||
routes: [
|
||
...new Set(
|
||
entries.filter((e) => e.marker?.show).map((e) => e.record.routeId),
|
||
),
|
||
],
|
||
};
|
||
});
|
||
check(
|
||
`Boston live/${view.name}: observed vehicles in the oblique street view`,
|
||
fleet.total > 0 && fleet.visible > 0 && fleet.fixtures === 0,
|
||
JSON.stringify({ view, fleet }),
|
||
{ unexercised: fleet.visible === 0 },
|
||
);
|
||
const pixels = await sampleRendered(page);
|
||
const contrast = reduceSensorContrast(pixels, 'white', view.style);
|
||
check(
|
||
`Boston live/${view.name}: unobscured sensor contrast`,
|
||
contrast.pass,
|
||
JSON.stringify(contrast),
|
||
{ unexercised: contrast.unexercised },
|
||
);
|
||
const target = pixels[0];
|
||
let selection = null;
|
||
if (target) {
|
||
await page.mouse.click(target.x, target.y);
|
||
await wait(250);
|
||
selection = await page.evaluate((key) => {
|
||
const state = window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._transitStateForTest();
|
||
return {
|
||
expected: key,
|
||
actual: state._selectedKey,
|
||
pick: state._lastPickForTest ?? null,
|
||
};
|
||
}, target.key);
|
||
}
|
||
check(
|
||
`Boston live/${view.name}: real mouse selects an observed vehicle`,
|
||
selection?.actual === target?.key && !!target,
|
||
JSON.stringify(selection),
|
||
{ unexercised: !target },
|
||
);
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-boston-live-${view.name}.jpg`,
|
||
type: 'jpeg',
|
||
quality: 90,
|
||
});
|
||
evidence.push({ view, fleet, pixels, contrast, selection });
|
||
}
|
||
await writeFile(
|
||
`${shots}/${tag}-boston-live.json`,
|
||
JSON.stringify(evidence, null, 2),
|
||
);
|
||
}
|
||
|
||
/** Google 3D proof: paired framebuffer reads reject coincidental road colours. */
|
||
export async function runTrailVisibility({
|
||
page,
|
||
check,
|
||
wait,
|
||
shots,
|
||
tag,
|
||
selectStyle,
|
||
altitude = 600,
|
||
pitch = 45,
|
||
}) {
|
||
const name = 'Google 3D selected trail visible at 6 of 8 projected samples';
|
||
await selectStyle(page, 'normal');
|
||
await page.evaluate(
|
||
async ({ altitude, pitch }) => {
|
||
const app = window.__godsEyeView;
|
||
await app.dataManager.setEnabled('transit', true, { source: 'qa' });
|
||
if (app.mapStackController.isStackAvailable('photoreal'))
|
||
await app.mapStackController.setStack('photoreal');
|
||
const camera = app.viewer.camera,
|
||
C = camera.positionCartographic.constructor;
|
||
camera.setView({
|
||
destination: C.toCartesian(
|
||
C.fromDegrees(
|
||
-97.7431,
|
||
30.26725 - altitude / Math.tan((pitch * Math.PI) / 180) / 111320,
|
||
altitude,
|
||
),
|
||
),
|
||
orientation: { heading: 0, pitch: (-pitch * Math.PI) / 180, roll: 0 },
|
||
});
|
||
},
|
||
{ altitude, pitch },
|
||
);
|
||
await wait(8000);
|
||
const setup = await page.evaluate(
|
||
async ({ altitude, pitch, feed }) => {
|
||
const app = window.__godsEyeView,
|
||
scene = app.viewer.scene;
|
||
const layer = app.dataManager.layers.get('transit').module;
|
||
const state = layer._transitStateForTest(),
|
||
parts = layer._transitPartsForTest();
|
||
const google =
|
||
!!app.tileset &&
|
||
app.tileset.show !== false &&
|
||
app.mapStackController.getActiveId() === 'photoreal';
|
||
if (!google)
|
||
return { google: false, reason: 'visible Google 3D tileset required' };
|
||
const C = scene.camera.positionCartographic.constructor;
|
||
const centreLat = 30.267 + 90 / 111320;
|
||
const floor = scene.sampleHeight(C.fromDegrees(-97.7431, centreLat));
|
||
if (Number.isFinite(floor))
|
||
scene.camera.setView({
|
||
destination: C.toCartesian(
|
||
C.fromDegrees(
|
||
-97.7431,
|
||
centreLat - altitude / Math.tan((pitch * Math.PI) / 180) / 111320,
|
||
floor + altitude,
|
||
),
|
||
),
|
||
orientation: { heading: 0, pitch: (-pitch * Math.PI) / 180, roll: 0 },
|
||
});
|
||
parts.selection.clearSelection();
|
||
parts.ingestion.abortAllInFlight();
|
||
state._activeFeeds.clear();
|
||
for (const key of state._vehicles.keys())
|
||
parts.ingestion.removeVehicle(key);
|
||
clearTimeout(state._cameraDebounceTimer);
|
||
state._cameraDebounceTimer = null;
|
||
const { seek, setRate } = await import('/src/data/contactPlayback.js');
|
||
const now = Date.now();
|
||
// Nine straight street fixes, 30 m apart. Use the production surface path.
|
||
for (let i = 0; i < 9; i++) {
|
||
const timestamp = (now - 120000 + i * 15000) / 1000;
|
||
parts.ingestion.applySnapshot(
|
||
feed,
|
||
{
|
||
fetchedAt: timestamp * 1000,
|
||
vehicles: [
|
||
{
|
||
id: 'trail-visible',
|
||
routeId: '1',
|
||
tripId: 'trail-visible',
|
||
lat: 30.267 + (i * 30) / 111320,
|
||
lon: -97.7431,
|
||
timestamp,
|
||
timestampSource: 'vehicle',
|
||
bearing: 0,
|
||
},
|
||
],
|
||
},
|
||
{ stale: false },
|
||
);
|
||
}
|
||
const entry = state._vehicles.get(`${feed.id}:trail-visible`);
|
||
entry.qaFixture = true;
|
||
const clocks = { wallNowMs: now, monoNowMs: performance.now() };
|
||
seek(entry.track, now - 45000, clocks);
|
||
setRate(entry.track, 1, clocks);
|
||
parts.rendering.sampleIdle(entry);
|
||
parts.height.anchorFloors();
|
||
parts.rendering.refreshVisibility();
|
||
parts.rendering.maintainPresentation();
|
||
parts.selection.selectVehicle(entry.key);
|
||
return {
|
||
google,
|
||
key: entry.key,
|
||
fixes: entry.track.count,
|
||
startDisplayT: now - 45000,
|
||
startLat: entry.sample.lat,
|
||
};
|
||
},
|
||
{ altitude, pitch, feed: TRAIL_VISIBILITY_FEED },
|
||
);
|
||
if (!setup.google) {
|
||
check(name, false, JSON.stringify(setup), { unexercised: true });
|
||
return;
|
||
}
|
||
const cost = await page.evaluate(async (key) => {
|
||
const app = window.__godsEyeView,
|
||
scene = app.viewer.scene;
|
||
const layer = app.dataManager.layers.get('transit').module;
|
||
const parts = layer._transitPartsForTest(),
|
||
entry = layer._transitStateForTest()._vehicles.get(key);
|
||
const gl = scene.context._gl,
|
||
originals = new Map(),
|
||
wrapped = new Map();
|
||
let owner = null,
|
||
headBytes = 0,
|
||
bodyBytes = 0,
|
||
headUploadMax = 0,
|
||
bodyUploadMax = 0,
|
||
frames = 0;
|
||
const headCpu = [];
|
||
const wrap = (primitive, kind) => {
|
||
if (!primitive || wrapped.has(primitive)) return;
|
||
const update = primitive.update;
|
||
wrapped.set(primitive, update);
|
||
primitive.update = function (frameState) {
|
||
const before = performance.now();
|
||
owner = kind;
|
||
try {
|
||
return update.call(this, frameState);
|
||
} finally {
|
||
owner = null;
|
||
if (kind === 'head') headCpu.push(performance.now() - before);
|
||
}
|
||
};
|
||
};
|
||
for (const name of ['bufferData', 'bufferSubData']) {
|
||
const original = gl[name];
|
||
originals.set(name, original);
|
||
gl[name] = function (...args) {
|
||
if (owner) {
|
||
const value = args[name === 'bufferData' ? 1 : 2],
|
||
offset = args[3] || 0,
|
||
length = args[4];
|
||
const bytes =
|
||
typeof value === 'number'
|
||
? value
|
||
: value
|
||
? length !== undefined
|
||
? length * (value.BYTES_PER_ELEMENT || 1)
|
||
: value.byteLength - offset * (value.BYTES_PER_ELEMENT || 1)
|
||
: 0;
|
||
if (owner === 'head') headBytes += bytes;
|
||
else bodyBytes += bytes;
|
||
}
|
||
return original.apply(this, args);
|
||
};
|
||
}
|
||
const pre = scene.preRender.addEventListener(() => {
|
||
headBytes = bodyBytes = 0;
|
||
const trail = parts.trails.diagnostics();
|
||
wrap(trail?.body, 'body');
|
||
wrap(trail?.headPrimitive || trail?.head?._polylineCollection, 'head');
|
||
});
|
||
const post = scene.postRender.addEventListener(() => {
|
||
frames++;
|
||
headUploadMax = Math.max(headUploadMax, headBytes);
|
||
bodyUploadMax = Math.max(bodyUploadMax, bodyBytes);
|
||
});
|
||
try {
|
||
// Include a full history upload, even if the first selection already rendered.
|
||
entry.pathRevision = -1;
|
||
parts.trails.prepareEntry(entry);
|
||
scene.requestRender();
|
||
await new Promise((resolve) => setTimeout(resolve, 20000));
|
||
headCpu.sort((a, b) => a - b);
|
||
return {
|
||
frames,
|
||
headUploadMax,
|
||
bodyUploadMax,
|
||
headCpuP95Ms: headCpu[Math.floor(headCpu.length * 0.95)] ?? null,
|
||
headCpuMaxMs: headCpu.at(-1) ?? null,
|
||
};
|
||
} finally {
|
||
pre();
|
||
post();
|
||
for (const [name, original] of originals) gl[name] = original;
|
||
for (const [primitive, update] of wrapped)
|
||
if (!primitive.isDestroyed()) primitive.update = update;
|
||
}
|
||
}, setup.key);
|
||
const result = await page.evaluate(async (setup) => {
|
||
const app = window.__godsEyeView,
|
||
scene = app.viewer.scene;
|
||
const layer = app.dataManager.layers.get('transit').module;
|
||
const state = layer._transitStateForTest(),
|
||
parts = layer._transitPartsForTest();
|
||
const entry = state._vehicles.get(setup.key);
|
||
const trail = parts.trails.diagnostics();
|
||
if (!entry || !trail)
|
||
return { ...setup, present: 0, reason: 'selection disappeared' };
|
||
const { setRate } = await import('/src/data/contactPlayback.js');
|
||
setRate(entry.track, 0, {
|
||
wallNowMs: Date.now(),
|
||
monoNowMs: performance.now(),
|
||
});
|
||
parts.rendering.sampleIdle(entry);
|
||
parts.rendering.schedulePlayback(entry);
|
||
parts.rendering.syncRenderHold();
|
||
const ready = () =>
|
||
app.tileset?.show !== false &&
|
||
app.tileset?.tilesLoaded === true &&
|
||
(scene.globe?.show === false || scene.globe?.tilesLoaded === true) &&
|
||
trail.body?.ready === true &&
|
||
(!trail.headPrimitive || trail.headPrimitive.ready === true);
|
||
// Require sustained readiness after freezing playback, before projecting
|
||
// onto the refined surface. Repeated captures still check pixel stability.
|
||
const tilesReady = await new Promise((resolve) => {
|
||
const started = performance.now();
|
||
let readySince = null;
|
||
const timer = setInterval(() => {
|
||
const now = performance.now();
|
||
readySince = ready() ? (readySince ?? now) : null;
|
||
scene.requestRender();
|
||
if (
|
||
(readySince !== null && now - readySince >= 500) ||
|
||
now - started >= 30000
|
||
) {
|
||
clearInterval(timer);
|
||
resolve(readySince !== null && now - readySince >= 500);
|
||
}
|
||
}, 80);
|
||
});
|
||
if (!tilesReady)
|
||
return {
|
||
...setup,
|
||
present: 0,
|
||
reason: 'tiles or trail geometry did not become ready',
|
||
};
|
||
const canvas = scene.canvas,
|
||
gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
|
||
const scale = canvas.width / canvas.clientWidth;
|
||
const points = entry.trailSegments
|
||
.filter((s) => s.toT <= entry.sample.displayT)
|
||
.flatMap((s) => s.positions);
|
||
if (trail.head?.show) points.push(...trail.head.positions);
|
||
if (points.length < 2)
|
||
return { ...setup, present: 0, reason: 'no completed path' };
|
||
const C = scene.camera.positionCartographic.constructor;
|
||
const V = entry.marker.position.constructor;
|
||
const lengths = [0];
|
||
for (let i = 1; i < points.length; i++)
|
||
lengths.push(lengths.at(-1) + V.distance(points[i - 1], points[i]));
|
||
const mul = (m, v) =>
|
||
[0, 1, 2, 3].map(
|
||
(i) =>
|
||
m[i] * v[0] + m[i + 4] * v[1] + m[i + 8] * v[2] + m[i + 12] * v[3],
|
||
);
|
||
const samples = Array.from({ length: 8 }, (_, i) => {
|
||
const d = (lengths.at(-1) * (i + 1)) / 9;
|
||
let j = 1;
|
||
while (j < lengths.length - 1 && lengths[j] < d) j++;
|
||
const p = V.lerp(
|
||
points[j - 1],
|
||
points[j],
|
||
(d - lengths[j - 1]) / Math.max(0.001, lengths[j] - lengths[j - 1]),
|
||
new V(),
|
||
);
|
||
const cart = C.fromCartesian(p);
|
||
const height = scene.sampleHeight(
|
||
cart,
|
||
[entry.marker, trail.body, trail.headPrimitive].filter(Boolean),
|
||
);
|
||
if (Number.isFinite(height)) cart.height = height;
|
||
const surface = C.toCartesian(cart);
|
||
const q = mul(
|
||
scene.camera.frustum.projectionMatrix,
|
||
mul(scene.camera.viewMatrix, [surface.x, surface.y, surface.z, 1]),
|
||
);
|
||
return {
|
||
x: ((q[0] / q[3]) * 0.5 + 0.5) * canvas.clientWidth,
|
||
y: (0.5 - (q[1] / q[3]) * 0.5) * canvas.clientHeight,
|
||
inFront: q[3] > 0,
|
||
radius: (Math.SQRT2 * Math.ceil(3 * scale)) / scale,
|
||
};
|
||
});
|
||
const marker = entry.marker.position;
|
||
const markerClip = mul(
|
||
scene.camera.frustum.projectionMatrix,
|
||
mul(scene.camera.viewMatrix, [marker.x, marker.y, marker.z, 1]),
|
||
);
|
||
const sprite = {
|
||
x: ((markerClip[0] / markerClip[3]) * 0.5 + 0.5) * canvas.clientWidth,
|
||
y: (0.5 - (markerClip[1] / markerClip[3]) * 0.5) * canvas.clientHeight,
|
||
// Include the padded, rotated sprite and its selection bracket.
|
||
radius: Math.hypot(entry.marker.width, entry.marker.height) / 2 + 4,
|
||
};
|
||
const read = () =>
|
||
samples.map(({ x, y, inFront }) => {
|
||
const r = Math.ceil(3 * scale),
|
||
px = Math.round(x * scale),
|
||
py = Math.round(canvas.height - 1 - y * scale);
|
||
if (
|
||
!inFront ||
|
||
px < r ||
|
||
py < r ||
|
||
px + r >= canvas.width ||
|
||
py + r >= canvas.height
|
||
)
|
||
return null;
|
||
const data = new Uint8Array((2 * r + 1) ** 2 * 4);
|
||
gl.readPixels(
|
||
px - r,
|
||
py - r,
|
||
2 * r + 1,
|
||
2 * r + 1,
|
||
gl.RGBA,
|
||
gl.UNSIGNED_BYTE,
|
||
data,
|
||
);
|
||
return data;
|
||
});
|
||
const frame = () =>
|
||
new Promise((resolve, reject) => {
|
||
const timeout = setTimeout(() => {
|
||
remove();
|
||
reject(new Error('Trail framebuffer did not render within 5 s'));
|
||
}, 5000);
|
||
const remove = scene.postRender.addEventListener(() => {
|
||
remove();
|
||
clearTimeout(timeout);
|
||
resolve(read());
|
||
});
|
||
scene.requestRender();
|
||
});
|
||
const bodyShow = trail.body?.show,
|
||
headShow = trail.head?.show,
|
||
headPrimitiveShow = trail.headPrimitive?.show,
|
||
backingShow = trail.backing?.show;
|
||
let showTrail = false;
|
||
const applyVisibility = () => {
|
||
if (trail.body) trail.body.show = showTrail && bodyShow;
|
||
if (trail.headPrimitive)
|
||
trail.headPrimitive.show = showTrail && headPrimitiveShow;
|
||
if (trail.head) trail.head.show = showTrail && headShow;
|
||
if (trail.backing) trail.backing.show = showTrail && backingShow;
|
||
};
|
||
// Override the layer's frame update in both states; selection stays fixed.
|
||
const removeVisibility = scene.preRender.addEventListener(applyVisibility);
|
||
const captures = [];
|
||
let captureReady = true;
|
||
try {
|
||
for (const visible of [false, true, false, true]) {
|
||
showTrail = visible;
|
||
// Let post-processing settle before each measured framebuffer.
|
||
for (let i = 0; i < 3; i++) await frame();
|
||
captures.push(await frame());
|
||
const current = parts.trails.diagnostics();
|
||
captureReady &&=
|
||
ready() &&
|
||
current?.body === trail.body &&
|
||
current?.headPrimitive === trail.headPrimitive;
|
||
}
|
||
} finally {
|
||
removeVisibility();
|
||
if (trail.body) trail.body.show = bodyShow;
|
||
if (trail.headPrimitive) trail.headPrimitive.show = headPrimitiveShow;
|
||
if (trail.head) trail.head.show = headShow;
|
||
if (trail.backing) trail.backing.show = backingShow;
|
||
await frame();
|
||
}
|
||
const [off, on, offAgain, onAgain] = captures.map((patches) =>
|
||
patches.map((p) => (p ? Array.from(p) : null)),
|
||
);
|
||
return {
|
||
...setup,
|
||
fixes: entry.track.count,
|
||
selected: state._selectedKey === setup.key,
|
||
pathMetres: lengths.at(-1),
|
||
samples,
|
||
on,
|
||
off,
|
||
onAgain,
|
||
offAgain,
|
||
sprite,
|
||
tilesReady: captureReady,
|
||
elapsedDisplayMs: entry.sample.displayT - setup.startDisplayT,
|
||
movedMetres: Math.abs(entry.sample.lat - setup.startLat) * 111320,
|
||
body: trail.body?.constructor.name,
|
||
headStrategy: trail.headStrategy || 'PolylineCollection',
|
||
headRebuilds: trail.headRebuilds ?? null,
|
||
};
|
||
}, setup);
|
||
const pixels = reduceTrailPixels(result.on, result.off, result);
|
||
result.cost = cost;
|
||
result.altitude = altitude;
|
||
result.pitch = pitch;
|
||
result.present = pixels.present;
|
||
result.total = pixels.total;
|
||
result.samples = result.samples?.map((s, i) => ({
|
||
...s,
|
||
hit: pixels.hits[i],
|
||
stable: pixels.stable[i],
|
||
eligible: pixels.eligible[i],
|
||
}));
|
||
await captureQaScreenshot(page, {
|
||
path: `${shots}/${tag}-${altitude}m-trail-visible.jpg`,
|
||
type: 'jpeg',
|
||
quality: 95,
|
||
});
|
||
await writeFile(
|
||
`${shots}/${tag}-${altitude}m-trail-visible.json`,
|
||
JSON.stringify(result, null, 2),
|
||
);
|
||
for (const key of ['on', 'off', 'onAgain', 'offAgain']) delete result[key];
|
||
check(
|
||
name,
|
||
result.google &&
|
||
result.selected &&
|
||
result.fixes >= 5 &&
|
||
result.pathMetres > 15 &&
|
||
result.elapsedDisplayMs >= 19000 &&
|
||
result.movedMetres >= 5 &&
|
||
pixels.pass,
|
||
JSON.stringify(result),
|
||
);
|
||
check(
|
||
'selected trail stays within 2 MiB rebuild and 2 KiB/frame head uploads',
|
||
cost.frames > 30 &&
|
||
cost.bodyUploadMax > 0 &&
|
||
cost.bodyUploadMax <= 2 * 1024 * 1024 &&
|
||
cost.headUploadMax > 0 &&
|
||
cost.headUploadMax <= 2048,
|
||
JSON.stringify({ altitude, ...cost }),
|
||
);
|
||
await page.evaluate(() =>
|
||
window.__godsEyeView.dataManager.layers
|
||
.get('transit')
|
||
.module._transitPartsForTest()
|
||
.selection.clearSelection(),
|
||
);
|
||
}
|