mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Move Cesium viewer, map, sky, projection, trail and sonar internals into its engine. Drive styles, bloom, sharpening and contact sonar through engine.render. Count camera-input suspensions across all three engines and migrate the feature callers. Preserve Cesium's effects and input behaviour; fix transit lens clicks on Cesium and make zero sharpening on Navara disable sharpening, as it does on Cesium. Parse imported files into plain records and draw them through movers, lines, ground and imagery on both engines. Follow Cesium's KML style precedence, preserve local KMZ images and frame the drawable records. Open overlays use imagery when the engine has no native map-overlay API. Run every imported-display case on fake and headless Cesium engines. The shared import path retains these known differences from Cesium's old DataSources: wall fills, extruded prisms and gx:LatLonQuad are undrawn; raised polygon fills drape while outlines retain altitude; GroundOverlay rotation, altitude and RGB tint are not applied; rhumb lines become great circles. Ground heights use the loaded surface synchronously instead of waiting for most-detailed sampling. Supported KMZ ground overlays now draw on Navara too. Document the limits rather than claiming full parity. Combine batches B and C because their disjoint path manifests cannot place the shared boundary and format files in a later commit while keeping B independently valid. This combined commit owns the shared docs, package boundaries, format scope, locale catalogs and coupling baseline. Remove five obsolete import strings from all eleven catalogs. Make the load-time source scan include new files and skip deleted paths so the same checks work before and after recording the moves. Coupling: Navara renderer lines fall from 1695 to 1294, Cesium import files from 25 to 9, viewer lines from 1177 to 1026, SDK loads from 4 to 3 and engine-name lines from 62 to 42. No count grows. The full unit suite and the boundary, format and coupling checks pass. Browser validation remains to be run. Browser checks to run GOOGLE_MAPS_API_KEY= CESIUM_ION_TOKEN= npm run dev -- --port 4291 node scripts/qa-contract-suite.mjs http://localhost:4291 node scripts/qa-navara-visual-styles.mjs http://localhost:4291 node scripts/qa-navara-bloom.mjs http://localhost:4291 node scripts/qa-navara-sonar.mjs http://localhost:4291 QA_BASE_URL=http://localhost:4291 node scripts/qa-visual-effects.mjs QA_BASE_URL=http://localhost:4291 node scripts/qa-zoom-out-guard.mjs node scripts/qa-sky-model-lighting.mjs --url http://localhost:4291 node scripts/qa-geo-import.mjs http://localhost:4291 node scripts/qa-geo-import-regressions.mjs http://localhost:4291 node scripts/qa-geo-import-large.mjs http://localhost:4291 node scripts/qa-navara-geo-import.mjs http://localhost:4291 Use the keyless server for every check. Photoreal-only cases remain unverified; do not enable paid tiles to run them.
337 lines
12 KiB
JavaScript
337 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
||
// UTILITIES ▸ Import on Navara under the strict network policy: GeoJSON,
|
||
// KML, KMZ (a packed icon and a ground overlay) and GPX through the real
|
||
// file input, each one row; Navara draws their shapes in the row colour and
|
||
// their pins, counts what it cannot draw (the KMZ ground overlay) and says
|
||
// so in the hint; hide, fly-to and remove work on the engine; the files
|
||
// survive a switch to Cesium and back and draw on each engine. No file makes
|
||
// the page request anything it names (the strict policy fails any request
|
||
// outside the preview and the free tile cache).
|
||
//
|
||
// node scripts/qa-navara-geo-import.mjs http://127.0.0.1:<PORT>/
|
||
import assert from 'node:assert/strict';
|
||
import fs from 'node:fs';
|
||
import os from 'node:os';
|
||
import path from 'node:path';
|
||
import sharp from 'sharp';
|
||
import { fromDegrees } from '../src/geo/cartesian3.js';
|
||
import { createStrict, localPreview } from './qa-strict-harness.mjs';
|
||
|
||
const VIEW = { lat: 37.7694, lon: -122.4862, alt: 4200 };
|
||
const base = localPreview(process.argv[2]);
|
||
base.search = '?engine=navara&welcome=0';
|
||
base.hash = `v=2&lat=${VIEW.lat}&lon=${VIEW.lon}&alt=${VIEW.alt}&heading=0&pitch=-90&roll=0&map=osm&l=`;
|
||
const strict = createStrict({ origin: base.origin, layers: ['geo-import'] });
|
||
const SHOTS = process.env.QA_SHOT_DIR || 'qa-shots/navara-geo-import';
|
||
fs.mkdirSync(SHOTS, { recursive: true });
|
||
const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||
const TRAP = 'gev-qa-trap.invalid';
|
||
|
||
/* ── fixtures (as scripts/qa-geo-import.mjs) ───────────────────────────── */
|
||
const ring = [
|
||
[-122.511, 37.7645],
|
||
[-122.4545, 37.7645],
|
||
[-122.4545, 37.7745],
|
||
[-122.511, 37.7745],
|
||
[-122.511, 37.7645],
|
||
];
|
||
const geojson = JSON.stringify({
|
||
type: 'FeatureCollection',
|
||
features: [
|
||
{
|
||
type: 'Feature',
|
||
properties: {
|
||
name: 'QA park',
|
||
description: `<img src="https://${TRAP}/props.png">`,
|
||
},
|
||
geometry: { type: 'Polygon', coordinates: [ring] },
|
||
},
|
||
{
|
||
type: 'Feature',
|
||
properties: { name: 'QA pin' },
|
||
geometry: { type: 'Point', coordinates: [-122.4862, 37.7694] },
|
||
},
|
||
],
|
||
});
|
||
const kml = (iconHref, overlay) => `<?xml version="1.0" encoding="UTF-8"?>
|
||
<kml xmlns="http://www.opengis.net/kml/2.2">
|
||
<Document>
|
||
<Style id="s"><IconStyle><Icon><href>${iconHref}</href></Icon></IconStyle></Style>
|
||
<NetworkLink><Link><href>https://${TRAP}/link.kml</href></Link></NetworkLink>
|
||
<Placemark><name>QA KML pin</name><styleUrl>#s</styleUrl>
|
||
<description><![CDATA[<img src="https://${TRAP}/balloon.png">]]></description>
|
||
<Point><coordinates>-122.47,37.77,0</coordinates></Point></Placemark>
|
||
<Placemark><name>QA KML line</name>
|
||
<LineString><coordinates>-122.50,37.766 -122.46,37.772</coordinates></LineString></Placemark>
|
||
<GroundOverlay><Icon><href>${overlay}</href></Icon>
|
||
<LatLonBox><north>37.77</north><south>37.76</south><east>-122.46</east><west>-122.47</west></LatLonBox></GroundOverlay>
|
||
</Document>
|
||
</kml>`;
|
||
const gpx = `<?xml version="1.0" encoding="UTF-8"?>
|
||
<gpx version="1.1" creator="qa" xmlns="http://www.topografix.com/GPX/1/1">
|
||
<wpt lat="37.769" lon="-122.49"><name>QA waypoint</name></wpt>
|
||
<trk><name>QA track</name><trkseg>
|
||
<trkpt lat="37.766" lon="-122.505"></trkpt><trkpt lat="37.768" lon="-122.49"></trkpt>
|
||
</trkseg></trk>
|
||
</gpx>`;
|
||
// 8×8 opaque white PNG.
|
||
const PNG = await sharp({
|
||
create: { width: 8, height: 8, channels: 4, background: '#ffffff' },
|
||
})
|
||
.png()
|
||
.toBuffer();
|
||
function storedZip(files) {
|
||
const parts = [];
|
||
const central = [];
|
||
let offset = 0;
|
||
for (const [name, data] of files) {
|
||
const n = Buffer.from(name);
|
||
const local = Buffer.alloc(30);
|
||
local.writeUInt32LE(0x04034b50, 0);
|
||
local.writeUInt32LE(data.length, 18);
|
||
local.writeUInt32LE(data.length, 22);
|
||
local.writeUInt16LE(n.length, 26);
|
||
const c = Buffer.alloc(46);
|
||
c.writeUInt32LE(0x02014b50, 0);
|
||
c.writeUInt32LE(data.length, 20);
|
||
c.writeUInt32LE(data.length, 24);
|
||
c.writeUInt16LE(n.length, 28);
|
||
c.writeUInt32LE(offset, 42);
|
||
parts.push(local, n, data);
|
||
central.push(c, n);
|
||
offset += 30 + n.length + data.length;
|
||
}
|
||
const dir = Buffer.concat(central);
|
||
const end = Buffer.alloc(22);
|
||
end.writeUInt32LE(0x06054b50, 0);
|
||
end.writeUInt16LE(files.length, 8);
|
||
end.writeUInt16LE(files.length, 10);
|
||
end.writeUInt32LE(dir.length, 12);
|
||
end.writeUInt32LE(offset, 16);
|
||
return Buffer.concat([...parts, dir, end]);
|
||
}
|
||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gev-qa-navara-import-'));
|
||
const fixture = (name, data) => {
|
||
const file = path.join(dir, name);
|
||
fs.writeFileSync(file, data);
|
||
return file;
|
||
};
|
||
const FILES = [
|
||
fixture('park.geojson', geojson),
|
||
fixture(
|
||
'remote-bits.kml',
|
||
kml(`https://${TRAP}/icon.png`, `https://${TRAP}/overlay.png`),
|
||
),
|
||
fixture(
|
||
'packed.kmz',
|
||
storedZip([
|
||
['doc.kml', Buffer.from(kml('files/pin.png', 'files/overlay.png'))],
|
||
['files/pin.png', PNG],
|
||
['files/overlay.png', PNG],
|
||
]),
|
||
),
|
||
fixture('walk.gpx', gpx),
|
||
];
|
||
|
||
await strict.run(
|
||
{
|
||
args: [
|
||
'--disable-background-timer-throttling',
|
||
'--disable-renderer-backgrounding',
|
||
],
|
||
},
|
||
async (browser) => {
|
||
const page = await browser.newPage();
|
||
await page.setViewport({ width: 1280, height: 860 });
|
||
const errors = [];
|
||
page.on('pageerror', (error) => errors.push(error.message));
|
||
await page.goto(base.href);
|
||
const ready = async (kind) => {
|
||
await page.waitForFunction(
|
||
(k) =>
|
||
window.__godsEyeView?.engine?.kind === k &&
|
||
window.__gevGeoImport?.diagnostics().attached &&
|
||
!document.querySelector('#globe-engine')?.disabled &&
|
||
!document.querySelector('.engine-switch-frame') &&
|
||
document.querySelector('#loading-screen.hidden'),
|
||
{ timeout: 120000 },
|
||
kind,
|
||
);
|
||
await page.evaluate(
|
||
() => window.__godsEyeView.styleManager.initialRestorePromise,
|
||
);
|
||
};
|
||
await ready('navara');
|
||
assert.equal(
|
||
await page.evaluate(() =>
|
||
Boolean(window.__godsEyeView.tileset || window.__GOOGLE_MAPS_API_KEY__),
|
||
),
|
||
false,
|
||
'keyless preview required',
|
||
);
|
||
const state = () =>
|
||
page.evaluate(() => ({
|
||
files: window.__gevGeoImport.list(),
|
||
diagnostics: window.__gevGeoImport.diagnostics(),
|
||
rows: document.querySelectorAll('#geo-import-list .geo-import-row')
|
||
.length,
|
||
hint: document.getElementById('geo-import-hint')?.textContent || '',
|
||
// Navara draws the pins as mover sets; Cesium as entities (none).
|
||
pins: window.__godsEyeView.engine.movers
|
||
.list()
|
||
.filter(({ id }) => id.startsWith('geo-import-'))
|
||
.reduce((n, set) => n + set.count, 0),
|
||
}));
|
||
/** Pixels near the first file's colour (#39d0ff) on the canvas. */
|
||
const cyan = async () => {
|
||
await page.evaluate(() => window.__godsEyeView.requestRender?.('qa'));
|
||
await wait(900);
|
||
const { data, info } = await sharp(
|
||
await page.screenshot({
|
||
clip: { x: 400, y: 260, width: 480, height: 300 },
|
||
}),
|
||
)
|
||
.removeAlpha()
|
||
.raw()
|
||
.toBuffer({ resolveWithObject: true });
|
||
let n = 0;
|
||
for (let i = 0; i < data.length; i += info.channels) {
|
||
const [r, g, b] = [data[i], data[i + 1], data[i + 2]];
|
||
if (b > 120 && g > 90 && b - r > 50) n++;
|
||
}
|
||
return n;
|
||
};
|
||
const setAll = (visible) =>
|
||
page.evaluate((v) => {
|
||
for (const file of window.__gevGeoImport.list())
|
||
window.__gevGeoImport.setVisible(file.id, v);
|
||
}, visible);
|
||
|
||
await page.evaluate(() => {
|
||
const panel = document.getElementById('utilities-panel');
|
||
if (panel?.classList.contains('collapsed'))
|
||
document
|
||
.querySelector(
|
||
'.panel-collapse-btn[data-collapse-target="utilities-panel"]',
|
||
)
|
||
?.click();
|
||
});
|
||
const input = await page.$('#geo-import-input');
|
||
assert.ok(input, 'the Import file input');
|
||
await input.uploadFile(...FILES);
|
||
await page.waitForFunction(
|
||
() =>
|
||
window.__gevGeoImport.list().length === 4 &&
|
||
!/Reading/.test(
|
||
document.getElementById('geo-import-hint')?.textContent || '',
|
||
),
|
||
{ timeout: 90000 },
|
||
);
|
||
const imported = await state();
|
||
console.log('navara import', JSON.stringify(imported));
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'GeoJSON, KML, KMZ and GPX each become one row and one drawing on Navara',
|
||
imported.files.length === 4 &&
|
||
imported.rows === 4 &&
|
||
imported.diagnostics.drawn === 4,
|
||
{ files: imported.files.map((f) => f.format), rows: imported.rows },
|
||
);
|
||
// Packed overlays draw through imagery; remote overlays are removed on import.
|
||
const undrawn = Object.fromEntries(
|
||
imported.files.map((f) => [f.name, f.undrawn]),
|
||
);
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'all supported geometry, including the packed overlay, draws on Navara',
|
||
undrawn['packed.kmz'] === 0 &&
|
||
undrawn['park.geojson'] === 0 &&
|
||
undrawn['remote-bits.kml'] === 0 &&
|
||
undrawn['walk.gpx'] === 0,
|
||
{ undrawn, hint: imported.hint },
|
||
);
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'the files’ pins are drawn as Navara sprites',
|
||
imported.pins >= 4,
|
||
{ pins: imported.pins },
|
||
);
|
||
// The first file is flown to after the batch; settle there.
|
||
await wait(3000);
|
||
await page.screenshot({ path: `${SHOTS}/navara-imported.png` });
|
||
|
||
for (const kind of ['navara', 'cesium', 'navara']) {
|
||
if (
|
||
(await page.evaluate(() => window.__godsEyeView.engine.kind)) !== kind
|
||
) {
|
||
await strict.pick(page, kind);
|
||
await ready(kind);
|
||
await page.waitForFunction(
|
||
() => window.__gevGeoImport.diagnostics().drawn === 4,
|
||
{ timeout: 60000 },
|
||
);
|
||
await wait(2500);
|
||
await page.screenshot({ path: `${SHOTS}/${kind}-after-switch.png` });
|
||
}
|
||
const shown = await cyan();
|
||
await setAll(false);
|
||
const hidden = await cyan();
|
||
await setAll(true);
|
||
console.log(kind, 'cyan', { shown, hidden });
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'the imported shapes paint the first file’s colour and stop when hidden',
|
||
shown - hidden > 1500,
|
||
{ shown, hidden },
|
||
);
|
||
const kept = await state();
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'the same four files are listed and drawn on this engine',
|
||
kept.files.length === 4 && kept.diagnostics.drawn === 4,
|
||
kept.diagnostics,
|
||
);
|
||
}
|
||
// Fly-to on Navara goes through the engine camera.
|
||
const flight = await page.evaluate(
|
||
async (destination) => {
|
||
const { engine } = window.__godsEyeView;
|
||
engine.camera.setView({ destination });
|
||
const before = engine.camera.height();
|
||
const [first] = window.__gevGeoImport.list();
|
||
const ok = window.__gevGeoImport.flyTo(first.id);
|
||
await new Promise((r) => setTimeout(r, 2500));
|
||
return { ok, before, after: engine.camera.height() };
|
||
},
|
||
fromDegrees(-100, 40, 3e6),
|
||
);
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'Fly to a file moves the Navara camera onto it',
|
||
flight.ok && flight.after < flight.before / 2,
|
||
flight,
|
||
);
|
||
// Remove gives the drawing back.
|
||
await page.evaluate(() => {
|
||
for (const file of window.__gevGeoImport.list())
|
||
window.__gevGeoImport.remove(file.id);
|
||
});
|
||
const removed = await state();
|
||
await strict.check(
|
||
page,
|
||
'geo-import',
|
||
'Remove takes every file and its pins off Navara',
|
||
removed.files.length === 0 && removed.rows === 0 && removed.pins === 0,
|
||
{ files: removed.files.length, pins: removed.pins },
|
||
);
|
||
assert.deepEqual(errors, []);
|
||
console.log('PASS Navara import of GeoJSON, KML, KMZ and GPX');
|
||
},
|
||
);
|