Draw nine layers' fills through engine.ground, one display each

Earthquakes, air quality, GNSS Integrity, fire perimeters, Prohibited &
Restricted Airspace, Active Fires, S2 GhostMaps, cyclone advisories and
submarine cables each have one render/display.js on the globe contract;
their render/cesium* and render/navara* files go. Their discs, cells,
polygons and corridors are engine.ground sets, so on Navara they come from
the one ground screen pass with exact colours instead of nine hand-written
classification passes and lit SDK vector layers. Cesium's look stays the
reference:

- Earthquake and air-quality discs have no outline (Cesium drew none on
  clamped ellipses); earthquake discs can now be picked on Navara too.
- Perimeters, drone zones and GhostMaps polygons outline their outer
  ring only, as Cesium did.
- GNSS cells stay out of the pick pass; cyclone cones, tracks and centres
  are culled by a port of Cesium's horizon occluder.
- Submarine cables are one ground corridor set, as Cesium batched them;
  landing points, tips and stems are movers and lines.
- FIRMS glows are a sprite set and its cells a ground set. The far-zoom
  heat raster, which no primitive draws yet, sits behind one seam,
  render/heatField.js, with a Cesium and a Navara backend.

The shared Navara ground helpers that only these layers used go
(navaraGroundCells, the cell and ground geometry, the zone renderers), as
does the ground prototype script.

Coupling: layer renderer lines fall from 1636/6953 to 1011/4832
(Cesium/Navara), Navara ground passes from 7 to 5, Cesium-importing files
from 65 to 53, engine.extensions reads from 26 to 19.
This commit is contained in:
German Khokhlov committed 2026-11-07 06:20:48 +04:00
1 parent 974a0b6361
commit 54fe0aea40
124 files changed
+8407 -9576

No files matched your search

+5 -12
View File
@@ -1,6 +1,5 @@
import { fromDegrees } from '../../geo/cartesian3.js';
import { createPerimetersCesiumRenderer } from './render/cesium.js';
export { containmentColor } from './render/cesium.js';
import { createPerimetersDisplay } from './render/display.js';
import {
PERIMETER_OVERLAY_SOURCE_ID,
perimeterAnchorDegrees,
@@ -51,13 +50,12 @@ function samePolygons(left, right) {
export function createFirePerimetersLayer({
source,
overlayHost = null,
screenSpaceEventHandlerFactory = null,
picking = null,
pointer = null,
inciwebSource = null,
inciwebPublications = null,
openExternal = null,
createRenderer = createPerimetersCesiumRenderer,
createRenderer = ({ engine }) => createPerimetersDisplay(engine),
} = {}) {
if (typeof source?.getSnapshot !== 'function')
throw new TypeError('Fire perimeters require a snapshot source');
@@ -90,8 +88,7 @@ export function createFirePerimetersLayer({
_linkRequest = null;
}
const canSelect = () =>
overlayHost && screenSpaceEventHandlerFactory && picking;
const canSelect = () => overlayHost && picking;
/**
* Refresh the InciWeb catalog off the render path: a hanging or failed
@@ -273,7 +270,7 @@ export function createFirePerimetersLayer({
throw new Error('Fire perimeter layer is already initialized');
initialized = true;
try {
if (viewer || engine) this.attachRenderer(viewer, { engine });
if (engine) this.attachRenderer(viewer, { engine });
} catch (error) {
this.destroy();
throw error;
@@ -283,11 +280,7 @@ export function createFirePerimetersLayer({
attachRenderer(viewer, { engine = null } = {}) {
if (!initialized || renderer)
throw new Error('Invalid fire perimeter scene attachment');
renderer = createRenderer({
viewer,
engine,
screenSpaceEventHandlerFactory,
});
renderer = createRenderer({ engine });
renderer.setVisible(_enabled);
if (geometry.size) renderer.replace([...geometry.values()]);
if (_enabled) {
+121 -151
View File
@@ -1,5 +1,7 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { createFakeEngine } from '../../globe/testing/fakeEngine.js';
import { createFakeGroundHarness } from '../../testSupport/groundDisplayEngines.mjs';
import { createFirePerimetersLayer } from './index.js';
function harness(
@@ -14,22 +16,14 @@ function harness(
}),
} = {},
) {
const sources = [];
const overlay = { entries: new Map(), visible: null };
const clicks = { handler: null, destroyed: 0 };
const owners = new Map();
const opened = [];
const viewer = {
scene: { pick },
dataSources: {
add(value) {
sources.push(value);
},
remove(value) {
sources.splice(sources.indexOf(value), 1);
},
},
};
const ground = createFakeGroundHarness();
const { engine } = ground;
// What a click picks: `scene.pick()` (null for nothing).
const scene = { pick };
engine.fake.script('pick', () => scene.pick() ?? undefined);
const layer = createFirePerimetersLayer({
source,
overlayHost: {
@@ -44,15 +38,6 @@ function harness(
},
hitTest: (x, y, options) => cardHit(x, y, options),
},
screenSpaceEventHandlerFactory: () => ({
setInputAction(callback) {
clicks.handler = callback;
},
destroy() {
clicks.destroyed += 1;
clicks.handler = null;
},
}),
picking: {
resolvePickId: (picked) => picked?.id ?? null,
isOwnedByOtherLayer: (layerId, pickedId) =>
@@ -67,9 +52,45 @@ function harness(
inciwebPublications: { getPublication: publication },
openExternal: (url) => opened.push(url),
});
layer.init(viewer);
layer.enable(viewer);
return { layer, viewer, sources, overlay, clicks, owners, opened };
layer.init(null, { engine });
layer.enable();
return {
layer,
engine,
ground,
scene,
overlay,
owners,
opened,
/** The perimeters' ground set (undefined once released). */
zones: () => ground.set('fire-perimeters'),
/** A click through the engine's input, picking `scene.pick()`. */
click: (event) => engine.fake.input('click', event),
};
}
// A layer on its own fake engine, for tests that only refresh.
function plainLayer(options) {
const layer = createFirePerimetersLayer({
overlayHost: {
setEntries() {},
setVisible() {},
clearSource() {},
hitTest: () => null,
},
picking: {
resolvePickId: () => null,
isOwnedByOtherLayer: () => false,
registerPickOwner() {},
unregisterPickOwner() {},
},
pointer: { isPointerFree: () => true },
openExternal: () => {},
...options,
});
layer.init(null, { engine: createFakeEngine() });
layer.enable();
return layer;
}
const ring = [
@@ -97,21 +118,27 @@ const row = {
polygons: [[ring]],
};
test('each perimeter polygon renders as one filled entity with its fire line', async () => {
test('each perimeter polygon renders as one fill with its fire line', async () => {
const h = harness({
getSnapshot: async () => [
row,
{ ...row, stableId: 'other', polygons: [[ring], [ring]] },
],
});
assert.equal(await h.layer.update(h.viewer), true);
const entities = h.sources[0].entities.values;
assert.equal(entities.length, 3);
assert.equal(entities[0].id, 'fire-perimeter:2026-NMGNF-000123:0');
assert.ok(entities[0].polygon, 'perimeter fill missing');
assert.ok(entities[0].polyline, 'fire line missing');
assert.equal(entities[1].id, 'fire-perimeter:other:0');
assert.equal(entities[2].id, 'fire-perimeter:other:1');
assert.equal(await h.layer.update(), true);
const { items } = h.zones();
const ids = [
'fire-perimeter:2026-NMGNF-000123:0',
'fire-perimeter:other:0',
'fire-perimeter:other:1',
];
assert.equal(items.length, 6, 'a fill and a fire line per polygon');
assert.deepEqual(
items.map(({ pickId }) => pickId),
[...ids, ...ids],
);
assert.ok(items.slice(0, 3).every((item) => item.fill && !item.outline));
assert.ok(items.slice(3).every((item) => item.outline && !item.fill));
assert.equal(h.layer.getStats().count, 2);
});
@@ -126,14 +153,14 @@ test('late refresh cannot publish after disable or destroy', async () => {
});
},
});
const pending = h.layer.update(h.viewer);
h.layer[action](h.viewer);
const pending = h.layer.update();
h.layer[action]();
assert.equal(signal.aborted, true);
if (action === 'disable') h.layer.enable(h.viewer);
if (action === 'disable') h.layer.enable();
resolve([row]);
assert.equal(await pending, false);
assert.equal(h.layer.getStats().count, 0);
h.layer.destroy(h.viewer);
h.layer.destroy();
}
});
@@ -145,8 +172,8 @@ test('clicking a perimeter publishes its incident card; empty space clears it',
pick: () => pickResult,
},
);
await h.layer.update(h.viewer);
assert.equal(typeof h.clicks.handler, 'function', 'click handler missing');
await h.layer.update();
assert.equal(h.ground.listeners(), 1, 'click handler missing');
// Deliberately NOT registered as a pick owner: sibling layers' click
// handlers yield to owned picks before their own card hit-tests, so
// claiming these large ground polygons would make FIRMS/vessel/CCTV
@@ -154,7 +181,7 @@ test('clicking a perimeter publishes its incident card; empty space clears it',
assert.equal(h.owners.size, 0);
pickResult = { id: 'fire-perimeter:2026-NMGNF-000123:0' };
h.clicks.handler({ position: { x: 10, y: 10 } });
h.click({ position: { x: 10, y: 10 } });
const entries = h.overlay.entries.get('fire-perimeters');
assert.equal(entries.length, 1);
assert.equal(entries[0].id, 'fire-perimeter-card:2026-NMGNF-000123');
@@ -162,7 +189,7 @@ test('clicking a perimeter publishes its incident card; empty space clears it',
assert.ok(entries[0].position, 'card must carry a world anchor');
pickResult = { id: 'other-layer:aircraft-1' };
h.clicks.handler({ position: { x: 10, y: 10 } });
h.click({ position: { x: 10, y: 10 } });
assert.equal(
h.overlay.entries.get('fire-perimeters')?.length,
1,
@@ -170,7 +197,7 @@ test('clicking a perimeter publishes its incident card; empty space clears it',
);
pickResult = null;
h.clicks.handler({ position: { x: 10, y: 10 } });
h.click({ position: { x: 10, y: 10 } });
assert.equal(h.overlay.entries.get('fire-perimeters')?.length ?? 0, 0);
});
@@ -179,10 +206,10 @@ test('disable removes the click handler, pick ownership, and any card', async ()
{ getSnapshot: async () => [row] },
{ pick: () => ({ id: 'fire-perimeter:2026-NMGNF-000123:0' }) },
);
await h.layer.update(h.viewer);
h.clicks.handler({ position: { x: 10, y: 10 } });
h.layer.disable(h.viewer);
assert.equal(h.clicks.destroyed, 1);
await h.layer.update();
h.click({ position: { x: 10, y: 10 } });
h.layer.disable();
assert.equal(h.ground.listeners(), 0);
assert.equal(h.owners.has('fire-perimeters'), false);
assert.equal(h.overlay.entries.has('fire-perimeters'), false);
});
@@ -193,11 +220,11 @@ test('a refresh that drops the selected incident also drops its card', async ()
{ getSnapshot: async () => rows },
{ pick: () => ({ id: 'fire-perimeter:2026-NMGNF-000123:0' }) },
);
await h.layer.update(h.viewer);
h.clicks.handler({ position: { x: 10, y: 10 } });
await h.layer.update();
h.click({ position: { x: 10, y: 10 } });
assert.equal(h.overlay.entries.get('fire-perimeters').length, 1);
rows = [{ ...row, stableId: 'different' }];
await h.layer.update(h.viewer);
await h.layer.update();
assert.equal(h.overlay.entries.get('fire-perimeters')?.length ?? 0, 0);
});
@@ -218,12 +245,12 @@ test('a matched incident card carries the InciWeb line and click-through', async
cardHit: () => cardHitResult,
},
);
await h.layer.update(h.viewer);
await h.layer.update();
// Select via a perimeter pick.
h.viewer.scene.pick = () => ({
h.scene.pick = () => ({
id: 'fire-perimeter:2026-NMGNF-000123:0',
});
h.clicks.handler({ position: { x: 10, y: 10 } });
h.click({ position: { x: 10, y: 10 } });
// The card publishes immediately; the link line lands once the
// publication's currency is validated.
assert.equal(h.overlay.entries.get('fire-perimeters').length, 1);
@@ -233,8 +260,8 @@ test('a matched incident card carries the InciWeb line and click-through', async
// Clicking the card itself opens the InciWeb page.
cardHitResult = { entryId: entries[0].id };
h.viewer.scene.pick = () => null;
h.clicks.handler({ position: { x: 12, y: 12 } });
h.scene.pick = () => null;
h.click({ position: { x: 12, y: 12 } });
assert.deepEqual(h.opened, ['https://inciweb.wildfire.gov/node/329300']);
assert.equal(
h.overlay.entries.get('fire-perimeters').length,
@@ -253,16 +280,16 @@ test('an unmatched incident renders no InciWeb line and card clicks stay inert',
cardHit: () => cardHitResult,
},
);
await h.layer.update(h.viewer);
h.clicks.handler({ position: { x: 10, y: 10 } });
await h.layer.update();
h.click({ position: { x: 10, y: 10 } });
const entries = h.overlay.entries.get('fire-perimeters');
assert.equal(
entries[0].details.some((line) => line.includes('InciWeb')),
false,
);
cardHitResult = { entryId: entries[0].id };
h.viewer.scene.pick = () => null;
h.clicks.handler({ position: { x: 12, y: 12 } });
h.scene.pick = () => null;
h.click({ position: { x: 12, y: 12 } });
assert.deepEqual(h.opened, []);
assert.equal(h.overlay.entries.get('fire-perimeters').length, 1);
});
@@ -283,8 +310,8 @@ test('a complex member resolves to its complex page from the catalog', async ()
],
},
);
await h.layer.update(h.viewer);
h.clicks.handler({ position: { x: 10, y: 10 } });
await h.layer.update();
h.click({ position: { x: 10, y: 10 } });
await new Promise((done) => setTimeout(done, 0));
const entries = h.overlay.entries.get('fire-perimeters');
assert.equal(entries[0].details.at(-1), 'InciWeb ↗ · click card to open');
@@ -317,8 +344,8 @@ test('a stale or unverifiable publication yields no link', async () => {
publication,
},
);
await h.layer.update(h.viewer);
h.clicks.handler({ position: { x: 10, y: 10 } });
await h.layer.update();
h.click({ position: { x: 10, y: 10 } });
await new Promise((done) => setTimeout(done, 0));
const entries = h.overlay.entries.get('fire-perimeters');
assert.equal(entries.length, 1);
@@ -327,99 +354,47 @@ test('a stale or unverifiable publication yields no link', async () => {
false,
);
assert.equal(entries[0].interactive, false);
h.layer.destroy(h.viewer);
h.layer.destroy();
}
});
test('a hanging InciWeb index fetch never blocks the perimeter refresh', async () => {
const h = harness({ getSnapshot: async () => [row] }, { inciwebIndex: null });
// Replace the index source with one that never resolves.
h.layer.destroy(h.viewer);
h.layer.destroy();
const hanging = harness({ getSnapshot: async () => [row] });
hanging.layer.destroy(hanging.viewer);
const sources = [];
const viewer = {
scene: { pick: () => null },
dataSources: {
add: (v) => sources.push(v),
remove: (v) => sources.splice(sources.indexOf(v), 1),
},
};
const layer = createFirePerimetersLayer({
hanging.layer.destroy();
const layer = plainLayer({
source: { getSnapshot: async () => [row] },
overlayHost: {
setEntries() {},
setVisible() {},
clearSource() {},
hitTest: () => null,
},
screenSpaceEventHandlerFactory: () => ({
setInputAction() {},
destroy() {},
}),
picking: {
resolvePickId: () => null,
isOwnedByOtherLayer: () => false,
registerPickOwner() {},
unregisterPickOwner() {},
},
pointer: { isPointerFree: () => true },
inciwebSource: { getIndex: () => new Promise(() => {}) },
inciwebPublications: {
getPublication: async () => ({ createdMs: 1, changedMs: 1 }),
},
openExternal: () => {},
});
layer.init(viewer);
layer.enable(viewer);
assert.equal(await layer.update(viewer), true);
assert.equal(await layer.update(), true);
assert.equal(layer.getStats().count, 1);
layer.destroy(viewer);
layer.destroy();
});
test('an InciWeb outage never breaks the perimeter refresh', async () => {
const h = harness({ getSnapshot: async () => [row] });
const failing = createFirePerimetersLayer({
const failing = plainLayer({
source: { getSnapshot: async () => [row] },
overlayHost: {
setEntries() {},
setVisible() {},
clearSource() {},
hitTest: () => null,
},
screenSpaceEventHandlerFactory: () => ({
setInputAction() {},
destroy() {},
}),
picking: {
resolvePickId: () => null,
isOwnedByOtherLayer: () => false,
registerPickOwner() {},
unregisterPickOwner() {},
},
pointer: { isPointerFree: () => true },
inciwebSource: {
getIndex: async () => {
throw new Error('InciWeb HTTP 503');
},
},
openExternal: () => {},
});
const viewer = {
scene: { pick: () => null },
dataSources: { add() {}, remove() {} },
};
failing.init(viewer);
failing.enable(viewer);
assert.equal(await failing.update(viewer), true);
assert.equal(await failing.update(), true);
assert.equal(failing.getStats().count, 1);
failing.destroy(viewer);
h.layer.destroy(h.viewer);
failing.destroy();
h.layer.destroy();
});
test('analyst records expose incident facts without geometry payloads', async () => {
const h = harness({ getSnapshot: async () => [row] });
await h.layer.update(h.viewer);
await h.layer.update();
const records = h.layer.getAnalystRecords();
assert.equal(records.length, 1);
assert.equal(records[0].name, 'Fixture Fire');
@@ -438,40 +413,34 @@ test('analyst records expose incident facts without geometry payloads', async ()
assert.equal('polygons' in records[0], false);
});
test('unchanged snapshots retain entity identity even if source ordering changes', async () => {
test('unchanged snapshots keep the drawn perimeters even if source ordering changes', async () => {
let rows = [row, { ...row, stableId: 'other' }];
const h = harness({ getSnapshot: async () => rows });
await h.layer.update();
const original = [...h.sources[0].entities.values];
let removals = 0;
const entities = h.sources[0].entities;
const removeAll = entities.removeAll.bind(entities);
entities.removeAll = () => {
removals++;
removeAll();
};
const original = h.zones();
const redraws = () => h.zones().commits - original.commits;
rows = [...rows].reverse();
await h.layer.update();
assert.equal(removals, 0);
assert.equal(entities.values[0], original[0]);
assert.equal(redraws(), 0);
assert.equal(h.zones().items, original.items);
rows = rows.map((value) => ({
...value,
updatedTime: value.updatedTime + 1,
}));
await h.layer.update();
assert.equal(removals, 1);
assert.notEqual(entities.values[0], original[0]);
assert.equal(redraws(), 1);
assert.notEqual(h.zones().items, original.items);
rows = rows.map((value) => ({ ...value, containedPct: 100 }));
await h.layer.update();
assert.equal(
removals,
redraws(),
2,
'incident facts can change without a new polygon timestamp',
);
assert.equal(h.layer.getRowControls().legend[3].count, 2);
rows = [];
await h.layer.update();
assert.equal(entities.values.length, 0);
assert.equal(h.zones().items.length, 0);
h.layer.destroy();
});
@@ -538,11 +507,11 @@ for (const action of ['disable', 'destroy', 'selection']) {
},
);
await h.layer.update();
h.clicks.handler({ position: { x: 1, y: 1 } });
h.click({ position: { x: 1, y: 1 } });
assert.equal(signal.aborted, false);
if (action === 'selection') {
pick = { id: 'fire-perimeter:other:0' };
h.clicks.handler({ position: { x: 1, y: 1 } });
h.click({ position: { x: 1, y: 1 } });
} else h.layer[action]();
assert.equal(signal.aborted, true);
const entries = h.overlay.entries.get('fire-perimeters');
@@ -560,11 +529,11 @@ test('a stale snapshot reads stale, dated by its own fetch, and a fresh one clea
getSnapshot: async () => snapshot.rows,
getSnapshotDetail: async () => snapshot,
});
await h.layer.update(h.viewer);
await h.layer.update();
assert.equal(h.layer.getStats().stale, true);
assert.equal(h.layer.getStats().lastUpdate, fetchedAt);
snapshot = { rows: [row], stale: false, fetchedAt: Date.now() };
await h.layer.update(h.viewer);
await h.layer.update();
assert.equal(h.layer.getStats().stale, false);
assert.ok(h.layer.getStats().lastUpdate > fetchedAt);
});
@@ -578,10 +547,10 @@ test('a failed refresh after a stale snapshot reads as the failure, not stale',
return { rows: [row], stale: true, fetchedAt: Date.now() - 60_000 };
},
});
await h.layer.update(h.viewer);
await h.layer.update();
assert.equal(h.layer.getStats().stale, true);
fail = true;
await h.layer.update(h.viewer);
await h.layer.update();
assert.equal(h.layer.getStats().stale, false);
assert.equal(h.layer.getStats().error, 'WFIGS HTTP 502');
});
@@ -603,19 +572,20 @@ test('a selected fire retains its card and changed polygon through a scene hando
);
try {
await h.layer.update();
h.clicks.handler({ position: { x: 0, y: 0 } });
h.click({ position: { x: 0, y: 0 } });
assert.equal(
h.overlay.entries.get('fire-perimeters')[0].id,
'fire-perimeter-card:incident:one',
);
h.layer.detachRenderer();
assert.equal(h.sources.length, 0);
assert.equal(h.ground.sets(), 0);
geometry = [[ring.map(([lon, lat]) => [lon + 0.1, lat])]];
assert.equal(await h.layer.update(), true);
const record = h.layer.getAnalystRecords()[0];
assert.equal(record.id, 'incident:one');
h.layer.attachRenderer(h.viewer);
assert.equal(h.sources[0].entities.values.length, 1);
h.layer.attachRenderer(null, { engine: h.engine });
assert.equal(h.zones().items.length, 2, 'the fill and its fire line');
assert.equal(h.zones().items[0].rings[0][0][0], ring[0][0] + 0.1);
assert.equal(
h.overlay.entries.get('fire-perimeters')[0].id,
'fire-perimeter-card:incident:one',
-20
View File
@@ -1,20 +0,0 @@
import * as Cesium from 'cesium';
import { containmentAccent } from '../cards.js';
import { createZonesCesiumRenderer } from '../../shared/render/cesiumZones.js';
/** Fill/line color for a perimeter by containment progress (same ramp as the card accent). */
export function containmentColor(containedPct) {
return Cesium.Color.fromCssColorString(containmentAccent(containedPct));
}
export function createPerimetersCesiumRenderer({
viewer,
screenSpaceEventHandlerFactory,
}) {
return createZonesCesiumRenderer({
viewer,
screenSpaceEventHandlerFactory,
name: 'fire-perimeters',
idPrefix: 'fire-perimeter',
colorOf: (row) => containmentAccent(row.containedPct),
});
}
+83
View File
@@ -0,0 +1,83 @@
// The fire perimeters on the globe contract (engine.ground, engine.input),
// the same on every engine: each row's polygons (holes kept) as a 0.25
// fill in its containment colour, under a 2 px ground outline at 0.9 along
// the outer ring only, every polygon and its outline picked as
// `fire-perimeter:${stableId}:${index}`. All fills come before all outlines
// in the set, so an outline is never covered by a later fill (on Cesium the
// outlines are one batch over the fills).
import { rgbaFromCss } from '../../shared/color.js';
import { containmentAccent } from '../cards.js';
const SET_ID = 'fire-perimeters';
const FILL_ALPHA = 0.25;
const OUTLINE_ALPHA = 0.9;
const OUTLINE_PX = 2;
/** What a pick of a perimeter's polygon returns. */
export const perimeterPickId = (row, index) =>
`fire-perimeter:${row.stableId}:${index}`;
/**
* The perimeters: `{ setVisible, replace(rows), onClick(listener) → remove,
* pick(click), destroy }`. A click listener gets the engine's click with its
* pick; pick(click) is that pick (null for none).
* @param {import('../../../globe/contract.js').GlobeEngine} engine
*/
export function createPerimetersDisplay(engine) {
if (!engine?.ground)
throw new TypeError('The fire perimeters display needs a globe engine');
const set = engine.ground.createSet({
id: SET_ID,
kind: 'polygon',
pickable: true,
});
set.show(false);
let destroyed = false;
const removers = new Set();
return {
setVisible(show) {
if (!destroyed) set.show(show);
},
replace(rows) {
if (destroyed) return;
const fills = [];
const outlines = [];
for (const row of rows) {
const { red, green, blue } = rgbaFromCss(
containmentAccent(row.containedPct),
);
for (const [index, rings] of row.polygons.entries()) {
const pickId = perimeterPickId(row, index);
fills.push({ rings, fill: [red, green, blue, FILL_ALPHA], pickId });
outlines.push({
rings: rings.slice(0, 1),
outline: {
color: [red, green, blue, OUTLINE_ALPHA],
widthPx: OUTLINE_PX,
},
pickId,
});
}
}
set.replace([...fills, ...outlines]);
set.commit();
},
onClick(listener) {
if (destroyed) return () => {};
const remove = engine.input.on('click', listener, { pick: true });
const off = () => {
if (removers.delete(off)) remove();
};
removers.add(off);
return off;
},
pick: (click) => click?.picked ?? null,
destroy() {
if (destroyed) return;
destroyed = true;
for (const off of [...removers]) off();
set.destroy();
},
};
}
@@ -0,0 +1,269 @@
// The fire perimeters on the engine contract, on the fake engine and on the
// Cesium engine (its ground batches over fake primitives): fills with their
// holes at 0.25 and a 2 px fire line at 0.9 along the outer ring only, in
// the containment colour; clicks through the engine's input selecting an
// incident's card; visibility and teardown.
import assert from 'node:assert/strict';
import test from 'node:test';
import * as Cesium from 'cesium';
import * as geo from '../../../geo/index.js';
import {
GROUND_HARNESSES,
createFakeGroundHarness,
instanceColor,
} from '../../../testSupport/groundDisplayEngines.mjs';
import { rgbaFromCss } from '../../shared/color.js';
import { containmentAccent } from '../cards.js';
import { createFirePerimetersLayer } from '../index.js';
import { createPerimetersDisplay } from './display.js';
const outer = [
[-108.2, 35.1],
[-107.9, 35.1],
[-107.9, 35.4],
[-108.2, 35.4],
[-108.2, 35.1],
];
const hole = [
[-108.1, 35.2],
[-108.0, 35.2],
[-108.0, 35.3],
[-108.1, 35.2],
];
const second = outer.map(([lon, lat]) => [lon + 1, lat]);
const row = {
stableId: '2026-NMGNF-000123',
name: 'Fixture Fire',
acres: 512.5,
containedPct: 40,
state: 'US-NM',
discoveredTime: 1757900000000,
updatedTime: 1757950000000,
polygons: [[outer, hole]],
};
const other = {
...row,
stableId: 'other',
name: 'Other Fire',
containedPct: 100,
polygons: [[second], [second.map(([lon, lat]) => [lon, lat + 1])]],
};
const PICKS = [
'fire-perimeter:2026-NMGNF-000123:0',
'fire-perimeter:other:0',
'fire-perimeter:other:1',
];
const colorOf = (incident) =>
rgbaFromCss(containmentAccent(incident.containedPct));
// Per polygon: its incident's colour.
const COLORS = [colorOf(row), colorOf(other), colorOf(other)];
function fixture(makeHarness) {
const h = makeHarness();
const entries = new Map();
const layer = createFirePerimetersLayer({
source: { getSnapshot: async () => [row, other] },
overlayHost: {
setEntries: (id, value) => entries.set(id, value),
setVisible() {},
clearSource: (id) => entries.delete(id),
hitTest: () => null,
},
picking: {
resolvePickId: (picked) => picked?.id ?? null,
isOwnedByOtherLayer: (_layer, id) => id.startsWith('other-layer:'),
},
pointer: { isPointerFree: () => true },
});
layer.init(null, { engine: h.engine });
layer.enable();
return { ...h, layer, entries, card: () => entries.get('fire-perimeters') };
}
const near = (actual, expected, label, tolerance = 1e-9) =>
assert.ok(
Math.abs(actual - expected) < tolerance,
`${label}: ${actual} vs ${expected}`,
);
test('the display needs a globe engine', () => {
assert.throws(() => createPerimetersDisplay(null), TypeError);
});
for (const makeHarness of GROUND_HARNESSES) {
const { name } = makeHarness();
test(`each polygon is a 0.25 fill with its holes under a 2 px fire line at 0.9 on its outer ring (${name})`, async () => {
const f = fixture(makeHarness);
try {
assert.equal(await f.layer.update(), true);
const set = f.set('fire-perimeters');
assert.equal(set.options.kind, 'polygon');
assert.equal(set.options.pickable, true);
assert.equal(set.shown, true);
const fills = set.items.slice(0, 3);
const lines = set.items.slice(3);
assert.equal(set.items.length, 6, 'every fill, then every fire line');
assert.deepEqual(
fills.map(({ rings, pickId, outline }) => ({ rings, pickId, outline })),
[
{ rings: [outer, hole], pickId: PICKS[0], outline: undefined },
{ rings: [second], pickId: PICKS[1], outline: undefined },
{
rings: other.polygons[1],
pickId: PICKS[2],
outline: undefined,
},
],
);
assert.deepEqual(
lines.map(({ rings, pickId, fill, outline }) => ({
rings,
pickId,
fill,
widthPx: outline.widthPx,
})),
[
{ rings: [outer], pickId: PICKS[0], fill: undefined, widthPx: 2 },
{ rings: [second], pickId: PICKS[1], fill: undefined, widthPx: 2 },
{
rings: other.polygons[1],
pickId: PICKS[2],
fill: undefined,
widthPx: 2,
},
],
);
fills.forEach(({ fill }, index) =>
assert.deepEqual(fill, COLORS[index].withAlpha(0.25).rgba()),
);
lines.forEach(({ outline }, index) =>
assert.deepEqual(outline.color, COLORS[index].withAlpha(0.9).rgba()),
);
if (f.cesium) {
const primitives = f.primitives('fire-perimeters');
assert.equal(primitives.fills.length, 1, 'one fill batch');
assert.equal(primitives.lines.length, 1, 'one fire-line batch');
const fillInstances = primitives.fills[0].options.geometryInstances;
const lineInstances = primitives.lines[0].options.geometryInstances;
assert.equal(fillInstances.length, 3);
assert.equal(lineInstances.length, 3, 'no line along a hole');
assert.equal(
primitives.fills[0].options.classificationType,
Cesium.ClassificationType.BOTH,
);
assert.equal(primitives.fills[0].options.allowPicking, true);
assert.ok(fillInstances[0].geometry instanceof Cesium.PolygonGeometry);
assert.equal(
fillInstances[0].geometry._polygonHierarchy.holes.length,
1,
);
fillInstances.forEach((instance, index) =>
instanceColor(instance).forEach((channel, at) =>
near(
channel,
COLORS[index].withAlpha(0.25).rgba()[at],
`fill ${index}.${at}`,
0.5 / 255,
),
),
);
lineInstances.forEach((instance, index) => {
assert.ok(instance.geometry instanceof Cesium.GroundPolylineGeometry);
assert.equal(instance.geometry.width, 2);
assert.equal(instance.geometry.loop, true);
instanceColor(instance).forEach((channel, at) =>
near(
channel,
COLORS[index].withAlpha(0.9).rgba()[at],
`line ${index}.${at}`,
0.5 / 255,
),
);
});
}
f.layer.disable();
assert.equal(f.set('fire-perimeters').shown, false);
if (f.cesium) assert.equal(f.collectionShown('fire-perimeters'), false);
} finally {
f.layer.destroy();
}
assert.equal(f.sets(), 0);
f.destroy();
});
test(`a click on a perimeter or its fire line selects the incident; empty space clears it (${name})`, async () => {
const f = fixture(makeHarness);
try {
await f.layer.update();
assert.equal(f.listeners(), 1, 'one click listener while enabled');
f.click({ set: 'fire-perimeters', instance: 0 });
assert.equal(f.card()[0].id, 'fire-perimeter-card:2026-NMGNF-000123');
// The other incident's second fire line.
f.click({ set: 'fire-perimeters', instance: 5 });
assert.equal(f.card()[0].id, 'fire-perimeter-card:other');
f.click({ id: 'other-layer:aircraft-1' });
assert.equal(
f.card()[0].id,
'fire-perimeter-card:other',
'a sibling layer pick keeps the selection',
);
f.click(undefined);
assert.deepEqual(f.card(), []);
f.layer.disable();
assert.equal(f.listeners(), 0, 'disable removes the click listener');
f.layer.enable();
assert.equal(f.listeners(), 1);
f.layer.detachRenderer();
assert.equal(f.listeners(), 0, 'detach removes it too');
assert.equal(f.sets(), 0);
} finally {
f.layer.destroy();
f.destroy();
}
});
}
test('a click inside a perimeter picks it on the ground, not in its hole (the fake engine)', async () => {
const f = fixture(createFakeGroundHarness);
try {
await f.layer.update();
const clickAt = (lon, lat) => {
f.engine.camera.setView({
destination: geo.cartesian3.fromDegrees(lon, lat, 30_000),
});
const { width, height } = f.engine.host.size();
f.engine.fake.input('click', {
position: { x: width / 2, y: height / 2 },
});
};
clickAt(-108.15, 35.35);
assert.equal(f.card()[0].id, 'fire-perimeter-card:2026-NMGNF-000123');
clickAt(-108.03, 35.22);
assert.deepEqual(f.card(), [], 'the unburned hole is empty space');
} finally {
f.layer.destroy();
f.destroy();
}
});
test('the display ignores calls after destroy and destroys once', () => {
const h = createFakeGroundHarness();
const display = createPerimetersDisplay(h.engine);
assert.equal(h.set('fire-perimeters').shown, false, 'hidden until shown');
const off = display.onClick(() => {});
assert.equal(h.listeners(), 1);
display.destroy();
display.destroy();
assert.equal(h.listeners(), 0, 'destroy removes its click listeners');
off();
assert.equal(h.sets(), 0);
display.setVisible(true);
display.replace([row]);
assert.equal(h.listeners(), 0);
display.onClick(() => {})();
assert.equal(display.pick({}), null);
assert.equal(display.pick({ picked: { id: 'x' } }).id, 'x');
h.destroy();
});
-46
View File
@@ -1,46 +0,0 @@
// A prototype fire-perimeter renderer on engine.ground, for every engine:
// each row's polygons (holes kept) as a 0.25 fill under a 2 px outline at
// 0.9 in its containment colour, as the zones draw on Cesium, picked as
// `fire-perimeter:${stableId}:${index}`. Not wired into the layer:
// scripts/qa-ground-prototypes.mjs draws it next to cesium.js to compare.
import { rgbaFromCss } from '../../shared/color.js';
import { containmentAccent } from '../cards.js';
export function createPerimetersGroundRenderer(engine) {
const set = engine.ground.createSet({
id: 'fire-perimeters',
kind: 'polygon',
pickable: true,
});
set.show(false);
return {
setVisible(show) {
set.show(show);
},
replace(rows) {
const items = [];
for (const row of rows) {
const { red, green, blue } = rgbaFromCss(
containmentAccent(row.containedPct),
);
for (const [index, rings] of row.polygons.entries())
items.push({
rings,
fill: [red, green, blue, 0.25],
outline: { color: [red, green, blue, 0.9], widthPx: 2 },
pickId: `fire-perimeter:${row.stableId}:${index}`,
});
}
set.replace(items);
set.commit();
},
pick(event) {
return event.picked?.owner === 'fire-perimeters'
? { id: event.picked.id }
: null;
},
destroy() {
set.destroy();
},
};
}
-13
View File
@@ -1,13 +0,0 @@
import { containmentAccent } from '../cards.js';
import { createZonesNavaraRenderer } from '../../shared/render/navaraZones.js';
export function createPerimetersNavaraRenderer(engine, { view }) {
return createZonesNavaraRenderer(
engine,
{ view },
{
idPrefix: 'fire-perimeter',
colorOf: (row) => containmentAccent(row.containedPct),
},
);
}