mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 10:24:02 +00:00
Traffic roads come from OpenFreeMap vector tiles, or TomTom flow tiles with a key (Hybrid by default). Military areas use OpenFreeMap polygons with a bundled worldwide name index; wide views show named points. ALPR reads an hourly OpenStreetMap extract. Cockpit place context and country, state and US county outlines use bundled Natural Earth and US Census data. Overpass is used only when an operator configures their own endpoint. Also: camera arrivals no longer land below ground, keyless terrain retries on 429, bounded relation geometry for configured Overpass, one shared OpenStreetMap credit, and separate tile and API transports for embedders. Co-authored-by: theGaryLarson <[email protected]> Co-authored-by: Milan Khanal <[email protected]>
This commit is contained in:
200 files changed
+26665
-1977
No files matched your search
@@ -0,0 +1,759 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Build the bundled administrative-boundary packs read by
|
||||
* `src/data/adminBoundaries.js`:
|
||||
*
|
||||
* src/data/local_data/natural_earth/states_provinces.json
|
||||
* Natural Earth 10m admin-1 states and provinces (public domain).
|
||||
* src/data/local_data/us_census_counties/counties.json
|
||||
* US Census Bureau cartographic boundary counties (public domain).
|
||||
*
|
||||
* Both sources are pinned by URL and SHA-256, so a rerun reproduces the packs
|
||||
* byte for byte. Downloads are cached outside the repository (default: the
|
||||
* system temp directory) and are never committed.
|
||||
*
|
||||
* Usage:
|
||||
* node scripts/build-admin-packs.mjs [--cache <dir>] [--only countries|admin1|counties]
|
||||
*
|
||||
* The provenance READMEs beside each pack record these parameters.
|
||||
*/
|
||||
|
||||
import { createHash } from 'node:crypto';
|
||||
import { mkdir, readFile, writeFile } from 'node:fs/promises';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { inflateRawSync } from 'node:zlib';
|
||||
import { normalizeAdminName } from '../src/data/adminBoundaries.js';
|
||||
|
||||
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
||||
const NE_COMMIT = 'ca96624a56bd078437bca8184e78163e5039ad19';
|
||||
const NE_BASE = `https://raw.githubusercontent.com/nvkelso/natural-earth-vector/${NE_COMMIT}/geojson`;
|
||||
|
||||
export const SOURCES = Object.freeze({
|
||||
countries: {
|
||||
url: `${NE_BASE}/ne_10m_admin_0_countries.geojson`,
|
||||
sha256: '239eec57ac17f100a11e2536cffc56752c318b50ae765b0918ff7aab4ce8f255',
|
||||
},
|
||||
mapUnits: {
|
||||
url: `${NE_BASE}/ne_10m_admin_0_map_units.geojson`,
|
||||
sha256: '57da82be755f4afccd8f3b14251bb2752f5df1395f47d2d86f817470c4a48862',
|
||||
},
|
||||
admin1: {
|
||||
url: `${NE_BASE}/ne_10m_admin_1_states_provinces.geojson`,
|
||||
sha256: '22d0e3ad85eb3e27f17cabf8ba2d50e554fbc27a87796ff891d958185da62fb5',
|
||||
},
|
||||
places: {
|
||||
url: `${NE_BASE}/ne_10m_populated_places_simple.geojson`,
|
||||
sha256: 'fd3fa867a320cbd5c5b6bb5bc550afeec2939fb2cef688e508007282a55ac42f',
|
||||
},
|
||||
counties: {
|
||||
url: 'https://www2.census.gov/geo/tiger/GENZ2025/shp/cb_2025_us_county_5m.zip',
|
||||
sha256: 'faec522080681e79be5be435c981009a77891206ff8a7f1d142f3bf5da9ebd74',
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* Pack parameters. The Douglas-Peucker tolerance scales with the unit's size
|
||||
* (`toleranceFactor` × √area, clamped to `[minToleranceDeg, maxToleranceDeg]`)
|
||||
* because a unit is viewed at a zoom that fits it: Texas keeps ~2 km detail,
|
||||
* Bavaria ~1 km, Travis County ~150 m. Parts smaller than `minPartKm2` or than
|
||||
* `minPartShare` of the largest part are dropped (the largest part always
|
||||
* stays); holes under `minHoleKm2` are dropped.
|
||||
*/
|
||||
export const PARAMS = Object.freeze({
|
||||
countries: {
|
||||
toleranceFactor: 0.004,
|
||||
minToleranceDeg: 0.005,
|
||||
maxToleranceDeg: 0.02,
|
||||
decimals: 3,
|
||||
minPartKm2: 20,
|
||||
minPartShare: 0.00003,
|
||||
minHoleKm2: 20,
|
||||
},
|
||||
admin1: {
|
||||
toleranceFactor: 0.004,
|
||||
minToleranceDeg: 0.005,
|
||||
maxToleranceDeg: 0.02,
|
||||
decimals: 3,
|
||||
minPartKm2: 20,
|
||||
minPartShare: 0.0003,
|
||||
minHoleKm2: 20,
|
||||
},
|
||||
counties: {
|
||||
toleranceFactor: 0.003,
|
||||
minToleranceDeg: 0.0005,
|
||||
maxToleranceDeg: 0.01,
|
||||
decimals: 4,
|
||||
minPartKm2: 1,
|
||||
minPartShare: 0.001,
|
||||
minHoleKm2: 1,
|
||||
},
|
||||
// A bare admin-1 name is marked ambiguous — the resolver then lets a
|
||||
// geocoder decide — when it is also a country, the name of a city of at
|
||||
// least `insideMinPopulation` inside the unit's box ("New York", "Madrid"),
|
||||
// or the name of a city of at least `elsewhereMinPopulation` outside it
|
||||
// ("Santa Fe", "Victoria"). A unit no larger than `cityStateMaxKm2` whose
|
||||
// own city lies inside is the city itself (Berlin, Vienna, Paris): it is
|
||||
// marked `cityState` and may be named alone however small.
|
||||
ambiguity: {
|
||||
insideMinPopulation: 200_000,
|
||||
elsewhereMinPopulation: 50_000,
|
||||
cityStateMaxKm2: 1_000,
|
||||
},
|
||||
});
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
const cacheDir = path.resolve(
|
||||
args.includes('--cache')
|
||||
? args[args.indexOf('--cache') + 1]
|
||||
: path.join(os.tmpdir(), 'gev-admin-packs'),
|
||||
);
|
||||
const only = args.includes('--only') ? args[args.indexOf('--only') + 1] : null;
|
||||
|
||||
async function fetchPinned(name) {
|
||||
const { url, sha256 } = SOURCES[name];
|
||||
const file = path.join(cacheDir, path.basename(new URL(url).pathname));
|
||||
let bytes = await readFile(file).catch(() => null);
|
||||
if (!bytes) {
|
||||
console.log(`Downloading ${url}`);
|
||||
const response = await fetch(url);
|
||||
if (!response.ok) throw new Error(`HTTP ${response.status} for ${url}`);
|
||||
bytes = Buffer.from(await response.arrayBuffer());
|
||||
await mkdir(cacheDir, { recursive: true });
|
||||
await writeFile(file, bytes);
|
||||
}
|
||||
const digest = createHash('sha256').update(bytes).digest('hex');
|
||||
if (digest !== sha256)
|
||||
throw new Error(
|
||||
`${name}: SHA-256 ${digest} does not match the pinned ${sha256}`,
|
||||
);
|
||||
return { bytes, digest };
|
||||
}
|
||||
|
||||
// ── geometry ────────────────────────────────────────────────────────────
|
||||
|
||||
const EARTH_RADIUS_KM = 6371;
|
||||
const toRad = (d) => (d * Math.PI) / 180;
|
||||
|
||||
/** Spherical ring area (km²); matches src/data/naturalEarthRegions.js. */
|
||||
function ringAreaKm2(ring) {
|
||||
const n = ring.length;
|
||||
if (n < 3) return 0;
|
||||
let sum = 0;
|
||||
for (let i = 0; i < n; i++) {
|
||||
const [lon1, lat1] = ring[i];
|
||||
const [lon2, lat2] = ring[(i + 1) % n];
|
||||
sum +=
|
||||
toRad(lon2 - lon1) * (2 + Math.sin(toRad(lat1)) + Math.sin(toRad(lat2)));
|
||||
}
|
||||
return Math.abs((sum * EARTH_RADIUS_KM * EARTH_RADIUS_KM) / 2);
|
||||
}
|
||||
|
||||
/** Signed planar (shoelace) area: positive counter-clockwise in lon/lat. */
|
||||
function signedArea(ring) {
|
||||
let sum = 0;
|
||||
for (let i = 0, j = ring.length - 1; i < ring.length; j = i++)
|
||||
sum += ring[j][0] * ring[i][1] - ring[i][0] * ring[j][1];
|
||||
return sum / 2;
|
||||
}
|
||||
|
||||
function segDist(p, a, b) {
|
||||
let [x, y] = p;
|
||||
const [x1, y1] = a;
|
||||
const [x2, y2] = b;
|
||||
const dx = x2 - x1;
|
||||
const dy = y2 - y1;
|
||||
if (dx !== 0 || dy !== 0) {
|
||||
const t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);
|
||||
if (t > 1) {
|
||||
x -= x2;
|
||||
y -= y2;
|
||||
return Math.hypot(x, y);
|
||||
}
|
||||
if (t > 0) {
|
||||
x -= x1 + dx * t;
|
||||
y -= y1 + dy * t;
|
||||
return Math.hypot(x, y);
|
||||
}
|
||||
}
|
||||
return Math.hypot(x - x1, y - y1);
|
||||
}
|
||||
|
||||
/** Iterative Douglas-Peucker over an open point list. */
|
||||
function douglasPeucker(points, tolerance) {
|
||||
if (points.length <= 2) return points.slice();
|
||||
const keep = new Uint8Array(points.length);
|
||||
keep[0] = keep[points.length - 1] = 1;
|
||||
const stack = [[0, points.length - 1]];
|
||||
while (stack.length) {
|
||||
const [first, last] = stack.pop();
|
||||
let maxDist = 0;
|
||||
let index = -1;
|
||||
for (let i = first + 1; i < last; i++) {
|
||||
const d = segDist(points[i], points[first], points[last]);
|
||||
if (d > maxDist) {
|
||||
maxDist = d;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
if (maxDist > tolerance && index !== -1) {
|
||||
keep[index] = 1;
|
||||
stack.push([first, index], [index, last]);
|
||||
}
|
||||
}
|
||||
return points.filter((_, i) => keep[i]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Simplify a closed ring to an OPEN rounded ring. The ring is split at its
|
||||
* farthest vertex from the start so Douglas-Peucker has two anchored halves
|
||||
* (a closed ring has no chord to measure against). Returns null when fewer
|
||||
* than four distinct vertices survive.
|
||||
*/
|
||||
function simplifyRing(ring, tolerance, decimals) {
|
||||
let open = ring.slice();
|
||||
const first = open[0];
|
||||
const last = open[open.length - 1];
|
||||
if (open.length > 1 && first[0] === last[0] && first[1] === last[1])
|
||||
open = open.slice(0, -1);
|
||||
if (open.length < 4) return null;
|
||||
let far = 1;
|
||||
let farDist = -1;
|
||||
for (let i = 1; i < open.length; i++) {
|
||||
const d = Math.hypot(open[i][0] - first[0], open[i][1] - first[1]);
|
||||
if (d > farDist) {
|
||||
farDist = d;
|
||||
far = i;
|
||||
}
|
||||
}
|
||||
const a = douglasPeucker(open.slice(0, far + 1), tolerance);
|
||||
const b = douglasPeucker([...open.slice(far), first], tolerance);
|
||||
const simplified = [...a, ...b.slice(1, -1)];
|
||||
const factor = 10 ** decimals;
|
||||
const out = [];
|
||||
for (const [lon, lat] of simplified) {
|
||||
const p = [
|
||||
Math.round(lon * factor) / factor,
|
||||
Math.round(lat * factor) / factor,
|
||||
];
|
||||
const prev = out[out.length - 1];
|
||||
if (prev && prev[0] === p[0] && prev[1] === p[1]) continue;
|
||||
out.push(p);
|
||||
}
|
||||
while (
|
||||
out.length > 1 &&
|
||||
out[0][0] === out[out.length - 1][0] &&
|
||||
out[0][1] === out[out.length - 1][1]
|
||||
)
|
||||
out.pop();
|
||||
return out.length >= 4 ? out : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Simplify polygons ([outer, ...holes][]): drop parts and holes under the
|
||||
* area floors (the largest part always stays), orient outers
|
||||
* counter-clockwise and holes clockwise, sort parts by area descending.
|
||||
*/
|
||||
function simplifyPolygons(polygons, params, tolerance, decimals) {
|
||||
const parts = [];
|
||||
for (const poly of polygons) {
|
||||
const outer = simplifyRing(poly[0], tolerance, decimals);
|
||||
if (!outer) continue;
|
||||
const area = ringAreaKm2(outer);
|
||||
if (signedArea(outer) < 0) outer.reverse();
|
||||
const holes = [];
|
||||
for (const hole of poly.slice(1)) {
|
||||
const ring = simplifyRing(hole, tolerance, decimals);
|
||||
if (!ring || ringAreaKm2(ring) < params.minHoleKm2) continue;
|
||||
if (signedArea(ring) > 0) ring.reverse();
|
||||
holes.push(ring);
|
||||
}
|
||||
parts.push({ rings: [outer, ...holes], area });
|
||||
}
|
||||
parts.sort((x, y) => y.area - x.area);
|
||||
const floor = Math.max(
|
||||
params.minPartKm2,
|
||||
(parts[0]?.area || 0) * params.minPartShare,
|
||||
);
|
||||
return parts
|
||||
.filter((part, index) => index === 0 || part.area >= floor)
|
||||
.map((part) => part.rings);
|
||||
}
|
||||
|
||||
/**
|
||||
* Simplify one unit at its size-scaled tolerance. A unit too small to
|
||||
* survive the pack precision (a Maldives atoll) is kept at one more decimal
|
||||
* and a fifth of the minimum tolerance, or failing that unsimplified at two
|
||||
* more decimals; the caller records `d`.
|
||||
*/
|
||||
function simplifyUnit(polygons, params) {
|
||||
const sourceArea = polygons.reduce(
|
||||
(sum, poly) => sum + ringAreaKm2(poly[0]),
|
||||
0,
|
||||
);
|
||||
const tolerance = Math.min(
|
||||
params.maxToleranceDeg,
|
||||
Math.max(
|
||||
params.minToleranceDeg,
|
||||
(params.toleranceFactor * Math.sqrt(sourceArea)) / 111.32,
|
||||
),
|
||||
);
|
||||
const coarse = simplifyPolygons(polygons, params, tolerance, params.decimals);
|
||||
if (coarse.length) return { polygons: coarse, decimals: params.decimals };
|
||||
const fine = simplifyPolygons(
|
||||
polygons,
|
||||
params,
|
||||
params.minToleranceDeg / 5,
|
||||
params.decimals + 1,
|
||||
);
|
||||
if (fine.length) return { polygons: fine, decimals: params.decimals + 1 };
|
||||
// Smaller still (Vatican City): the source ring as drawn.
|
||||
const exact = simplifyPolygons(polygons, params, 0, params.decimals + 2);
|
||||
return { polygons: exact, decimals: params.decimals + 2 };
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode a rounded open ring as integers in units of 10^-decimals degrees:
|
||||
* the first vertex absolute, every later vertex as a delta from the previous
|
||||
* one — [lon0, lat0, dLon1, dLat1, …]. Decoded by `decodeRing` in
|
||||
* src/data/adminBoundaries.js.
|
||||
*/
|
||||
function encodeRing(ring, decimals) {
|
||||
const factor = 10 ** decimals;
|
||||
const out = [];
|
||||
let px = 0;
|
||||
let py = 0;
|
||||
for (const [lon, lat] of ring) {
|
||||
const x = Math.round(lon * factor);
|
||||
const y = Math.round(lat * factor);
|
||||
out.push(x - px, y - py);
|
||||
px = x;
|
||||
py = y;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function encodeUnit({ polygons, decimals }) {
|
||||
return polygons.map((poly) => poly.map((ring) => encodeRing(ring, decimals)));
|
||||
}
|
||||
|
||||
function geojsonPolygons(geometry) {
|
||||
if (geometry?.type === 'Polygon') return [geometry.coordinates];
|
||||
if (geometry?.type === 'MultiPolygon') return geometry.coordinates;
|
||||
return [];
|
||||
}
|
||||
|
||||
function bboxOf(polygons) {
|
||||
let w = Infinity;
|
||||
let s = Infinity;
|
||||
let e = -Infinity;
|
||||
let n = -Infinity;
|
||||
for (const poly of polygons)
|
||||
for (const [lon, lat] of poly[0]) {
|
||||
if (lon < w) w = lon;
|
||||
if (lon > e) e = lon;
|
||||
if (lat < s) s = lat;
|
||||
if (lat > n) n = lat;
|
||||
}
|
||||
return [w, s, e, n];
|
||||
}
|
||||
|
||||
// ── zip / shapefile / dbf ───────────────────────────────────────────────
|
||||
|
||||
/** Read named entries from a zip archive (stored or deflated). */
|
||||
function unzip(buffer) {
|
||||
let eocd = buffer.length - 22;
|
||||
while (eocd >= 0 && buffer.readUInt32LE(eocd) !== 0x06054b50) eocd--;
|
||||
if (eocd < 0) throw new Error('zip: end of central directory not found');
|
||||
const count = buffer.readUInt16LE(eocd + 10);
|
||||
let offset = buffer.readUInt32LE(eocd + 16);
|
||||
const files = new Map();
|
||||
for (let i = 0; i < count; i++) {
|
||||
if (buffer.readUInt32LE(offset) !== 0x02014b50)
|
||||
throw new Error('zip: bad central directory entry');
|
||||
const method = buffer.readUInt16LE(offset + 10);
|
||||
const compressed = buffer.readUInt32LE(offset + 20);
|
||||
const nameLength = buffer.readUInt16LE(offset + 28);
|
||||
const extraLength = buffer.readUInt16LE(offset + 30);
|
||||
const commentLength = buffer.readUInt16LE(offset + 32);
|
||||
const local = buffer.readUInt32LE(offset + 42);
|
||||
const name = buffer.toString('utf8', offset + 46, offset + 46 + nameLength);
|
||||
const dataStart =
|
||||
local +
|
||||
30 +
|
||||
buffer.readUInt16LE(local + 26) +
|
||||
buffer.readUInt16LE(local + 28);
|
||||
const data = buffer.subarray(dataStart, dataStart + compressed);
|
||||
if (method === 0) files.set(name, data);
|
||||
else if (method === 8) files.set(name, inflateRawSync(data));
|
||||
else throw new Error(`zip: unsupported method ${method} for ${name}`);
|
||||
offset += 46 + nameLength + extraLength + commentLength;
|
||||
}
|
||||
return files;
|
||||
}
|
||||
|
||||
/** Polygon records (shape type 5) as arrays of closed [lon, lat] rings. */
|
||||
function readShp(buffer) {
|
||||
const shapes = [];
|
||||
let offset = 100;
|
||||
while (offset < buffer.length) {
|
||||
const length = buffer.readInt32BE(offset + 4) * 2;
|
||||
const content = offset + 8;
|
||||
const type = buffer.readInt32LE(content);
|
||||
const rings = [];
|
||||
if (type === 5) {
|
||||
const numParts = buffer.readInt32LE(content + 36);
|
||||
const numPoints = buffer.readInt32LE(content + 40);
|
||||
const partsAt = content + 44;
|
||||
const pointsAt = partsAt + numParts * 4;
|
||||
for (let p = 0; p < numParts; p++) {
|
||||
const start = buffer.readInt32LE(partsAt + p * 4);
|
||||
const end =
|
||||
p + 1 < numParts
|
||||
? buffer.readInt32LE(partsAt + (p + 1) * 4)
|
||||
: numPoints;
|
||||
const ring = [];
|
||||
for (let i = start; i < end; i++)
|
||||
ring.push([
|
||||
buffer.readDoubleLE(pointsAt + i * 16),
|
||||
buffer.readDoubleLE(pointsAt + i * 16 + 8),
|
||||
]);
|
||||
rings.push(ring);
|
||||
}
|
||||
} else if (type !== 0) {
|
||||
throw new Error(`shp: unsupported shape type ${type}`);
|
||||
}
|
||||
shapes.push(rings);
|
||||
offset = content + length;
|
||||
}
|
||||
return shapes;
|
||||
}
|
||||
|
||||
/** dBASE records as plain objects (character and numeric fields). */
|
||||
function readDbf(buffer) {
|
||||
const count = buffer.readUInt32LE(4);
|
||||
const headerLength = buffer.readUInt16LE(8);
|
||||
const recordLength = buffer.readUInt16LE(10);
|
||||
const fields = [];
|
||||
for (let at = 32; buffer[at] !== 0x0d; at += 32) {
|
||||
fields.push({
|
||||
name: buffer.toString('latin1', at, at + 11).replace(/\0.*$/, ''),
|
||||
length: buffer[at + 16],
|
||||
});
|
||||
}
|
||||
const records = [];
|
||||
for (let r = 0; r < count; r++) {
|
||||
let at = headerLength + r * recordLength + 1;
|
||||
const record = {};
|
||||
for (const field of fields) {
|
||||
record[field.name] = buffer
|
||||
.toString('utf8', at, at + field.length)
|
||||
.trim();
|
||||
at += field.length;
|
||||
}
|
||||
records.push(record);
|
||||
}
|
||||
return records;
|
||||
}
|
||||
|
||||
/** Group shapefile rings into polygons: clockwise outers, holes assigned by containment. */
|
||||
function shpPolygons(rings) {
|
||||
const outers = [];
|
||||
const holes = [];
|
||||
for (const ring of rings) {
|
||||
if (ring.length < 4) continue;
|
||||
(signedArea(ring) < 0 ? outers : holes).push(ring);
|
||||
}
|
||||
const polygons = outers.map((outer) => [outer]);
|
||||
for (const hole of holes) {
|
||||
const [x, y] = hole[0];
|
||||
const owner = polygons.find(([outer]) => pointInRing(outer, x, y));
|
||||
if (owner) owner.push(hole);
|
||||
else polygons.push([hole.slice().reverse()]);
|
||||
}
|
||||
return polygons;
|
||||
}
|
||||
|
||||
function pointInRing(ring, x, y) {
|
||||
let inside = false;
|
||||
for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
|
||||
const [xi, yi] = ring[i];
|
||||
const [xj, yj] = ring[j];
|
||||
if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
|
||||
inside = !inside;
|
||||
}
|
||||
return inside;
|
||||
}
|
||||
|
||||
// ── packs ────────────────────────────────────────────────────────────────
|
||||
|
||||
const LATIN = /^[\p{Script=Latin}\p{N}\s.,'’()\-/&]+$/u;
|
||||
|
||||
function uniqueNames(values, exclude) {
|
||||
const seen = new Set(exclude.map(normalizeAdminName));
|
||||
const out = [];
|
||||
for (const value of values) {
|
||||
const text = String(value || '').trim();
|
||||
const key = normalizeAdminName(text);
|
||||
if (!text || !key || seen.has(key) || !LATIN.test(text)) continue;
|
||||
seen.add(key);
|
||||
out.push(text);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function buildCountries() {
|
||||
const source = await fetchPinned('countries');
|
||||
const mapUnits = await fetchPinned('mapUnits');
|
||||
const params = PARAMS.countries;
|
||||
const features = [];
|
||||
for (const { properties: p, geometry } of JSON.parse(source.bytes).features) {
|
||||
const unit = simplifyUnit(geojsonPolygons(geometry), params);
|
||||
if (!unit.polygons.length) continue;
|
||||
const name = p.ADMIN || p.NAME_EN || p.NAME;
|
||||
features.push({
|
||||
name,
|
||||
alt: uniqueNames(
|
||||
[p.NAME, p.NAME_LONG, p.NAME_EN, p.FORMAL_EN, p.BRK_NAME].filter(
|
||||
Boolean,
|
||||
),
|
||||
[name],
|
||||
),
|
||||
country: name,
|
||||
iso: p.ADM0_A3,
|
||||
iso2: p.ISO_A2_EH || p.ISO_A2,
|
||||
type: 'Country',
|
||||
...(unit.decimals !== params.decimals ? { d: unit.decimals } : {}),
|
||||
polygons: encodeUnit(unit),
|
||||
});
|
||||
}
|
||||
for (const { properties: p, geometry } of JSON.parse(mapUnits.bytes)
|
||||
.features) {
|
||||
if (p.ADM0_A3 !== 'GBR') continue;
|
||||
const unit = simplifyUnit(geojsonPolygons(geometry), params);
|
||||
features.push({
|
||||
name: p.GEOUNIT,
|
||||
country: p.ADMIN,
|
||||
iso: p.GU_A3,
|
||||
iso2: 'GB',
|
||||
type: 'Constituent country',
|
||||
...(unit.decimals !== params.decimals ? { d: unit.decimals } : {}),
|
||||
polygons: encodeUnit(unit),
|
||||
});
|
||||
}
|
||||
features.sort((a, b) => a.name.localeCompare(b.name));
|
||||
return {
|
||||
meta: {
|
||||
title: 'Natural Earth admin-0 countries',
|
||||
mapUnits: SOURCES.mapUnits,
|
||||
source: 'ne_10m_admin_0_countries',
|
||||
url: SOURCES.countries.url,
|
||||
sha256: source.digest,
|
||||
commit: NE_COMMIT,
|
||||
license:
|
||||
'Public domain (https://www.naturalearthdata.com/about/terms-of-use/)',
|
||||
decimals: params.decimals,
|
||||
curation: params,
|
||||
script: 'scripts/build-admin-packs.mjs',
|
||||
},
|
||||
features,
|
||||
};
|
||||
}
|
||||
|
||||
async function buildAdmin1() {
|
||||
const params = PARAMS.admin1;
|
||||
const source = await fetchPinned('admin1');
|
||||
const places = await fetchPinned('places');
|
||||
const collection = JSON.parse(source.bytes.toString('utf8'));
|
||||
const { ambiguity } = PARAMS;
|
||||
const cities = JSON.parse(places.bytes.toString('utf8'))
|
||||
.features.map((f) => f.properties)
|
||||
.filter((p) => p.pop_max >= ambiguity.elsewhereMinPopulation)
|
||||
.map((p) => ({
|
||||
keys: new Set([p.name, p.nameascii].map(normalizeAdminName)),
|
||||
lon: p.longitude,
|
||||
lat: p.latitude,
|
||||
population: p.pop_max,
|
||||
country: p.adm0name,
|
||||
}));
|
||||
const countryNames = new Set();
|
||||
for (const { properties: p } of collection.features)
|
||||
for (const name of [p.admin, p.geonunit])
|
||||
if (name) countryNames.add(normalizeAdminName(name));
|
||||
|
||||
const features = [];
|
||||
for (const { properties: p, geometry } of collection.features) {
|
||||
const name = String(p.name || '').trim();
|
||||
if (!name) continue;
|
||||
const unit = simplifyUnit(geojsonPolygons(geometry), params);
|
||||
if (!unit.polygons.length) continue;
|
||||
const nameEn =
|
||||
p.name_en && normalizeAdminName(p.name_en) !== normalizeAdminName(name)
|
||||
? String(p.name_en).trim()
|
||||
: null;
|
||||
const alt = uniqueNames(
|
||||
String(p.name_alt || '').split('|'),
|
||||
[name, nameEn].filter(Boolean),
|
||||
);
|
||||
const bbox = bboxOf(unit.polygons);
|
||||
const areaKm2 = unit.polygons.reduce(
|
||||
(sum, poly) => sum + ringAreaKm2(poly[0]),
|
||||
0,
|
||||
);
|
||||
const keys = new Set(
|
||||
[name, nameEn, ...alt].filter(Boolean).map(normalizeAdminName),
|
||||
);
|
||||
const amb = [];
|
||||
const ambAbroad = [];
|
||||
let cityState = false;
|
||||
const inBox = (c) =>
|
||||
c.lon >= bbox[0] &&
|
||||
c.lon <= bbox[2] &&
|
||||
c.lat >= bbox[1] &&
|
||||
c.lat <= bbox[3];
|
||||
for (const key of keys) {
|
||||
const namesakes = cities.filter((c) => c.keys.has(key));
|
||||
const ownCity = namesakes.some(
|
||||
(c) => inBox(c) && c.population >= ambiguity.insideMinPopulation,
|
||||
);
|
||||
const cityInside = ownCity && areaKm2 > ambiguity.cityStateMaxKm2;
|
||||
if (ownCity && !cityInside) cityState = true;
|
||||
const elsewhere = namesakes.filter((c) => !inBox(c));
|
||||
if (
|
||||
countryNames.has(key) ||
|
||||
cityInside ||
|
||||
elsewhere.some((c) => c.country === p.admin)
|
||||
)
|
||||
amb.push(key);
|
||||
// Only abroad: "Victoria, Australia" settles it; "Victoria" alone not.
|
||||
else if (elsewhere.length) ambAbroad.push(key);
|
||||
}
|
||||
const postal = String(p.postal || '').trim();
|
||||
features.push({
|
||||
name,
|
||||
...(nameEn ? { nameEn } : {}),
|
||||
...(alt.length ? { alt } : {}),
|
||||
...(/^[A-Z]{2}$/.test(postal) ? { postal } : {}),
|
||||
type: p.type_en || p.type || null,
|
||||
...(Number.isFinite(p.min_label) ? { rank: p.min_label } : {}),
|
||||
country: p.admin,
|
||||
iso2: p.iso_a2 && p.iso_a2 !== '-99' ? p.iso_a2 : null,
|
||||
iso: p.iso_3166_2 && !p.iso_3166_2.includes('~') ? p.iso_3166_2 : null,
|
||||
...(amb.length ? { amb: amb.sort() } : {}),
|
||||
...(ambAbroad.length ? { ambAbroad: ambAbroad.sort() } : {}),
|
||||
...(cityState ? { cityState } : {}),
|
||||
...(Number.isFinite(p.longitude) && Number.isFinite(p.latitude)
|
||||
? {
|
||||
label: [
|
||||
Math.round(p.longitude * 1000) / 1000,
|
||||
Math.round(p.latitude * 1000) / 1000,
|
||||
],
|
||||
}
|
||||
: {}),
|
||||
...(unit.decimals !== params.decimals ? { d: unit.decimals } : {}),
|
||||
polygons: encodeUnit(unit),
|
||||
});
|
||||
}
|
||||
features.sort(
|
||||
(a, b) =>
|
||||
a.country.localeCompare(b.country) ||
|
||||
a.name.localeCompare(b.name) ||
|
||||
(a.iso || '').localeCompare(b.iso || ''),
|
||||
);
|
||||
return {
|
||||
meta: {
|
||||
title: 'Natural Earth admin-1 states and provinces',
|
||||
source: 'ne_10m_admin_1_states_provinces',
|
||||
url: SOURCES.admin1.url,
|
||||
sha256: source.digest,
|
||||
ambiguitySource: SOURCES.places.url,
|
||||
ambiguitySha256: places.digest,
|
||||
commit: NE_COMMIT,
|
||||
license:
|
||||
'Public domain (https://www.naturalearthdata.com/about/terms-of-use/)',
|
||||
schema:
|
||||
'features[]: name, nameEn?, alt?[], postal?, type, rank? (min_label: the zoom at which Natural Earth labels the unit; lower is more prominent), country, iso2, iso (ISO 3166-2), amb?[] (normalized names that are also a country or a city — alone or with the country named), ambAbroad?[] (names shared only with a city in another country — ambiguous alone, settled by naming the country), cityState? (the unit is its own city), label? [lon, lat] label point, d? (decimals when not meta.decimals), polygons[][ring] (first ring outer, rest holes; each ring open and encoded as integers in 10^-d degrees, first vertex absolute then [dLon, dLat] deltas)',
|
||||
decimals: params.decimals,
|
||||
curation: { ...params, ambiguity },
|
||||
script: 'scripts/build-admin-packs.mjs',
|
||||
},
|
||||
features,
|
||||
};
|
||||
}
|
||||
|
||||
async function buildCounties() {
|
||||
const params = PARAMS.counties;
|
||||
const source = await fetchPinned('counties');
|
||||
const files = unzip(source.bytes);
|
||||
const base = path.basename(new URL(SOURCES.counties.url).pathname, '.zip');
|
||||
const shapes = readShp(files.get(`${base}.shp`));
|
||||
const records = readDbf(files.get(`${base}.dbf`));
|
||||
if (shapes.length !== records.length)
|
||||
throw new Error('counties: shp/dbf record counts differ');
|
||||
const features = [];
|
||||
records.forEach((record, index) => {
|
||||
const unit = simplifyUnit(shpPolygons(shapes[index]), params);
|
||||
if (!unit.polygons.length) return;
|
||||
const lsad = record.NAMELSAD.startsWith(record.NAME)
|
||||
? record.NAMELSAD.slice(record.NAME.length).trim()
|
||||
: '';
|
||||
features.push({
|
||||
name: record.NAME,
|
||||
full: record.NAMELSAD,
|
||||
...(lsad ? { lsad } : {}),
|
||||
state: record.STATE_NAME,
|
||||
st: record.STUSPS,
|
||||
geoid: record.GEOID,
|
||||
...(unit.decimals !== params.decimals ? { d: unit.decimals } : {}),
|
||||
polygons: encodeUnit(unit),
|
||||
});
|
||||
});
|
||||
features.sort((a, b) => a.geoid.localeCompare(b.geoid));
|
||||
return {
|
||||
meta: {
|
||||
title: 'US Census Bureau cartographic boundary counties',
|
||||
source: base,
|
||||
url: SOURCES.counties.url,
|
||||
sha256: source.digest,
|
||||
license: 'Public domain (U.S. Government work, 17 U.S.C. § 105)',
|
||||
schema:
|
||||
'features[]: name, full (NAMELSAD), lsad? (County, Parish, Borough, …), state, st (USPS), geoid, d? (decimals when not meta.decimals), polygons[][ring] (first ring outer, rest holes; each ring open and encoded as integers in 10^-d degrees, first vertex absolute then [dLon, dLat] deltas)',
|
||||
decimals: params.decimals,
|
||||
curation: params,
|
||||
script: 'scripts/build-admin-packs.mjs',
|
||||
},
|
||||
features,
|
||||
};
|
||||
}
|
||||
|
||||
async function writePack(relative, pack) {
|
||||
const file = path.join(ROOT, relative);
|
||||
await mkdir(path.dirname(file), { recursive: true });
|
||||
const text = JSON.stringify(pack) + '\n';
|
||||
await writeFile(file, text);
|
||||
const parts = pack.features.reduce((n, f) => n + f.polygons.length, 0);
|
||||
const vertices = pack.features.reduce(
|
||||
(n, f) => n + f.polygons.flat().reduce((m, ring) => m + ring.length / 2, 0),
|
||||
0,
|
||||
);
|
||||
console.log(
|
||||
`${relative}: ${pack.features.length} features, ${parts} parts, ${vertices} vertices, ${Buffer.byteLength(text)} bytes`,
|
||||
);
|
||||
}
|
||||
|
||||
if (!only || only === 'countries')
|
||||
await writePack(
|
||||
'src/data/local_data/natural_earth/countries.json',
|
||||
await buildCountries(),
|
||||
);
|
||||
if (!only || only === 'admin1')
|
||||
await writePack(
|
||||
'src/data/local_data/natural_earth/states_provinces.json',
|
||||
await buildAdmin1(),
|
||||
);
|
||||
if (!only || only === 'counties')
|
||||
await writePack(
|
||||
'src/data/local_data/us_census_counties/counties.json',
|
||||
await buildCounties(),
|
||||
);
|
||||
@@ -0,0 +1,84 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Maintainer-only Overture military-name pack build (DuckDB 1.5.5)."""
|
||||
import argparse
|
||||
import gzip
|
||||
import hashlib
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import re
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
RELEASE = '2026-09-23.1'
|
||||
CLASSES = ['military_land', 'airfield', 'naval_base', 'range', 'barracks', 'base', 'training_area']
|
||||
PACK = ROOT / 'src/data/local_data/osm_military_names'
|
||||
|
||||
|
||||
def assemble(rows):
|
||||
records = []
|
||||
snapshots = set()
|
||||
for row in rows:
|
||||
source = next(s for s in row['sources'] if s['dataset'] == 'OpenStreetMap')
|
||||
match = re.fullmatch(r'([nwr])(\d+)@\d+', source['record_id'])
|
||||
if not match:
|
||||
raise ValueError('Invalid typed OSM identity')
|
||||
ident = match[1] + match[2]
|
||||
bbox = [row['bbox'][k] for k in ['xmin', 'ymin', 'xmax', 'ymax']]
|
||||
lon, lat, area = row['lon'], row['lat'], row['area']
|
||||
if not all(math.isfinite(v) for v in [lon, lat, area, *bbox]):
|
||||
raise ValueError('Invalid geometry measurement')
|
||||
if not bbox[0] - 1e-7 <= lon <= bbox[2] + 1e-7 or not bbox[1] - 1e-7 <= lat <= bbox[3] + 1e-7:
|
||||
raise ValueError('Label outside source bounds')
|
||||
kind = row['military'] if row['military'] in CLASSES else 'military_land'
|
||||
records.append([ident, row['name'], round(lon, 5), round(lat, 5),
|
||||
*[round(v, 4) for v in bbox], CLASSES.index(kind), max(1, round(abs(area)))])
|
||||
snapshots.add(source['version'][:10])
|
||||
records.sort(key=lambda r: (r[0][0], int(r[0][1:])))
|
||||
if len(set(r[0] for r in records)) != len(records):
|
||||
raise ValueError('Duplicate OSM identity')
|
||||
return {'release': RELEASE, 'snapshots': sorted(snapshots), 'classes': CLASSES, 'records': records}
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--cache', type=Path, required=True)
|
||||
parser.add_argument('--extensions', type=Path)
|
||||
parser.add_argument('--verify', action='store_true')
|
||||
args = parser.parse_args()
|
||||
args.cache.mkdir(parents=True, exist_ok=True)
|
||||
cached = args.cache / ('military-names-' + RELEASE + '.json')
|
||||
if not cached.exists():
|
||||
import duckdb
|
||||
if duckdb.__version__ != '1.5.5':
|
||||
raise RuntimeError('Use duckdb==1.5.5')
|
||||
config = {'threads': '8', 'memory_limit': '3GB', 'temp_directory': str(args.cache / 'temp')}
|
||||
if args.extensions:
|
||||
config['extension_directory'] = str(args.extensions)
|
||||
connection = duckdb.connect(config=config)
|
||||
if not args.extensions:
|
||||
connection.execute('INSTALL httpfs; INSTALL spatial;')
|
||||
connection.execute('LOAD httpfs; LOAD spatial; SET geometry_always_xy=true; SET enable_progress_bar=false;')
|
||||
files = json.loads((ROOT / 'scripts/military-names-files.json').read_text())
|
||||
if not all('/' + RELEASE + '/' in url for url in files):
|
||||
raise ValueError('Unexpected source release')
|
||||
cursor = connection.execute((ROOT / 'scripts/military-names.sql').read_text(), [files])
|
||||
fields = [d[0] for d in cursor.description]
|
||||
rows = [dict(zip(fields, row)) for row in cursor.fetchall()]
|
||||
cached.write_text(json.dumps(rows, ensure_ascii=False, separators=(',', ':')))
|
||||
pack = assemble(json.loads(cached.read_text()))
|
||||
raw = json.dumps(pack, ensure_ascii=False, separators=(',', ':')).encode()
|
||||
digest = hashlib.sha256(raw).hexdigest()
|
||||
if args.verify:
|
||||
expected = (PACK / 'names.sha256').read_text().split()[0]
|
||||
if digest != expected:
|
||||
raise ValueError(f'Output SHA-256 mismatch: {digest}')
|
||||
else:
|
||||
PACK.mkdir(parents=True, exist_ok=True)
|
||||
(PACK / 'names.json').write_bytes(raw)
|
||||
(PACK / 'names.sha256').write_text(digest + ' names.json\n')
|
||||
print(json.dumps({'records': len(pack['records']), 'rawBytes': len(raw),
|
||||
'gzipBytes': len(gzip.compress(raw, compresslevel=9, mtime=0)), 'sha256': digest}))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -26,11 +26,17 @@
|
||||
"src/annotations/drawMode.test.mjs",
|
||||
"src/annotations/drawTool.js",
|
||||
"src/annotations/drawTool.test.mjs",
|
||||
"src/annotations/adminOutline.test.mjs",
|
||||
"src/annotations/regionRing.test.mjs",
|
||||
"src/data/adminBoundaries.test.mjs",
|
||||
"scripts/build-admin-packs.mjs",
|
||||
"scripts/qa-admin-outlines.mjs",
|
||||
"src/data/inputOwnership.test.mjs",
|
||||
"docs/CODE-BOUNDARIES.md",
|
||||
"src/main.js",
|
||||
"docs/APPLICATION.md",
|
||||
"scripts/qa-application.mjs",
|
||||
"scripts/qa-terrain-429.mjs",
|
||||
"src/app/application.js",
|
||||
"src/app/application.test.mjs",
|
||||
"src/app/mapLifecycle.test.mjs",
|
||||
@@ -581,6 +587,8 @@
|
||||
"src/maps/imagery.js",
|
||||
"src/maps/registry.js",
|
||||
"src/maps/terrain.js",
|
||||
"src/maps/terrainRetry.js",
|
||||
"src/maps/terrainRetry.test.mjs",
|
||||
"src/mapStackController.js",
|
||||
"src/mapStartup.js",
|
||||
"src/mapStackChips.test.mjs",
|
||||
@@ -844,5 +852,17 @@
|
||||
"src/ui/imageryBoxTool.test.mjs",
|
||||
"src/ui/recentImagery.test.mjs",
|
||||
"src/layers/recentImagery/testDoubles.mjs",
|
||||
"scripts/qa-recent-imagery.mjs"
|
||||
"scripts/qa-recent-imagery.mjs",
|
||||
"scripts/qa-overpass-offload.mjs",
|
||||
"src/overpassOffload.test.mjs",
|
||||
"src/sources/openFreeMap.test.mjs",
|
||||
"src/sources/vectorTiles.test.mjs",
|
||||
"src/sources/militaryTileGeometry.test.mjs",
|
||||
"src/layers/traffic/surface.test.mjs",
|
||||
"src/layers/traffic/roadModes.test.mjs",
|
||||
"scripts/qa-traffic-motion.mjs",
|
||||
"src/layers/traffic/motion.test.mjs",
|
||||
"scripts/qa-journey-recorder.mjs",
|
||||
"scripts/qa-alpr-journey.mjs",
|
||||
"scripts/qa-context-arrivals.mjs"
|
||||
]
|
||||
@@ -0,0 +1,66 @@
|
||||
[
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00000-18dcb239-f29e-5e57-b36f-4bd46c12fb86-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00001-4a0ec645-f2e2-5fd1-aeaf-a2210290fe76-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00002-0bfb9ec4-5947-583a-9b20-5b39a6635e7d-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00003-0aa711cc-b475-5914-9670-7295640f184f-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00004-9a1af7ec-89dd-5aa1-a419-d6325719c330-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00005-e85508c1-3f80-5883-8539-35302da710f3-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00006-184886ec-67b4-5a65-852f-f26f757aaeea-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00007-adbd870a-4116-50a2-9554-57064af19a18-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00008-6362555a-8b0c-5589-a6fe-b71ddca82083-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00009-19bb41f3-6c3b-579a-adae-8f69030c37c7-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00010-0e372a9c-a60d-5b06-89e2-866989d612dd-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00011-2ae04990-7b00-5def-bf72-12b2fdc13b48-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00012-dcfe8859-26a4-544b-ad61-dfbc7e7f272a-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00013-a369ed98-5e3b-5bda-94c9-460f06e8746b-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00014-d03d3cde-6ae3-5938-abe9-b2018f7ab0e3-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00015-57a736a1-7d58-5851-877a-2fca7de484ba-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00016-141b8ad5-f6d4-5f5e-8353-450a53188e27-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00017-14133e77-297b-57f3-b028-c5133bb56578-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00018-65485e6e-8939-51ab-8566-47dd3887b6c3-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00019-64fb52b8-5ba4-5f00-860f-4fe71e1c9f3a-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00020-0feea924-6adb-5118-9a2b-e0a0d3ef6963-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00021-a9115b0c-a202-5468-bfae-0a1e6f953be3-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00022-440ee3b6-f6ae-5bf9-b5d1-cc81fcb0a430-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00023-53a4d462-62b9-589c-9650-f7c9652354e7-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00024-54089af7-32f4-5ad8-8970-cea7350cbb20-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00025-59cc63a7-e7da-58e2-8d06-1df15f3a0636-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00026-ba0e8b28-756c-5b5e-aa01-0939a15e45c8-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00027-8237ebb3-2fcb-50d7-884b-81c8e81bda1e-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00028-6fb209d3-9fbe-5155-9983-896b1bb9e84e-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00029-e86227ec-f5f7-51c6-b537-a10334796cc4-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00030-a2779b0d-003a-5f5d-812c-02eb4a5db71f-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00031-554320d6-a62d-5be7-80b0-d32fb67d87ca-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00032-a49d2756-469a-571f-86ef-be60690cfaea-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00033-0b36146b-6963-5133-8a67-ced0bbb37d6a-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00034-b676aef2-1e90-5966-8531-40f42c5d01d6-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00035-c9b04728-fc59-50f2-bfa8-5f8692ea731e-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00036-22a0fbd7-fd24-5832-ac6c-85e82b56ced6-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00037-d157ddb7-8962-515b-9ec3-d54333fcf836-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00038-39d77c44-55f2-5792-83e1-cac6416d0630-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00039-f6871cf2-753b-53f1-aacf-645ea035826d-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00040-3d142e7a-4189-5e50-9f68-0f77e9a51047-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00041-9e6d1cdd-f130-5089-9d0f-703626552100-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00042-4cefe8fe-4966-5e1e-9cf5-19fd90384db8-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00043-65360671-af63-58dd-9784-bceb07abe219-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00044-b423bff1-dd2b-52c4-90f6-cd1605e4d83f-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00045-1f4d97be-99fc-50de-b9cb-f3624c9a1817-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00046-32a9756a-e3a0-5980-a8d9-88dd475f25b9-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00047-cf80d668-e9f1-5f69-8e21-0a73f1732e5f-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00048-8d932283-4f3f-533d-895b-684faaa9cc34-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00049-996168f3-0c3a-5b58-8444-168c7d859a04-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00050-f9c3c526-3ea5-5dab-a46d-05c623c3e905-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00051-72b4d98d-4b3b-5b3b-a565-62c206d4fa29-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00052-7385fa90-2fa9-53c8-9ed4-96d5703f3a37-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00053-96804709-94fa-56d2-bafd-69b2cbce3881-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00054-520c3c50-82f8-5f3d-97b5-fa8f5f4e65e7-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00055-8742f073-69cd-579e-bf00-b16b6e6a7669-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00056-58083e97-7020-5522-ac19-d8a5b4dcbc98-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00057-bf201c73-1fb3-5dbc-8cec-d344d999820e-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00058-9e1561c3-ba15-528b-8db3-62ce04b1570b-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00059-dd8cd7ca-410f-54f8-9b50-66beb004d640-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00060-203c7177-ec4a-55c2-8003-d828b144a6d6-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00061-0da76969-7fb1-56b9-bb83-4e40f3acea8d-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00062-13344b87-db6c-5415-a48e-afd95a928a85-c000.zstd.parquet",
|
||||
"https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-09-23.1/theme=base/type=land_use/part-00063-a61ab643-210f-518d-b6b8-894f72e5c094-c000.zstd.parquet"
|
||||
]
|
||||
@@ -0,0 +1,11 @@
|
||||
SELECT names.primary AS name, bbox, sources,
|
||||
source_tags['military'] AS military,
|
||||
ST_X(ST_PointOnSurface(geometry)) AS lon,
|
||||
ST_Y(ST_PointOnSurface(geometry)) AS lat,
|
||||
ST_Area_Spheroid(geometry) AS area
|
||||
FROM read_parquet(?)
|
||||
WHERE subtype = 'military'
|
||||
AND nullif(trim(names.primary), '') IS NOT NULL
|
||||
AND (source_tags['landuse'] = 'military'
|
||||
OR source_tags['military'] IN
|
||||
('airfield', 'naval_base', 'range', 'barracks', 'base', 'training_area'))
|
||||
+145
-21
@@ -9,7 +9,8 @@
|
||||
"src/data/infrastructure.js",
|
||||
"src/data/localGeojsonCore.js",
|
||||
"src/data/localGeojsonLod.js",
|
||||
"src/data/inputOwnership.js"
|
||||
"src/data/inputOwnership.js",
|
||||
"src/data/infrastructureOverlayEntry.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
},
|
||||
@@ -249,7 +250,12 @@
|
||||
"src/data/regionalModel.js",
|
||||
"src/nominatimGeocode.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/rateLimit.js"
|
||||
"src/sources/rateLimit.js",
|
||||
"src/data/local_data/natural_earth/marine.json",
|
||||
"src/data/local_data/natural_earth/regions.json",
|
||||
"src/data/naturalEarthRegions.js",
|
||||
"src/data/bundledJson.js",
|
||||
"src/data/retryableLoad.js"
|
||||
],
|
||||
"external": []
|
||||
},
|
||||
@@ -615,7 +621,8 @@
|
||||
"src/ui/shellFacade.js",
|
||||
"src/ui/localSdrControls.js",
|
||||
"src/layers/localAdsb/feedNames.js",
|
||||
"src/ui/localSdrPresentation.js"
|
||||
"src/ui/localSdrPresentation.js",
|
||||
"src/data/cameraArrival.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
},
|
||||
@@ -719,7 +726,8 @@
|
||||
"src/director/sharing/lifetime.js",
|
||||
"src/director/authoring.js",
|
||||
"src/scenes/sharing.js",
|
||||
"src/ui/sceneSharing.js"
|
||||
"src/ui/sceneSharing.js",
|
||||
"src/data/cameraArrival.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
},
|
||||
@@ -963,6 +971,7 @@
|
||||
"installations-layer": {
|
||||
"exports": ["./layers/installations"],
|
||||
"modules": [
|
||||
"src/data/cameraSensitivity.js",
|
||||
"src/data/installationFeedback.js",
|
||||
"src/data/militaryInstallationData.js",
|
||||
"src/layers/installations/controls.js",
|
||||
@@ -976,9 +985,23 @@
|
||||
"src/layers/installations/source.js",
|
||||
"src/layers/installations/state.js",
|
||||
"src/layers/installations/viewport.js",
|
||||
"src/data/inputOwnership.js"
|
||||
"src/data/inputOwnership.js",
|
||||
"src/data/tomtomTiles.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/data/militaryNames.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/data/local_data/osm_military_names/names.json",
|
||||
"src/data/bundledJson.js",
|
||||
"src/data/retryableLoad.js",
|
||||
"src/layers/installations/namedMarkers.js",
|
||||
"src/data/infrastructureOverlayEntry.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
"external": ["cesium", "@mapbox/vector-tile", "pbf"]
|
||||
},
|
||||
"awareness-layer": {
|
||||
"exports": ["./layers/awareness"],
|
||||
@@ -1022,18 +1045,29 @@
|
||||
"src/layers/traffic/flow.js",
|
||||
"src/layers/traffic/flowDecode.js",
|
||||
"src/layers/traffic/flowSource.js",
|
||||
"src/layers/traffic/footprint.js",
|
||||
"src/layers/traffic/index.js",
|
||||
"src/layers/traffic/ingestion.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/layers/traffic/lifecycle.js",
|
||||
"src/layers/traffic/model.js",
|
||||
"src/layers/traffic/policy.js",
|
||||
"src/layers/traffic/rendering.js",
|
||||
"src/layers/traffic/retention.js",
|
||||
"src/layers/traffic/source.js",
|
||||
"src/layers/traffic/state.js",
|
||||
"src/layers/traffic/style.js",
|
||||
"src/layers/traffic/surface.js",
|
||||
"src/layers/traffic/timing.js",
|
||||
"src/layers/traffic/viewport.js",
|
||||
"src/sources/overpassRoads.js"
|
||||
"src/sources/overpassRoads.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/layers/traffic/roadModes.js"
|
||||
],
|
||||
"external": ["cesium", "pbf", "@mapbox/vector-tile"]
|
||||
},
|
||||
@@ -1111,9 +1145,16 @@
|
||||
"src/layers/alpr/overlay.js",
|
||||
"src/layers/alpr/source.js",
|
||||
"src/data/inputOwnership.js",
|
||||
"src/layers/alpr/records.js"
|
||||
"src/layers/alpr/records.js",
|
||||
"src/data/tomtomTiles.js",
|
||||
"src/layers/alpr/tileRecords.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/layers/alpr/floors.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
"external": ["cesium", "@mapbox/vector-tile", "pbf"]
|
||||
},
|
||||
"radio-layer": {
|
||||
"exports": ["./layers/radio"],
|
||||
@@ -1208,6 +1249,7 @@
|
||||
"src/maps/imagery.js",
|
||||
"src/maps/registry.js",
|
||||
"src/maps/terrain.js",
|
||||
"src/maps/terrainRetry.js",
|
||||
"src/keySetupCore.mjs",
|
||||
"src/maps/imageryHost.js"
|
||||
],
|
||||
@@ -1322,6 +1364,7 @@
|
||||
"src/app/atmosphereCompat.js",
|
||||
"src/bloom.js",
|
||||
"src/camera.js",
|
||||
"src/cameraGroundGuard.js",
|
||||
"src/cameraVerbs.js",
|
||||
"src/cctvFocusPolicy.js",
|
||||
"src/cctvFocusRequest.js",
|
||||
@@ -1410,6 +1453,10 @@
|
||||
"src/data/modelVisualAnchor.js",
|
||||
"src/data/motionModel.js",
|
||||
"src/data/naturalEarthRegions.js",
|
||||
"src/data/adminBoundaries.js",
|
||||
"src/data/local_data/natural_earth/states_provinces.json",
|
||||
"src/data/local_data/natural_earth/countries.json",
|
||||
"src/data/local_data/us_census_counties/counties.json",
|
||||
"src/data/neighborhoodPolygons.js",
|
||||
"src/data/pickRegistry.js",
|
||||
"src/data/radio.js",
|
||||
@@ -1635,15 +1682,19 @@
|
||||
"src/layers/traffic/flow.js",
|
||||
"src/layers/traffic/flowDecode.js",
|
||||
"src/layers/traffic/flowSource.js",
|
||||
"src/layers/traffic/footprint.js",
|
||||
"src/layers/traffic/index.js",
|
||||
"src/layers/traffic/ingestion.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/layers/traffic/lifecycle.js",
|
||||
"src/layers/traffic/model.js",
|
||||
"src/layers/traffic/policy.js",
|
||||
"src/layers/traffic/rendering.js",
|
||||
"src/layers/traffic/retention.js",
|
||||
"src/layers/traffic/source.js",
|
||||
"src/layers/traffic/state.js",
|
||||
"src/layers/traffic/style.js",
|
||||
"src/layers/traffic/surface.js",
|
||||
"src/layers/traffic/timing.js",
|
||||
"src/layers/traffic/viewport.js",
|
||||
"src/layers/vessels/cards.js",
|
||||
@@ -1675,6 +1726,7 @@
|
||||
"src/maps/imagery.js",
|
||||
"src/maps/registry.js",
|
||||
"src/maps/terrain.js",
|
||||
"src/maps/terrainRetry.js",
|
||||
"src/navigationPolicy.js",
|
||||
"src/orbit.js",
|
||||
"src/overlays/worldOverlay.js",
|
||||
@@ -1961,7 +2013,21 @@
|
||||
"src/layers/recentImagery/thumbnails.js",
|
||||
"src/maps/imageryHost.js",
|
||||
"src/ui/recentImagery.js",
|
||||
"src/ui/imageryBoxTool.js"
|
||||
"src/ui/imageryBoxTool.js",
|
||||
"src/layers/alpr/tileRecords.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/layers/traffic/roadModes.js",
|
||||
"src/data/cameraArrival.js",
|
||||
"src/layers/alpr/floors.js",
|
||||
"src/data/militaryNames.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/data/local_data/osm_military_names/names.json",
|
||||
"src/layers/installations/namedMarkers.js",
|
||||
"src/data/infrastructureOverlayEntry.js"
|
||||
],
|
||||
"external": [
|
||||
"hls.js",
|
||||
@@ -2067,6 +2133,10 @@
|
||||
"src/data/modelVisualAnchor.js",
|
||||
"src/data/motionModel.js",
|
||||
"src/data/naturalEarthRegions.js",
|
||||
"src/data/adminBoundaries.js",
|
||||
"src/data/local_data/natural_earth/states_provinces.json",
|
||||
"src/data/local_data/natural_earth/countries.json",
|
||||
"src/data/local_data/us_census_counties/counties.json",
|
||||
"src/data/neighborhoodPolygons.js",
|
||||
"src/data/pickRegistry.js",
|
||||
"src/data/radioCountry.js",
|
||||
@@ -2275,15 +2345,19 @@
|
||||
"src/layers/traffic/flow.js",
|
||||
"src/layers/traffic/flowDecode.js",
|
||||
"src/layers/traffic/flowSource.js",
|
||||
"src/layers/traffic/footprint.js",
|
||||
"src/layers/traffic/index.js",
|
||||
"src/layers/traffic/ingestion.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/layers/traffic/lifecycle.js",
|
||||
"src/layers/traffic/model.js",
|
||||
"src/layers/traffic/policy.js",
|
||||
"src/layers/traffic/rendering.js",
|
||||
"src/layers/traffic/retention.js",
|
||||
"src/layers/traffic/source.js",
|
||||
"src/layers/traffic/state.js",
|
||||
"src/layers/traffic/style.js",
|
||||
"src/layers/traffic/surface.js",
|
||||
"src/layers/traffic/timing.js",
|
||||
"src/layers/traffic/viewport.js",
|
||||
"src/layers/vessels/cards.js",
|
||||
@@ -2326,6 +2400,7 @@
|
||||
"src/layers/vessels/snapshotRenderer.js",
|
||||
"src/data/inputOwnership.js",
|
||||
"src/annotations/worldAnnotationRenderer.js",
|
||||
"src/cameraGroundGuard.js",
|
||||
"src/cameraVerbs.js",
|
||||
"src/services/groundFloor.js",
|
||||
"src/data/routeSteps.js",
|
||||
@@ -2422,7 +2497,21 @@
|
||||
"src/layers/recentImagery/catalog.js",
|
||||
"src/layers/recentImagery/rendering.js",
|
||||
"src/layers/recentImagery/thumbnails.js",
|
||||
"src/maps/imageryHost.js"
|
||||
"src/maps/imageryHost.js",
|
||||
"src/layers/alpr/tileRecords.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/layers/traffic/roadModes.js",
|
||||
"src/data/cameraArrival.js",
|
||||
"src/layers/alpr/floors.js",
|
||||
"src/data/militaryNames.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/data/local_data/osm_military_names/names.json",
|
||||
"src/layers/installations/namedMarkers.js",
|
||||
"src/data/infrastructureOverlayEntry.js"
|
||||
],
|
||||
"external": [
|
||||
"hls.js",
|
||||
@@ -2449,6 +2538,10 @@
|
||||
"src/data/local_data/natural_earth/regions.json",
|
||||
"src/data/local_data/neighborhoods/san-francisco.json",
|
||||
"src/data/naturalEarthRegions.js",
|
||||
"src/data/adminBoundaries.js",
|
||||
"src/data/local_data/natural_earth/states_provinces.json",
|
||||
"src/data/local_data/natural_earth/countries.json",
|
||||
"src/data/local_data/us_census_counties/counties.json",
|
||||
"src/data/neighborhoodPolygons.js",
|
||||
"src/data/bundledJson.js",
|
||||
"src/data/retryableLoad.js",
|
||||
@@ -2456,6 +2549,7 @@
|
||||
"src/keylessGeocoder.js",
|
||||
"src/layers/firms/anchors.js",
|
||||
"src/locations.js",
|
||||
"src/cameraGroundGuard.js",
|
||||
"src/search/defaults.js",
|
||||
"src/search/geospatial.js",
|
||||
"src/search/google.js",
|
||||
@@ -2478,7 +2572,9 @@
|
||||
"src/sources/featureGeometry.js",
|
||||
"src/sources/overpassFeaturesRecords.js",
|
||||
"src/sources/overpassFeatures.js",
|
||||
"src/sources/featureSource.js"
|
||||
"src/sources/featureSource.js",
|
||||
"src/sources/capability.js",
|
||||
"src/data/cameraArrival.js"
|
||||
],
|
||||
"external": [
|
||||
"cesium",
|
||||
@@ -2491,7 +2587,7 @@
|
||||
},
|
||||
"layer-lifecycle": {
|
||||
"exports": ["./data/lifecycle"],
|
||||
"modules": ["src/data/lifecycle.js"],
|
||||
"modules": ["src/data/lifecycle.js", "src/data/cameraArrival.js"],
|
||||
"external": []
|
||||
},
|
||||
"ui-navigation": {
|
||||
@@ -2499,7 +2595,8 @@
|
||||
"modules": [
|
||||
"src/navigationPolicy.js",
|
||||
"src/ui/navigationController.js",
|
||||
"src/app/stateChannel.js"
|
||||
"src/app/stateChannel.js",
|
||||
"src/data/cameraArrival.js"
|
||||
],
|
||||
"external": ["cesium"]
|
||||
},
|
||||
@@ -2661,9 +2758,14 @@
|
||||
"modules": [
|
||||
"src/layers/alpr/policy.js",
|
||||
"src/layers/alpr/records.js",
|
||||
"src/layers/alpr/source.js"
|
||||
"src/layers/alpr/source.js",
|
||||
"src/data/tomtomTiles.js",
|
||||
"src/layers/alpr/tileRecords.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js"
|
||||
],
|
||||
"external": []
|
||||
"external": ["@mapbox/vector-tile", "pbf"]
|
||||
},
|
||||
"bikeshare-source": {
|
||||
"exports": ["./layers/bikeshare/source"],
|
||||
@@ -2692,9 +2794,21 @@
|
||||
"exports": ["./layers/installations/source"],
|
||||
"modules": [
|
||||
"src/layers/installations/source.js",
|
||||
"src/data/militaryInstallationData.js"
|
||||
"src/data/militaryInstallationData.js",
|
||||
"src/data/tomtomTiles.js",
|
||||
"src/sources/capability.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/data/militaryNames.js",
|
||||
"src/sources/requestDeadline.js",
|
||||
"src/data/local_data/osm_military_names/names.json",
|
||||
"src/data/bundledJson.js",
|
||||
"src/data/retryableLoad.js"
|
||||
],
|
||||
"external": []
|
||||
"external": ["@mapbox/vector-tile", "pbf"]
|
||||
},
|
||||
"launches-source": {
|
||||
"exports": ["./layers/launches/source"],
|
||||
@@ -2717,8 +2831,16 @@
|
||||
"src/data/tomtomTiles.js",
|
||||
"src/layers/traffic/flowDecode.js",
|
||||
"src/layers/traffic/flowSource.js",
|
||||
"src/layers/traffic/footprint.js",
|
||||
"src/layers/traffic/source.js",
|
||||
"src/sources/overpassRoads.js"
|
||||
"src/sources/overpassRoads.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/sources/openFreeMap.js",
|
||||
"src/sources/militaryTileGeometry.js",
|
||||
"src/sources/vectorTiles.js",
|
||||
"src/sources/phaseTiming.js",
|
||||
"src/layers/traffic/roadModes.js",
|
||||
"src/data/flowMatch.js"
|
||||
],
|
||||
"external": ["@mapbox/vector-tile", "pbf"]
|
||||
},
|
||||
@@ -2855,7 +2977,8 @@
|
||||
"src/sources/featureGeometry.js",
|
||||
"src/sources/overpassFeaturesRecords.js",
|
||||
"src/sources/overpassFeatures.js",
|
||||
"src/sources/featureSource.js"
|
||||
"src/sources/featureSource.js",
|
||||
"src/sources/capability.js"
|
||||
],
|
||||
"external": ["cesium", "egm96-universal", "pbf"]
|
||||
},
|
||||
@@ -2924,7 +3047,8 @@
|
||||
"src/sources/featureGeometry.js",
|
||||
"src/sources/overpassFeaturesRecords.js",
|
||||
"src/sources/overpassFeatures.js",
|
||||
"src/sources/featureSource.js"
|
||||
"src/sources/featureSource.js",
|
||||
"src/sources/capability.js"
|
||||
],
|
||||
"external": []
|
||||
},
|
||||
|
||||
@@ -0,0 +1,655 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* qa-admin-outlines.mjs — bundled state/province/county outlines, driven like a
|
||||
* user would drive them.
|
||||
*
|
||||
* Run: node scripts/qa-admin-outlines.mjs http://localhost:4173 [--headful] [--no-video]
|
||||
*
|
||||
* Journey: frame Texas at state scale and outline "Texas"; pan and zoom toward
|
||||
* Austin in smooth 2–3 s moves; outline "Travis County, Texas"; pan north and
|
||||
* outline the neighbouring "Williamson County, Texas"; zoom out to see both;
|
||||
* then outline "Bavaria" (framed, as a voice request for a distant place is),
|
||||
* and finally Brandenburg (Berlin is a hole) and Hawaii (eight islands).
|
||||
*
|
||||
* Asserts for every outline: it resolves from the bundled packs (no geocode,
|
||||
* boundary or Overpass request), is drawn as a draped outline within the
|
||||
* budget, and holds still — no rebuilt primitives and no new entities while
|
||||
* the camera is still. The whole journey must log zero console/page errors and
|
||||
* send zero requests to any Overpass host or nominatim.openstreetmap.org.
|
||||
*
|
||||
* Evidence in qa-shots/ (gitignored): admin-outlines-<step>.png screenshots,
|
||||
* admin-outlines-journey.mp4 (CDP screencast at ~24 fps, frames re-timed from
|
||||
* their capture timestamps), and admin-outlines-result.json with per-step
|
||||
* timings, frame-time p50/p95 and still-camera frame-difference statistics.
|
||||
* Exits nonzero on any failed assertion.
|
||||
*/
|
||||
import assert from 'node:assert/strict';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import fs from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
import puppeteer from 'puppeteer';
|
||||
import sharp from 'sharp';
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-admin-outlines.mjs <dev-server-url> [--headful] [--no-video]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const url = args.find((arg) => !arg.startsWith('--'));
|
||||
if (!url || !['http:', 'https:'].includes(new URL(url).protocol))
|
||||
throw new Error('Supply a running dev server URL; see --help');
|
||||
const recordVideo = !args.includes('--no-video');
|
||||
const shots = path.resolve('qa-shots');
|
||||
const framesDir = path.join(shots, 'admin-outlines-frames');
|
||||
await fs.mkdir(shots, { recursive: true });
|
||||
await fs.rm(framesDir, { recursive: true, force: true });
|
||||
await fs.mkdir(framesDir, { recursive: true });
|
||||
|
||||
const OUTLINE_BUDGET_MS = 1500;
|
||||
const STILL_MS = 3000;
|
||||
const FRAME_INTERVAL_S = 1 / 24;
|
||||
|
||||
const result = {
|
||||
url,
|
||||
steps: [],
|
||||
forbiddenRequests: [],
|
||||
lookups: [],
|
||||
packRequests: [],
|
||||
consoleErrors: [],
|
||||
pageErrors: [],
|
||||
screenshots: [],
|
||||
video: null,
|
||||
};
|
||||
|
||||
const browser = await puppeteer.launch({
|
||||
headless: !args.includes('--headful'),
|
||||
protocolTimeout: 300_000,
|
||||
args: [
|
||||
'--no-sandbox',
|
||||
'--use-gl=angle',
|
||||
'--disable-dev-shm-usage',
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
],
|
||||
});
|
||||
|
||||
let page;
|
||||
const frames = [];
|
||||
let lastKept = -Infinity;
|
||||
let recording = false;
|
||||
let marker = 'startup';
|
||||
|
||||
try {
|
||||
page = await browser.newPage();
|
||||
await page.evaluateOnNewDocument(() => {
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed');
|
||||
});
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
const client = await page.createCDPSession();
|
||||
await client.send('Network.enable');
|
||||
client.on('Network.requestWillBeSent', ({ request }) => {
|
||||
const target = new URL(request.url);
|
||||
const where = `${request.method} ${target.origin}${target.pathname}`;
|
||||
if (
|
||||
target.hostname.includes('overpass') ||
|
||||
target.hostname === 'nominatim.openstreetmap.org'
|
||||
)
|
||||
result.forbiddenRequests.push({ step: marker, request: where });
|
||||
// Lookups an outline could make: a forward geocode, a place search, an
|
||||
// Overpass boundary query. The HUD's reverse geocode of the camera centre
|
||||
// (latlng=) is not one of them.
|
||||
const local = target.origin === new URL(url).origin;
|
||||
const reverse = target.searchParams.has('latlng');
|
||||
const lookup =
|
||||
!reverse &&
|
||||
((local &&
|
||||
/^\/api\/(overpass|geocode|google\/text-search|nominatim|photon)/.test(
|
||||
target.pathname,
|
||||
)) ||
|
||||
(target.hostname === 'maps.googleapis.com' &&
|
||||
target.pathname.includes('/geocode/')) ||
|
||||
target.hostname === 'photon.komoot.io');
|
||||
if (lookup) result.lookups.push({ step: marker, request: where });
|
||||
if (/\/(states_provinces|countries|counties)\.json$/.test(target.pathname))
|
||||
result.packRequests.push({ step: marker, pack: target.pathname });
|
||||
});
|
||||
page.on('pageerror', (error) =>
|
||||
result.pageErrors.push({ step: marker, message: error.message }),
|
||||
);
|
||||
page.on('console', (message) => {
|
||||
if (message.type() === 'error')
|
||||
result.consoleErrors.push({ step: marker, message: message.text() });
|
||||
});
|
||||
|
||||
client.on('Page.screencastFrame', async ({ data, metadata, sessionId }) => {
|
||||
client.send('Page.screencastFrameAck', { sessionId }).catch(() => {});
|
||||
if (!recording) return;
|
||||
const t = metadata.timestamp;
|
||||
if (t - lastKept < FRAME_INTERVAL_S * 0.9) return;
|
||||
lastKept = t;
|
||||
const file = path.join(
|
||||
framesDir,
|
||||
`${String(frames.length).padStart(6, '0')}.jpg`,
|
||||
);
|
||||
frames.push({ file, t, step: marker });
|
||||
await fs.writeFile(file, Buffer.from(data, 'base64'));
|
||||
});
|
||||
|
||||
console.log('Loading viewer...');
|
||||
const navigationUrl = new URL(url);
|
||||
navigationUrl.searchParams.set('welcome', '0');
|
||||
await page.goto(navigationUrl.href, {
|
||||
waitUntil: 'domcontentloaded',
|
||||
timeout: 60_000,
|
||||
});
|
||||
await page.waitForFunction(
|
||||
() => window.__godsEyeView?.viewer && window.__godsEyeView?.annotations,
|
||||
{ timeout: 90_000, polling: 500 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 90_000, polling: 250 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await page.waitForFunction(
|
||||
() => !document.querySelector('#first-run-launcher:not([hidden])'),
|
||||
{ timeout: 10_000 },
|
||||
);
|
||||
result.renderer = await page.evaluate(() => {
|
||||
const gl = window.__godsEyeView.viewer.scene.context._gl;
|
||||
const debug = gl.getExtension('WEBGL_debug_renderer_info');
|
||||
return debug
|
||||
? gl.getParameter(debug.UNMASKED_RENDERER_WEBGL)
|
||||
: gl.getParameter(gl.RENDERER);
|
||||
});
|
||||
console.log('Renderer:', result.renderer);
|
||||
|
||||
// In-page helpers: camera moves, frame timing and annotation state.
|
||||
await page.evaluate(() => {
|
||||
const { viewer } = window.__godsEyeView;
|
||||
const Cesium = window.__CESIUM__;
|
||||
window.__qaOutlines = {
|
||||
fly(view, duration) {
|
||||
return new Promise((resolve) => {
|
||||
viewer.camera.cancelFlight();
|
||||
viewer.camera.flyTo({
|
||||
destination: Cesium.Cartesian3.fromDegrees(
|
||||
view.lon,
|
||||
view.lat,
|
||||
view.height,
|
||||
),
|
||||
orientation: {
|
||||
heading: Cesium.Math.toRadians(view.heading ?? 0),
|
||||
pitch: Cesium.Math.toRadians(view.pitch ?? -70),
|
||||
roll: 0,
|
||||
},
|
||||
duration,
|
||||
easingFunction: Cesium.EasingFunction.QUADRATIC_IN_OUT,
|
||||
complete: resolve,
|
||||
cancel: resolve,
|
||||
});
|
||||
});
|
||||
},
|
||||
frameTimes(ms) {
|
||||
return new Promise((resolve) => {
|
||||
const deltas = [];
|
||||
let last = performance.now();
|
||||
const end = last + ms;
|
||||
const step = (now) => {
|
||||
deltas.push(now - last);
|
||||
last = now;
|
||||
if (now < end) requestAnimationFrame(step);
|
||||
else resolve(deltas.slice(1));
|
||||
};
|
||||
requestAnimationFrame(step);
|
||||
});
|
||||
},
|
||||
annotationSource() {
|
||||
for (let i = 0; i < viewer.dataSources.length; i++) {
|
||||
const source = viewer.dataSources.get(i);
|
||||
if (source.name === 'gev-annotations') return source;
|
||||
}
|
||||
return null;
|
||||
},
|
||||
groundPrimitives() {
|
||||
const list = [];
|
||||
const walk = (collection) => {
|
||||
for (let i = 0; i < collection.length; i++) {
|
||||
const item = collection.get(i);
|
||||
if (item?.length !== undefined && typeof item.get === 'function')
|
||||
walk(item);
|
||||
else list.push(item);
|
||||
}
|
||||
};
|
||||
walk(viewer.scene.groundPrimitives);
|
||||
return list;
|
||||
},
|
||||
snapshot() {
|
||||
const source = this.annotationSource();
|
||||
const entities = source ? source.entities.values : [];
|
||||
const primitives = this.groundPrimitives();
|
||||
window.__qaPrimitiveIds ??= new WeakMap();
|
||||
let next = window.__qaPrimitiveNext ?? 1;
|
||||
const ids = primitives.map((primitive) => {
|
||||
if (!window.__qaPrimitiveIds.has(primitive))
|
||||
window.__qaPrimitiveIds.set(primitive, next++);
|
||||
return window.__qaPrimitiveIds.get(primitive);
|
||||
});
|
||||
window.__qaPrimitiveNext = next;
|
||||
return {
|
||||
entities: entities.length,
|
||||
polygons: entities.filter((e) => e.polygon).length,
|
||||
polylines: entities.filter((e) => e.polyline).length,
|
||||
draped:
|
||||
entities.every(
|
||||
(e) =>
|
||||
!e.polygon ||
|
||||
e.polygon.classificationType?.getValue() ===
|
||||
Cesium.ClassificationType.BOTH,
|
||||
) &&
|
||||
entities.every(
|
||||
(e) => !e.polyline || e.polyline.clampToGround?.getValue(),
|
||||
),
|
||||
primitiveIds: ids,
|
||||
ready: viewer.dataSourceDisplay.ready,
|
||||
};
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const settle = () =>
|
||||
page
|
||||
.waitForFunction(
|
||||
() => {
|
||||
const { scene } = window.__godsEyeView.viewer;
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const p = scene.primitives.get(i);
|
||||
if (p?.show && typeof p.tilesLoaded === 'boolean' && !p.tilesLoaded)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
{ timeout: 60_000, polling: 500 },
|
||||
)
|
||||
.catch(() => {});
|
||||
|
||||
async function shot(name) {
|
||||
await page.evaluate(
|
||||
() =>
|
||||
new Promise((resolve) =>
|
||||
requestAnimationFrame(() => requestAnimationFrame(resolve)),
|
||||
),
|
||||
);
|
||||
const filename = `admin-outlines-${name}.png`;
|
||||
await page.screenshot({ path: path.join(shots, filename) });
|
||||
result.screenshots.push(filename);
|
||||
}
|
||||
|
||||
async function move(name, view, duration = 2.5) {
|
||||
marker = `move:${name}`;
|
||||
const [, times] = await Promise.all([
|
||||
page.evaluate((v, d) => window.__qaOutlines.fly(v, d), view, duration),
|
||||
page.evaluate((ms) => window.__qaOutlines.frameTimes(ms), duration * 900),
|
||||
]);
|
||||
result.steps.push({ step: `move:${name}`, frameTimes: stats(times) });
|
||||
}
|
||||
|
||||
/** Annotate like the voice tool does, then watch the mark while still. */
|
||||
async function outline(name, target, { flyTo = false } = {}) {
|
||||
marker = `outline:${name}`;
|
||||
const lookupsBefore = result.lookups.length;
|
||||
const errorsBefore = result.consoleErrors.length + result.pageErrors.length;
|
||||
const timing = await page.evaluate(
|
||||
async (target, flyTo) => {
|
||||
const started = performance.now();
|
||||
const response = await window.__godsEyeView.annotations.annotate(
|
||||
[{ type: 'area', target, label: target, footprint: true }],
|
||||
{ flyTo },
|
||||
);
|
||||
const resolvedMs = performance.now() - started;
|
||||
// "Drawn" = the first rendered frame after the entity visualizers have
|
||||
// built the mark's primitives (each tick updates them before render).
|
||||
const { viewer } = window.__godsEyeView;
|
||||
await new Promise((resolve) => {
|
||||
const off = viewer.scene.postRender.addEventListener(() => {
|
||||
if (!viewer.dataSourceDisplay.ready) return;
|
||||
off();
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
const drawnMs = performance.now() - started;
|
||||
const mark = window.__godsEyeView.annotations
|
||||
.list()
|
||||
.find((m) => m.id === response.ids?.[0]);
|
||||
return {
|
||||
response: response.results?.[0] ?? null,
|
||||
resolvedMs,
|
||||
drawnMs,
|
||||
parts: mark?.polygons?.length ?? (mark?.ring ? 1 : 0),
|
||||
holes: (mark?.polygons ?? []).reduce(
|
||||
(n, part) => n + part.length - 1,
|
||||
0,
|
||||
),
|
||||
ringVertices: mark?.ring?.length ?? 0,
|
||||
pending: Boolean(mark?.pendingOutline),
|
||||
};
|
||||
},
|
||||
target,
|
||||
flyTo,
|
||||
);
|
||||
if (flyTo) await new Promise((r) => setTimeout(r, 2200));
|
||||
await settle();
|
||||
// Hold still: the drawn mark must not rebuild or grow.
|
||||
marker = `still:${name}`;
|
||||
const before = await page.evaluate(() => window.__qaOutlines.snapshot());
|
||||
const stillStart = frames.length;
|
||||
const times = await page.evaluate(
|
||||
(ms) => window.__qaOutlines.frameTimes(ms),
|
||||
STILL_MS,
|
||||
);
|
||||
const after = await page.evaluate(() => window.__qaOutlines.snapshot());
|
||||
const step = {
|
||||
step: `outline:${name}`,
|
||||
target,
|
||||
...timing,
|
||||
entities: after.entities,
|
||||
polygons: after.polygons,
|
||||
polylines: after.polylines,
|
||||
draped: after.draped,
|
||||
stableWhileStill:
|
||||
before.entities === after.entities &&
|
||||
JSON.stringify(before.primitiveIds) ===
|
||||
JSON.stringify(after.primitiveIds),
|
||||
stillFrameTimes: stats(times),
|
||||
stillFrames: [stillStart, frames.length],
|
||||
lookups: result.lookups.slice(lookupsBefore),
|
||||
errors:
|
||||
result.consoleErrors.length + result.pageErrors.length - errorsBefore,
|
||||
};
|
||||
result.steps.push(step);
|
||||
console.log(
|
||||
`${name}: resolved ${timing.resolvedMs.toFixed(0)} ms, drawn ${timing.drawnMs.toFixed(0)} ms, ` +
|
||||
`${timing.parts} part(s), ${timing.holes} hole(s), via ${timing.response?.resolvedVia}; ` +
|
||||
`still p50/p95 ${step.stillFrameTimes.p50}/${step.stillFrameTimes.p95} ms; ` +
|
||||
`stable=${step.stableWhileStill}`,
|
||||
);
|
||||
assert.equal(timing.response?.ok, true, `${name}: annotation drawn`);
|
||||
assert.equal(timing.response.outline, true, `${name}: outline, not a pin`);
|
||||
assert.equal(timing.response.resolvedVia, 'bundled', `${name}: bundled`);
|
||||
assert.equal(timing.pending, false, `${name}: nothing pending`);
|
||||
assert.ok(
|
||||
timing.drawnMs < OUTLINE_BUDGET_MS,
|
||||
`${name}: drawn in ${timing.drawnMs} ms`,
|
||||
);
|
||||
assert.equal(step.draped, true, `${name}: draped on terrain/tiles`);
|
||||
assert.equal(step.stableWhileStill, true, `${name}: no redraw when still`);
|
||||
assert.deepEqual(step.lookups, [], `${name}: no network lookups`);
|
||||
assert.equal(step.errors, 0, `${name}: no console errors`);
|
||||
return step;
|
||||
}
|
||||
|
||||
// Start from a clean board and the default layers, as a user would.
|
||||
await page.evaluate(() => window.__godsEyeView.annotations.clear?.());
|
||||
await page.evaluate(() =>
|
||||
window.__qaOutlines.fly(
|
||||
{ lat: 25.5, lon: -99.6, height: 2_600_000, pitch: -80 },
|
||||
0,
|
||||
),
|
||||
);
|
||||
await settle();
|
||||
if (recordVideo) {
|
||||
await client.send('Page.startScreencast', {
|
||||
format: 'jpeg',
|
||||
quality: 72,
|
||||
maxWidth: 1280,
|
||||
maxHeight: 800,
|
||||
everyNthFrame: 1,
|
||||
});
|
||||
recording = true;
|
||||
}
|
||||
|
||||
await outline('texas', 'Texas');
|
||||
await shot('texas');
|
||||
await move('pan-west', {
|
||||
lat: 25.2,
|
||||
lon: -101.5,
|
||||
height: 2_300_000,
|
||||
pitch: -75,
|
||||
});
|
||||
await move('zoom-central-texas', {
|
||||
lat: 28.8,
|
||||
lon: -98.2,
|
||||
height: 700_000,
|
||||
pitch: -65,
|
||||
});
|
||||
await move('zoom-austin', {
|
||||
lat: 29.75,
|
||||
lon: -97.8,
|
||||
height: 120_000,
|
||||
pitch: -55,
|
||||
});
|
||||
await settle();
|
||||
await outline('travis', 'Travis County, Texas');
|
||||
await shot('travis');
|
||||
await move('pan-williamson', {
|
||||
lat: 30.05,
|
||||
lon: -97.65,
|
||||
height: 110_000,
|
||||
pitch: -55,
|
||||
});
|
||||
await settle();
|
||||
await outline('williamson', 'Williamson County, Texas');
|
||||
// Close over the shared Travis/Williamson line near Pflugerville: the
|
||||
// outline must lie on the photoreal mesh, not float above or sink into it.
|
||||
const border = await page.evaluate(() => {
|
||||
const travis = window.__godsEyeView.annotations
|
||||
.list()
|
||||
.find((m) => m.label === 'Travis County, Texas');
|
||||
let best = null;
|
||||
for (const [lon, lat] of travis.ring) {
|
||||
const d = (lat - 30.46) ** 2 + (lon + 97.62) ** 2;
|
||||
if (!best || d < best.d) best = { lon, lat, d };
|
||||
}
|
||||
return best;
|
||||
});
|
||||
await move(
|
||||
'drape-close',
|
||||
{ lat: border.lat - 0.035, lon: border.lon, height: 2500, pitch: -40 },
|
||||
3,
|
||||
);
|
||||
await settle();
|
||||
await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 2500);
|
||||
await shot('drape-close');
|
||||
await move('zoom-out-both', {
|
||||
lat: 29.55,
|
||||
lon: -97.7,
|
||||
height: 260_000,
|
||||
pitch: -60,
|
||||
});
|
||||
await settle();
|
||||
await page.evaluate((ms) => new Promise((r) => setTimeout(r, ms)), 1500);
|
||||
await shot('both-counties');
|
||||
await outline('bavaria', 'Bavaria', { flyTo: true });
|
||||
await shot('bavaria');
|
||||
await move(
|
||||
'orbit-bavaria',
|
||||
{ lat: 46.6, lon: 11.9, height: 650_000, heading: 20, pitch: -55 },
|
||||
3,
|
||||
);
|
||||
await settle();
|
||||
await shot('bavaria-orbit');
|
||||
// A hole (Berlin inside Brandenburg) and islands (Hawaii) draw as such.
|
||||
const brandenburg = await outline('brandenburg', 'Brandenburg', {
|
||||
flyTo: true,
|
||||
});
|
||||
assert.ok(brandenburg.holes >= 1, 'Brandenburg keeps the Berlin hole');
|
||||
await shot('brandenburg');
|
||||
const hawaii = await outline('hawaii', 'Hawaii', { flyTo: true });
|
||||
assert.ok(hawaii.parts >= 7, 'Hawaii keeps its islands');
|
||||
await shot('hawaii');
|
||||
marker = 'end';
|
||||
|
||||
for (const [name, target, lat, lon, height] of [
|
||||
['scotland', 'Scotland', 57, -4, 800000],
|
||||
['england', 'England', 52.5, -1.5, 800000],
|
||||
['wales', 'Wales', 52.3, -3.7, 420000],
|
||||
['northern-ireland', 'Northern Ireland', 54.7, -6.7, 300000],
|
||||
['switzerland', 'Switzerland', 46.8, 8.2, 500000],
|
||||
['iran', 'Iran', 32, 54, 2200000],
|
||||
['france', 'France', 46.6, 2.2, 1600000],
|
||||
['japan', 'Japan', 37, 138, 2200000],
|
||||
['georgia-state', 'Georgia', 32.6, -83.4, 650000],
|
||||
['georgia-country', 'Georgia', 42, 43.6, 700000],
|
||||
['georgia-qualified', 'the country of Georgia', 42, 43.6, 700000],
|
||||
]) {
|
||||
await page.evaluate(() => window.__godsEyeView.annotations.clear());
|
||||
await move(name, { lat, lon, height, pitch: -90 }, 1);
|
||||
await outline(name, target);
|
||||
await shot(name);
|
||||
const rendered = await page.evaluate(() => window.__qaOutlines.snapshot());
|
||||
assert.ok(rendered.polygons > 0, `${target} polygon renders`);
|
||||
}
|
||||
|
||||
if (recordVideo) {
|
||||
recording = false;
|
||||
await client.send('Page.stopScreencast');
|
||||
}
|
||||
result.totals = {
|
||||
forbiddenRequests: result.forbiddenRequests.length,
|
||||
consoleErrors: result.consoleErrors.length,
|
||||
pageErrors: result.pageErrors.length,
|
||||
};
|
||||
assert.deepEqual(
|
||||
result.forbiddenRequests,
|
||||
[],
|
||||
'no Overpass or nominatim.openstreetmap.org requests',
|
||||
);
|
||||
// The packs load on the first outline that needs them, never at start-up.
|
||||
assert.deepEqual(
|
||||
result.packRequests.map((r) => [r.step, path.basename(r.pack)]),
|
||||
[
|
||||
['outline:texas', 'states_provinces.json'],
|
||||
['outline:travis', 'counties.json'],
|
||||
['outline:scotland', 'countries.json'],
|
||||
],
|
||||
'packs load lazily, once each',
|
||||
);
|
||||
assert.deepEqual(result.pageErrors, [], 'no page errors');
|
||||
assert.deepEqual(result.consoleErrors, [], 'no console errors');
|
||||
} catch (error) {
|
||||
result.failure = error.message;
|
||||
console.error(error);
|
||||
process.exitCode = 1;
|
||||
if (page)
|
||||
await page
|
||||
.screenshot({ path: path.join(shots, 'admin-outlines-failure.png') })
|
||||
.catch(() => {});
|
||||
} finally {
|
||||
await browser.close();
|
||||
}
|
||||
|
||||
if (recordVideo && frames.length > 1) {
|
||||
// Frame-to-frame change while the camera is still: steady pulses read as
|
||||
// small, even values; a flicker (a part vanishing and returning) as a spike.
|
||||
for (const step of result.steps.filter((s) => s.stillFrames)) {
|
||||
const [start, end] = step.stillFrames;
|
||||
const diffs = [];
|
||||
let previous = null;
|
||||
for (const frame of frames.slice(start, end)) {
|
||||
const pixels = await sharp(frame.file)
|
||||
.resize(160, 100, { fit: 'fill' })
|
||||
.greyscale()
|
||||
.raw()
|
||||
.toBuffer();
|
||||
if (previous) {
|
||||
let sum = 0;
|
||||
let max = 0;
|
||||
for (let i = 0; i < pixels.length; i++) {
|
||||
const d = Math.abs(pixels[i] - previous[i]);
|
||||
sum += d;
|
||||
if (d > max) max = d;
|
||||
}
|
||||
diffs.push(sum / pixels.length);
|
||||
}
|
||||
previous = pixels;
|
||||
}
|
||||
step.stillFrameDiff = {
|
||||
frames: end - start,
|
||||
meanAbsDiff: stats(diffs, 3),
|
||||
};
|
||||
}
|
||||
const list = [];
|
||||
for (let i = 0; i < frames.length; i++) {
|
||||
const duration =
|
||||
i + 1 < frames.length ? frames[i + 1].t - frames[i].t : FRAME_INTERVAL_S;
|
||||
list.push(`file '${frames[i].file}'`, `duration ${duration.toFixed(4)}`);
|
||||
}
|
||||
list.push(`file '${frames.at(-1).file}'`);
|
||||
const listFile = path.join(framesDir, 'frames.txt');
|
||||
await fs.writeFile(listFile, list.join('\n') + '\n');
|
||||
const video = path.join(shots, 'admin-outlines-journey.mp4');
|
||||
execFileSync('ffmpeg', [
|
||||
'-y',
|
||||
'-loglevel',
|
||||
'error',
|
||||
'-f',
|
||||
'concat',
|
||||
'-safe',
|
||||
'0',
|
||||
'-i',
|
||||
listFile,
|
||||
'-vf',
|
||||
'fps=24,format=yuv420p',
|
||||
'-c:v',
|
||||
'libx264',
|
||||
'-crf',
|
||||
'23',
|
||||
video,
|
||||
]);
|
||||
const span = frames.at(-1).t - frames[0].t;
|
||||
result.video = {
|
||||
file: path.relative(process.cwd(), video),
|
||||
frames: frames.length,
|
||||
seconds: Number(span.toFixed(1)),
|
||||
capturedFps: Number(((frames.length - 1) / span).toFixed(1)),
|
||||
};
|
||||
console.log('Video:', result.video);
|
||||
await fs.rm(framesDir, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
await fs.writeFile(
|
||||
path.join(shots, 'admin-outlines-result.json'),
|
||||
JSON.stringify(result, null, 2),
|
||||
);
|
||||
console.table(
|
||||
result.steps.map((s) => ({
|
||||
step: s.step,
|
||||
resolvedMs: s.resolvedMs?.toFixed(0),
|
||||
drawnMs: s.drawnMs?.toFixed(0),
|
||||
parts: s.parts,
|
||||
stable: s.stableWhileStill,
|
||||
p50: (s.stillFrameTimes || s.frameTimes)?.p50,
|
||||
p95: (s.stillFrameTimes || s.frameTimes)?.p95,
|
||||
stillDiffP95: s.stillFrameDiff?.meanAbsDiff.p95,
|
||||
stillDiffMax: s.stillFrameDiff?.meanAbsDiff.max,
|
||||
})),
|
||||
);
|
||||
console.log(process.exitCode ? 'FAILED' : 'PASSED');
|
||||
|
||||
function stats(values, digits = 1) {
|
||||
if (!values.length) return { n: 0 };
|
||||
const sorted = [...values].sort((a, b) => a - b);
|
||||
const at = (q) =>
|
||||
Number(
|
||||
sorted[
|
||||
Math.min(sorted.length - 1, Math.floor(q * sorted.length))
|
||||
].toFixed(digits),
|
||||
);
|
||||
return { n: values.length, p50: at(0.5), p95: at(0.95), max: at(1) };
|
||||
}
|
||||
@@ -0,0 +1,588 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* qa-alpr-journey.mjs — ALPR cameras on a realistic Austin camera journey.
|
||||
*
|
||||
* Run: node scripts/qa-alpr-journey.mjs http://localhost:4173 [--headful]
|
||||
* [--passes off,on,on] [--out qa-shots/alpr-journey] [--no-assert]
|
||||
*
|
||||
* Drives the same eased camera path several times: a neighbourhood by Camp
|
||||
* Mabry (~2 km across), two 600 m pans, a small zoom out and back, downtown
|
||||
* (~6 km), the whole city (~30 km) and back to the neighbourhood. The first
|
||||
* pass runs with Mapped ALPR Cameras off (it also warms the photoreal tiles),
|
||||
* then ALPR is switched on mid-journey from its layer row and the path repeats
|
||||
* cold and warm.
|
||||
*
|
||||
* Per stop it records: time from the camera stopping to cameras shown (or an
|
||||
* explicit "zoom in" state), the camera count and row status, rAF interval and
|
||||
* Cesium render CPU time (mean / p50 / p95) while moving and while holding, and
|
||||
* marker stability while the camera is still (camera-set changes after the stop
|
||||
* has settled). Asserts, unless --no-assert: neighbourhood and downtown show
|
||||
* cameras within 2 s on the warm pass; the whole-city stop shows cameras or a
|
||||
* zoom-in prompt and never ends a hold still loading; at most one visible
|
||||
* marker update per stop and none after 3 s while still; warm-pass frame p50/p95 within 10% of the ALPR-off pass (plus a
|
||||
* 2 ms floor for timer noise); zero console errors.
|
||||
*
|
||||
* Rendered-state checks read the recorded frames, not entity state: ALPR-cyan
|
||||
* pixels per frame during each hold, minus the ALPR-off pass at the same stop,
|
||||
* give when markers actually reached the screen. Cameras projected on screen
|
||||
* must be painted, no later than 700 ms after the layer state settled (a
|
||||
* missing render request fails here), within 2 s of the stop on the warm pass;
|
||||
* a view whose loaded cameras are all off screen must say "None on screen".
|
||||
* At the end of each hold the screen is compared with the same scene after
|
||||
* forcing four frames; any marker difference is a missing render request.
|
||||
* --self-test-drop-renders disables explicit render requests during the ALPR
|
||||
* passes to prove those checks fail.
|
||||
*
|
||||
* Writes <out>/result.json, <out>/clip.mp4 (CDP screencast with real frame
|
||||
* timing) and per-stop screenshots. Needs ffmpeg on PATH.
|
||||
*/
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import puppeteer from 'puppeteer';
|
||||
import sharp from 'sharp';
|
||||
import {
|
||||
createScreencast,
|
||||
frameStats,
|
||||
installFrameProbe,
|
||||
moveCamera,
|
||||
pageNow,
|
||||
readFrames,
|
||||
} from './qa-journey-recorder.mjs';
|
||||
|
||||
const argv = process.argv.slice(2);
|
||||
if (argv.includes('--help') || argv.includes('-h')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-alpr-journey.mjs <dev-server-url> [--headful] [--passes off,on,on] [--out dir] [--no-assert] [--self-test-drop-renders]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const option = (name, fallback) => {
|
||||
const i = argv.indexOf(name);
|
||||
return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
|
||||
};
|
||||
const appUrl =
|
||||
argv.find((arg) => /^https?:/.test(arg)) || 'http://localhost:4173';
|
||||
const outDir = path.resolve(option('--out', 'qa-shots/alpr-journey'));
|
||||
const passes = option('--passes', 'off,on,on').split(',');
|
||||
const assertOn = !argv.includes('--no-assert');
|
||||
const dropRenders = argv.includes('--self-test-drop-renders');
|
||||
fs.mkdirSync(outDir, { recursive: true });
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
const cyanCount = async (file) => {
|
||||
const { data, info } = await sharp(file)
|
||||
.resize({ width: 640 })
|
||||
.raw()
|
||||
.toBuffer({ resolveWithObject: true });
|
||||
let n = 0;
|
||||
for (let i = 0; i < data.length; i += info.channels) {
|
||||
const r = data[i];
|
||||
const g = data[i + 1];
|
||||
const b = data[i + 2];
|
||||
if (r < 140 && g > 160 && b > 205 && b - r > 80) n += 1;
|
||||
}
|
||||
return n;
|
||||
};
|
||||
|
||||
/** Cyan pixels (at 640 px width) that mean at least one badge is painted. */
|
||||
const MIN_MARKER_PIXELS = 12;
|
||||
|
||||
// Camp Mabry neighbourhood (Tarrytown / Bryker Woods), downtown, whole city.
|
||||
const N = {
|
||||
lat: 30.2985,
|
||||
lon: -97.7655,
|
||||
height: 1500,
|
||||
heading: 20,
|
||||
pitch: -55,
|
||||
};
|
||||
const east = (view, m) => ({
|
||||
...view,
|
||||
lon: view.lon + m / (111_320 * Math.cos((view.lat * Math.PI) / 180)),
|
||||
});
|
||||
const north = (view, m) => ({ ...view, lat: view.lat + m / 111_320 });
|
||||
const STOPS = [
|
||||
{ name: 'neighbourhood', view: N, move: 0, hold: 6, scale: 'neighbourhood' },
|
||||
{
|
||||
name: 'pan-east-600m',
|
||||
view: east(N, 600),
|
||||
move: 2.5,
|
||||
hold: 5,
|
||||
scale: 'neighbourhood',
|
||||
},
|
||||
{
|
||||
name: 'pan-north-600m',
|
||||
view: north(east(N, 600), 600),
|
||||
move: 2.5,
|
||||
hold: 5,
|
||||
scale: 'neighbourhood',
|
||||
},
|
||||
{
|
||||
name: 'zoom-out-3km',
|
||||
view: { ...north(east(N, 600), 600), height: 3000 },
|
||||
move: 2.5,
|
||||
hold: 5,
|
||||
scale: 'neighbourhood',
|
||||
},
|
||||
{
|
||||
name: 'zoom-back-in',
|
||||
view: north(east(N, 600), 600),
|
||||
move: 2.5,
|
||||
hold: 5,
|
||||
scale: 'neighbourhood',
|
||||
},
|
||||
{
|
||||
name: 'downtown-6km',
|
||||
view: { lat: 30.262, lon: -97.7431, height: 4500, heading: 0, pitch: -60 },
|
||||
move: 3,
|
||||
hold: 7,
|
||||
scale: 'downtown',
|
||||
},
|
||||
{
|
||||
name: 'city-30km',
|
||||
view: { lat: 30.2, lon: -97.75, height: 24000, heading: 0, pitch: -65 },
|
||||
move: 3,
|
||||
hold: 8,
|
||||
scale: 'city',
|
||||
},
|
||||
{
|
||||
name: 'back-to-neighbourhood',
|
||||
view: N,
|
||||
move: 3,
|
||||
hold: 6,
|
||||
scale: 'neighbourhood',
|
||||
},
|
||||
];
|
||||
|
||||
const browser = await puppeteer.launch({
|
||||
headless: !argv.includes('--headful'),
|
||||
protocolTimeout: 300_000,
|
||||
args: [
|
||||
'--no-sandbox',
|
||||
...(process.platform === 'darwin'
|
||||
? ['--use-angle=metal', '--enable-gpu']
|
||||
: ['--use-gl=angle', '--use-angle=swiftshader']),
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
'--disable-backgrounding-occluded-windows',
|
||||
],
|
||||
});
|
||||
const result = {
|
||||
url: appUrl,
|
||||
startedAt: new Date().toISOString(),
|
||||
passes: [],
|
||||
consoleErrors: [],
|
||||
failures: [],
|
||||
};
|
||||
const fail = (message) => {
|
||||
result.failures.push(message);
|
||||
console.log(`[FAIL] ${message}`);
|
||||
};
|
||||
let page;
|
||||
try {
|
||||
page = await browser.newPage();
|
||||
await page.setViewport({ width: 1440, height: 900 });
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
page.on('console', (message) => {
|
||||
if (message.type() === 'error') result.consoleErrors.push(message.text());
|
||||
});
|
||||
page.on('pageerror', (error) => result.consoleErrors.push(error.message));
|
||||
const url = new URL(appUrl);
|
||||
url.searchParams.set('welcome', '0');
|
||||
await page.goto(url.href, { waitUntil: 'domcontentloaded', timeout: 90_000 });
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120_000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await installFrameProbe(page);
|
||||
// ALPR watcher: row state every 100 ms and the rendered camera set (ids and
|
||||
// visibility) as a cheap hash, so structural churn while still is visible.
|
||||
await page.evaluate(() => {
|
||||
const samples = [];
|
||||
window.__gevAlprSamples = samples;
|
||||
setInterval(() => {
|
||||
const entry = window.__godsEyeView.dataManager.layers.get('alpr-cameras');
|
||||
const stats = entry?.module?.getStats?.() || {};
|
||||
// Layers that publish a render revision are measured by it; otherwise
|
||||
// hash the rendered entity ids and their visibility.
|
||||
let hash = 0;
|
||||
let shown = 0;
|
||||
if (Number.isFinite(stats.renderRevision)) {
|
||||
hash = stats.renderRevision;
|
||||
shown = stats.shown ?? stats.count ?? 0;
|
||||
} else {
|
||||
const entities =
|
||||
entry?.module && entry.enabled
|
||||
? window.__godsEyeView.viewer.dataSources.getByName(
|
||||
'alpr-cameras',
|
||||
)[0]?.entities.values || []
|
||||
: [];
|
||||
for (const entity of entities) {
|
||||
if (entity.show === false) continue;
|
||||
shown += 1;
|
||||
const id = String(entity.id);
|
||||
for (let i = 0; i < id.length; i++)
|
||||
hash = (hash * 31 + id.charCodeAt(i)) | 0;
|
||||
}
|
||||
}
|
||||
samples.push({
|
||||
t: performance.now(),
|
||||
enabled: Boolean(entry?.enabled),
|
||||
count: stats.count ?? 0,
|
||||
shown,
|
||||
hash,
|
||||
loading: Boolean(stats.loading),
|
||||
status: stats.status || null,
|
||||
label: stats.loadingLabel || '',
|
||||
onScreen: stats.onScreen ?? null,
|
||||
});
|
||||
if (samples.length > 20_000) samples.splice(0, 5_000);
|
||||
}, 100);
|
||||
});
|
||||
const recorder = await createScreencast(page, outDir);
|
||||
await recorder.start();
|
||||
|
||||
async function waitTiles(maxMs = 20_000) {
|
||||
await page
|
||||
.waitForFunction(
|
||||
() => {
|
||||
const { scene } = window.__godsEyeView.viewer;
|
||||
if (scene.globe.show) return scene.globe.tilesLoaded;
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const p = scene.primitives.get(i);
|
||||
if (p.show && p.tilesLoaded === false) return false;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
{ timeout: maxMs, polling: 250 },
|
||||
)
|
||||
.catch(() => {});
|
||||
}
|
||||
|
||||
for (const [passIndex, mode] of passes.entries()) {
|
||||
const alpr = mode === 'on';
|
||||
const passName = `${passIndex + 1}-${mode}${alpr && passes.slice(0, passIndex).includes('on') ? '-warm' : alpr ? '-cold' : ''}`;
|
||||
console.log(`Pass ${passName}`);
|
||||
await moveCamera(page, STOPS[0].view, 0);
|
||||
await waitTiles();
|
||||
if (
|
||||
alpr !==
|
||||
(await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.isEnabled('alpr-cameras'),
|
||||
))
|
||||
) {
|
||||
// The user's switch: the layer row, not a private API.
|
||||
await page.evaluate(
|
||||
(enabled) =>
|
||||
window.__godsEyeView.dataManager.setEnabled('alpr-cameras', enabled, {
|
||||
origin: 'user',
|
||||
}),
|
||||
alpr,
|
||||
);
|
||||
}
|
||||
if (alpr && dropRenders)
|
||||
// Self-test: drop explicit render requests so markers reach the screen
|
||||
// only with the next camera move. The rendered-pixel checks must fail.
|
||||
await page.evaluate(() => {
|
||||
window.__godsEyeView.viewer.scene.requestRender = () => {};
|
||||
});
|
||||
const pass = { name: passName, alpr, stops: [] };
|
||||
for (const stop of STOPS) {
|
||||
const moveStart = await pageNow(page);
|
||||
if (stop.move) await moveCamera(page, stop.view, stop.move);
|
||||
else await moveCamera(page, stop.view, 0);
|
||||
const holdStart = await pageNow(page);
|
||||
const holdStartEpoch = await page.evaluate(
|
||||
() => performance.timeOrigin + performance.now(),
|
||||
);
|
||||
await sleep(stop.hold * 1000);
|
||||
const holdEnd = await pageNow(page);
|
||||
// Render truth: what the screen shows at the end of the hold versus the
|
||||
// same scene after forcing a few frames. A difference means the layer
|
||||
// changed state without asking for a render.
|
||||
let staleFrame = null;
|
||||
if (alpr) {
|
||||
const shown = await cyanCount(await page.screenshot({ type: 'png' }));
|
||||
await page.evaluate(async () => {
|
||||
const { scene } = window.__godsEyeView.viewer;
|
||||
const mode = scene.requestRenderMode;
|
||||
scene.requestRenderMode = false;
|
||||
for (let i = 0; i < 4; i++)
|
||||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||||
scene.requestRenderMode = mode;
|
||||
});
|
||||
const forced = await cyanCount(await page.screenshot({ type: 'png' }));
|
||||
staleFrame = {
|
||||
shown,
|
||||
forced,
|
||||
stale: Math.abs(forced - shown) > Math.max(8, forced * 0.15),
|
||||
};
|
||||
}
|
||||
const moving = frameStats(await readFrames(page, moveStart, holdStart));
|
||||
const holding = frameStats(await readFrames(page, holdStart, holdEnd));
|
||||
const samples = await page.evaluate(
|
||||
(a, b) => window.__gevAlprSamples.filter((s) => s.t >= a && s.t < b),
|
||||
holdStart,
|
||||
holdEnd,
|
||||
);
|
||||
// Time to cameras: the last visible change (or the end of loading) after
|
||||
// the camera stopped. More than one visible change, or any change after
|
||||
// 3 s, is flicker: a still camera must see one clean update at most.
|
||||
let visualChanges = 0;
|
||||
const changeLog = [];
|
||||
let lastChangeAt = null;
|
||||
let loadingEndAt = null;
|
||||
let wasLoading = false;
|
||||
let previous = null;
|
||||
for (const s of samples) {
|
||||
if (
|
||||
previous &&
|
||||
(s.hash !== previous.hash || s.shown !== previous.shown)
|
||||
) {
|
||||
visualChanges += 1;
|
||||
lastChangeAt = s.t;
|
||||
changeLog.push({
|
||||
atMs: Math.round(s.t - holdStart),
|
||||
shown: s.shown,
|
||||
loading: s.loading,
|
||||
});
|
||||
}
|
||||
if (s.loading) wasLoading = true;
|
||||
else if (wasLoading && loadingEndAt === null) loadingEndAt = s.t;
|
||||
previous = s;
|
||||
}
|
||||
const first = samples[0] || {};
|
||||
const settledAt = Math.max(
|
||||
lastChangeAt ?? holdStart,
|
||||
loadingEndAt ?? (first.loading ? holdEnd : holdStart),
|
||||
);
|
||||
const end = samples.at(-1) || {};
|
||||
const row = {
|
||||
stop: stop.name,
|
||||
scale: stop.scale,
|
||||
holdEpochMs: [holdStartEpoch, holdStartEpoch + (holdEnd - holdStart)],
|
||||
onScreen: end.onScreen ?? null,
|
||||
staleFrame,
|
||||
timeToCamerasMs: alpr ? Math.round(settledAt - holdStart) : null,
|
||||
cameras: end.count ?? 0,
|
||||
shown: end.shown ?? 0,
|
||||
status: end.status,
|
||||
label: end.label,
|
||||
loadingAtHoldEnd: Boolean(end.loading),
|
||||
visualChanges,
|
||||
changeLog,
|
||||
lateChanges: samples.filter(
|
||||
(sample, i) =>
|
||||
i > 0 &&
|
||||
sample.t > holdStart + 3000 &&
|
||||
(sample.hash !== samples[i - 1].hash ||
|
||||
sample.shown !== samples[i - 1].shown),
|
||||
).length,
|
||||
moving,
|
||||
holding,
|
||||
};
|
||||
pass.stops.push(row);
|
||||
console.log(
|
||||
` ${stop.name.padEnd(22)} cams ${String(row.cameras).padStart(5)} t ${String(row.timeToCamerasMs ?? '-').padStart(5)} ms frame p50/p95 ${holding.frameP50}/${holding.frameP95} render p50/p95 ${holding.renderP50}/${holding.renderP95} changes ${visualChanges}/${row.lateChanges} ${row.status || ''} ${row.label || ''}`,
|
||||
);
|
||||
if (passIndex === passes.length - 1) {
|
||||
await page.screenshot({
|
||||
path: path.join(outDir, `${passName}-${stop.name}.png`),
|
||||
});
|
||||
}
|
||||
}
|
||||
result.passes.push(pass);
|
||||
}
|
||||
const clip = await recorder.stop();
|
||||
result.clip = clip;
|
||||
// Clip-relative hold windows, so a reviewer can jump to each stop.
|
||||
const clipStart = recorder.frames[0]?.timestamp * 1000;
|
||||
for (const pass of result.passes)
|
||||
for (const stop of pass.stops)
|
||||
stop.clipSeconds = stop.holdEpochMs.map(
|
||||
(ms) => Math.round((ms - clipStart) / 100) / 10,
|
||||
);
|
||||
console.log('clip', clip);
|
||||
|
||||
// Rendered-state check from the recorded frames themselves: count ALPR-cyan
|
||||
// pixels per frame during each hold, subtract the ALPR-off pass at the same
|
||||
// stop, and find when the markers actually became visible on screen. Entity
|
||||
// state can be ready while nothing is painted (a missing render request),
|
||||
// which this catches and the in-page samples cannot.
|
||||
const framesIn = ([a, b]) =>
|
||||
recorder.frames.filter(
|
||||
(frame) => frame.timestamp * 1000 >= a && frame.timestamp * 1000 < b,
|
||||
);
|
||||
const median = (list) =>
|
||||
list.length ? [...list].sort((x, y) => x - y)[list.length >> 1] : 0;
|
||||
const offPass = result.passes.find((p) => !p.alpr);
|
||||
for (const pass of result.passes) {
|
||||
for (const [index, stop] of pass.stops.entries()) {
|
||||
const frames = framesIn(stop.holdEpochMs);
|
||||
const counts = [];
|
||||
for (const frame of frames)
|
||||
counts.push({
|
||||
atMs: Math.round(frame.timestamp * 1000 - stop.holdEpochMs[0]),
|
||||
cyan: await cyanCount(frame.file),
|
||||
});
|
||||
stop.pixelTimeline = counts;
|
||||
if (!pass.alpr) {
|
||||
stop.cyanBaseline = median(counts.map((c) => c.cyan));
|
||||
continue;
|
||||
}
|
||||
const baseline = offPass?.stops[index]?.cyanBaseline ?? 0;
|
||||
const tail = counts.filter(
|
||||
(c) => c.atMs >= stop.holdEpochMs[1] - stop.holdEpochMs[0] - 1000,
|
||||
);
|
||||
const final = median(tail.map((c) => c.cyan)) - baseline;
|
||||
stop.renderedMarkerPixels = final;
|
||||
let visibleAt = null;
|
||||
if (final >= MIN_MARKER_PIXELS) {
|
||||
for (let i = counts.length - 1; i >= 0; i--) {
|
||||
if (counts[i].cyan - baseline >= final * 0.8)
|
||||
visibleAt = counts[i].atMs;
|
||||
else break;
|
||||
}
|
||||
}
|
||||
stop.renderedVisibleAtMs = visibleAt;
|
||||
console.log(
|
||||
` ${pass.name} ${stop.stop.padEnd(22)} on screen ${stop.onScreen ?? '-'} marker px ${final} visible at ${visibleAt ?? '-'} ms (state ${stop.timeToCamerasMs} ms) end-of-hold px ${stop.staleFrame?.shown} / forced ${stop.staleFrame?.forced}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Aggregate and assert.
|
||||
const aggregate = (pass, phase) => {
|
||||
const frames = pass.stops.map((s) => s[phase]);
|
||||
const weighted = (key) => {
|
||||
const total = frames.reduce((n, f) => n + (f.frames || 0), 0);
|
||||
return (
|
||||
Math.round(
|
||||
(frames.reduce((n, f) => n + (f[key] || 0) * (f.frames || 0), 0) /
|
||||
Math.max(1, total)) *
|
||||
10,
|
||||
) / 10
|
||||
);
|
||||
};
|
||||
return {
|
||||
frameP50: weighted('frameP50'),
|
||||
frameP95: weighted('frameP95'),
|
||||
renderP50: weighted('renderP50'),
|
||||
renderP95: weighted('renderP95'),
|
||||
longFrames: frames.reduce((n, f) => n + f.longFrames, 0),
|
||||
};
|
||||
};
|
||||
result.summary = result.passes.map((pass) => ({
|
||||
pass: pass.name,
|
||||
moving: aggregate(pass, 'moving'),
|
||||
holding: aggregate(pass, 'holding'),
|
||||
}));
|
||||
console.table(
|
||||
result.summary.map((s) => ({
|
||||
pass: s.pass,
|
||||
'move p50/p95': `${s.moving.frameP50}/${s.moving.frameP95}`,
|
||||
'hold p50/p95': `${s.holding.frameP50}/${s.holding.frameP95}`,
|
||||
'render hold p50/p95': `${s.holding.renderP50}/${s.holding.renderP95}`,
|
||||
'long frames': s.moving.longFrames + s.holding.longFrames,
|
||||
})),
|
||||
);
|
||||
if (assertOn) {
|
||||
const off = result.summary.find((s) => s.pass.includes('off'));
|
||||
const warm = result.summary.find((s) => s.pass.endsWith('warm'));
|
||||
const warmPass = result.passes.find((p) => p.name.endsWith('warm'));
|
||||
const onPasses = result.passes.filter((p) => p.alpr);
|
||||
if (off && warm) {
|
||||
for (const phase of ['moving', 'holding'])
|
||||
for (const key of ['frameP50', 'frameP95'])
|
||||
if (warm[phase][key] > off[phase][key] * 1.1 + 2)
|
||||
fail(
|
||||
`${phase} ${key} ${warm[phase][key]} ms with ALPR vs ${off[phase][key]} ms without`,
|
||||
);
|
||||
}
|
||||
for (const stop of warmPass?.stops || []) {
|
||||
if (
|
||||
stop.scale !== 'city' &&
|
||||
!(
|
||||
stop.timeToCamerasMs !== null &&
|
||||
stop.timeToCamerasMs <= 2000 &&
|
||||
stop.cameras > 0
|
||||
)
|
||||
)
|
||||
fail(
|
||||
`${stop.stop}: cameras after ${stop.timeToCamerasMs} ms (${stop.cameras}) on the warm pass`,
|
||||
);
|
||||
}
|
||||
for (const pass of onPasses)
|
||||
for (const stop of pass.stops) {
|
||||
if (stop.staleFrame?.stale)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: screen showed ${stop.staleFrame.shown} marker px, ${stop.staleFrame.forced} after forcing a render`,
|
||||
);
|
||||
// Cameras on screen must be painted, and painted when state says so.
|
||||
if (stop.onScreen > 0 && stop.renderedMarkerPixels < MIN_MARKER_PIXELS)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: ${stop.onScreen} cameras on screen but no markers rendered`,
|
||||
);
|
||||
if (
|
||||
stop.renderedVisibleAtMs !== null &&
|
||||
stop.renderedVisibleAtMs > stop.timeToCamerasMs + 700
|
||||
)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: markers rendered ${stop.renderedVisibleAtMs} ms after the stop, ${stop.timeToCamerasMs} ms after state`,
|
||||
);
|
||||
if (
|
||||
pass.name.endsWith('warm') &&
|
||||
stop.scale !== 'city' &&
|
||||
stop.renderedVisibleAtMs !== null &&
|
||||
stop.renderedVisibleAtMs > 2000
|
||||
)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: markers visible only after ${stop.renderedVisibleAtMs} ms`,
|
||||
);
|
||||
if (
|
||||
stop.cameras > 0 &&
|
||||
stop.onScreen === 0 &&
|
||||
!/none on screen/i.test(stop.label)
|
||||
)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: no camera on screen and no explicit state`,
|
||||
);
|
||||
if (stop.loadingAtHoldEnd)
|
||||
fail(`${pass.name} ${stop.stop}: still loading when the hold ended`);
|
||||
if (
|
||||
stop.scale === 'city' &&
|
||||
!(stop.cameras > 0 || /zoom in/i.test(stop.label))
|
||||
)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: neither cameras nor a zoom-in prompt`,
|
||||
);
|
||||
if (stop.visualChanges > 1 || stop.lateChanges > 0)
|
||||
fail(
|
||||
`${pass.name} ${stop.stop}: ${stop.visualChanges} marker changes (${stop.lateChanges} after 3 s) while the camera was still`,
|
||||
);
|
||||
}
|
||||
const errors = result.consoleErrors.filter(
|
||||
(text) => !/favicon/i.test(text),
|
||||
);
|
||||
if (errors.length)
|
||||
fail(`console errors: ${errors.slice(0, 3).join(' | ')}`);
|
||||
}
|
||||
} catch (error) {
|
||||
fail(error.stack || error.message);
|
||||
} finally {
|
||||
fs.writeFileSync(
|
||||
path.join(outDir, 'result.json'),
|
||||
JSON.stringify(result, null, 1),
|
||||
);
|
||||
await browser.close();
|
||||
}
|
||||
console.log(
|
||||
`${result.failures.length ? 'FAIL' : 'PASS'} — ${path.join(outDir, 'result.json')}`,
|
||||
);
|
||||
process.exit(result.failures.length ? 1 : 0);
|
||||
@@ -0,0 +1,590 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* qa-context-arrivals.mjs — search arrivals above the surface, and Contacts
|
||||
* listing mapped installations around a moving tracked aircraft.
|
||||
*
|
||||
* Run: node scripts/qa-context-arrivals.mjs http://localhost:4173 [--headful]
|
||||
* [--out qa-shots/context-arrivals] [--only arrivals|contacts]
|
||||
*
|
||||
* Arrivals: types "Camp Mabry" and "39.7392, -104.9903" (downtown Denver)
|
||||
* into the location search, waits for the flight and the photoreal tiles,
|
||||
* orbits a little like a user looking around, and asserts the camera sits at
|
||||
* least 60 m above the rendered surface under it and under the view centre.
|
||||
*
|
||||
* Contacts: serves two synthetic aircraft through the page's own
|
||||
* /api/opensky response (one flying north over Camp Mabry at 2,500 m, one
|
||||
* near Fort Cavazos) and an empty military feed, starts from a wide Texas
|
||||
* view, and presses CONTACTS as a user would. Asserts the Mapped
|
||||
* installations row lists at least one site with a distance within 15 s,
|
||||
* never falls back to "?" while the aircraft moves (30 s), keeps its site
|
||||
* entities (no rebuilds while the view is still), still lists sites in
|
||||
* Cockpit, and that SEARCH NEARBY SITES reports what it found. Then re-enters
|
||||
* Contacts on the Fort Cavazos aircraft and asserts a site within 30 km.
|
||||
* Requires zero console errors.
|
||||
*
|
||||
* Writes <out>/result.json, screenshots and <out>/clip.mp4 (CDP screencast
|
||||
* with real frame timing; needs ffmpeg).
|
||||
*/
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import puppeteer from 'puppeteer';
|
||||
import { createScreencast, moveCamera } from './qa-journey-recorder.mjs';
|
||||
|
||||
const argv = process.argv.slice(2);
|
||||
if (argv.includes('--help') || argv.includes('-h')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-context-arrivals.mjs <dev-server-url> [--headful] [--out dir] [--only arrivals|contacts]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const option = (name, fallback) => {
|
||||
const i = argv.indexOf(name);
|
||||
return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
|
||||
};
|
||||
const appUrl =
|
||||
argv.find((arg) => /^https?:/.test(arg)) || 'http://localhost:4173';
|
||||
const outDir = path.resolve(option('--out', 'qa-shots/context-arrivals'));
|
||||
const only = option('--only', null);
|
||||
fs.mkdirSync(outDir, { recursive: true });
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
const result = {
|
||||
url: appUrl,
|
||||
arrivals: [],
|
||||
contacts: {},
|
||||
consoleErrors: [],
|
||||
failures: [],
|
||||
};
|
||||
const check = (name, ok, detail = '') => {
|
||||
console.log(
|
||||
`[${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`,
|
||||
);
|
||||
if (!ok) result.failures.push(`${name}${detail ? ` — ${detail}` : ''}`);
|
||||
};
|
||||
|
||||
const browser = await puppeteer.launch({
|
||||
headless: !argv.includes('--headful'),
|
||||
protocolTimeout: 300_000,
|
||||
args: [
|
||||
'--no-sandbox',
|
||||
...(process.platform === 'darwin'
|
||||
? ['--use-angle=metal', '--enable-gpu']
|
||||
: ['--use-gl=angle', '--use-angle=swiftshader']),
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
'--disable-backgrounding-occluded-windows',
|
||||
],
|
||||
});
|
||||
|
||||
async function openPage({ aircraft = false } = {}) {
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1440, height: 900 });
|
||||
page.on('console', (message) => {
|
||||
if (message.type() === 'error') result.consoleErrors.push(message.text());
|
||||
});
|
||||
page.on('pageerror', (error) => result.consoleErrors.push(error.message));
|
||||
page.on('response', (response) => {
|
||||
if (response.status() < 400) return;
|
||||
const url = new URL(response.url());
|
||||
// Track/enrichment lookups for the synthetic ICAOs have no upstream record.
|
||||
const synthetic = /aaa05\d/i.test(url.search + url.pathname);
|
||||
(synthetic
|
||||
? (result.expectedMisses ??= [])
|
||||
: (result.httpErrors ??= [])
|
||||
).push(`${response.status()} ${url.pathname}${url.search}`);
|
||||
});
|
||||
await page.evaluateOnNewDocument((aircraft) => {
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed');
|
||||
if (!aircraft) return;
|
||||
// Synthetic traffic through the app's own feed endpoints: one aircraft
|
||||
// flying north over Camp Mabry, one loitering near Fort Cavazos.
|
||||
const started = Date.now();
|
||||
const realFetch = window.fetch.bind(window);
|
||||
window.fetch = (input, init) => {
|
||||
const raw =
|
||||
typeof input === 'string' || input instanceof URL
|
||||
? String(input)
|
||||
: input?.url;
|
||||
let url;
|
||||
try {
|
||||
url = new URL(raw, location.href);
|
||||
} catch {
|
||||
return realFetch(input, init);
|
||||
}
|
||||
if (url.origin === location.origin && url.pathname === '/api/opensky') {
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
const seconds = (Date.now() - started) / 1000;
|
||||
const lat = 30.29 + (seconds * 120) / 111_320;
|
||||
const json = {
|
||||
time: now,
|
||||
states: [
|
||||
[
|
||||
'aaa051',
|
||||
'QA051',
|
||||
'Synthetic',
|
||||
now,
|
||||
now,
|
||||
-97.765,
|
||||
lat,
|
||||
2500,
|
||||
false,
|
||||
120,
|
||||
0,
|
||||
0,
|
||||
null,
|
||||
2500,
|
||||
null,
|
||||
false,
|
||||
0,
|
||||
],
|
||||
[
|
||||
'aaa052',
|
||||
'QA052',
|
||||
'Synthetic',
|
||||
now,
|
||||
now,
|
||||
-97.72,
|
||||
31.12,
|
||||
3000,
|
||||
false,
|
||||
90,
|
||||
270,
|
||||
0,
|
||||
null,
|
||||
3000,
|
||||
null,
|
||||
false,
|
||||
0,
|
||||
],
|
||||
],
|
||||
};
|
||||
return Promise.resolve(Response.json(json));
|
||||
}
|
||||
if (url.origin === location.origin && url.pathname === '/api/adsblol/mil')
|
||||
return Promise.resolve(
|
||||
Response.json({ ac: [], now: Date.now(), total: 0 }),
|
||||
);
|
||||
return realFetch(input, init);
|
||||
};
|
||||
}, aircraft);
|
||||
const url = new URL(appUrl);
|
||||
url.searchParams.set('welcome', '0');
|
||||
await page.goto(url.href, { waitUntil: 'domcontentloaded', timeout: 90_000 });
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120_000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
return page;
|
||||
}
|
||||
|
||||
async function waitTiles(page, maxMs = 30_000) {
|
||||
await page
|
||||
.waitForFunction(
|
||||
() => {
|
||||
const { scene } = window.__godsEyeView.viewer;
|
||||
if (scene.globe.show) return scene.globe.tilesLoaded;
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const p = scene.primitives.get(i);
|
||||
if (p.show && p.tilesLoaded === false) return false;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
{ timeout: maxMs, polling: 250 },
|
||||
)
|
||||
.catch(() => {});
|
||||
}
|
||||
|
||||
/** Camera height above the rendered surface under it and under the view centre. */
|
||||
function clearance(page) {
|
||||
return page.evaluate(() => {
|
||||
const { viewer } = window.__godsEyeView;
|
||||
const { scene, camera } = viewer;
|
||||
const carto = camera.positionCartographic.clone();
|
||||
const sample = (c) => {
|
||||
try {
|
||||
const h = scene.sampleHeight(c);
|
||||
return Number.isFinite(h) ? h : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
const under = sample(carto);
|
||||
let centre = null;
|
||||
const canvas = scene.canvas;
|
||||
const hit = scene.pickPosition?.({
|
||||
x: canvas.clientWidth / 2,
|
||||
y: canvas.clientHeight / 2,
|
||||
});
|
||||
if (hit) centre = scene.globe.ellipsoid.cartesianToCartographic(hit);
|
||||
const centreSurface = centre ? sample(centre) : null;
|
||||
const surface = Math.max(under ?? -Infinity, centreSurface ?? -Infinity);
|
||||
return {
|
||||
lat: (carto.latitude * 180) / Math.PI,
|
||||
lon: (carto.longitude * 180) / Math.PI,
|
||||
cameraM: Math.round(carto.height),
|
||||
surfaceUnderM: under === null ? null : Math.round(under),
|
||||
surfaceCentreM: centreSurface === null ? null : Math.round(centreSurface),
|
||||
clearanceM: Number.isFinite(surface)
|
||||
? Math.round(carto.height - surface)
|
||||
: null,
|
||||
pitchDeg: Math.round((camera.pitch * 180) / Math.PI),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
async function arrivals() {
|
||||
const page = await openPage();
|
||||
const dir = path.join(outDir, 'arrivals');
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
const recorder = await createScreencast(page, dir);
|
||||
await recorder.start();
|
||||
for (const query of ['Camp Mabry', '39.7392, -104.9903']) {
|
||||
await page.evaluate(() =>
|
||||
document.getElementById('search-toggle')?.click(),
|
||||
);
|
||||
await page.focus('#location-search');
|
||||
await page.evaluate(() => {
|
||||
document.getElementById('location-search').value = '';
|
||||
});
|
||||
await page.type('#location-search', query, { delay: 40 });
|
||||
await page.keyboard.press('Enter');
|
||||
// Wait for the flight to land: the camera still for 1.5 s.
|
||||
const landed = Date.now();
|
||||
let last = null;
|
||||
let stillSince = null;
|
||||
while (Date.now() - landed < 30_000) {
|
||||
const now = await page.evaluate(() => {
|
||||
const c = window.__godsEyeView.viewer.camera.positionWC;
|
||||
return [c.x, c.y, c.z];
|
||||
});
|
||||
const moved =
|
||||
!last ||
|
||||
Math.hypot(now[0] - last[0], now[1] - last[1], now[2] - last[2]) > 0.5;
|
||||
last = now;
|
||||
if (moved) stillSince = null;
|
||||
else stillSince ??= Date.now();
|
||||
if (
|
||||
Date.now() - landed > 4000 &&
|
||||
stillSince &&
|
||||
Date.now() - stillSince > 1500
|
||||
)
|
||||
break;
|
||||
await sleep(250);
|
||||
}
|
||||
await waitTiles(page);
|
||||
await sleep(2500); // the ground guard measures after tiles stream in
|
||||
const arrived = await clearance(page);
|
||||
const slug = query.replace(/\W+/g, '-').replace(/^-|-$/g, '').toLowerCase();
|
||||
await page.screenshot({ path: path.join(dir, `arrival-${slug}.png`) });
|
||||
// Look around: a gentle orbit, then check the eye still clears the ground.
|
||||
const view = await page.evaluate(() => {
|
||||
const c = window.__godsEyeView.viewer.camera;
|
||||
return {
|
||||
lat: (c.positionCartographic.latitude * 180) / Math.PI,
|
||||
lon: (c.positionCartographic.longitude * 180) / Math.PI,
|
||||
height: c.positionCartographic.height,
|
||||
heading: (c.heading * 180) / Math.PI,
|
||||
pitch: (c.pitch * 180) / Math.PI,
|
||||
};
|
||||
});
|
||||
await moveCamera(page, { ...view, heading: view.heading + 25 }, 2.5);
|
||||
await sleep(1500);
|
||||
const lookedAround = await clearance(page);
|
||||
result.arrivals.push({ query, arrived, lookedAround });
|
||||
check(
|
||||
`${query}: arrival clears the rendered surface`,
|
||||
arrived.clearanceM !== null && arrived.clearanceM >= 60,
|
||||
JSON.stringify(arrived),
|
||||
);
|
||||
}
|
||||
result.arrivalClip = await recorder.stop();
|
||||
await page.close();
|
||||
}
|
||||
|
||||
async function contacts() {
|
||||
const page = await openPage({ aircraft: true });
|
||||
const dir = path.join(outDir, 'contacts');
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('flights', true, {
|
||||
origin: 'user',
|
||||
}),
|
||||
);
|
||||
// A wide Texas view: installation viewports are unbounded here.
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat: 30.35, lon: -97.76, height: 900_000, pitch: -90 },
|
||||
0,
|
||||
);
|
||||
await sleep(3000);
|
||||
// In-page probe: row text and installation entity churn every 250 ms.
|
||||
await page.evaluate(() => {
|
||||
const samples = [];
|
||||
window.__gevContextSamples = samples;
|
||||
let created = 0;
|
||||
const seen = new WeakSet();
|
||||
setInterval(() => {
|
||||
const row = [
|
||||
...document.querySelectorAll(
|
||||
'#military-awareness-panel .military-awareness-row',
|
||||
),
|
||||
].find(
|
||||
(candidate) =>
|
||||
candidate.querySelector('strong')?.textContent?.trim() ===
|
||||
'Mapped installations',
|
||||
);
|
||||
const ds = window.__godsEyeView.viewer.dataSources.getByName(
|
||||
'military-installations',
|
||||
)[0];
|
||||
for (const entity of ds?.entities.values || [])
|
||||
if (!seen.has(entity)) {
|
||||
seen.add(entity);
|
||||
created += 1;
|
||||
}
|
||||
samples.push({
|
||||
t: performance.now(),
|
||||
count: row?.querySelector('b')?.textContent?.trim() ?? null,
|
||||
text: row?.innerText?.replace(/\s+/g, ' ').trim() ?? null,
|
||||
installations: [
|
||||
...(row?.querySelectorAll('button[data-awareness-id]') || []),
|
||||
].map((button) => ({
|
||||
id: button.dataset.awarenessId,
|
||||
name: button.childNodes[0]?.textContent?.trim(),
|
||||
distance: button.querySelector('span')?.textContent?.trim(),
|
||||
})),
|
||||
entities: ds?.entities.values.length ?? 0,
|
||||
created,
|
||||
tracked:
|
||||
window.__godsEyeView.viewer.trackedEntity?.gevTrackedId ?? null,
|
||||
cockpit: document.body.classList.contains('cockpit-mode'),
|
||||
});
|
||||
if (samples.length > 5000) samples.splice(0, 1000);
|
||||
}, 250);
|
||||
});
|
||||
const recorder = await createScreencast(page, dir);
|
||||
await recorder.start();
|
||||
const t0 = await page.evaluate(() => performance.now());
|
||||
await page.evaluate(() =>
|
||||
document.getElementById('global-context-flights-btn').click(),
|
||||
);
|
||||
await page
|
||||
.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView.viewer.trackedEntity?.gevTrackedId ===
|
||||
'flights:aaa051',
|
||||
{ timeout: 60_000 },
|
||||
)
|
||||
.catch(() => {});
|
||||
const readSamples = (from) =>
|
||||
page.evaluate(
|
||||
(a) => window.__gevContextSamples.filter((s) => s.t >= a),
|
||||
from,
|
||||
);
|
||||
const numeric = (s) => /^\d+/.test(String(s.count ?? ''));
|
||||
// Up to 15 s for the first answer, then watch 30 s of flight.
|
||||
const deadline = Date.now() + 15_000;
|
||||
let first = null;
|
||||
while (Date.now() < deadline && !first) {
|
||||
first = (await readSamples(t0)).find(
|
||||
(s) =>
|
||||
numeric(s) &&
|
||||
Number.parseInt(s.count, 10) >= 1 &&
|
||||
/\d+(\.\d+)? k?m\b/.test(s.text),
|
||||
);
|
||||
if (!first) await sleep(500);
|
||||
}
|
||||
check(
|
||||
'Contacts lists a mapped installation with a distance',
|
||||
Boolean(first),
|
||||
first
|
||||
? `${Math.round(first.t - t0)} ms: ${first.text}`
|
||||
: 'row never answered',
|
||||
);
|
||||
await page.screenshot({ path: path.join(dir, 'contacts-camp-mabry.png') });
|
||||
await sleep(30_000);
|
||||
const flight = (await readSamples(first?.t ?? t0)).filter(
|
||||
(s) => s.tracked === 'flights:aaa051',
|
||||
);
|
||||
const reverted = flight.filter((s) => !numeric(s));
|
||||
const createdDuring = flight.length
|
||||
? flight.at(-1).created - flight[0].created
|
||||
: 0;
|
||||
result.contacts.mabry = {
|
||||
firstAnswerMs: first ? Math.round(first.t - t0) : null,
|
||||
firstText: first?.text ?? null,
|
||||
lastText: flight.at(-1)?.text ?? null,
|
||||
samples: flight.length,
|
||||
revertedSamples: reverted.length,
|
||||
entities: flight.at(-1)?.entities ?? 0,
|
||||
entitiesCreatedWhileTracking: createdDuring,
|
||||
};
|
||||
check(
|
||||
'the row never falls back to "?" while the aircraft moves',
|
||||
reverted.length === 0,
|
||||
`${reverted.length}/${flight.length}`,
|
||||
);
|
||||
check(
|
||||
'site entities are not rebuilt while tracking',
|
||||
createdDuring === 0,
|
||||
`${createdDuring} created`,
|
||||
);
|
||||
|
||||
// Cockpit: the same context must hold with a horizon view.
|
||||
const cockpit = await page.evaluate(() => {
|
||||
const view = window.__godsEyeView.styleManager.cockpitView;
|
||||
view.syncEntry();
|
||||
return view.enter();
|
||||
});
|
||||
await sleep(12_000);
|
||||
const inCockpit = (
|
||||
await readSamples((await page.evaluate(() => performance.now())) - 8000)
|
||||
).filter((s) => s.cockpit);
|
||||
const scope = await page.evaluate(
|
||||
() =>
|
||||
document.getElementById('cockpit-context-subject')?.textContent || null,
|
||||
);
|
||||
await page.screenshot({ path: path.join(dir, 'cockpit-camp-mabry.png') });
|
||||
result.contacts.cockpit = {
|
||||
entered: cockpit,
|
||||
samples: inCockpit.length,
|
||||
last: inCockpit.at(-1)?.text ?? null,
|
||||
scope,
|
||||
};
|
||||
check(
|
||||
'Cockpit scope names the installation window',
|
||||
/INSTALLATIONS WITHIN \d+ KM/.test(scope || ''),
|
||||
scope || 'no scope',
|
||||
);
|
||||
check(
|
||||
'Cockpit keeps mapped installations listed',
|
||||
cockpit !== false &&
|
||||
inCockpit.length > 0 &&
|
||||
inCockpit.every((s) => numeric(s) && Number.parseInt(s.count, 10) >= 1),
|
||||
inCockpit.at(-1)?.text || 'no cockpit samples',
|
||||
);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.styleManager.cockpitView.exit?.(),
|
||||
);
|
||||
await sleep(2000);
|
||||
|
||||
// SEARCH NEARBY SITES, as the user presses it.
|
||||
await page.evaluate(() => {
|
||||
document.getElementById('toast').textContent = '';
|
||||
document.getElementById('installations-search-btn').click();
|
||||
});
|
||||
await page
|
||||
.waitForFunction(
|
||||
() => document.getElementById('toast').textContent.trim().length > 0,
|
||||
{ timeout: 20_000 },
|
||||
)
|
||||
.catch(() => {});
|
||||
const toast = await page.evaluate(() =>
|
||||
document.getElementById('toast').textContent.trim(),
|
||||
);
|
||||
await sleep(1500);
|
||||
const afterSearch = (
|
||||
await readSamples((await page.evaluate(() => performance.now())) - 1000)
|
||||
).at(-1);
|
||||
result.contacts.search = { toast, row: afterSearch?.text ?? null };
|
||||
check(
|
||||
'SEARCH NEARBY SITES reports what it found and the row still lists sites',
|
||||
/mapped sites? within \d+ km/i.test(toast) && numeric(afterSearch || {}),
|
||||
`toast "${toast}" · ${afterSearch?.text}`,
|
||||
);
|
||||
|
||||
// Fort Cavazos: leave Contacts, track the other aircraft, re-enter.
|
||||
await page.evaluate(() =>
|
||||
document.getElementById('global-context-flights-btn').click(),
|
||||
);
|
||||
await sleep(2000);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('flights')
|
||||
.module.trackById('aaa052'),
|
||||
);
|
||||
await sleep(3000);
|
||||
const t1 = await page.evaluate(() => performance.now());
|
||||
await page.evaluate(() =>
|
||||
document.getElementById('global-context-flights-btn').click(),
|
||||
);
|
||||
let cavazos = null;
|
||||
const cavazosDeadline = Date.now() + 20_000;
|
||||
while (Date.now() < cavazosDeadline) {
|
||||
const latest = (await readSamples(t1))
|
||||
.filter((s) => s.tracked === 'flights:aaa052' && numeric(s))
|
||||
.at(-1);
|
||||
const site = latest?.installations.find(
|
||||
(record) => record.name === 'Fort Hood',
|
||||
);
|
||||
const nearest = site?.distance?.match(/^(\d+(?:\.\d+)?) (k?m)$/);
|
||||
const km = nearest
|
||||
? Number(nearest[1]) / (nearest[2] === 'm' ? 1000 : 1)
|
||||
: null;
|
||||
if (km !== null && km <= 30) {
|
||||
cavazos = {
|
||||
text: latest.text,
|
||||
nearestKm: km,
|
||||
site,
|
||||
afterMs: Math.round(latest.t - t1),
|
||||
};
|
||||
break;
|
||||
}
|
||||
await sleep(500);
|
||||
}
|
||||
await sleep(2000);
|
||||
await page.screenshot({ path: path.join(dir, 'contacts-fort-cavazos.png') });
|
||||
result.contacts.cavazos = cavazos;
|
||||
check(
|
||||
'Fort Cavazos contact lists Fort Hood within 30 km',
|
||||
Boolean(cavazos),
|
||||
JSON.stringify(cavazos),
|
||||
);
|
||||
result.contactsClip = await recorder.stop();
|
||||
await page.close();
|
||||
}
|
||||
|
||||
try {
|
||||
if (only !== 'contacts') await arrivals();
|
||||
if (only !== 'arrivals') await contacts();
|
||||
// A 404 for a synthetic aircraft's track logs "Failed to load resource";
|
||||
// count those only when every failed response was such an expected miss.
|
||||
const resourceErrors = result.consoleErrors.filter((text) =>
|
||||
/Failed to load resource/.test(text),
|
||||
).length;
|
||||
const errors = result.consoleErrors.filter(
|
||||
(text) =>
|
||||
!/favicon/i.test(text) &&
|
||||
!(
|
||||
/Failed to load resource/.test(text) &&
|
||||
!(result.httpErrors || []).length &&
|
||||
resourceErrors <= (result.expectedMisses || []).length
|
||||
),
|
||||
);
|
||||
check(
|
||||
'zero console errors',
|
||||
errors.length === 0,
|
||||
errors.slice(0, 3).join(' | '),
|
||||
);
|
||||
check(
|
||||
'zero failed app responses',
|
||||
!(result.httpErrors || []).length,
|
||||
(result.httpErrors || []).slice(0, 3).join(' | '),
|
||||
);
|
||||
} catch (error) {
|
||||
check('harness completed', false, error.stack || error.message);
|
||||
} finally {
|
||||
fs.writeFileSync(
|
||||
path.join(outDir, 'result.json'),
|
||||
JSON.stringify(result, null, 1),
|
||||
);
|
||||
await browser.close();
|
||||
}
|
||||
console.log(
|
||||
`${result.failures.length ? 'FAIL' : 'PASS'} — ${path.join(outDir, 'result.json')}`,
|
||||
);
|
||||
process.exit(result.failures.length ? 1 : 0);
|
||||
@@ -0,0 +1,159 @@
|
||||
#!/usr/bin/env node
|
||||
/** Persistent inline attribution through actual OSM layer display lifetimes. */
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs/promises';
|
||||
import puppeteer from 'puppeteer';
|
||||
import { moveCamera } from './qa-journey-recorder.mjs';
|
||||
const url = process.argv.find((a) => /^https?:/.test(a));
|
||||
if (!url) throw new Error('Supply the running server URL');
|
||||
const dir = process.env.QA_POLISH_DIR || 'qa-shots/final-polish';
|
||||
await fs.mkdir(dir, { recursive: true });
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
const result = { states: [], errors: [] };
|
||||
const browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
args: ['--use-angle=metal'],
|
||||
});
|
||||
try {
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1440, height: 900 });
|
||||
page.on('pageerror', (e) => result.errors.push(e.message));
|
||||
page.on('console', (m) => {
|
||||
if (m.type() === 'error') result.errors.push(m.text());
|
||||
});
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
await page.goto(`${url}/?welcome=0`, { waitUntil: 'domcontentloaded' });
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await page.evaluate(async () => {
|
||||
const g = window.__godsEyeView;
|
||||
for (const [id] of g.dataManager.layers)
|
||||
await g.dataManager.setEnabled(id, false);
|
||||
g.styleManager.setDetection({ enabled: false });
|
||||
});
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lon: -97.765, lat: 30.3125, height: 3500, pitch: -80 },
|
||||
0,
|
||||
);
|
||||
const toggle = (id, value) =>
|
||||
page.evaluate(
|
||||
(id, value) => window.__godsEyeView.dataManager.setEnabled(id, value),
|
||||
id,
|
||||
value,
|
||||
);
|
||||
const text = () => page.$eval('#cesium-credits', (e) => e.innerText);
|
||||
const shot = async (name, osm, tiles) => {
|
||||
await sleep(300);
|
||||
const state = await page.$eval('#cesium-credits', (e) => {
|
||||
const nodes = [
|
||||
...e.querySelectorAll('a,img,.cesium-credit-expand-link'),
|
||||
].filter((n) =>
|
||||
n.checkVisibility({ visibilityProperty: true, opacityProperty: true }),
|
||||
);
|
||||
return {
|
||||
text: e.innerText,
|
||||
rects: nodes
|
||||
.map((n) => {
|
||||
const b = n.getBoundingClientRect();
|
||||
return {
|
||||
text: n.textContent || n.alt || 'image',
|
||||
x: b.x,
|
||||
y: b.y,
|
||||
width: b.width,
|
||||
height: b.height,
|
||||
reachable: n.contains(
|
||||
document.elementFromPoint(
|
||||
b.x + b.width / 2,
|
||||
b.y + b.height / 2,
|
||||
),
|
||||
),
|
||||
};
|
||||
})
|
||||
.filter((b) => b.width > 0 && b.height > 0),
|
||||
};
|
||||
});
|
||||
assert.equal(state.text.includes('© OpenStreetMap'), osm);
|
||||
assert.equal(state.text.includes('© OpenMapTiles'), tiles);
|
||||
assert.equal(
|
||||
(state.text.match(/© OpenStreetMap/g) || []).length,
|
||||
osm ? 1 : 0,
|
||||
);
|
||||
assert.ok(state.rects.length >= 3);
|
||||
const centers = state.rects.map((b) => b.y + b.height / 2);
|
||||
assert.ok(
|
||||
Math.max(...centers) - Math.min(...centers) < 12,
|
||||
`${name}: credits stay on one desktop row`,
|
||||
);
|
||||
assert.ok(
|
||||
state.rects.every(
|
||||
(b) => b.x >= 0 && b.x + b.width <= page.viewport().width,
|
||||
),
|
||||
'no credit clipped',
|
||||
);
|
||||
assert.ok(
|
||||
state.rects.every((b) => b.reachable),
|
||||
'all credits and the attribution link remain clear of controls',
|
||||
);
|
||||
await page.screenshot({ path: `${dir}/after-${name}.png` });
|
||||
await page.screenshot({
|
||||
path: `${dir}/after-${name}-row.png`,
|
||||
clip: { x: 16, y: 750, width: 1150, height: 150 },
|
||||
});
|
||||
result.states.push({ name, ...state });
|
||||
};
|
||||
await sleep(1600);
|
||||
await shot('nothing', false, false);
|
||||
await toggle('alpr-cameras', true);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
document
|
||||
.querySelector('#cesium-credits')
|
||||
.innerText.includes('© OpenStreetMap'),
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
await shot('alpr', true, false);
|
||||
await sleep(6000);
|
||||
await shot('alpr-persistent', true, false);
|
||||
await toggle('traffic', true);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
document
|
||||
.querySelector('#cesium-credits')
|
||||
.innerText.includes('© OpenMapTiles'),
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
await shot('alpr-and-traffic', true, true);
|
||||
await toggle('alpr-cameras', false);
|
||||
await shot('traffic', true, true);
|
||||
for (const width of [1280, 1920]) {
|
||||
await page.setViewport({ width, height: 900 });
|
||||
await sleep(500);
|
||||
await shot(`traffic-${width}`, true, true);
|
||||
}
|
||||
await page.setViewport({ width: 1440, height: 900 });
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.styleManager.setCleanView(true),
|
||||
);
|
||||
await shot('traffic-clean-ui', true, true);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.styleManager.setCleanView(false),
|
||||
);
|
||||
await toggle('traffic', false);
|
||||
await shot('nothing-restored', false, false);
|
||||
assert.deepEqual(result.errors, []);
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
} finally {
|
||||
await fs.writeFile(`${dir}/credits.json`, JSON.stringify(result, null, 2));
|
||||
await browser.close();
|
||||
}
|
||||
@@ -0,0 +1,412 @@
|
||||
#!/usr/bin/env node
|
||||
/** Mapped installations: isolated camera navigation, cached revisits and Contacts release. */
|
||||
import fs from 'node:fs';
|
||||
import puppeteer from 'puppeteer';
|
||||
import { moveCamera } from './qa-journey-recorder.mjs';
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-installation-navigation.mjs <url> [--baseline]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const baseline = args.includes('--baseline');
|
||||
const result = { views: [], errors: [], forbidden: [], failures: [] };
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
const browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
args: ['--use-angle=metal', '--disable-background-timer-throttling'],
|
||||
protocolTimeout: 120000,
|
||||
});
|
||||
try {
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
const tiles = [];
|
||||
page.on('request', (r) => {
|
||||
const u = new URL(r.url());
|
||||
if (
|
||||
u.hostname === 'tiles.openfreemap.org' &&
|
||||
/\/\d+\/\d+\/\d+(\.pbf)?$/.test(u.pathname)
|
||||
)
|
||||
tiles.push(u.pathname);
|
||||
if (
|
||||
/overpass/i.test(u.hostname) ||
|
||||
u.hostname === 'nominatim.openstreetmap.org'
|
||||
)
|
||||
result.forbidden.push(u.hostname);
|
||||
});
|
||||
page.on('pageerror', (e) => result.errors.push(e.message));
|
||||
page.on('console', (m) => {
|
||||
if (m.type() === 'error') result.errors.push(m.text());
|
||||
});
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
await page.goto(
|
||||
args.find((a) => /^https?:/.test(a)),
|
||||
{ waitUntil: 'domcontentloaded' },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await page.evaluate(async () => {
|
||||
const g = window.__godsEyeView;
|
||||
for (const [id] of g.dataManager.layers)
|
||||
await g.dataManager.setEnabled(id, false);
|
||||
g.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||||
window.installationEvents = { changed: 0, end: 0 };
|
||||
window.installationEntityRefs = new Map();
|
||||
g.viewer.camera.changed.addEventListener(
|
||||
() => window.installationEvents.changed++,
|
||||
);
|
||||
g.viewer.camera.moveEnd.addEventListener(
|
||||
() => window.installationEvents.end++,
|
||||
);
|
||||
});
|
||||
let low = 60000,
|
||||
high = 400000;
|
||||
for (let i = 0; i < 9; i++) {
|
||||
const height = (low + high) / 2;
|
||||
await moveCamera(page, { lat: 32.72, lon: -117.16, height, pitch: -90 }, 0);
|
||||
const fits = await page.evaluate(async () => {
|
||||
const { installationTileZoom } =
|
||||
await import('/src/layers/installations/source.js');
|
||||
const r = window.__godsEyeView.viewer.camera.computeViewRectangle();
|
||||
const d = 180 / Math.PI;
|
||||
return (
|
||||
r &&
|
||||
installationTileZoom({
|
||||
west: r.west * d,
|
||||
east: r.east * d,
|
||||
south: r.south * d,
|
||||
north: r.north * d,
|
||||
}) !== null
|
||||
);
|
||||
});
|
||||
if (fits) low = height;
|
||||
else high = height;
|
||||
}
|
||||
const widestHeight = Math.floor(low);
|
||||
result.widestHeight = widestHeight;
|
||||
result.firstTooWideHeight = Math.ceil(high);
|
||||
let enabled = false;
|
||||
const places = [
|
||||
['san-diego', 32.72, -117.16],
|
||||
['pendleton', 33.33, -117.4],
|
||||
['miramar', 32.87, -117.14],
|
||||
['san-diego-return', 32.72, -117.16],
|
||||
];
|
||||
for (const height of [
|
||||
5000,
|
||||
20000,
|
||||
60000,
|
||||
150000,
|
||||
widestHeight,
|
||||
400000,
|
||||
5000,
|
||||
]) {
|
||||
for (const [name, lat, lon] of height >= 150000
|
||||
? places.slice(0, 1)
|
||||
: places) {
|
||||
const before = tiles.length;
|
||||
const previous = await page.evaluate(
|
||||
() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats().lastUpdate,
|
||||
);
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat, lon, height, pitch: -90 },
|
||||
enabled ? 0.6 : 0,
|
||||
);
|
||||
const stop = Date.now();
|
||||
if (!enabled) {
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled(
|
||||
'military-installations',
|
||||
true,
|
||||
),
|
||||
);
|
||||
enabled = true;
|
||||
}
|
||||
await page
|
||||
.waitForFunction(
|
||||
(prev, wide) => {
|
||||
const s = window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats();
|
||||
return (
|
||||
!s.loading &&
|
||||
(s.lastUpdate > prev || (wide && s.status === 'zoom-in'))
|
||||
);
|
||||
},
|
||||
{ timeout: 6000 },
|
||||
previous,
|
||||
height === 400000,
|
||||
)
|
||||
.catch(() => {});
|
||||
const snapshot = await page.evaluate(() => {
|
||||
const g = window.__godsEyeView;
|
||||
const ds = g.viewer.dataSources.getByName('military-installations')[0];
|
||||
const points = ds.entities.values.filter((e) => e.point);
|
||||
const stable = points.every(
|
||||
(e) =>
|
||||
!window.installationEntityRefs.has(e.id) ||
|
||||
window.installationEntityRefs.get(e.id) === e,
|
||||
);
|
||||
window.installationEntityRefs = new Map(points.map((e) => [e.id, e]));
|
||||
return {
|
||||
...g.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats(),
|
||||
stable,
|
||||
ids: points.map((e) => e.id),
|
||||
events: { ...window.installationEvents },
|
||||
};
|
||||
});
|
||||
const row = {
|
||||
name,
|
||||
height,
|
||||
ms: Date.now() - stop,
|
||||
tiles: tiles.length - before,
|
||||
updated: snapshot.lastUpdate > previous,
|
||||
...snapshot,
|
||||
};
|
||||
if (
|
||||
(!row.stable && result.views.at(-1)?.height === height) ||
|
||||
new Set(row.ids).size !== row.ids.length
|
||||
)
|
||||
result.failures.push(
|
||||
`${name}/${height}: unstable or duplicate site entities`,
|
||||
);
|
||||
if (name.endsWith('return')) {
|
||||
const first = result.views.find(
|
||||
(v) => v.name === 'san-diego' && v.height === height,
|
||||
);
|
||||
if (
|
||||
first &&
|
||||
JSON.stringify([...first.ids].sort()) !==
|
||||
JSON.stringify([...row.ids].sort())
|
||||
)
|
||||
result.failures.push(
|
||||
`${name}/${height}: changed site ids on revisit`,
|
||||
);
|
||||
}
|
||||
result.views.push(row);
|
||||
console.log(JSON.stringify(row));
|
||||
if (!row.updated && row.status !== 'zoom-in')
|
||||
result.failures.push(`${name}/${height}: no reload`);
|
||||
if (row.ms > 1500 && row.status !== 'zoom-in')
|
||||
result.failures.push(`${name}/${height}: ${row.ms} ms`);
|
||||
if (name.endsWith('return') && row.tiles)
|
||||
result.failures.push(`${name}/${height}: revisit fetched ${row.tiles}`);
|
||||
}
|
||||
}
|
||||
for (const gesture of [
|
||||
'wheel',
|
||||
'keyboard',
|
||||
'contacts-close',
|
||||
'contacts-clear',
|
||||
]) {
|
||||
let previous = await page.evaluate(
|
||||
() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats().lastUpdate,
|
||||
);
|
||||
if (gesture === 'wheel') {
|
||||
await page.mouse.move(640, 400);
|
||||
await page.mouse.wheel({ deltaY: -350 });
|
||||
} else if (gesture === 'keyboard') {
|
||||
await page.evaluate(() =>
|
||||
document.getElementById('search-toggle').click(),
|
||||
);
|
||||
await page.focus('#location-search');
|
||||
await page.evaluate(() => {
|
||||
document.getElementById('location-search').value = '';
|
||||
});
|
||||
await page.type('#location-search', '33.33, -117.40');
|
||||
await page.keyboard.press('Enter');
|
||||
await sleep(4500);
|
||||
} else {
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat: 32.87, lon: -117.14, height: 5000, pitch: -90 },
|
||||
0.6,
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView.viewer.dataSources
|
||||
.getByName('military-installations')[0]
|
||||
.entities.values.some((e) => e.point),
|
||||
{ timeout: 5000 },
|
||||
);
|
||||
await page.evaluate(() => {
|
||||
const button = document.getElementById('global-context-flights-btn');
|
||||
if (button.getAttribute('aria-selected') !== 'true') button.click();
|
||||
});
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const g = window.__godsEyeView;
|
||||
return (
|
||||
g.dataManager.isEffectivelyEnabled('military-awareness') &&
|
||||
!g.dataManager.layers.get('military-awareness').module.getParams()
|
||||
.passive
|
||||
);
|
||||
},
|
||||
{ timeout: 15000 },
|
||||
);
|
||||
await sleep(1000);
|
||||
await page.evaluate(async () => {
|
||||
const g = window.__godsEyeView;
|
||||
const ds = g.viewer.dataSources.getByName('military-installations')[0];
|
||||
const id = ds.entities.values.find((e) => e.point).id;
|
||||
window.installationSubjectId = id;
|
||||
await g.dataManager.layers
|
||||
.get('military-awareness')
|
||||
.module.focusTarget('military-installations', id);
|
||||
});
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const a =
|
||||
window.__godsEyeView.dataManager.layers.get(
|
||||
'military-awareness',
|
||||
).module;
|
||||
const subject = a.getContextSnapshot()?.subject;
|
||||
return (
|
||||
subject?.layerId === 'military-installations' &&
|
||||
subject.id === window.installationSubjectId &&
|
||||
!a._getAwarenessNavigationStateForTest().pendingSelectionKey
|
||||
);
|
||||
},
|
||||
{ timeout: 15000 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() => !window.__godsEyeView.viewer.camera._currentFlight,
|
||||
{ timeout: 10000 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats().coverage.kind === 'subject',
|
||||
{ timeout: 10000 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
document
|
||||
.getElementById('global-context-flights-btn')
|
||||
.getAttribute('aria-busy') === 'false',
|
||||
{ timeout: 30000 },
|
||||
);
|
||||
const anchored = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats(),
|
||||
);
|
||||
if (anchored.coverage.kind !== 'subject')
|
||||
result.failures.push(`${gesture}: Contacts did not acquire subject`);
|
||||
result.contextClear = await page.evaluate(async (clear) => {
|
||||
if (clear) {
|
||||
const { clearSelectedEntityContextForLayer, getContextStore } =
|
||||
await import('/src/data/contextStore.js');
|
||||
const store = getContextStore();
|
||||
const before = {
|
||||
selectedId: store.selectedEntityId,
|
||||
record: store.entities.get(store.selectedEntityId)?.id,
|
||||
subject: window.__godsEyeView.dataManager.layers
|
||||
.get('military-awareness')
|
||||
.module.getContextSnapshot()?.subject,
|
||||
};
|
||||
clearSelectedEntityContextForLayer('military-installations');
|
||||
return before;
|
||||
} else document.getElementById('global-context-flights-btn').click();
|
||||
}, gesture === 'contacts-clear');
|
||||
if (gesture === 'contacts-clear') {
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
!window.__godsEyeView.dataManager.layers
|
||||
.get('military-awareness')
|
||||
.module.getContextSnapshot(),
|
||||
{ timeout: 5000 },
|
||||
);
|
||||
} else {
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const button = document.getElementById(
|
||||
'global-context-flights-btn',
|
||||
);
|
||||
return (
|
||||
button.getAttribute('aria-selected') === 'false' &&
|
||||
button.getAttribute('aria-busy') === 'false'
|
||||
);
|
||||
},
|
||||
{ timeout: 30000 },
|
||||
);
|
||||
}
|
||||
await page.waitForFunction(
|
||||
() => !window.__godsEyeView.viewer.camera._currentFlight,
|
||||
{ timeout: 10000 },
|
||||
);
|
||||
await sleep(500);
|
||||
previous = await page.evaluate(
|
||||
() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats().lastUpdate,
|
||||
);
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat: 33.33, lon: -117.4, height: 5000, pitch: -90 },
|
||||
0.6,
|
||||
);
|
||||
}
|
||||
await page
|
||||
.waitForFunction(
|
||||
(prev) => {
|
||||
const s = window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats();
|
||||
return (
|
||||
!s.loading && s.lastUpdate > prev && s.coverage.kind === 'viewport'
|
||||
);
|
||||
},
|
||||
{ timeout: 6000 },
|
||||
previous,
|
||||
)
|
||||
.catch(() => result.failures.push(`${gesture}: no viewport reload`));
|
||||
const row = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats(),
|
||||
);
|
||||
if (gesture.startsWith('contacts') && row.count !== 1)
|
||||
result.failures.push(
|
||||
`${gesture}: destination count ${row.count}, expected 1`,
|
||||
);
|
||||
result.views.push({ name: gesture, ...row });
|
||||
console.log(JSON.stringify({ name: gesture, ...row }));
|
||||
}
|
||||
await page.screenshot({ path: 'qa-shots/installations-navigation.png' });
|
||||
} finally {
|
||||
fs.mkdirSync('qa-shots', { recursive: true });
|
||||
fs.writeFileSync(
|
||||
`qa-shots/installations-navigation-${baseline ? 'before' : 'after'}.json`,
|
||||
JSON.stringify(result, null, 2),
|
||||
);
|
||||
await browser.close();
|
||||
}
|
||||
if (
|
||||
!baseline &&
|
||||
(result.failures.length || result.errors.length || result.forbidden.length)
|
||||
)
|
||||
process.exitCode = 1;
|
||||
@@ -0,0 +1,404 @@
|
||||
/** Shared browser assertions for installation label persistence and selection. */
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs/promises';
|
||||
import { moveCamera, createScreencast } from './qa-journey-recorder.mjs';
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
|
||||
export async function checkInstallationPan(page, dir) {
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('local-datacenters', true),
|
||||
);
|
||||
await sleep(3000);
|
||||
await page.evaluate(async () => {
|
||||
const { getOverlayPaintRect } =
|
||||
await import('/src/overlays/worldOverlay.js');
|
||||
const g = window.__godsEyeView;
|
||||
const installations = g.dataManager.layers.get(
|
||||
'military-installations',
|
||||
).module;
|
||||
const centerIds = [];
|
||||
for (let i = 0; i < g.viewer.dataSources.length; i++)
|
||||
for (const e of g.viewer.dataSources.get(i).entities.values)
|
||||
if (e.__localLayerId === 'local-datacenters') centerIds.push(e.id);
|
||||
window.__polishPanFrames = [];
|
||||
window.__stopPolishPan = g.viewer.scene.postRender.addEventListener(() => {
|
||||
const sites = [],
|
||||
centers = [];
|
||||
installations.visitNamedMarkers((id) => {
|
||||
if (getOverlayPaintRect('military-installations', id)) sites.push(id);
|
||||
});
|
||||
for (const id of centerIds)
|
||||
if (getOverlayPaintRect('local-datacenters', id)) centers.push(id);
|
||||
window.__polishPanFrames.push({ t: performance.now(), sites, centers });
|
||||
});
|
||||
});
|
||||
await moveCamera(page, { lon: -99, lat: 39, height: 6500000, pitch: -90 }, 8);
|
||||
const frames = await page.evaluate(() => {
|
||||
window.__stopPolishPan();
|
||||
return window.__polishPanFrames;
|
||||
});
|
||||
const count = (key) => {
|
||||
let appeared = 0,
|
||||
disappeared = 0,
|
||||
reappeared = 0;
|
||||
const seen = new Set(frames[0][key]);
|
||||
for (let i = 1; i < frames.length; i++) {
|
||||
const previous = new Set(frames[i - 1][key]),
|
||||
next = new Set(frames[i][key]);
|
||||
frames[i][`${key}Appeared`] = [...next].filter((id) => !previous.has(id));
|
||||
frames[i][`${key}Disappeared`] = [...previous].filter(
|
||||
(id) => !next.has(id),
|
||||
);
|
||||
for (const id of frames[i][`${key}Appeared`]) {
|
||||
appeared++;
|
||||
if (seen.has(id)) reappeared++;
|
||||
seen.add(id);
|
||||
}
|
||||
disappeared += frames[i][`${key}Disappeared`].length;
|
||||
}
|
||||
const mean =
|
||||
frames.reduce((sum, f) => sum + f[key].length, 0) / frames.length;
|
||||
return {
|
||||
appeared,
|
||||
disappeared,
|
||||
reappeared,
|
||||
mean,
|
||||
eventsPerLabel: (appeared + disappeared) / mean,
|
||||
};
|
||||
};
|
||||
const result = {
|
||||
frames: frames.length,
|
||||
installations: count('sites'),
|
||||
datacenters: count('centers'),
|
||||
};
|
||||
await fs.writeFile(
|
||||
`${dir}/slow-pan-frames.json`,
|
||||
JSON.stringify(frames, null, 2),
|
||||
);
|
||||
await fs.writeFile(`${dir}/slow-pan.json`, JSON.stringify(result, null, 2));
|
||||
assert.ok(frames.length > 100);
|
||||
assert.ok(
|
||||
result.installations.mean >= 5 && result.datacenters.mean >= 5,
|
||||
'both real layers contribute visible labels on the same pan',
|
||||
);
|
||||
assert.ok(
|
||||
frames.every((f) => f.sites.length <= 24),
|
||||
'shared-domain budget cannot exceed the installation title cap',
|
||||
);
|
||||
assert.ok(
|
||||
result.installations.eventsPerLabel <=
|
||||
result.datacenters.eventsPerLabel + 0.1,
|
||||
'installation label transitions per label match Data Centers on the same slow pan',
|
||||
);
|
||||
assert.ok(
|
||||
result.installations.reappeared <= result.datacenters.reappeared,
|
||||
'installation labels do not flicker off and back on more than Data Centers',
|
||||
);
|
||||
await page.screenshot({ path: `${dir}/slow-pan-side-by-side.png` });
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('local-datacenters', false),
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
export async function checkInstallationSelection(
|
||||
page,
|
||||
dir,
|
||||
{ video = true } = {},
|
||||
) {
|
||||
const result = [];
|
||||
const recorder = video
|
||||
? await createScreencast(page, `${dir}/selection-orbit`, { fps: 24 })
|
||||
: null;
|
||||
await recorder?.start();
|
||||
try {
|
||||
for (const site of [
|
||||
{
|
||||
key: 'mabry',
|
||||
name: 'Camp Mabry',
|
||||
lon: -97.765,
|
||||
lat: 30.3125,
|
||||
height: 3500,
|
||||
},
|
||||
{
|
||||
key: 'naval',
|
||||
name: 'Naval Base San Diego',
|
||||
lon: -117.119,
|
||||
lat: 32.684,
|
||||
height: 6500,
|
||||
},
|
||||
]) {
|
||||
await moveCamera(page, { ...site, pitch: -80 }, 1.5);
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const s = window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats();
|
||||
return !s.loading && s.count > 0;
|
||||
},
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
await sleep(1500);
|
||||
const picked = await page.evaluate(async (site) => {
|
||||
const C = await import('/node_modules/cesium/Build/Cesium/index.js');
|
||||
const g = window.__godsEyeView,
|
||||
layer = g.dataManager.layers.get('military-installations').module;
|
||||
const record = layer
|
||||
.getNearby(C.Cartesian3.fromDegrees(site.lon, site.lat), 100000, 1000)
|
||||
.find((r) => r.name === site.name && r.footprints?.length);
|
||||
if (!record) throw new Error(`No polygon for ${site.name}`);
|
||||
let point;
|
||||
layer.visitNamedMarkers((id, p) => {
|
||||
if (id === record.id) point = p.position;
|
||||
});
|
||||
const screen = C.SceneTransforms.worldToWindowCoordinates(
|
||||
g.viewer.scene,
|
||||
point,
|
||||
);
|
||||
window.__polishSelectedId = record.id;
|
||||
window.__polishTitlePaints = [];
|
||||
const canvas = document.getElementById('world-overlay-canvas'),
|
||||
ctx = canvas.getContext('2d');
|
||||
const original = ctx.fillText;
|
||||
const matches = (text) =>
|
||||
String(text).toLowerCase() === site.name.toLowerCase();
|
||||
ctx.fillText = function (text, ...args) {
|
||||
if (matches(text))
|
||||
window.__polishTitlePaints.push({ t: performance.now(), text });
|
||||
return original.call(this, text, ...args);
|
||||
};
|
||||
window.__restorePolishPaint = () => {
|
||||
ctx.fillText = original;
|
||||
};
|
||||
window.__polishSelectionFrames = [];
|
||||
const { getSelectedEntityContext } =
|
||||
await import('/src/data/contextStore.js');
|
||||
const { getOverlayPaintRect, getWorldOverlayDiagnostics } =
|
||||
await import('/src/overlays/worldOverlay.js');
|
||||
const knownFills = new Set();
|
||||
const fillEntities = () => {
|
||||
const list = [];
|
||||
for (let i = 0; i < g.viewer.dataSources.length; i++)
|
||||
for (const e of g.viewer.dataSources.get(i).entities.values)
|
||||
if (e.id.startsWith(`${record.id}:selected-fill:`)) list.push(e);
|
||||
for (const e of list) knownFills.add(e);
|
||||
return list;
|
||||
};
|
||||
// Geometry-instance ids prove the ground primitive actually built, not just an entity declaration.
|
||||
const primitives = () => {
|
||||
let count = 0;
|
||||
const walk = (collection) => {
|
||||
if (collection?._collectionsArray) {
|
||||
for (const child of collection._collectionsArray) walk(child);
|
||||
return;
|
||||
}
|
||||
for (let i = 0; i < (collection?.length || 0); i++) {
|
||||
const p = collection.get(i);
|
||||
if (
|
||||
p.ready &&
|
||||
typeof p.getGeometryInstanceAttributes === 'function'
|
||||
) {
|
||||
for (const e of knownFills) {
|
||||
try {
|
||||
const a = p.getGeometryInstanceAttributes(e);
|
||||
if (a && (!a.show || a.show[0])) count++;
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
if (typeof p.get === 'function' || p._collectionsArray) walk(p);
|
||||
}
|
||||
};
|
||||
walk(g.viewer.scene.groundPrimitives);
|
||||
return count;
|
||||
};
|
||||
window.__polishFillProbe = () => ({
|
||||
entities: fillEntities().length,
|
||||
primitives: primitives(),
|
||||
classification: fillEntities().map((e) =>
|
||||
e.polygon.classificationType.getValue(),
|
||||
),
|
||||
selected: getSelectedEntityContext()?.id || null,
|
||||
});
|
||||
window.__stopPolishSelection =
|
||||
g.viewer.scene.postRender.addEventListener(() => {
|
||||
window.__polishSelectionFrames.push({
|
||||
paints: window.__polishTitlePaints.splice(0).length,
|
||||
own: Boolean(
|
||||
getOverlayPaintRect('military-installations', record.id),
|
||||
),
|
||||
tracked: Boolean(
|
||||
getOverlayPaintRect('tracked', `installations:${record.id}`),
|
||||
),
|
||||
selected: getSelectedEntityContext()?.id === record.id,
|
||||
total:
|
||||
getWorldOverlayDiagnostics().paintedBySource[
|
||||
'military-installations'
|
||||
] || 0,
|
||||
});
|
||||
});
|
||||
return {
|
||||
id: record.id,
|
||||
x: screen.x,
|
||||
y: screen.y,
|
||||
parts: record.footprints.length,
|
||||
};
|
||||
}, site);
|
||||
await page.screenshot({
|
||||
path: `${dir}/after-${site.key}-unselected.png`,
|
||||
});
|
||||
await page.mouse.click(picked.x, picked.y);
|
||||
await page
|
||||
.waitForFunction(
|
||||
() => {
|
||||
const p = window.__polishFillProbe();
|
||||
return p.selected === window.__polishSelectedId && p.primitives > 0;
|
||||
},
|
||||
{ timeout: 20000 },
|
||||
)
|
||||
.catch(async (error) => {
|
||||
await page.screenshot({ path: `${dir}/selection-failure.png` });
|
||||
const diagnostic = await page.evaluate(() => {
|
||||
const g = window.__godsEyeView;
|
||||
const describe = (p) => ({
|
||||
type: p.constructor.name,
|
||||
ready: p.ready,
|
||||
length: p.length,
|
||||
keys: Object.keys(p).filter((k) =>
|
||||
/primitive|instance|collection/i.test(k),
|
||||
),
|
||||
ids: p._instanceIds?.map((id) => id.id || String(id)),
|
||||
children:
|
||||
typeof p.get === 'function'
|
||||
? Array.from({ length: p.length }, (_, i) =>
|
||||
describe(p.get(i)),
|
||||
)
|
||||
: p._collectionsArray?.map(describe),
|
||||
});
|
||||
return {
|
||||
probe: window.__polishFillProbe(),
|
||||
stats: g.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats(),
|
||||
primitives: describe(g.viewer.scene.groundPrimitives),
|
||||
frames: window.__polishSelectionFrames.slice(-5),
|
||||
};
|
||||
});
|
||||
await fs.writeFile(
|
||||
`${dir}/selection-failure.json`,
|
||||
JSON.stringify({ picked, ...diagnostic }, null, 2),
|
||||
);
|
||||
throw error;
|
||||
});
|
||||
await sleep(500);
|
||||
const selected = await page.evaluate(() => window.__polishFillProbe());
|
||||
await page.screenshot({ path: `${dir}/after-selection-${site.key}.png` });
|
||||
// Close, oblique angles expose surface clipping and floating fills.
|
||||
for (const heading of [30, 120]) {
|
||||
await page.evaluate(
|
||||
async (site, heading) => {
|
||||
const C =
|
||||
await import('/node_modules/cesium/Build/Cesium/index.js');
|
||||
const g = window.__godsEyeView;
|
||||
const target = C.Cartesian3.fromDegrees(
|
||||
site.lon,
|
||||
site.lat,
|
||||
site.key === 'mabry' ? 180 : 10,
|
||||
);
|
||||
g.viewer.camera.lookAt(
|
||||
target,
|
||||
new C.HeadingPitchRange(
|
||||
C.Math.toRadians(heading),
|
||||
C.Math.toRadians(-30),
|
||||
800,
|
||||
),
|
||||
);
|
||||
g.viewer.camera.lookAtTransform(C.Matrix4.IDENTITY);
|
||||
},
|
||||
site,
|
||||
heading,
|
||||
);
|
||||
await sleep(1700);
|
||||
assert.ok(
|
||||
(await page.evaluate(() => window.__polishFillProbe())).selected,
|
||||
'orbit must preserve installation selection',
|
||||
);
|
||||
await page.screenshot({
|
||||
path: `${dir}/after-${site.key}-orbit-${heading}.png`,
|
||||
});
|
||||
}
|
||||
await moveCamera(page, { ...site, pitch: -80 }, 1);
|
||||
await sleep(900);
|
||||
const empty = await page.evaluate(() => {
|
||||
const g = window.__godsEyeView;
|
||||
for (let y = 250; y < 650; y += 75)
|
||||
for (let x = 400; x < 850; x += 75) {
|
||||
const pick = g.viewer.scene.pick({ x, y });
|
||||
if (!pick?.id?.installationId && !pick?.id?.gevTrackedId)
|
||||
return { x, y };
|
||||
}
|
||||
throw new Error('No empty map point');
|
||||
});
|
||||
await page.mouse.click(empty.x, empty.y);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__polishFillProbe().selected === null &&
|
||||
window.__polishFillProbe().entities === 0,
|
||||
);
|
||||
await sleep(600);
|
||||
const deselected = await page.evaluate(() => {
|
||||
window.__stopPolishSelection();
|
||||
window.__restorePolishPaint();
|
||||
return {
|
||||
...window.__polishFillProbe(),
|
||||
frames: window.__polishSelectionFrames,
|
||||
};
|
||||
});
|
||||
assert.equal(selected.entities, picked.parts);
|
||||
assert.equal(selected.primitives, picked.parts);
|
||||
assert.ok(
|
||||
selected.classification.every((c) => c === 1),
|
||||
'Google 3D tile classification',
|
||||
);
|
||||
assert.equal(deselected.entities, 0);
|
||||
assert.equal(deselected.primitives, 0);
|
||||
const selectedFrames = deselected.frames.filter(
|
||||
(f) => f.selected && f.own,
|
||||
);
|
||||
assert.ok(selectedFrames.length > 10);
|
||||
assert.ok(
|
||||
selectedFrames.every((f) => !f.tracked && f.paints === 1),
|
||||
'selected record has exactly one painted overlay element',
|
||||
);
|
||||
assert.ok(
|
||||
deselected.frames
|
||||
.slice(-5)
|
||||
.every((f) => !f.selected && f.own && !f.tracked && f.paints === 1),
|
||||
'deselect restores the one ambient entry',
|
||||
);
|
||||
await page.screenshot({
|
||||
path: `${dir}/after-${site.key}-deselected.png`,
|
||||
});
|
||||
result.push({ site, picked, selected, deselected });
|
||||
}
|
||||
} finally {
|
||||
await fs.writeFile(
|
||||
`${dir}/selection-checks.json`,
|
||||
JSON.stringify(result, null, 2),
|
||||
);
|
||||
if (recorder)
|
||||
await fs.writeFile(
|
||||
`${dir}/selection-video.json`,
|
||||
JSON.stringify(await recorder.stop(), null, 2),
|
||||
);
|
||||
}
|
||||
return result.map(({ site, picked, selected, deselected }) => ({
|
||||
site: site.name,
|
||||
id: picked.id,
|
||||
selected,
|
||||
deselected: {
|
||||
entities: deselected.entities,
|
||||
primitives: deselected.primitives,
|
||||
},
|
||||
frames: deselected.frames.length,
|
||||
}));
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
/**
|
||||
* qa-journey-recorder.mjs — shared support for journey QA gates (not a gate).
|
||||
*
|
||||
* - `createScreencast(page, dir)` records CDP `Page.startScreencast` frames
|
||||
* (every compositor frame) with their real timestamps and builds
|
||||
* `<dir>/clip.mp4` through ffmpeg's concat demuxer with per-frame
|
||||
* durations, so held frames last as long as they did on screen.
|
||||
* - `installFrameProbe(page)` measures every animation frame in the page:
|
||||
* the requestAnimationFrame interval and, for frames Cesium rendered, the
|
||||
* CPU time between `scene.preUpdate` and `scene.postRender`.
|
||||
* - `frameStats(frames)` reduces a probe window to count / mean / p50 / p95.
|
||||
* - `moveCamera(page, view, seconds)` eases the camera like a drag or wheel
|
||||
* zoom rather than teleporting it.
|
||||
*/
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
|
||||
/** Percentile of a numeric list (nearest rank); NaN for an empty list. */
|
||||
export function percentile(values, p) {
|
||||
if (!values.length) return Number.NaN;
|
||||
const sorted = [...values].sort((a, b) => a - b);
|
||||
return sorted[
|
||||
Math.min(sorted.length - 1, Math.ceil((p / 100) * sorted.length) - 1)
|
||||
];
|
||||
}
|
||||
|
||||
/** Summarize probe frames: rAF interval and Cesium render CPU time (ms). */
|
||||
export function frameStats(frames) {
|
||||
const intervals = frames.map((f) => f.dt).filter(Number.isFinite);
|
||||
const renders = frames.map((f) => f.renderMs).filter(Number.isFinite);
|
||||
const round = (v) => (Number.isFinite(v) ? Math.round(v * 10) / 10 : null);
|
||||
const mean = (list) =>
|
||||
list.length ? list.reduce((a, b) => a + b, 0) / list.length : Number.NaN;
|
||||
return {
|
||||
frames: intervals.length,
|
||||
frameMean: round(mean(intervals)),
|
||||
frameP50: round(percentile(intervals, 50)),
|
||||
frameP95: round(percentile(intervals, 95)),
|
||||
longFrames: intervals.filter((v) => v > 50).length,
|
||||
renderedFrames: renders.length,
|
||||
renderMean: round(mean(renders)),
|
||||
renderP50: round(percentile(renders, 50)),
|
||||
renderP95: round(percentile(renders, 95)),
|
||||
};
|
||||
}
|
||||
|
||||
/** Install the in-page frame probe once per document; returns nothing. */
|
||||
export async function installFrameProbe(page) {
|
||||
await page.evaluate(() => {
|
||||
if (window.__gevFrameProbe) return;
|
||||
const { viewer } = window.__godsEyeView;
|
||||
const probe = { frames: [], started: 0 };
|
||||
window.__gevFrameProbe = probe;
|
||||
let last = performance.now();
|
||||
let renderStart = null;
|
||||
let pendingRender = null;
|
||||
viewer.scene.preUpdate.addEventListener(() => {
|
||||
renderStart = performance.now();
|
||||
});
|
||||
viewer.scene.postRender.addEventListener(() => {
|
||||
if (renderStart !== null) pendingRender = performance.now() - renderStart;
|
||||
renderStart = null;
|
||||
});
|
||||
const tick = (now) => {
|
||||
probe.frames.push({ t: now, dt: now - last, renderMs: pendingRender });
|
||||
if (probe.frames.length > 40_000) probe.frames.splice(0, 10_000);
|
||||
pendingRender = null;
|
||||
last = now;
|
||||
requestAnimationFrame(tick);
|
||||
};
|
||||
requestAnimationFrame(tick);
|
||||
});
|
||||
}
|
||||
|
||||
/** Read probe frames with t in [t0, t1) (page performance.now() times). */
|
||||
export async function readFrames(page, t0, t1 = Infinity) {
|
||||
return page.evaluate(
|
||||
(a, b) =>
|
||||
window.__gevFrameProbe.frames.filter(
|
||||
(f) => f.t >= a && f.t < (b ?? Infinity),
|
||||
),
|
||||
t0,
|
||||
Number.isFinite(t1) ? t1 : null,
|
||||
);
|
||||
}
|
||||
|
||||
/** Page clock in ms (performance.now()). */
|
||||
export function pageNow(page) {
|
||||
return page.evaluate(() => performance.now());
|
||||
}
|
||||
|
||||
/**
|
||||
* Ease the camera to a view over `seconds`, resolving when it lands.
|
||||
* @param {import('puppeteer').Page} page Page.
|
||||
* @param {{lat:number, lon:number, height:number, heading?:number, pitch?:number}} view
|
||||
* Destination (degrees, metres).
|
||||
* @param {number} seconds Flight duration; 0 jumps.
|
||||
*/
|
||||
export async function moveCamera(page, view, seconds) {
|
||||
await page.evaluate(
|
||||
(v, duration) =>
|
||||
new Promise((resolve) => {
|
||||
const { viewer } = window.__godsEyeView;
|
||||
const C = viewer.camera;
|
||||
C.cancelFlight();
|
||||
C.flyTo({
|
||||
destination: viewer.scene.globe.ellipsoid.cartographicToCartesian({
|
||||
latitude: (v.lat * Math.PI) / 180,
|
||||
longitude: (v.lon * Math.PI) / 180,
|
||||
height: v.height,
|
||||
}),
|
||||
orientation: {
|
||||
heading: ((v.heading ?? 0) * Math.PI) / 180,
|
||||
pitch: ((v.pitch ?? -45) * Math.PI) / 180,
|
||||
roll: 0,
|
||||
},
|
||||
duration,
|
||||
// Straight, eased motion like a drag or wheel zoom, not an arc.
|
||||
maximumHeight: Math.max(v.height, C.positionCartographic.height),
|
||||
complete: resolve,
|
||||
cancel: resolve,
|
||||
});
|
||||
}),
|
||||
view,
|
||||
seconds,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record the page with CDP screencast frames and real per-frame timing.
|
||||
* @param {import('puppeteer').Page} page Page to record.
|
||||
* @param {string} dir Output directory (frames + clip.mp4).
|
||||
* @param {{maxWidth?: number, maxHeight?: number, quality?: number, fps?: number|null}} [options]
|
||||
*/
|
||||
export async function createScreencast(page, dir, options = {}) {
|
||||
const {
|
||||
maxWidth = 1280,
|
||||
maxHeight = 800,
|
||||
quality = 70,
|
||||
fps = null,
|
||||
} = options;
|
||||
const framesDir = path.join(dir, 'frames');
|
||||
fs.rmSync(framesDir, { recursive: true, force: true });
|
||||
fs.mkdirSync(framesDir, { recursive: true });
|
||||
const cdp = await page.createCDPSession();
|
||||
const frames = [];
|
||||
let recording = false;
|
||||
cdp.on('Page.screencastFrame', async (frame) => {
|
||||
const file = path.join(
|
||||
framesDir,
|
||||
`f${String(frames.length).padStart(5, '0')}.jpg`,
|
||||
);
|
||||
if (recording) {
|
||||
fs.writeFileSync(file, Buffer.from(frame.data, 'base64'));
|
||||
frames.push({ file, timestamp: frame.metadata.timestamp });
|
||||
}
|
||||
await cdp
|
||||
.send('Page.screencastFrameAck', { sessionId: frame.sessionId })
|
||||
.catch(() => {});
|
||||
});
|
||||
return {
|
||||
frames,
|
||||
async start() {
|
||||
recording = true;
|
||||
await cdp.send('Page.startScreencast', {
|
||||
format: 'jpeg',
|
||||
quality,
|
||||
maxWidth,
|
||||
maxHeight,
|
||||
everyNthFrame: 1,
|
||||
});
|
||||
},
|
||||
/** Stop, encode with real timing, and return clip facts. */
|
||||
async stop() {
|
||||
recording = false;
|
||||
await cdp.send('Page.stopScreencast').catch(() => {});
|
||||
await cdp.detach().catch(() => {});
|
||||
if (frames.length < 2) return { clip: null, frames: frames.length };
|
||||
const lines = [];
|
||||
for (let i = 0; i < frames.length; i++) {
|
||||
const next = frames[i + 1]?.timestamp;
|
||||
const duration = next
|
||||
? Math.min(2, Math.max(0.001, next - frames[i].timestamp))
|
||||
: 0.05;
|
||||
lines.push(`file '${path.resolve(frames[i].file)}'`);
|
||||
lines.push(`duration ${duration.toFixed(4)}`);
|
||||
}
|
||||
// The concat demuxer ignores the last duration unless the file repeats.
|
||||
lines.push(`file '${path.resolve(frames.at(-1).file)}'`);
|
||||
const list = path.join(dir, 'frames.txt');
|
||||
fs.writeFileSync(list, `${lines.join('\n')}\n`);
|
||||
const clip = path.join(dir, 'clip.mp4');
|
||||
execFileSync('ffmpeg', [
|
||||
'-y',
|
||||
'-loglevel',
|
||||
'error',
|
||||
'-f',
|
||||
'concat',
|
||||
'-safe',
|
||||
'0',
|
||||
'-i',
|
||||
list,
|
||||
'-fps_mode',
|
||||
fps ? 'cfr' : 'vfr',
|
||||
'-c:v',
|
||||
'libx264',
|
||||
'-pix_fmt',
|
||||
'yuv420p',
|
||||
'-vf',
|
||||
`scale=trunc(iw/2)*2:trunc(ih/2)*2${fps ? `,fps=${fps}` : ''}`,
|
||||
clip,
|
||||
]);
|
||||
const seconds = frames.at(-1).timestamp - frames[0].timestamp;
|
||||
return {
|
||||
clip,
|
||||
frames: frames.length,
|
||||
seconds: Math.round(seconds * 10) / 10,
|
||||
fps: Math.round((frames.length / Math.max(seconds, 0.001)) * 10) / 10,
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,485 @@
|
||||
#!/usr/bin/env node
|
||||
/** Named military areas: continent performance, close identities and a recorded zoom. */
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs/promises';
|
||||
import puppeteer from 'puppeteer';
|
||||
import {
|
||||
checkInstallationPan,
|
||||
checkInstallationSelection,
|
||||
} from './qa-installation-polish.mjs';
|
||||
import {
|
||||
createScreencast,
|
||||
installFrameProbe,
|
||||
readFrames,
|
||||
frameStats,
|
||||
pageNow,
|
||||
moveCamera,
|
||||
} from './qa-journey-recorder.mjs';
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
console.log('Usage: node scripts/qa-military-names.mjs <url> [--no-video]');
|
||||
process.exit(0);
|
||||
}
|
||||
const url = args.find((a) => /^https?:/.test(a));
|
||||
if (!url) throw new Error('Supply the running server URL');
|
||||
const dir = process.env.QA_NAMES_DIR || 'qa-shots/military-names';
|
||||
await fs.mkdir(dir, { recursive: true });
|
||||
const result = {
|
||||
views: [],
|
||||
sites: [],
|
||||
errors: [],
|
||||
forbidden: [],
|
||||
packs: [],
|
||||
video: null,
|
||||
};
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
const browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
protocolTimeout: 180000,
|
||||
args: [
|
||||
'--use-angle=metal',
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
],
|
||||
});
|
||||
let recorder;
|
||||
try {
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
page.on('pageerror', (e) => result.errors.push(e.message));
|
||||
page.on('console', (m) => {
|
||||
if (m.type() === 'error') result.errors.push(m.text());
|
||||
});
|
||||
page.on('request', (request) => {
|
||||
const u = new URL(request.url());
|
||||
if (
|
||||
/overpass/i.test(u.hostname) ||
|
||||
u.hostname === 'nominatim.openstreetmap.org'
|
||||
)
|
||||
result.forbidden.push(u.origin);
|
||||
if (u.pathname.endsWith('/osm_military_names/names.json'))
|
||||
result.packs.push(u.pathname);
|
||||
});
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
await page.goto(url + (url.includes('?') ? '&' : '?') + 'welcome=0', {
|
||||
waitUntil: 'domcontentloaded',
|
||||
});
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
result.page = await page.evaluate(() => ({
|
||||
url: location.href,
|
||||
title: document.title,
|
||||
canvas: Boolean(document.querySelector('#cesiumContainer canvas')),
|
||||
errorOverlay: Boolean(document.querySelector('vite-error-overlay')),
|
||||
}));
|
||||
assert.equal(new URL(result.page.url).origin, new URL(url).origin);
|
||||
assert.ok(
|
||||
result.page.title && result.page.canvas && !result.page.errorOverlay,
|
||||
);
|
||||
await page.evaluate(async () => {
|
||||
const g = window.__godsEyeView;
|
||||
for (const [id] of g.dataManager.layers)
|
||||
await g.dataManager.setEnabled(id, false);
|
||||
g.styleManager.setDetection({ enabled: false });
|
||||
g.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||||
});
|
||||
assert.equal(result.packs.length, 0, 'names pack stays unloaded at startup');
|
||||
result.renderer = await page.evaluate(() => {
|
||||
const gl = window.__godsEyeView.viewer.scene.context._gl;
|
||||
const ext = gl.getExtension('WEBGL_debug_renderer_info');
|
||||
return ext
|
||||
? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL)
|
||||
: gl.getParameter(gl.RENDERER);
|
||||
});
|
||||
assert.doesNotMatch(result.renderer, /swiftshader|software/i);
|
||||
await installFrameProbe(page);
|
||||
const stats = () =>
|
||||
page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats(),
|
||||
);
|
||||
const settle = async () => {
|
||||
await sleep(500);
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const s = window.__godsEyeView.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.getStats();
|
||||
return !s.loading && s.count > 0 && s.status === 'ready';
|
||||
},
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
await sleep(1200);
|
||||
};
|
||||
const us = { lon: -100, lat: 39, height: 6500000, pitch: -90 };
|
||||
await moveCamera(page, us, 0);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('military-installations', true),
|
||||
);
|
||||
await settle();
|
||||
result.credit = await page.evaluate(() => {
|
||||
const el = document.querySelector('#cesium-credits');
|
||||
return {
|
||||
text: el?.innerText || '',
|
||||
visible: Boolean(el && getComputedStyle(el).display !== 'none'),
|
||||
};
|
||||
});
|
||||
assert.match(result.credit.text, /© OpenStreetMap/);
|
||||
assert.doesNotMatch(
|
||||
result.credit.text,
|
||||
/© OpenMapTiles/,
|
||||
'wide bundled names use no vector tiles',
|
||||
);
|
||||
assert.ok(result.credit.visible);
|
||||
await page.screenshot({ path: `${dir}/credit.png` });
|
||||
for (const [name, view] of [
|
||||
['us', us],
|
||||
['europe', { lon: 12, lat: 50, height: 4500000, pitch: -90 }],
|
||||
]) {
|
||||
await moveCamera(page, view, 2);
|
||||
await settle();
|
||||
const before = await stats();
|
||||
const overlaps = await page.evaluate(async () => {
|
||||
const { getOverlayPaintRect } =
|
||||
await import('/src/overlays/worldOverlay.js');
|
||||
const layer = window.__godsEyeView.dataManager.layers.get(
|
||||
'military-installations',
|
||||
).module;
|
||||
const rects = [];
|
||||
layer.visitNamedMarkers((id) => {
|
||||
const rect = getOverlayPaintRect('military-installations', id);
|
||||
if (rect) rects.push(rect);
|
||||
});
|
||||
let overlaps = 0;
|
||||
for (let a = 0; a < rects.length; a++)
|
||||
for (let b = a + 1; b < rects.length; b++) {
|
||||
const x = rects[a],
|
||||
y = rects[b];
|
||||
if (
|
||||
x.x < y.x + y.w &&
|
||||
y.x < x.x + x.w &&
|
||||
x.y < y.y + y.h &&
|
||||
y.y < x.y + x.h
|
||||
)
|
||||
overlaps++;
|
||||
}
|
||||
return overlaps;
|
||||
});
|
||||
// Incumbents retain their placements during camera motion, as for Data Centers.
|
||||
assert.ok(
|
||||
before.namedInView > 0 &&
|
||||
before.namedMarkers > 0 &&
|
||||
before.pointsOnScreen > 0,
|
||||
);
|
||||
assert.ok(
|
||||
before.labelsOnScreen > 0 && before.labelsOnScreen <= before.labelCap,
|
||||
);
|
||||
await page.evaluate(async () => {
|
||||
// Use the governor's hold so an asynchronous idle transition cannot
|
||||
// overwrite a raw scene flag during the sustained-render measurement.
|
||||
const { holdContinuousRender } = await import('/src/renderGovernor.js');
|
||||
holdContinuousRender('qa-military-names-fps');
|
||||
});
|
||||
const t0 = await pageNow(page);
|
||||
await sleep(3500);
|
||||
const frames = await readFrames(page, t0);
|
||||
await page.evaluate(async () => {
|
||||
const { releaseContinuousRender } =
|
||||
await import('/src/renderGovernor.js');
|
||||
releaseContinuousRender('qa-military-names-fps');
|
||||
});
|
||||
const metrics = frameStats(frames);
|
||||
const seconds = frames.reduce((sum, frame) => sum + frame.dt, 0) / 1000;
|
||||
const fps = metrics.renderedFrames / seconds;
|
||||
const rafFps = metrics.frames / seconds;
|
||||
result.views.push({ name, ...before, overlaps, fps, rafFps, ...metrics });
|
||||
console.log(name, JSON.stringify(result.views.at(-1)));
|
||||
await page.screenshot({ path: `${dir}/${name}.png` });
|
||||
assert.ok(fps >= 55, `${name} fps ${fps.toFixed(1)} < 55`);
|
||||
}
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.styleManager.setCleanView(true),
|
||||
);
|
||||
await sleep(300);
|
||||
result.cleanUi = await page.evaluate(async () => {
|
||||
const host = await import('/src/overlays/worldOverlay.js');
|
||||
const root = document.getElementById('world-overlay-root');
|
||||
return {
|
||||
active: document.body.classList.contains('ui-clean-view'),
|
||||
visible: root.checkVisibility({
|
||||
visibilityProperty: true,
|
||||
opacityProperty: true,
|
||||
}),
|
||||
labels:
|
||||
host.getWorldOverlayDiagnostics().paintedBySource[
|
||||
'military-installations'
|
||||
] || 0,
|
||||
};
|
||||
});
|
||||
assert.ok(
|
||||
result.cleanUi.active &&
|
||||
result.cleanUi.visible &&
|
||||
result.cleanUi.labels > 0,
|
||||
);
|
||||
await page.screenshot({ path: `${dir}/clean-ui.png` });
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.styleManager.setCleanView(false),
|
||||
);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled(
|
||||
'military-installations',
|
||||
false,
|
||||
),
|
||||
);
|
||||
result.disabled = await page.evaluate(async () => {
|
||||
const host = await import('/src/overlays/worldOverlay.js');
|
||||
return host.getWorldOverlayDiagnostics().entriesBySource[
|
||||
'military-installations'
|
||||
];
|
||||
});
|
||||
assert.equal(result.disabled, 0);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('military-installations', true),
|
||||
);
|
||||
await moveCamera(page, us, 1);
|
||||
await settle();
|
||||
result.slowPan = await checkInstallationPan(page, dir);
|
||||
await moveCamera(page, us, 1);
|
||||
await settle();
|
||||
if (!args.includes('--no-video')) {
|
||||
recorder = await createScreencast(page, `${dir}/us-to-san-diego`, {
|
||||
fps: 24,
|
||||
});
|
||||
await recorder.start();
|
||||
}
|
||||
await page.evaluate(async () => {
|
||||
const C = await import('/node_modules/cesium/Build/Cesium/index.js');
|
||||
const { getOverlayPaintRect } =
|
||||
await import('/src/overlays/worldOverlay.js');
|
||||
const g = window.__godsEyeView;
|
||||
const layer = g.dataManager.layers.get('military-installations').module;
|
||||
const overlay = document.createElement('div');
|
||||
overlay.id = 'installation-label-probe';
|
||||
overlay.style.cssText =
|
||||
'position:fixed;top:60px;left:360px;z-index:99999;background:#07121cdd;color:#fff;padding:8px 12px;font:13px monospace;pointer-events:none';
|
||||
document.body.append(overlay);
|
||||
const screen = new C.Cartesian2();
|
||||
window.__installationFrames = [];
|
||||
window.__stopInstallationFrames =
|
||||
g.viewer.scene.postRender.addEventListener(() => {
|
||||
const stats = layer.getStats();
|
||||
const markers = [],
|
||||
labels = [],
|
||||
rects = [];
|
||||
layer.visitNamedMarkers((id, point) => {
|
||||
const rect = getOverlayPaintRect('military-installations', id);
|
||||
if (rect) rects.push(rect);
|
||||
const p = C.SceneTransforms.worldToWindowCoordinates(
|
||||
g.viewer.scene,
|
||||
point.position,
|
||||
screen,
|
||||
);
|
||||
if (
|
||||
point.show &&
|
||||
p &&
|
||||
p.x >= 0 &&
|
||||
p.y >= 0 &&
|
||||
p.x < 1280 &&
|
||||
p.y < 800
|
||||
) {
|
||||
markers.push(id);
|
||||
if (rect) labels.push(id);
|
||||
}
|
||||
});
|
||||
let overlaps = 0;
|
||||
for (let a = 0; a < rects.length; a++)
|
||||
for (let b = a + 1; b < rects.length; b++) {
|
||||
const x = rects[a],
|
||||
y = rects[b];
|
||||
if (
|
||||
x.x < y.x + y.w &&
|
||||
y.x < x.x + x.w &&
|
||||
x.y < y.y + y.h &&
|
||||
y.y < x.y + x.h
|
||||
)
|
||||
overlaps++;
|
||||
}
|
||||
const altitude = g.viewer.camera.positionCartographic.height;
|
||||
window.__installationFrames.push({
|
||||
t: performance.now(),
|
||||
altitude,
|
||||
markers,
|
||||
labels,
|
||||
paintedLabels: stats.labelsOnScreen,
|
||||
overlaps,
|
||||
loading: stats.loading,
|
||||
wide: stats.wide,
|
||||
});
|
||||
overlay.textContent = `${(altitude / 1000).toFixed(1)} km | markers ${markers.length} | labels ${labels.length} / 24`;
|
||||
});
|
||||
});
|
||||
const clipStart = await pageNow(page);
|
||||
await sleep(1200);
|
||||
for (const view of [
|
||||
{ lon: -116, lat: 35, height: 1500000, pitch: -85 },
|
||||
{ lon: -117.2, lat: 33, height: 200000, pitch: -80 },
|
||||
{ lon: -117.1, lat: 32.86, height: 18000, pitch: -80 },
|
||||
]) {
|
||||
await moveCamera(page, view, 3);
|
||||
await sleep(800);
|
||||
}
|
||||
await settle();
|
||||
await sleep(1500);
|
||||
result.clipFrames = await readFrames(page, clipStart);
|
||||
result.labelFrames = await page.evaluate(() => {
|
||||
window.__stopInstallationFrames();
|
||||
document.getElementById('installation-label-probe').remove();
|
||||
return window.__installationFrames;
|
||||
});
|
||||
await fs.writeFile(
|
||||
`${dir}/label-frames.json`,
|
||||
JSON.stringify(result.labelFrames, null, 2),
|
||||
);
|
||||
assert.ok(result.labelFrames.length > 100);
|
||||
assert.ok(
|
||||
result.labelFrames.every(
|
||||
(frame) =>
|
||||
frame.markers.length > 0 &&
|
||||
frame.labels.length > 0 &&
|
||||
frame.paintedLabels > 0 &&
|
||||
frame.paintedLabels <= 24,
|
||||
),
|
||||
'zoom never loses all visible named markers or labels',
|
||||
);
|
||||
if (recorder) {
|
||||
result.video = await recorder.stop();
|
||||
recorder = null;
|
||||
}
|
||||
result.selection = await checkInstallationSelection(page, dir, {
|
||||
video: !args.includes('--no-video'),
|
||||
});
|
||||
const sites = [
|
||||
['mabry', 'Camp Mabry', -97.765, 30.3125, 3500],
|
||||
['pendleton', 'Marine Corps Base Camp Pendleton', -117.4, 33.33, 25000],
|
||||
['miramar', 'Marine Corps Air Station Miramar', -117.14, 32.87, 18000],
|
||||
['ramstein', 'Ramstein Air Base', 7.6, 49.44, 7000],
|
||||
['lakenheath', 'RAF Lakenheath', 0.56, 52.41, 7000],
|
||||
['hood', 'Fort Hood', -97.78, 31.135, 30000],
|
||||
];
|
||||
for (const [key, expected, lon, lat, height] of sites) {
|
||||
await moveCamera(page, { lon, lat, height, pitch: -80 }, 1.5);
|
||||
await settle();
|
||||
const snapshot = await page.evaluate(
|
||||
(lat, lon) => {
|
||||
const g = window.__godsEyeView;
|
||||
const layer = g.dataManager.layers.get('military-installations').module;
|
||||
const position = g.viewer.scene.globe.ellipsoid.cartographicToCartesian(
|
||||
{
|
||||
longitude: (lon * Math.PI) / 180,
|
||||
latitude: (lat * Math.PI) / 180,
|
||||
height: 0,
|
||||
},
|
||||
);
|
||||
return {
|
||||
stats: layer.getStats(),
|
||||
records: layer.getNearby(position, 100000, 1000).map((r) => ({
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
memberNames: r.memberNames || [],
|
||||
hasPolygon: Boolean(r.footprints?.length),
|
||||
})),
|
||||
};
|
||||
},
|
||||
lat,
|
||||
lon,
|
||||
);
|
||||
result.sites.push({ key, expected, ...snapshot });
|
||||
assert.equal(
|
||||
new Set(snapshot.records.map((r) => r.id)).size,
|
||||
snapshot.records.length,
|
||||
);
|
||||
assert.ok(
|
||||
snapshot.stats.labelsOnScreen > 0 &&
|
||||
snapshot.stats.labelsOnScreen <= snapshot.stats.labelCap,
|
||||
);
|
||||
assert.ok(
|
||||
snapshot.records.some((r) => r.name === expected && r.hasPolygon),
|
||||
`${key}: missing named polygon ${expected}; got ${snapshot.records.map((r) => r.name).join(', ')}`,
|
||||
);
|
||||
await page.screenshot({ path: `${dir}/${key}.png` });
|
||||
console.log(key, expected);
|
||||
}
|
||||
await page.evaluate(() => {
|
||||
if (
|
||||
document
|
||||
.getElementById('global-context-panel')
|
||||
.classList.contains('collapsed')
|
||||
)
|
||||
document
|
||||
.querySelector('[data-collapse-target="global-context-panel"]')
|
||||
.click();
|
||||
});
|
||||
await page.waitForSelector('#global-context-flights-btn', { visible: true });
|
||||
await page.evaluate(() => {
|
||||
const button = document.getElementById('global-context-flights-btn');
|
||||
if (button.getAttribute('aria-selected') !== 'true') button.click();
|
||||
});
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const state = window.__godsEyeView.styleManager.getContextModeState();
|
||||
return state.mode === 'flights' && !state.changing;
|
||||
},
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
result.card = await page.evaluate(() => {
|
||||
const g = window.__godsEyeView;
|
||||
return g.dataManager.layers
|
||||
.get('military-installations')
|
||||
.module.focusById('osm:military:r13529728');
|
||||
});
|
||||
assert.equal(result.card, true);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
document
|
||||
.getElementById('military-awareness-panel')
|
||||
?.textContent.includes('Named areas') &&
|
||||
document
|
||||
.getElementById('military-awareness-panel')
|
||||
.checkVisibility({ visibilityProperty: true, opacityProperty: true }),
|
||||
{ timeout: 15000 },
|
||||
);
|
||||
result.cardText = await page.$eval(
|
||||
'#military-awareness-panel',
|
||||
(el) => el.textContent,
|
||||
);
|
||||
assert.match(result.cardText, /Fort Hood/);
|
||||
assert.match(result.cardText, /TA-25/);
|
||||
await sleep(1800);
|
||||
await page.$eval(
|
||||
'#military-awareness-panel .military-awareness-names',
|
||||
(el) => {
|
||||
el.open = true;
|
||||
},
|
||||
);
|
||||
await page.screenshot({ path: `${dir}/member-names-card.png` });
|
||||
assert.equal(result.packs.length, 1, 'single lazy asset fetch');
|
||||
assert.deepEqual(result.forbidden, []);
|
||||
assert.deepEqual(result.errors, []);
|
||||
} finally {
|
||||
if (recorder)
|
||||
result.video = await recorder.stop().catch((e) => ({ error: e.message }));
|
||||
await fs.writeFile(`${dir}/result.json`, JSON.stringify(result, null, 2));
|
||||
await browser.close();
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,362 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Keyless terrain throttling probe.
|
||||
*
|
||||
* On the keyless map source the browser fetches Re:Earth quantized-mesh tiles
|
||||
* (`terrain.reearth.land/cesium-mesh/ellipsoid/{z}/{x}/{y}.terrain`) directly.
|
||||
* A zoom-out burst asks for a few dozen shallow tiles at once and the upstream
|
||||
* answers HTTP 429 for most of them. This harness drives that burst, counts the
|
||||
* throttled responses, keeps the first 429's headers as evidence, and then
|
||||
* checks whether every throttled tile eventually loaded — the contract the
|
||||
* client-side retry in `src/maps/terrain.js` provides.
|
||||
*
|
||||
* Run against a keyless dev server (no Google or ion credentials):
|
||||
* env -u GOOGLE_MAPS_API_KEY -u CESIUM_ION_TOKEN npm run dev -- --port 4180
|
||||
* QA_BASE_URL=http://localhost:4180 node scripts/qa-terrain-429.mjs
|
||||
*
|
||||
* Flags: `--mode zoomOut|wheel` (default zoomOut), `--notches N` (default 12),
|
||||
* `--settle MS` (default 25000), `--rounds N` (default 1), `--inject N`
|
||||
* (answer the first N tile requests of each burst with a synthetic 429),
|
||||
* `--headful`.
|
||||
* Exits 1 when a throttled tile never recovered or a terrain tile is left in
|
||||
* Cesium's FAILED state.
|
||||
*/
|
||||
import fs from 'node:fs';
|
||||
import puppeteer from 'puppeteer';
|
||||
|
||||
const appUrl = process.env.QA_BASE_URL || 'http://localhost:4173';
|
||||
const argv = process.argv.slice(2);
|
||||
const flag = (name, fallback) => {
|
||||
const index = argv.indexOf(`--${name}`);
|
||||
return index >= 0 && argv[index + 1] !== undefined
|
||||
? argv[index + 1]
|
||||
: fallback;
|
||||
};
|
||||
const mode = flag('mode', 'zoomOut');
|
||||
const notches = Number(flag('notches', 12));
|
||||
const settleMs = Number(flag('settle', 25000));
|
||||
const rounds = Number(flag('rounds', 1));
|
||||
// The upstream throttle is load-dependent and does not fire on demand. With
|
||||
// `--inject N`, the first N tile requests of each burst are answered 429 by an
|
||||
// XMLHttpRequest shim inside the page so the recovery contract can be proven
|
||||
// deterministically; real 429s are still counted and kept as evidence. (CDP
|
||||
// request interception is not used: it stalls Cesium's request scheduler.)
|
||||
const inject = Number(flag('inject', 0));
|
||||
const headful = argv.includes('--headful');
|
||||
const TERRAIN_HOST = 'terrain.reearth.land';
|
||||
const TILE_PATTERN = /\/cesium-mesh\/ellipsoid\/\d+\/\d+\/\d+\.terrain/;
|
||||
|
||||
const executablePath =
|
||||
process.env.PUPPETEER_EXECUTABLE_PATH ||
|
||||
(await puppeteer.executablePath().catch(() => null));
|
||||
if (!executablePath || !fs.existsSync(executablePath)) {
|
||||
throw new Error('Puppeteer Chrome for Testing is unavailable');
|
||||
}
|
||||
|
||||
const browser = await puppeteer.launch({
|
||||
headless: headful ? false : 'new',
|
||||
executablePath,
|
||||
args: [
|
||||
...(process.platform === 'darwin'
|
||||
? ['--use-angle=metal', '--enable-gpu']
|
||||
: ['--use-gl=angle', '--use-angle=swiftshader']),
|
||||
'--no-sandbox',
|
||||
],
|
||||
});
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
|
||||
/** @type {Map<string, {statuses: number[], failures: number}>} per tile URL. */
|
||||
const tiles = new Map();
|
||||
const evidence = [];
|
||||
let layerJsonSeen = false;
|
||||
let recording = false;
|
||||
let requestsInWindow = 0;
|
||||
let throttledInWindow = 0;
|
||||
const tileEntry = (url) => {
|
||||
if (!tiles.has(url)) tiles.set(url, { statuses: [], failures: 0 });
|
||||
return tiles.get(url);
|
||||
};
|
||||
|
||||
if (inject > 0) {
|
||||
// Cesium fetches terrain through XMLHttpRequest and reads status, response
|
||||
// and getAllResponseHeaders() in its onload handler; shadowing those on the
|
||||
// instance is enough to make it see a throttled reply.
|
||||
await page.evaluateOnNewDocument((pattern) => {
|
||||
const tilePattern = new RegExp(pattern);
|
||||
const shim = { remaining: 0, injected: [] };
|
||||
window.__qaTerrainThrottle = shim;
|
||||
const open = XMLHttpRequest.prototype.open;
|
||||
const send = XMLHttpRequest.prototype.send;
|
||||
XMLHttpRequest.prototype.open = function (method, url, ...rest) {
|
||||
this.__qaUrl = String(url);
|
||||
return open.call(this, method, url, ...rest);
|
||||
};
|
||||
XMLHttpRequest.prototype.send = function (...args) {
|
||||
if (!(shim.remaining > 0 && tilePattern.test(this.__qaUrl || ''))) {
|
||||
return send.apply(this, args);
|
||||
}
|
||||
shim.remaining -= 1;
|
||||
shim.injected.push(this.__qaUrl);
|
||||
const xhr = this;
|
||||
setTimeout(() => {
|
||||
for (const [key, value] of [
|
||||
['status', 429],
|
||||
['readyState', 4],
|
||||
['response', null],
|
||||
]) {
|
||||
Object.defineProperty(xhr, key, { value, configurable: true });
|
||||
}
|
||||
xhr.getAllResponseHeaders = () => 'retry-after: 1\r\n';
|
||||
xhr.onload?.(new Event('load'));
|
||||
}, 30);
|
||||
return undefined;
|
||||
};
|
||||
}, TILE_PATTERN.source);
|
||||
}
|
||||
|
||||
page.on('response', async (response) => {
|
||||
const url = response.url();
|
||||
if (!url.includes(TERRAIN_HOST)) return;
|
||||
if (url.endsWith('layer.json')) layerJsonSeen = true;
|
||||
if (!TILE_PATTERN.test(url)) return;
|
||||
const status = response.status();
|
||||
tileEntry(url).statuses.push(status);
|
||||
if (recording) requestsInWindow += 1;
|
||||
if (status !== 429) return;
|
||||
if (recording) throttledInWindow += 1;
|
||||
if (evidence.length < 3) {
|
||||
let body = '';
|
||||
try {
|
||||
body = (await response.text()).slice(0, 160);
|
||||
} catch {
|
||||
/* body unavailable */
|
||||
}
|
||||
evidence.push({ url, status, headers: response.headers(), body });
|
||||
}
|
||||
});
|
||||
page.on('requestfailed', (request) => {
|
||||
const url = request.url();
|
||||
if (!TILE_PATTERN.test(url)) return;
|
||||
tileEntry(url).failures += 1;
|
||||
if (recording) requestsInWindow += 1;
|
||||
});
|
||||
|
||||
const consoleErrors = [];
|
||||
page.on('pageerror', (error) => consoleErrors.push(error.message));
|
||||
page.on('console', (message) => {
|
||||
if (message.type() === 'error') consoleErrors.push(message.text());
|
||||
});
|
||||
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
const waitFor = async (predicate, timeoutMs, label) => {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (await predicate()) return;
|
||||
await sleep(250);
|
||||
}
|
||||
throw new Error(`timed out waiting for ${label}`);
|
||||
};
|
||||
|
||||
const setCamera = (lon, lat, height) =>
|
||||
page.evaluate(
|
||||
({ lon, lat, height }) => {
|
||||
const viewer = window.__godsEyeView.viewer;
|
||||
// The app's own startup flight would otherwise keep steering the camera
|
||||
// through the burst and turn the zoom-out into a zoom-in.
|
||||
viewer.camera.cancelFlight();
|
||||
const cartographic =
|
||||
viewer.camera.positionCartographic.constructor.fromDegrees(
|
||||
lon,
|
||||
lat,
|
||||
height,
|
||||
);
|
||||
viewer.camera.setView({
|
||||
destination:
|
||||
viewer.scene.globe.ellipsoid.cartographicToCartesian(cartographic),
|
||||
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
|
||||
});
|
||||
window.__godsEyeView.requestRender?.();
|
||||
},
|
||||
{ lon, lat, height },
|
||||
);
|
||||
|
||||
const cameraHeight = () =>
|
||||
page.evaluate(
|
||||
() => window.__godsEyeView.viewer.camera.positionCartographic.height,
|
||||
);
|
||||
|
||||
const globeState = () =>
|
||||
page.evaluate(() => {
|
||||
const viewer = window.__godsEyeView.viewer;
|
||||
const surface = viewer.scene.globe._surface;
|
||||
let failed = 0;
|
||||
let loaded = 0;
|
||||
const visit = (tile) => {
|
||||
if (!tile) return;
|
||||
const state = tile.data?.terrainState;
|
||||
if (state === 0) failed += 1;
|
||||
else if (state === 6) loaded += 1;
|
||||
for (const child of tile._children || []) visit(child);
|
||||
};
|
||||
for (const tile of surface._levelZeroTiles || []) visit(tile);
|
||||
return {
|
||||
failed,
|
||||
loaded,
|
||||
tilesLoaded: viewer.scene.globe.tilesLoaded,
|
||||
provider: viewer.terrainProvider?.constructor?.name,
|
||||
};
|
||||
});
|
||||
|
||||
const burst = async () => {
|
||||
if (mode === 'zoomOut') {
|
||||
for (let i = 0; i < notches; i += 1) {
|
||||
await page.evaluate(() => {
|
||||
const viewer = window.__godsEyeView.viewer;
|
||||
viewer.camera.zoomOut(viewer.camera.positionCartographic.height * 0.6);
|
||||
window.__godsEyeView.requestRender?.();
|
||||
});
|
||||
await sleep(40);
|
||||
}
|
||||
return;
|
||||
}
|
||||
await page.mouse.move(640, 400);
|
||||
for (let i = 0; i < notches; i += 1) {
|
||||
await page.mouse.wheel({ deltaY: 200 });
|
||||
await page.evaluate(() => window.__godsEyeView.requestRender?.());
|
||||
await sleep(40);
|
||||
}
|
||||
};
|
||||
|
||||
try {
|
||||
await page.goto(appUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
|
||||
await page.waitForFunction(() => Boolean(window.__godsEyeView?.viewer), {
|
||||
timeout: 60000,
|
||||
});
|
||||
await waitFor(() => layerJsonSeen, 60000, 'the Re:Earth layer.json fetch');
|
||||
await waitFor(
|
||||
async () => (await globeState()).provider === 'CesiumTerrainProvider',
|
||||
30000,
|
||||
'the keyless terrain provider',
|
||||
);
|
||||
|
||||
const summaries = [];
|
||||
for (let round = 1; round <= rounds; round += 1) {
|
||||
// Re-apply the view until it sticks: a still-running startup flight can
|
||||
// overwrite the first setView on the very next frame.
|
||||
for (let attempt = 0; attempt < 5; attempt += 1) {
|
||||
await setCamera(-97.7431, 30.2672, 40000);
|
||||
await sleep(1500);
|
||||
const height = await cameraHeight();
|
||||
if (Math.abs(height - 40000) < 1000) break;
|
||||
}
|
||||
await waitFor(
|
||||
async () => (await globeState()).tilesLoaded,
|
||||
30000,
|
||||
'the 40 km view to settle',
|
||||
).catch(() => {});
|
||||
await sleep(2000);
|
||||
const settledHeight = await cameraHeight();
|
||||
if (Math.abs(settledHeight - 40000) > 1000) {
|
||||
throw new Error(
|
||||
`camera did not hold the 40 km start view (at ${Math.round(settledHeight)} m)`,
|
||||
);
|
||||
}
|
||||
const before = await globeState();
|
||||
tiles.clear();
|
||||
requestsInWindow = 0;
|
||||
throttledInWindow = 0;
|
||||
if (inject > 0) {
|
||||
await page.evaluate((count) => {
|
||||
window.__qaTerrainThrottle.remaining = count;
|
||||
window.__qaTerrainThrottle.injected = [];
|
||||
}, inject);
|
||||
}
|
||||
recording = true;
|
||||
const startHeight = await cameraHeight();
|
||||
await burst();
|
||||
const endHeight = await cameraHeight();
|
||||
await sleep(settleMs);
|
||||
recording = false;
|
||||
|
||||
// Injected throttles never reach the network, so fold them in from the
|
||||
// page: a later real 200 for the same tile is the retry succeeding.
|
||||
const injected =
|
||||
inject > 0
|
||||
? await page.evaluate(() => window.__qaTerrainThrottle.injected)
|
||||
: [];
|
||||
for (const url of injected) tileEntry(url).statuses.unshift(429);
|
||||
const throttled = [...tiles.entries()].filter(([, entry]) =>
|
||||
entry.statuses.includes(429),
|
||||
);
|
||||
const recovered = throttled.filter(([, entry]) =>
|
||||
entry.statuses.includes(200),
|
||||
);
|
||||
const unrecovered = throttled.filter(
|
||||
([, entry]) => !entry.statuses.includes(200),
|
||||
);
|
||||
const after = await globeState();
|
||||
summaries.push({
|
||||
round,
|
||||
mode,
|
||||
notches,
|
||||
startHeightKm: Math.round(startHeight / 1000),
|
||||
endHeightKm: Math.round(endHeight / 1000),
|
||||
tileResponses: requestsInWindow,
|
||||
throttledResponses: throttledInWindow,
|
||||
injectedThrottles: injected.length,
|
||||
throttledTiles: throttled.length,
|
||||
recoveredTiles: recovered.length,
|
||||
unrecoveredTiles: unrecovered.length,
|
||||
failedTilesBefore: before.failed,
|
||||
failedTilesAfter: after.failed,
|
||||
loadedTilesAfter: after.loaded,
|
||||
});
|
||||
console.log(JSON.stringify(summaries.at(-1)));
|
||||
if (unrecovered.length) {
|
||||
console.log(
|
||||
' unrecovered: ' +
|
||||
unrecovered
|
||||
.slice(0, 8)
|
||||
.map(
|
||||
([url, entry]) =>
|
||||
`${new URL(url).pathname} [${entry.statuses.join(',')}]`,
|
||||
)
|
||||
.join(' · '),
|
||||
);
|
||||
}
|
||||
}
|
||||
if (evidence.length) {
|
||||
console.log('first 429 evidence:');
|
||||
for (const item of evidence) {
|
||||
const headers = Object.fromEntries(
|
||||
Object.entries(item.headers).filter(([name]) =>
|
||||
/^(cf-|retry-after|server|content-type|date|x-ratelimit|ratelimit|access-control)/i.test(
|
||||
name,
|
||||
),
|
||||
),
|
||||
);
|
||||
console.log(
|
||||
` ${new URL(item.url).pathname} ${JSON.stringify(headers)} body=${JSON.stringify(item.body)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
const failures = summaries.filter(
|
||||
(summary) => summary.unrecoveredTiles > 0 || summary.failedTilesAfter > 0,
|
||||
);
|
||||
const terrainErrors = consoleErrors.filter((text) =>
|
||||
/terrain tile/i.test(text),
|
||||
);
|
||||
if (terrainErrors.length) {
|
||||
console.log(`terrain console errors: ${terrainErrors.length}`);
|
||||
console.log(` ${terrainErrors[0].slice(0, 200)}`);
|
||||
}
|
||||
console.log(
|
||||
failures.length
|
||||
? `FAIL — ${failures.length}/${summaries.length} round(s) left throttled terrain tiles unloaded`
|
||||
: `PASS — every throttled terrain tile recovered in ${summaries.length} round(s)`,
|
||||
);
|
||||
process.exitCode = failures.length ? 1 : 0;
|
||||
} finally {
|
||||
await browser.close();
|
||||
}
|
||||
@@ -0,0 +1,533 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Traffic motion acceptance: real-GPU Puppeteer, stable identities, stationary
|
||||
* camera holds and timestamped CDP JPEGs encoded with ffmpeg. No tile mocks.
|
||||
* Run: node scripts/qa-traffic-motion.mjs http://localhost:4186
|
||||
* --baseline records the unmodified pre-fix implementation (object identities
|
||||
* via WeakMap, never collection indices); it reports failures without exiting 1.
|
||||
* --mode=tomtom|osm|hybrid limits a diagnostic run. --tag=name keeps captures.
|
||||
* --journey follows a neighborhood-to-city route with layer toggles, then
|
||||
* checks Capitol/greenbelt/parking/corridor views against a 1.5 s limit.
|
||||
*/
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import puppeteer from 'puppeteer';
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-traffic-motion.mjs <url> [--baseline] [--mode=tomtom|osm|hybrid] [--tag=name] [--journey]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const url = args.find((a) => /^https?:/.test(a));
|
||||
if (!url) throw new Error('A running dev server URL is required');
|
||||
const baseline = args.includes('--baseline');
|
||||
const journey = args.includes('--journey');
|
||||
const option = (key) =>
|
||||
args.find((a) => a.startsWith(`--${key}=`))?.split('=')[1];
|
||||
const modes = option('mode') ? [option('mode')] : ['tomtom', 'osm', 'hybrid'];
|
||||
if (modes.some((m) => !['tomtom', 'osm', 'hybrid'].includes(m)))
|
||||
throw new Error('Invalid road mode');
|
||||
const root = path.resolve(
|
||||
'qa-shots/motion',
|
||||
option('tag') || (baseline ? 'before' : '.'),
|
||||
);
|
||||
fs.mkdirSync(root, { recursive: true });
|
||||
const revision = execFileSync('git', ['rev-parse', 'HEAD'], {
|
||||
encoding: 'utf8',
|
||||
}).trim();
|
||||
const browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
protocolTimeout: 300000,
|
||||
args: [
|
||||
'--use-angle=metal',
|
||||
'--window-size=1280,800',
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
],
|
||||
});
|
||||
const results = [];
|
||||
const delay = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
try {
|
||||
for (const mode of modes) {
|
||||
const dir = path.join(root, mode);
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
const page = await browser.newPage();
|
||||
const errors = [],
|
||||
forbidden = [],
|
||||
logs = [],
|
||||
tileRequests = [];
|
||||
page.on('pageerror', (e) => errors.push(e.message));
|
||||
page.on('console', (m) => {
|
||||
if (m.type() === 'error') errors.push(m.text());
|
||||
if (m.text().startsWith('[Data:Traffic]')) logs.push(m.text());
|
||||
});
|
||||
page.on('request', (r) => {
|
||||
const u = new URL(r.url());
|
||||
if (
|
||||
u.hostname === 'tiles.openfreemap.org' &&
|
||||
/\/\d+\/\d+\/\d+(?:\.pbf)?$/.test(u.pathname)
|
||||
)
|
||||
tileRequests.push(u.pathname);
|
||||
if (
|
||||
/overpass/i.test(u.hostname) ||
|
||||
u.hostname === 'nominatim.openstreetmap.org'
|
||||
)
|
||||
forbidden.push(u.hostname);
|
||||
});
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
const u = new URL(url);
|
||||
u.searchParams.set('trafficRoads', mode);
|
||||
u.searchParams.set('trafficDebug', '1');
|
||||
await page.goto(u.href, { waitUntil: 'domcontentloaded', timeout: 60000 });
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await page.evaluate(() => {
|
||||
const g = window.__godsEyeView;
|
||||
g.styleManager.setDetection({ enabled: false });
|
||||
for (const [id] of g.dataManager.layers)
|
||||
g.dataManager.setEnabled(id, false);
|
||||
g.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||||
});
|
||||
const identity = await page.evaluate(() => ({
|
||||
title: document.title,
|
||||
text: document.body.innerText.length,
|
||||
overlay: Boolean(document.querySelector('vite-error-overlay')),
|
||||
}));
|
||||
await page.evaluate((baseline) => {
|
||||
const { viewer, dataManager } = window.__godsEyeView;
|
||||
const layer = dataManager.layers.get('traffic').module;
|
||||
if (!baseline && typeof layer.visitMotionDots !== 'function')
|
||||
throw new Error('Traffic must expose stable dot identities');
|
||||
const scene = viewer.scene;
|
||||
const weakIds = new WeakMap();
|
||||
let nextId = 0,
|
||||
rebuilds = 0;
|
||||
const collections = [];
|
||||
function discoverCollections() {
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const p = scene.primitives.get(i);
|
||||
if (!Array.isArray(p._pointPrimitives) || collections.includes(p))
|
||||
continue;
|
||||
collections.push(p);
|
||||
const removeAll = p.removeAll;
|
||||
p.removeAll = function () {
|
||||
if (this.length) rebuilds++;
|
||||
return removeAll.call(this);
|
||||
};
|
||||
}
|
||||
}
|
||||
let previous = new Map(),
|
||||
previousN = 0,
|
||||
lastRebuilds = 0,
|
||||
lastTime = 0;
|
||||
const rows = [];
|
||||
window.__motion = {
|
||||
rows,
|
||||
active: false,
|
||||
moveEnds: [],
|
||||
label: 'camera moving',
|
||||
holdStart: null,
|
||||
};
|
||||
const clock = document.createElement('div');
|
||||
clock.style.cssText =
|
||||
'position:fixed;bottom:4px;left:38%;padding:3px 8px;background:#000c;color:#fff;font:12px monospace;z-index:999999;pointer-events:none';
|
||||
document.body.append(clock);
|
||||
viewer.camera.moveEnd.addEventListener(() =>
|
||||
window.__motion.moveEnds.push(performance.now()),
|
||||
);
|
||||
scene.postRender.addEventListener(() => {
|
||||
if (!window.__motion.active) return;
|
||||
discoverCollections();
|
||||
const now = performance.now(),
|
||||
points = new Map();
|
||||
clock.textContent =
|
||||
`QA: ${window.__motion.label}` +
|
||||
(window.__motion.holdStart === null
|
||||
? ''
|
||||
: ` | camera stopped +${((now - window.__motion.holdStart) / 1000).toFixed(1)}s`);
|
||||
const visit = (id, roadId, point) => {
|
||||
if (!point.show) return;
|
||||
const s = scene.cartesianToCanvasCoordinates(point.position);
|
||||
if (s && s.x >= 0 && s.y >= 0 && s.x <= 1280 && s.y <= 800)
|
||||
points.set(id, { x: s.x, y: s.y, roadId });
|
||||
};
|
||||
let n = 0,
|
||||
offRoad = 0;
|
||||
if (!baseline && layer.visitMotionDots) {
|
||||
layer.visitMotionDots((id, roadId, point, road) => {
|
||||
if (point.show) {
|
||||
const p = road?.roadProperties;
|
||||
const allowed = road?.directFlow
|
||||
? [
|
||||
'Motorway',
|
||||
'International road',
|
||||
'Major road',
|
||||
'Secondary road',
|
||||
'Connecting road',
|
||||
'Major local road',
|
||||
'Local road',
|
||||
'Minor local road',
|
||||
].includes(p?.roadType)
|
||||
: [
|
||||
'motorway',
|
||||
'trunk',
|
||||
'primary',
|
||||
'secondary',
|
||||
'tertiary',
|
||||
'minor',
|
||||
].includes(p?.class) &&
|
||||
!p?.service &&
|
||||
!p?.subclass &&
|
||||
!['no', 'private'].includes(p?.access) &&
|
||||
p?.brunnel !== 'tunnel';
|
||||
if (!allowed) offRoad++;
|
||||
}
|
||||
if (point.show) n++;
|
||||
visit(id, roadId, point);
|
||||
});
|
||||
} else {
|
||||
for (const coll of collections)
|
||||
if (coll.show)
|
||||
for (let i = 0; i < coll.length; i++) {
|
||||
const p = coll.get(i);
|
||||
if (!weakIds.has(p)) weakIds.set(p, ++nextId);
|
||||
if (p.show) n++;
|
||||
visit(weakIds.get(p), null, p);
|
||||
}
|
||||
}
|
||||
let tracked = 0,
|
||||
jumps = 0,
|
||||
reassigned = 0,
|
||||
births = 0,
|
||||
deaths = 0;
|
||||
for (const [id, p] of points) {
|
||||
const prev = previous.get(id);
|
||||
if (!prev) {
|
||||
births++;
|
||||
continue;
|
||||
}
|
||||
tracked++;
|
||||
if (Math.hypot(p.x - prev.x, p.y - prev.y) > 30) jumps++;
|
||||
if (p.roadId !== prev.roadId) reassigned++;
|
||||
}
|
||||
for (const id of previous.keys()) if (!points.has(id)) deaths++;
|
||||
rows.push({
|
||||
t: now,
|
||||
loading: layer.getStats().loading,
|
||||
syncing:
|
||||
document
|
||||
.getElementById('traffic-sync-chip')
|
||||
?.classList.contains('visible') &&
|
||||
document.getElementById('traffic-sync-progress')?.textContent ===
|
||||
'...',
|
||||
surfacePending: layer.getStats().surfacePending,
|
||||
offRoad,
|
||||
dt: now - lastTime,
|
||||
n,
|
||||
visible: points.size,
|
||||
tracked,
|
||||
jumps,
|
||||
jumpFrac: tracked ? jumps / tracked : 0,
|
||||
reassigned,
|
||||
births,
|
||||
deaths,
|
||||
sizeChanged: n !== previousN,
|
||||
rebuilds: rebuilds - lastRebuilds,
|
||||
});
|
||||
previous = points;
|
||||
previousN = n;
|
||||
lastRebuilds = rebuilds;
|
||||
lastTime = now;
|
||||
});
|
||||
}, baseline);
|
||||
const fly = (lat, lon, height, pitch, duration, heading = 20) =>
|
||||
page.evaluate(
|
||||
async (v) => {
|
||||
const { viewer } = window.__godsEyeView;
|
||||
window.__motion.label = 'camera moving';
|
||||
window.__motion.holdStart = null;
|
||||
viewer.camera.cancelFlight();
|
||||
await new Promise((resolve) =>
|
||||
viewer.camera.flyTo({
|
||||
destination: viewer.scene.globe.ellipsoid.cartographicToCartesian(
|
||||
{
|
||||
latitude: (v.lat * Math.PI) / 180,
|
||||
longitude: (v.lon * Math.PI) / 180,
|
||||
height: v.height,
|
||||
},
|
||||
),
|
||||
orientation: {
|
||||
heading: (v.heading * Math.PI) / 180,
|
||||
pitch: (v.pitch * Math.PI) / 180,
|
||||
roll: 0,
|
||||
},
|
||||
duration: v.duration,
|
||||
complete: resolve,
|
||||
cancel: resolve,
|
||||
}),
|
||||
);
|
||||
},
|
||||
{ lat, lon, height, pitch, duration, heading },
|
||||
);
|
||||
const cdp = await page.createCDPSession();
|
||||
let fi = 0;
|
||||
const frames = [];
|
||||
cdp.on('Page.screencastFrame', (f) => {
|
||||
const name = `f${String(fi++).padStart(5, '0')}.jpg`;
|
||||
fs.writeFileSync(path.join(dir, name), Buffer.from(f.data, 'base64'));
|
||||
frames.push({ name, timestamp: f.metadata.timestamp });
|
||||
cdp
|
||||
.send('Page.screencastFrameAck', { sessionId: f.sessionId })
|
||||
.catch(() => {});
|
||||
});
|
||||
await fly(
|
||||
...(journey
|
||||
? [30.25, -97.7497, 700, -40, 0, 10]
|
||||
: [30.2685, -97.7425, 450, -35, 0]),
|
||||
);
|
||||
await cdp.send('Page.startScreencast', {
|
||||
format: 'jpeg',
|
||||
quality: 65,
|
||||
maxWidth: 1280,
|
||||
maxHeight: 800,
|
||||
everyNthFrame: journey ? 1 : 3,
|
||||
});
|
||||
await page.evaluate(() => {
|
||||
window.__motion.active = true;
|
||||
});
|
||||
const holds = [];
|
||||
const hold = async (name, warm = false, holdMs = 10000, empty = false) => {
|
||||
const start = await page.evaluate((label) => {
|
||||
const start = performance.now();
|
||||
window.__motion.label = label;
|
||||
window.__motion.holdStart = start;
|
||||
return start;
|
||||
}, name);
|
||||
await delay(holdMs);
|
||||
const end = await page.evaluate(() => performance.now());
|
||||
holds.push({
|
||||
name,
|
||||
warm,
|
||||
start,
|
||||
end,
|
||||
empty,
|
||||
settleMs: journey ? 1500 : warm ? 1000 : 3000,
|
||||
});
|
||||
await page.screenshot({ path: path.join(dir, `${name}.png`) });
|
||||
console.log(`${mode}: captured ${name}`);
|
||||
};
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', true),
|
||||
);
|
||||
// Match motion-reference: begin the camera-motion scenario from a
|
||||
// settled street view. Initial mesh acquisition is recorded in the clip
|
||||
// and first-dot diagnostics, but is not a stationary motion hold.
|
||||
if (journey) {
|
||||
await delay(4000);
|
||||
await hold('south-congress', true, 6000);
|
||||
const step = async (name, view, ms = 6000, empty = false) => {
|
||||
await fly(...view);
|
||||
await hold(name, false, ms, empty);
|
||||
};
|
||||
await step('pan-north-400m', [30.2536, -97.7497, 700, -40, 2, 10], 4000);
|
||||
await step('pan-east-500m', [30.2536, -97.7445, 700, -40, 2, 10], 4000);
|
||||
await step('zoom-out-2.5km', [30.2536, -97.7445, 2500, -45, 2.5, 10]);
|
||||
await step(
|
||||
'downtown-2.5km',
|
||||
[30.2672, -97.7431, 2500, -45, 2.5, 10],
|
||||
5000,
|
||||
);
|
||||
await step('downtown-500m', [30.2672, -97.7431, 500, -35, 2.5, 20]);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('alpr-cameras', true),
|
||||
);
|
||||
await hold('enable-alpr', true, 6000);
|
||||
await step('pan-west-600m', [30.2672, -97.7494, 500, -35, 2, 20], 5000);
|
||||
await step('city-12km', [30.28, -97.75, 12000, -60, 3, 0], 8000, true);
|
||||
await fly(30.3125, -97.765, 1000, -45, 3, 0);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled(
|
||||
'military-installations',
|
||||
true,
|
||||
),
|
||||
);
|
||||
await hold('camp-mabry-1km', false, 8000);
|
||||
await step('camp-mabry-pan', [30.3125, -97.76, 1000, -45, 2, 30], 5000);
|
||||
await step('greenbelt', [30.312, -97.775, 1000, -55, 3, 0], 6000);
|
||||
await step('capitol', [30.2747, -97.7404, 500, -70, 3, 0], 6000);
|
||||
await step('commercial-parking', [30.307, -97.735, 600, -60, 3, 0], 6000);
|
||||
await step('corridor', [30.347, -97.799, 1000, -45, 3, 0], 6000);
|
||||
} else {
|
||||
await delay(12000);
|
||||
await page.waitForFunction(
|
||||
() => window.__motion.rows.some((r) => r.n > 0),
|
||||
{ timeout: 1000 },
|
||||
);
|
||||
await hold('street-warm', true);
|
||||
await fly(30.2685, -97.7425, 3000, -45, 1.5);
|
||||
await hold('zoom-out');
|
||||
await fly(30.2685, -97.72, 3000, -45, 1.5);
|
||||
await hold('pan-east');
|
||||
await fly(30.2685, -97.725, 600, -35, 1.5);
|
||||
await hold('zoom-in');
|
||||
await fly(-23.5505, -46.6333, 1250, -35, 1.5);
|
||||
await hold('sao-paulo');
|
||||
await fly(30.2685, -97.7425, 450, -35, 1.5);
|
||||
await hold('austin-revisit', true);
|
||||
}
|
||||
await page.evaluate(() => {
|
||||
window.__motion.active = false;
|
||||
});
|
||||
await cdp.send('Page.stopScreencast');
|
||||
const rows = await page.evaluate(() => window.__motion.rows);
|
||||
const surfacePhases = await page.evaluate(() =>
|
||||
performance
|
||||
.getEntriesByType('measure')
|
||||
.filter(
|
||||
(e) => e.name.startsWith('roads:') || e.name.startsWith('traffic:'),
|
||||
)
|
||||
.map((e) => ({
|
||||
name: e.name,
|
||||
start: e.startTime,
|
||||
duration: e.duration,
|
||||
detail: e.detail,
|
||||
})),
|
||||
);
|
||||
const stats = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers.get('traffic').module.getStats(),
|
||||
);
|
||||
const phases = holds.map((h) => {
|
||||
const all = rows.filter((r) => r.t >= h.start && r.t < h.end);
|
||||
const settled = all.filter((r) => r.t >= h.start + h.settleMs);
|
||||
const n = settled.map((r) => r.n);
|
||||
const lastBusy = all.findLastIndex(
|
||||
(r) => r.loading || r.syncing || r.sizeChanged || r.jumpFrac > 0.02,
|
||||
);
|
||||
// First observed settled frame after the last population/loading event.
|
||||
const steadyMs =
|
||||
lastBusy < 0
|
||||
? 0
|
||||
: Math.round((all[lastBusy + 1]?.t ?? h.end) - h.start);
|
||||
const phase = {
|
||||
mode,
|
||||
phase: h.name,
|
||||
steadyMs,
|
||||
lateLoadingFrames: settled.filter((r) => r.loading).length,
|
||||
offRoadDots: Math.max(0, ...all.map((r) => r.offRoad)),
|
||||
settleMs: h.settleMs,
|
||||
frames: settled.length,
|
||||
rebuilds: all.reduce((s, r) => s + r.rebuilds, 0),
|
||||
lateRebuilds: settled.reduce((s, r) => s + r.rebuilds, 0),
|
||||
jumpFrames: settled.filter((r) => r.jumpFrac > 0.02).length,
|
||||
reassigned: settled.reduce((s, r) => s + r.reassigned, 0),
|
||||
sizeChanges: settled.filter((r) => r.sizeChanged).length,
|
||||
minDots: Math.min(...n),
|
||||
maxDots: Math.max(...n),
|
||||
maxFrameMs: Math.round(Math.max(...settled.map((r) => r.dt))),
|
||||
};
|
||||
phase.passed =
|
||||
phase.frames >= 20 &&
|
||||
phase.rebuilds <= 1 &&
|
||||
phase.lateRebuilds === 0 &&
|
||||
phase.jumpFrames === 0 &&
|
||||
phase.reassigned === 0 &&
|
||||
phase.sizeChanges === 0 &&
|
||||
(h.empty ? phase.maxDots === 0 : phase.minDots > 0) &&
|
||||
(!journey ||
|
||||
(phase.steadyMs <= 1500 &&
|
||||
phase.offRoadDots === 0 &&
|
||||
all.at(-1)?.surfacePending === 0));
|
||||
return phase;
|
||||
});
|
||||
fs.writeFileSync(
|
||||
path.join(dir, 'frames.ffconcat'),
|
||||
'ffconcat version 1.0\n' +
|
||||
frames
|
||||
.map(
|
||||
(f, i) =>
|
||||
`file '${f.name}'\nduration ${Math.max(0.001, Math.min(2, (frames[i + 1]?.timestamp || f.timestamp + 0.1) - f.timestamp))}\n`,
|
||||
)
|
||||
.join(''),
|
||||
);
|
||||
execFileSync('ffmpeg', [
|
||||
'-y',
|
||||
'-loglevel',
|
||||
'error',
|
||||
'-safe',
|
||||
'0',
|
||||
'-f',
|
||||
'concat',
|
||||
'-i',
|
||||
path.join(dir, 'frames.ffconcat'),
|
||||
'-fps_mode',
|
||||
'vfr',
|
||||
'-c:v',
|
||||
'libx264',
|
||||
'-pix_fmt',
|
||||
'yuv420p',
|
||||
'-vf',
|
||||
journey ? 'scale=1280:-2' : 'scale=960:-2',
|
||||
path.join(dir, 'clip.mp4'),
|
||||
]);
|
||||
const result = {
|
||||
mode,
|
||||
revision,
|
||||
baseline,
|
||||
identity,
|
||||
url: u.href,
|
||||
phases,
|
||||
errors,
|
||||
forbidden,
|
||||
tileRequests,
|
||||
duplicateTiles: tileRequests.filter(
|
||||
(p, i) => tileRequests.indexOf(p) !== i,
|
||||
),
|
||||
stats,
|
||||
surfacePhases,
|
||||
logs,
|
||||
holds,
|
||||
rows,
|
||||
moveEnds: await page.evaluate(() => window.__motion.moveEnds),
|
||||
clip: path.join(dir, 'clip.mp4'),
|
||||
frames: frames.length,
|
||||
};
|
||||
result.passed =
|
||||
phases.every((p) => p.passed) &&
|
||||
!errors.length &&
|
||||
!forbidden.length &&
|
||||
result.duplicateTiles.length === 0 &&
|
||||
!identity.overlay &&
|
||||
identity.text > 100;
|
||||
fs.writeFileSync(
|
||||
path.join(dir, 'metrics.json'),
|
||||
JSON.stringify(result, null, 2),
|
||||
);
|
||||
results.push(result);
|
||||
console.table(phases);
|
||||
await page.close();
|
||||
}
|
||||
} finally {
|
||||
await browser.close();
|
||||
fs.writeFileSync(
|
||||
path.join(root, 'results.json'),
|
||||
JSON.stringify(
|
||||
results.map(({ rows, ...r }) => r),
|
||||
null,
|
||||
2,
|
||||
),
|
||||
);
|
||||
}
|
||||
if (!baseline && results.some((r) => !r.passed)) process.exitCode = 1;
|
||||
@@ -0,0 +1,315 @@
|
||||
#!/usr/bin/env node
|
||||
/** Reticle coverage on oblique arrivals: source requests, toggle oracle and zoom revisits. */
|
||||
import fs from 'node:fs';
|
||||
import puppeteer from 'puppeteer';
|
||||
import {
|
||||
moveCamera,
|
||||
createScreencast,
|
||||
installFrameProbe,
|
||||
} from './qa-journey-recorder.mjs';
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes('--help')) {
|
||||
console.log(
|
||||
'Usage: node scripts/qa-traffic-oblique.mjs <url> [--baseline] [--mode=hybrid|osm|tomtom]',
|
||||
);
|
||||
process.exit(0);
|
||||
}
|
||||
const baseline = args.includes('--baseline');
|
||||
const modeArg = args.find((a) => a.startsWith('--mode='))?.split('=')[1];
|
||||
const modes = modeArg ? [modeArg] : ['tomtom', 'osm', 'hybrid'];
|
||||
const out = `qa-shots/oblique-${baseline ? 'before' : 'after'}`;
|
||||
fs.mkdirSync(out, { recursive: true });
|
||||
const result = { views: [], errors: [], forbidden: [], failures: [] };
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
const browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
protocolTimeout: 180000,
|
||||
args: [
|
||||
'--use-angle=metal',
|
||||
'--disable-background-timer-throttling',
|
||||
'--disable-renderer-backgrounding',
|
||||
],
|
||||
});
|
||||
try {
|
||||
for (const mode of modes) {
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1280, height: 800 });
|
||||
const counts = { ofm: 0, tomtom: 0 };
|
||||
page.on('request', (r) => {
|
||||
const u = new URL(r.url());
|
||||
if (
|
||||
u.hostname === 'tiles.openfreemap.org' &&
|
||||
/\/\d+\/\d+\/\d+(\.pbf)?$/.test(u.pathname)
|
||||
)
|
||||
counts.ofm++;
|
||||
if (u.pathname.startsWith('/api/tomtom/flow/')) counts.tomtom++;
|
||||
if (
|
||||
/overpass/i.test(u.hostname) ||
|
||||
u.hostname === 'nominatim.openstreetmap.org'
|
||||
)
|
||||
result.forbidden.push(u.hostname);
|
||||
});
|
||||
page.on('pageerror', (e) => result.errors.push(e.message));
|
||||
page.on('console', (m) => {
|
||||
if (m.type() === 'error') result.errors.push(m.text());
|
||||
});
|
||||
await page.evaluateOnNewDocument(() =>
|
||||
sessionStorage.setItem('gev:first-run-mission-session:v1', 'dismissed'),
|
||||
);
|
||||
const url = new URL(args.find((a) => /^https?:/.test(a)));
|
||||
url.searchParams.set('trafficRoads', mode);
|
||||
await page.goto(url.href, { waitUntil: 'domcontentloaded' });
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
window.__godsEyeView?.dataManager &&
|
||||
document.getElementById('loading-screen')?.classList.contains('hidden'),
|
||||
{ timeout: 120000 },
|
||||
);
|
||||
await page.evaluate(
|
||||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||||
);
|
||||
await page.keyboard.press('Escape');
|
||||
await page.evaluate(async () => {
|
||||
const g = window.__godsEyeView;
|
||||
for (const [id] of g.dataManager.layers)
|
||||
await g.dataManager.setEnabled(id, false);
|
||||
g.styleManager.setDetection({ enabled: false });
|
||||
g.viewer.scene.screenSpaceCameraController.enableCollisionDetection = false;
|
||||
});
|
||||
const snap = () =>
|
||||
page.evaluate(() => {
|
||||
const { viewer, dataManager } = window.__godsEyeView;
|
||||
let upper = 0,
|
||||
lower = 0,
|
||||
near = 0;
|
||||
const camera = viewer.camera.positionWC;
|
||||
dataManager.layers
|
||||
.get('traffic')
|
||||
.module.visitMotionDots((id, key, p) => {
|
||||
if (!p.show) return;
|
||||
const s = viewer.scene.cartesianToCanvasCoordinates(p.position);
|
||||
if (s && s.x >= 240 && s.x <= 1040 && s.y >= 0 && s.y <= 800) {
|
||||
if (s.y < 400) upper++;
|
||||
else lower++;
|
||||
}
|
||||
});
|
||||
return {
|
||||
upper,
|
||||
lower,
|
||||
...dataManager.layers.get('traffic').module.getStats(),
|
||||
};
|
||||
});
|
||||
const settle = async () => {
|
||||
await sleep(700);
|
||||
await page
|
||||
.waitForFunction(
|
||||
() => {
|
||||
const s = window.__godsEyeView.dataManager.layers
|
||||
.get('traffic')
|
||||
.module.getStats();
|
||||
return !s.loading;
|
||||
},
|
||||
{ timeout: 15000 },
|
||||
)
|
||||
.catch(() => {});
|
||||
await sleep(1200);
|
||||
return snap();
|
||||
};
|
||||
for (const [name, lat, lon, height] of [
|
||||
['dubai', 24.964, 55.037, 276],
|
||||
['austin', 30.2672, -97.7431, 300],
|
||||
['london', 51.507, -0.128, 300],
|
||||
]) {
|
||||
const before = { ...counts };
|
||||
await moveCamera(page, { lat, lon, height: 3000, pitch: -45 }, 0);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', true),
|
||||
);
|
||||
await moveCamera(page, { lat, lon, height, pitch: -15 }, 1.4);
|
||||
const settled = await settle();
|
||||
const load = {
|
||||
ofm: counts.ofm - before.ofm,
|
||||
tomtom: counts.tomtom - before.tomtom,
|
||||
};
|
||||
await page.screenshot({ path: `${out}/${name}-${mode}.png` });
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||||
);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', true),
|
||||
);
|
||||
const toggled = await settle();
|
||||
const oracle =
|
||||
Math.abs(settled.upper - toggled.upper) / Math.max(1, toggled.upper);
|
||||
const preZoom = { ...counts };
|
||||
await moveCamera(page, { lat, lon, height: 3000, pitch: -15 }, 0.7);
|
||||
await settle();
|
||||
const atWide = { ...counts };
|
||||
await moveCamera(page, { lat, lon, height, pitch: -15 }, 0.7);
|
||||
await settle();
|
||||
const revisit = {
|
||||
ofm: counts.ofm - atWide.ofm,
|
||||
tomtom: counts.tomtom - atWide.tomtom,
|
||||
};
|
||||
const row = {
|
||||
mode,
|
||||
name,
|
||||
load,
|
||||
settled,
|
||||
toggled,
|
||||
oracle,
|
||||
revisit,
|
||||
zoomOut: {
|
||||
ofm: atWide.ofm - preZoom.ofm,
|
||||
tomtom: atWide.tomtom - preZoom.tomtom,
|
||||
},
|
||||
};
|
||||
result.views.push(row);
|
||||
console.log(JSON.stringify(row));
|
||||
if (oracle > 0.15)
|
||||
result.failures.push(`${name}/${mode}: upper oracle ${oracle}`);
|
||||
if (revisit.ofm || revisit.tomtom)
|
||||
result.failures.push(`${name}/${mode}: revisit requests`);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||||
);
|
||||
}
|
||||
const locationView = { lat: 24.973, lon: 55.037 };
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat: 24.964, lon: 55.037, height: 3000, pitch: -45 },
|
||||
0,
|
||||
);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', true),
|
||||
);
|
||||
const dir = `${out}/dubai-${mode}-journey`;
|
||||
const recording =
|
||||
mode === 'hybrid' ? await createScreencast(page, dir, { fps: 24 }) : null;
|
||||
await installFrameProbe(page);
|
||||
await page.evaluate(() => {
|
||||
const { viewer, dataManager } = window.__godsEyeView;
|
||||
window.__obliqueFrames = [];
|
||||
window.__obliqueMoving = true;
|
||||
viewer.scene.postRender.addEventListener(() => {
|
||||
const s = dataManager.layers.get('traffic').module.getStats();
|
||||
let upper = 0,
|
||||
lower = 0,
|
||||
near = 0;
|
||||
const camera = viewer.camera.positionWC;
|
||||
dataManager.layers
|
||||
.get('traffic')
|
||||
.module.visitMotionDots((id, key, p) => {
|
||||
if (!p.show) return;
|
||||
const q = viewer.scene.cartesianToCanvasCoordinates(p.position);
|
||||
if (q && q.x >= 240 && q.x <= 1040 && q.y >= 0 && q.y <= 800) {
|
||||
if (q.y < 400) upper++;
|
||||
else lower++;
|
||||
const dx = p.position.x - camera.x,
|
||||
dy = p.position.y - camera.y,
|
||||
dz = p.position.z - camera.z;
|
||||
if (dx * dx + dy * dy + dz * dz <= 1500 * 1500) near++;
|
||||
}
|
||||
});
|
||||
window.__obliqueFrames.push({
|
||||
t: performance.now(),
|
||||
moving: window.__obliqueMoving,
|
||||
count: s.count,
|
||||
loading: s.loading,
|
||||
upper,
|
||||
lower,
|
||||
near,
|
||||
publishes: s.motion.publishes,
|
||||
rebuilds: s.motion.rebuilds,
|
||||
});
|
||||
});
|
||||
});
|
||||
await recording?.start();
|
||||
await page.evaluate(async (v) => {
|
||||
const { flyToLandmark } = await import('/src/locations.js');
|
||||
await new Promise((resolve) =>
|
||||
flyToLandmark(window.__godsEyeView.viewer, v.lat, v.lon, {
|
||||
range: 1000,
|
||||
pitch: -15,
|
||||
heading: 0,
|
||||
duration: 1.6,
|
||||
buildingHeight: 0,
|
||||
onComplete: resolve,
|
||||
onCancel: resolve,
|
||||
}),
|
||||
);
|
||||
window.__obliqueMoving = false;
|
||||
}, locationView);
|
||||
const arrived = await settle();
|
||||
await page.evaluate(() => {
|
||||
window.__obliqueMoving = true;
|
||||
});
|
||||
await moveCamera(
|
||||
page,
|
||||
{ lat: 24.964, lon: 55.042, height: 300, pitch: -15 },
|
||||
1.2,
|
||||
);
|
||||
await page.evaluate(() => {
|
||||
window.__obliqueMoving = false;
|
||||
});
|
||||
const panned = await settle();
|
||||
await sleep(1800);
|
||||
const frames = await page.evaluate(() => window.__obliqueFrames);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', false),
|
||||
);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.setEnabled('traffic', true),
|
||||
);
|
||||
const fresh = await settle();
|
||||
const oracle =
|
||||
Math.abs(panned.upper - fresh.upper) / Math.max(1, fresh.upper);
|
||||
const stops = frames.flatMap((f, i) =>
|
||||
i && !f.moving && frames[i - 1].moving ? [i] : [],
|
||||
);
|
||||
const nearSettles = stops.map((start, index) => {
|
||||
let end = start + 1;
|
||||
while (end < frames.length && !frames[end].moving) end++;
|
||||
const phase = frames.slice(start, end),
|
||||
target = phase.at(-1).near;
|
||||
const reached = phase.find((f) => f.near >= target * 0.85);
|
||||
const ms = reached ? Math.round(reached.t - phase[0].t) : Infinity;
|
||||
if (target && ms > 1100)
|
||||
result.failures.push(
|
||||
`dubai-location-pan/${mode}/${index}: near settle ${ms} ms`,
|
||||
);
|
||||
return {
|
||||
phase: index === 0 ? 'arrival' : 'pan',
|
||||
ms,
|
||||
target,
|
||||
first: phase[0].near,
|
||||
};
|
||||
});
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
fs.writeFileSync(`${dir}/metrics.json`, JSON.stringify(frames));
|
||||
const clip = await recording?.stop();
|
||||
result.views.push({
|
||||
mode,
|
||||
name: 'dubai-location-pan',
|
||||
nearSettles,
|
||||
arrived,
|
||||
settled: panned,
|
||||
toggled: fresh,
|
||||
oracle,
|
||||
clip,
|
||||
});
|
||||
if (oracle > 0.15)
|
||||
result.failures.push(
|
||||
`dubai-location-pan/${mode}: upper oracle ${oracle}`,
|
||||
);
|
||||
await page.close();
|
||||
}
|
||||
} finally {
|
||||
fs.writeFileSync(`${out}/result.json`, JSON.stringify(result, null, 2));
|
||||
await browser.close();
|
||||
}
|
||||
if (
|
||||
!baseline &&
|
||||
(result.failures.length || result.errors.length || result.forbidden.length)
|
||||
)
|
||||
process.exitCode = 1;
|
||||
Reference in new issue
Block a user