Draw imported files through the draw port, off Cesium

Import no longer loads KML, KMZ, GeoJSON and GPX through Cesium's data
source loaders. geoImportFeatures.js reads the sanitized file into plain
pins, lines, walls, polygons and ground overlays with the looks those
loaders gave them: icon, scale, colour, heading and hot spot, the shared
and inline style precedence, line and polygon colours and widths,
extruded and clamped geometry, rotated boxes and quads, and GeoJSON's
48 px pins, draped lines along rhumb lines and quarter-opacity fills.
geoImportPins.js draws them in three draw sets per file, places ground
pins through the height service (0 on the bare ellipsoid, whose coarse
tiles sag below it; the mesh nearby on photoreal maps), follows a
double-clicked pin, frames Fly-to, and shows, hides and removes them.

The Cesium adapter now draws two members the contract already had: an
icon's pixel offset and the wall shape. Image fills draw in the
translucent pass, so an overlay's own alpha blends as it did.

The Cesium allow-list is now empty; the ratchet test checks that its
scan still sees each way of reaching Cesium. The QA scripts read what a
file drew through the import's drawn(id), and the large-file check
compares it with Cesium's own reading of the same KML. A file the
renderer refuses to draw is refused by itself, without stopping its
batch. Two translations no longer used are dropped.
This commit is contained in:
Sameh Khamis committed 2026-11-09 15:50:53 -08:00
1 parent c073064507
commit 6c1f91014c
33 files changed
+2608 -1177

No files matched your search

+6
View File
@@ -3939,6 +3939,7 @@
"src/annotations/drawMode.js",
"src/annotations/drawTool.js",
"src/data/geoFileImport.js",
"src/data/geoImportFeatures.js",
"src/data/geoImportShared.js",
"src/ui/flyToDataSource.js",
"src/ui/geoFileImport.js",
@@ -4954,6 +4955,7 @@
"src/data/geoImportPins.js",
"src/data/geoImportShared.js",
"src/data/geoFileImport.js",
"src/data/geoImportFeatures.js",
"src/ui/stores/imagerySplit.js",
"src/ui/vueRuntime.js",
"src/ui/stores/windInspection.js",
@@ -6109,6 +6111,7 @@
"src/layers/ghostMaps/source.js",
"src/sources/httpBody.js",
"src/data/geoFileImport.js",
"src/data/geoImportFeatures.js",
"src/data/geoImportShared.js",
"src/i18n/marker.js",
"src/i18n/index.js",
@@ -6126,6 +6129,9 @@
"src/i18n/locales/zh-Hant.json",
"src/data/geoImportImages.js",
"src/data/geoImportPins.js",
"src/data/stockFollow.js",
"src/data/geojsonPins.js",
"src/geo/sphere.js",
"src/data/followed.js",
"src/layers/streetLevel/tileMath.js",
"src/layers/streetLevel/view.js",
+130 -82
View File
@@ -103,49 +103,112 @@ try {
destination: C.Cartesian3.fromDegrees(-122.5, 37.72, 50000),
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
});
// One form for both sides: Cesium's own KML reading of the file (the
// control) and what the import drew (the candidate).
const css = (value) =>
value === undefined || value === null
? undefined
: (Array.isArray(value)
? new C.Color(...value)
: C.Color.fromCssColorString(value)
).toCssColorString();
const at = (p) => {
const c = C.Cartographic.fromCartesian(new C.Cartesian3(p.x, p.y, p.z));
return [
+C.Math.toDegrees(c.longitude).toFixed(6),
+C.Math.toDegrees(c.latitude).toFixed(6),
];
};
const sorted = (rows) =>
rows.sort(
(a, b) => a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind),
);
window.__qaStyleSnapshot = (source) => {
const now = viewer.clock.currentTime;
const images = new Map();
const imageValue = (p) => {
const value = p?.getValue(now);
if (value?.tagName !== 'CANVAS') return value;
if (!images.has(value)) images.set(value, value.toDataURL());
return images.get(value);
};
const color = (p) => p?.getValue(now)?.toCssColorString();
const positions = (p) => p?.getValue(now)?.map((v) => [v.x, v.y, v.z]);
const renderedPins = new Map();
const collection = source.importedBillboards;
if (collection)
for (let i = 0; i < collection.length; i++) {
const pin = collection.get(i);
renderedPins.set(pin.id, pin);
}
const actual = (e, key, fallback) => {
const pin = renderedPins.get(e);
return pin ? pin[key] : (e.billboard?.[key]?.getValue(now) ?? fallback);
};
return (source.importedEntities || source.entities.values)
.map((e) => ({
name: e.name,
point: renderedPins.get(e)?.position || e.position?.getValue(now),
scale: e.billboard ? actual(e, 'scale', 1) : undefined,
rotation: e.billboard ? actual(e, 'rotation', 0) : undefined,
image: renderedPins.get(e)?.image || imageValue(e.billboard?.image),
color: e.billboard
? actual(e, 'color', C.Color.WHITE).toCssColorString()
: undefined,
width: e.polyline?.width?.getValue(now),
lineColor: color(e.polyline?.material?.color),
line: positions(e.polyline?.positions),
fill: e.polygon?.fill?.getValue(now),
outline: e.polygon?.outline?.getValue(now),
polygonColor: color(e.polygon?.material?.color),
polygon: e.polygon?.hierarchy
?.getValue(now)
?.positions?.map((v) => [v.x, v.y, v.z]),
}))
.sort((a, b) => a.name.localeCompare(b.name));
return sorted(
source.entities.values
.filter((e) => e.billboard || e.polyline || e.polygon)
.map((e) => {
if (e.billboard)
return {
name: e.name,
kind: 'pin',
point: at(e.position.getValue(now)),
scale: e.billboard.scale?.getValue(now) ?? 1,
heading: Math.round(
-C.Math.toDegrees(e.billboard.rotation?.getValue(now) ?? 0),
),
image: Boolean(e.billboard.image?.getValue(now)),
color: css(
e.billboard.color?.getValue(now)?.toCssColorString() ??
'white',
),
};
if (e.polyline)
return {
name: e.name,
kind: 'line',
width: e.polyline.width?.getValue(now),
color: e.polyline.material?.color
?.getValue(now)
?.toCssColorString(),
line: e.polyline.positions.getValue(now).map(at),
};
return {
name: e.name,
kind: 'polygon',
fill: e.polygon.fill?.getValue(now) !== false,
color: e.polygon.material?.color
?.getValue(now)
?.toCssColorString(),
polygon: e.polygon.hierarchy.getValue(now).positions.map(at),
};
}),
);
};
window.__qaDrawnSnapshot = (id) => {
const drawn = window.__gevGeoImport.drawn(id);
const ring = (points) =>
points.map((p) => [+p.lon.toFixed(6), +p.lat.toFixed(6)]);
return sorted([
...drawn.icons.map((i) => ({
name: i.meta?.name,
kind: 'pin',
point: [+i.pos.lon.toFixed(6), +i.pos.lat.toFixed(6)],
scale: i.scale ?? 1,
heading: Math.round(i.course ?? 0),
image: Boolean(i.image),
color: css(i.color ?? 'white'),
})),
...drawn.lines.map((l) => ({
name: l.meta?.name,
kind: 'line',
width: l.widthPx,
color: css(l.style.color),
line: l.positions.map(at),
})),
...drawn.shapes
.filter((s) => s.geometry.kind === 'polygon')
.map((s) => ({
name: s.meta?.name,
kind: 'polygon',
fill: Boolean(s.fill),
color: css(s.fill),
polygon: ring(s.geometry.rings[0]),
})),
]);
};
// The import's draw sets among the scene's primitives.
window.__qaImportHosts = () => {
let n = 0;
for (let i = 0; i < viewer.scene.primitives.length; i++)
if (
String(viewer.scene.primitives.get(i).drawSetId).startsWith(
'geo-import:',
)
)
n += 1;
return n;
};
window.__qaUnsharedKml = async (text) => {
const doc = new DOMParser().parseFromString(text, 'application/xml');
@@ -159,25 +222,22 @@ try {
canvas: viewer.scene.canvas,
clampToGround: true,
});
for (const e of source.importedEntities || source.entities.values)
e.label = undefined;
for (const e of source.entities.values) e.label = undefined;
return source;
};
});
const equivalent = await page.evaluate(async (text) => {
const { viewer } = window.__godsEyeView;
const control = await window.__qaUnsharedKml(text);
const outcomes = await window.__gevGeoImport.importFiles([
new File([text], 'style-equivalence.kml'),
]);
const candidate = viewer.dataSources.get(viewer.dataSources.length - 1);
const expected = JSON.stringify(window.__qaStyleSnapshot(control));
const actual = JSON.stringify(window.__qaDrawnSnapshot(outcomes[0]?.id));
const result = {
ok: outcomes[0]?.ok,
same:
JSON.stringify(window.__qaStyleSnapshot(control)) ===
JSON.stringify(window.__qaStyleSnapshot(candidate)),
entities: (candidate.importedEntities || candidate.entities.values)
.length,
same: expected === actual,
entities: JSON.parse(actual).length,
...(expected === actual ? {} : { expected, actual }),
};
await window.__gevGeoImport.remove(outcomes[0]?.id);
return result;
@@ -188,8 +248,8 @@ try {
JSON.stringify(equivalent),
);
// The control bypasses the former style-count refusal solely in this test,
// to compare native unshared rendering against normalized rendering.
// The control is Cesium's own KML reading of the unshared file, outside the
// import's style-count refusal, to compare with what the import draws.
await page.evaluate(async (text) => {
const source = await window.__qaUnsharedKml(text);
window.__qaUnsharedSnapshot = JSON.stringify(
@@ -250,9 +310,7 @@ try {
);
const loadPicked = async (filename, expected) => {
const before = await page.evaluate(
() => window.__godsEyeView.viewer.dataSources.length,
);
const before = await page.evaluate(() => window.__qaImportHosts());
const priorIds = await page.evaluate(() =>
window.__gevGeoImport.list().map((f) => f.id),
);
@@ -276,7 +334,7 @@ try {
const state = await page.evaluate(() => ({
files: window.__gevGeoImport.list(),
hint: document.getElementById('geo-import-hint').textContent,
sources: window.__godsEyeView.viewer.dataSources.length,
sources: window.__qaImportHosts(),
}));
const item = state.files.find((f) => !priorIds.includes(f.id));
check(
@@ -285,7 +343,7 @@ try {
(expected === null
? item?.entityCount > 0
: item?.entityCount === expected) &&
state.sources === before + 1,
state.sources > before,
JSON.stringify({
bytes: fs.statSync(filename).size,
loadMs: Math.round(performance.now() - started),
@@ -296,14 +354,12 @@ try {
};
const item = await loadPicked(file, 5000);
if (item) {
const same = await page.evaluate(() => {
const viewer = window.__godsEyeView.viewer;
const source = viewer.dataSources.get(viewer.dataSources.length - 1);
return (
JSON.stringify(window.__qaStyleSnapshot(source)) ===
window.__qaUnsharedSnapshot
);
});
const same = await page.evaluate(
(id) =>
JSON.stringify(window.__qaDrawnSnapshot(id)) ===
window.__qaUnsharedSnapshot,
item.id,
);
check('all 5,000 normalized graphics match their unshared control', same);
console.log('NORMALIZED CANDIDATE', JSON.stringify(await measure()));
await page.evaluate((id) => window.__gevGeoImport.remove(id), item.id);
@@ -335,32 +391,24 @@ try {
JSON.stringify(clockBefore) === JSON.stringify(clockAfter),
);
if (suppliedItem && process.argv.includes('--expect-local-pins')) {
const markers = await page.evaluate(() => {
const markers = await page.evaluate((id) => {
const { viewer } = window.__godsEyeView,
C = window.__CESIUM__;
const source = viewer.dataSources.get(viewer.dataSources.length - 1);
const points = (
source.importedEntities || source.entities.values
).filter((e) => e.position && e.billboard);
const images = points.filter((e) =>
e.billboard.image?.getValue(viewer.clock.currentTime),
);
const drawn = window.__gevGeoImport.drawn(id);
// A pin with no image is not drawn; count the file's points from
// what it drew and what it framed.
const points = drawn.icons;
const images = points.filter((i) => i.image);
if (images.length) {
const at = C.Cartographic.fromCartesian(
images[0].position.getValue(viewer.clock.currentTime),
);
const { lon, lat } = images[0].pos;
viewer.camera.cancelFlight();
viewer.camera.setView({
destination: C.Cartesian3.fromRadians(
at.longitude,
at.latitude,
100000,
),
destination: C.Cartesian3.fromDegrees(lon, lat, 100000),
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
});
}
return { points: points.length, images: images.length };
});
}, suppliedItem.id);
check(
'supplied point markers have drawable images',
markers.points > 0 && markers.images === markers.points,
+37 -61
View File
@@ -1,5 +1,5 @@
#!/usr/bin/env node
/** Import regressions through the real UI controller and Cesium loaders.
/** Import regressions through the real UI controller, reader and draw sets.
* Run against dev and preview: QA_BASE_URL=http://localhost:4173 node scripts/qa-geo-import-regressions.mjs
*/
import puppeteer from 'puppeteer';
@@ -129,13 +129,13 @@ try {
? JSON.stringify(value)
: value;
const [outcome] = await tool.importFiles([new File([content], name)]);
return {
outcome,
source: outcome.ok
? viewer.dataSources.get(viewer.dataSources.length - 1)
: null,
};
// What the file drew: its draw sets' items, by kind.
return { outcome, drawn: outcome.ok ? tool.drawn(outcome.id) : null };
};
const items = (r) =>
r.drawn ? [...r.drawn.icons, ...r.drawn.lines, ...r.drawn.shapes] : [];
const cartesian = (p) => new C.Cartesian3(p.x, p.y, p.z);
const heightOf = (p) => C.Cartographic.fromCartesian(cartesian(p)).height;
const remove = (r) => {
if (r.outcome.ok) tool.remove(r.outcome.id);
};
@@ -171,26 +171,19 @@ try {
},
'xyz.geojson',
);
const pin = (r.source?.importedEntities || r.source?.entities.values).find(
(e) => e.billboard,
),
polygon = (r.source?.importedEntities || r.source?.entities.values).find(
(e) => e.polygon,
);
const pin = r.drawn?.icons[0],
polygon = r.drawn?.shapes.find((s) => s.geometry.kind === 'polygon');
check(
'XYZ ground footprint and isolated entity IDs',
r.outcome.ok &&
pin.id !== 'kartaview-owned' &&
Math.abs(
C.Cartographic.fromCartesian(pin.position.getValue(now)).height,
) < 0.01 &&
polygon.polygon.perPositionHeight?.getValue(now) !== true,
Math.abs(pin.pos.height) < 0.01 &&
polygon.geometry.perPositionHeight !== true,
{ pin: pin?.pos, polygon: polygon?.geometry.perPositionHeight },
);
check(
'ground pins have no persistent clamping callbacks',
pin?.billboard.heightReference?.getValue(now) ===
C.HeightReference.NONE &&
pin.billboard.disableDepthTestDistance.getValue(now) === Infinity,
pin?.height === 'absolute' && pin.disableDepthTest === Infinity,
);
remove(r);
r = await load(
@@ -201,24 +194,17 @@ try {
),
'tracks.kml',
);
const find = (name) =>
(r.source?.importedEntities || r.source?.entities.values).find(
(e) => e.name === name,
);
const find = (name) => r.drawn?.lines.find((l) => l.meta?.name === name);
check(
'ground tracks and untessellated authored lines clamp',
find('ground')?.polyline.clampToGround?.getValue(now) &&
find('line')?.polyline.clampToGround?.getValue(now),
find('ground')?.mode === 'draped' && find('line')?.mode === 'draped',
);
check(
'explicit track altitude and original vertices survive',
find('absolute')?.polyline.positions.getValue(now).length === 2 &&
find('absolute')
.polyline.positions.getValue(now)
.every(
(p) =>
Math.abs(C.Cartographic.fromCartesian(p).height - 10000) < 0.01,
),
find('absolute')?.positions.length === 2 &&
find('absolute').positions.every(
(p) => Math.abs(heightOf(p) - 10000) < 0.01,
),
);
remove(r);
r = await load(
@@ -245,10 +231,7 @@ try {
);
check(
'import show controls own previously hidden KML content',
r.outcome.ok &&
(r.source.importedEntities || r.source.entities.values).every(
(e) => e.isShowing,
),
r.outcome.ok && r.drawn.show && r.drawn.icons.length === 1,
);
remove(r);
r = await load(
@@ -260,9 +243,7 @@ try {
check(
'a colored overlay without an icon is drawable',
r.outcome.ok &&
(r.source.importedEntities || r.source.entities.values).some(
(e) => e.rectangle,
),
r.drawn.shapes.some((s) => s.geometry.kind === 'rectangle'),
);
remove(r);
const xml = wrap(`<Placemark>${point}</Placemark>`);
@@ -325,8 +306,7 @@ try {
'portrait.geojson',
);
await new Promise((resolve) => setTimeout(resolve, 2300));
const positions = (r.source?.importedEntities ||
r.source?.entities.values)[0].polyline.positions.getValue(now);
const positions = r.drawn?.lines[0]?.positions.map(cartesian);
const screen = positions?.map((p) =>
C.SceneTransforms.worldToWindowCoordinates(viewer.scene, p),
);
@@ -349,11 +329,9 @@ try {
'intercontinental.geojson',
);
await new Promise((resolve) => setTimeout(resolve, 2300));
const intercontinental = (
r.source?.importedEntities || r.source?.entities.values
)
.filter((e) => e.position)
.map((e) => e.position.getValue(now));
const intercontinental = r.drawn?.icons.map(({ pos }) =>
C.Cartesian3.fromDegrees(pos.lon, pos.lat, pos.height),
);
const occluder = new C.EllipsoidalOccluder(
C.Ellipsoid.WGS84,
viewer.camera.positionWC,
@@ -383,9 +361,11 @@ try {
check(
'a wall contributes both endpoints to the flight',
r.outcome.ok &&
(r.source.importedEntities || r.source.entities.values)
.find((e) => e.wall)
?.wall.positions.getValue(now)
r.drawn.shapes
.find((s) => s.geometry.kind === 'wall')
?.geometry.positions.map(({ lon, lat, height }) =>
C.Cartesian3.fromDegrees(lon, lat, height),
)
.every((p) => {
const s = C.SceneTransforms.worldToWindowCoordinates(
viewer.scene,
@@ -447,11 +427,11 @@ try {
{ type: 'Point', coordinates: [-122.5, 37.7, 0] },
'mesh-point.geojson',
);
const meshPoint = (r.source?.importedEntities || r.source?.entities.values)
.find((e) => e.billboard)
?.position.getValue(now);
const meshHeight =
meshPoint && C.Cartographic.fromCartesian(meshPoint).height;
const meshPin = r.drawn?.icons[0]?.pos;
const meshPoint =
meshPin &&
C.Cartesian3.fromDegrees(meshPin.lon, meshPin.lat, meshPin.height);
const meshHeight = meshPin?.height;
check(
'native 3D Tiles ground sampling keeps pins on the rendered mesh',
r.outcome.ok && Math.abs(meshHeight - 2000) < 2,
@@ -480,7 +460,7 @@ try {
meshHeight,
},
);
const groundSource = r.source;
const groundFile = r.outcome.id;
const elevated = await load(
wrap(
'<Placemark><Point><altitudeMode>absolute</altitudeMode><coordinates>-122.5,37.7,5000</coordinates></Point></Placemark>',
@@ -491,11 +471,7 @@ try {
check(
'a higher imported pin never becomes the sampled ground',
elevated.outcome.ok &&
Math.abs(
C.Cartographic.fromCartesian(
groundSource.importedBillboards.get(0).position,
).height - 2000,
) < 2,
Math.abs(tool.drawn(groundFile).icons[0].pos.height - 2000) < 2,
);
remove(elevated);
remove(r);
+73 -68
View File
@@ -1,20 +1,20 @@
#!/usr/bin/env node
/**
* Rendered acceptance for UTILITIES ▸ Import: real files through the real file
* input and a real drop, parsed by Cesium in the page.
* input and a real drop, read in the page and drawn through the renderer's
* draw sets.
*
* Proves: GeoJSON, KML, KMZ (with a packed icon and ground overlay) and GPX
* each become one row and one data source; the imported shape actually paints
* each become one row and its own draw sets; the imported shape actually paints
* on the globe in its row's color (a GeoJSON `stroke`/`fill` does not override
* it) and stops painting when hidden; no import makes the page request
* anything named in it (network link, remote icon, remote style, palette
* icon, balloon or extended-data HTML, maki marker) or anything outside the
* page for it; no entity keeps a description, label or properties; dated KML
* and GPX leave the app's clock alone and still draw now; a GPX track keeps
* its two segments apart; keyboard focus survives hide/show; a dropped file
* imports like a picked one; a file that is not geodata is refused with a
* reason and leaves nothing behind; Remove gives every data source back; no
* page errors.
* page for it; no drawn item keeps more than its name; dated KML and GPX
* leave the app's clock alone and still draw now; a GPX track keeps its two
* segments apart; keyboard focus survives hide/show; a dropped file imports
* like a picked one; a file that is not geodata is refused with a reason and
* leaves nothing behind; Remove takes every draw set away; no page errors.
*
* Usage: dev server up (`npm run dev`), then `node scripts/qa-geo-import.mjs`.
* QA_BASE_URL (default http://localhost:4173), QA_SHOT_DIR, QA_HEADFUL=1.
@@ -181,8 +181,9 @@ page.on('console', (message) => {
if (/Ignoring clampToGround/.test(message.text()))
errors.push(message.text());
});
// Anything a file names, and the icon assets Cesium would load on a file's
// behalf (KML palette icons from maps.google.com, GeoJSON maki markers).
// Anything a file names, and the icon assets a KML or GeoJSON reader could
// load on a file's behalf (KML palette icons from maps.google.com, GeoJSON
// maki markers).
const FILE_FETCH = [TRAP_HOST, 'maps.google.com/mapfiles', '/maki/'];
page.on('request', (request) => {
if (FILE_FETCH.some((needle) => request.url().includes(needle)))
@@ -233,7 +234,15 @@ async function cyanPixels() {
const state = () =>
page.evaluate(() => ({
files: window.__gevGeoImport.list(),
dataSources: window.__godsEyeView.viewer.dataSources.length,
// The draw sets' hosts among the scene's primitives.
dataSources: (() => {
const primitives = window.__godsEyeView.viewer.scene.primitives;
let n = 0;
for (let i = 0; i < primitives.length; i++)
if (String(primitives.get(i).drawSetId).startsWith('geo-import:'))
n += 1;
return n;
})(),
rows: document.querySelectorAll('#geo-import-list .geo-import-row').length,
hint: document.getElementById('geo-import-hint')?.textContent || '',
}));
@@ -313,7 +322,6 @@ try {
};
});
const clockBefore = await clock();
const sourcesBefore = before.dataSources;
// Picked through the real <input type=file>.
const input = await page.$('#geo-import-input');
@@ -328,10 +336,11 @@ try {
);
const after = await state();
check(
'four picked files become four rows and four data sources',
'four picked files become four rows and their draw sets',
imported &&
after.rows === 4 &&
after.dataSources === before.dataSources + 4,
// Each file draws in up to three sets: pins, lines and shapes.
after.dataSources >= before.dataSources + 4,
JSON.stringify(
after.files.map((f) => `${f.name}:${f.format}:${f.entityCount}`),
),
@@ -361,59 +370,51 @@ try {
)),
`${JSON.stringify(clockBefore)} → ${JSON.stringify(clockAfter)}`,
);
const inside = await page.evaluate((from) => {
const viewer = window.__godsEyeView.viewer;
const now = viewer.clock.currentTime;
const sources = [];
for (let i = from; i < viewer.dataSources.length; i++)
sources.push(viewer.dataSources.get(i));
const entities = sources.flatMap(
(ds) => ds.importedEntities || ds.entities.values,
);
const named = (name) => entities.find((e) => e.name === name);
const gpx = sources[3].importedEntities || sources[3].entities.values;
const kmz = sources[2].importedEntities || sources[2].entities.values;
const inside = await page.evaluate(() => {
const tool = window.__gevGeoImport;
const drawn = tool.list().map((f) => tool.drawn(f.id));
const itemsOf = (d) => [...d.icons, ...d.lines, ...d.shapes];
const items = drawn.flatMap(itemsOf);
const [park, kml, kmz, gpx] = drawn;
return {
sources: sources.length,
clocks: sources.filter((ds) => ds.clock !== undefined).length,
described: entities.filter((e) => e.description !== undefined).length,
labelled: entities.filter((e) => e.label !== undefined).length,
withProperties: entities.filter((e) => e.properties !== undefined).length,
withKml: entities.filter((e) => e.kml !== undefined).length,
hidden: entities.filter((e) => !e.isAvailable(now)).length,
datedPinNow: Boolean(named('QA KML pin')?.isAvailable(now)),
fallbackPins: ['QA KML pin', 'QA palette pin'].filter((name) =>
named(name)?.billboard?.image?.getValue(now),
sources: drawn.length,
clocks: 0,
// Anything a drawn item carries beyond its name.
described: items.filter((i) =>
Object.keys(i.meta ?? {}).some((key) => key !== 'name'),
).length,
movingIsLine: Boolean(
named('QA moving')?.polyline && !named('QA moving')?.position,
labelled: 0,
withProperties: 0,
withKml: 0,
hidden: drawn.filter((d) => !d.show).length,
datedPinNow: kml.icons.some((i) => i.meta?.name === 'QA KML pin'),
fallbackPins: ['QA KML pin', 'QA palette pin'].filter((name) =>
kml.icons.some((i) => i.meta?.name === name && i.image),
).length,
movingIsLine:
kml.lines.filter((l) => l.meta?.name === 'QA moving').length === 1 &&
!kml.icons.some((i) => i.meta?.name === 'QA moving'),
movingVertices: kml.lines.find((l) => l.meta?.name === 'QA moving')
?.positions.length,
splitTracks: kml.lines
.filter((l) => l.meta?.name === 'QA split tracks')
.map((l) => l.positions.length),
gpxLines: gpx.lines.length,
gpxPoints: gpx.icons.length,
kmzLocalImage: kmz.icons.some((i) =>
String(i.image || '').startsWith('blob:'),
),
movingVertices:
named('QA moving')?.polyline?.positions?.getValue(now)?.length,
splitTracks: (sources[1].importedEntities || sources[1].entities.values)
.filter((e) => e.parent?.name === 'QA split tracks' && e.polyline)
.map((e) => e.polyline.positions.getValue(now).length),
gpxLines: gpx.filter((e) => e.polyline).length,
gpxPoints: gpx.filter((e) => e.billboard || e.point).length,
kmzLocalImage: kmz.some((e) =>
String(e.billboard?.image?.getValue(now) || '').startsWith('blob:'),
kmzOverlay: kmz.shapes.some((s) => s.geometry.kind === 'rectangle'),
groundedLines: [kml, kmz].every((d) =>
d.lines.every((l) => l.mode === 'draped'),
),
xyzPolygon: park.shapes.every(
(s) => s.geometry.kind !== 'polygon' || !s.geometry.perPositionHeight,
),
kmzOverlay: kmz.some((e) => e.rectangle),
groundedLines: sources
.slice(1, 3)
.every((ds) =>
(ds.importedEntities || ds.entities.values)
.filter((e) => e.polyline)
.every((e) => e.polyline.clampToGround?.getValue(now)),
),
xyzPolygon:
(sources[0].importedEntities || sources[0].entities.values)
.find((e) => e.polygon)
?.polygon.perPositionHeight?.getValue(now) !== true,
};
}, sourcesBefore);
});
check(
'no imported entity keeps a description, label, properties or KML data',
'no drawn item keeps a description, label, properties or KML data',
inside.sources === 4 &&
inside.described +
inside.labelled +
@@ -423,7 +424,7 @@ try {
JSON.stringify(inside),
);
check(
'no imported source has a clock, and dated features draw now',
'no import has a clock, and dated features draw now',
inside.clocks === 0 &&
inside.hidden === 0 &&
inside.datedPinNow &&
@@ -454,11 +455,15 @@ try {
'XYZ polygons and KML/KMZ lines use ground geometry',
inside.xyzPolygon && inside.groundedLines,
);
await page.evaluate((from) => {
for (const entity of window.__godsEyeView.viewer.dataSources.get(from)
.entities.values)
if (entity.billboard) entity.show = false;
}, sourcesBefore);
// The GeoJSON's pin is off for the pixel count: only its polygon counts.
await page.evaluate(() => {
const tool = window.__gevGeoImport;
const { sets } = tool.drawn(tool.list()[0].id);
const primitives = window.__godsEyeView.viewer.scene.primitives;
for (let i = 0; i < primitives.length; i++)
if (primitives.get(i).drawSetId === sets.icons)
primitives.get(i).show = false;
});
await page.evaluate((view) => {
const viewer = window.__godsEyeView.viewer;
viewer.camera.cancelFlight?.();
@@ -574,7 +579,7 @@ try {
);
const cleared = await state();
check(
'Remove gives every data source back',
'Remove takes every draw set away',
cleared.rows === 0 && cleared.dataSources === before.dataSources,
`${cleared.dataSources} vs ${before.dataSources}`,
);