Files
gods-eye-view/src/layers/ghostMaps/render/display.js
T
German Khokhlov 54fe0aea40 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.
2026-11-07 06:20:48 +04:00

389 lines
13 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// The GhostMaps drawing on the globe contract, the same on every engine.
// Each drawn product edition owns three sets:
// - a ground 'polygon' set: KML polygons, their fill and their outline;
// - a ground 'corridor' set: KML lines, in pixels;
// - a sprite mover set: placemark icons, from an atlas of the edition's
// decoded images.
// Picks return `ghostmaps:${productId}:${index}:${part}` (a polygon's
// outline adds `:outline`), which the layer resolves to its report.
// Placemarks draw over the scene (depth test off) and are hidden beyond the
// horizon instead, as they would sink into terrain and 3D tiles otherwise.
import * as geo from '../../../geo/index.js';
import { normalizeGroundItem } from '../../../globe/ground.js';
import { rgbaFromCss } from '../../shared/color.js';
import { imageAtlasLayout } from '../../shared/render/imageAtlas.js';
const LAYER_ID = 's2-ghostmaps';
const TRANSPARENT = Object.freeze([0, 0, 0, 0]);
const WHITE = Object.freeze([1, 1, 1, 1]);
// Polygons under lines; placemarks are movers, over every ground fill.
const POLYGON_ORDER = 0;
const LINE_ORDER = 1;
// Atlas cells hold an icon at its own size up to this side; a larger icon
// keeps its drawn size, from a smaller texture.
const MAX_CELL_PX = 128;
const CELL_PAD_PX = 2;
// The horizon test lifts each placemark by this much: to first order the
// same margin as an occluder 1000 m under WGS84, since ground can lie below
// the ellipsoid (NYC −22 m).
const HORIZON_LIFT_M = 2000;
const clamp = (value, low, high) => Math.max(low, Math.min(high, value));
/** A KML colour (rgba in 0..1), else the product colour, at `alpha` when given. */
function colorOf(rgba, fallback, alpha) {
if (rgba) return [rgba[0], rgba[1], rgba[2], alpha ?? rgba[3]];
const { red, green, blue } = rgbaFromCss(fallback);
return [red, green, blue, alpha ?? 1];
}
/** Placemark scale: the KML icon scale at 0.7, within 0.35..1.5. */
export const ghostMapsIconScale = (style) =>
clamp((style.iconScale ?? 1) * 0.7, 0.35, 1.5);
/** Line width in pixels, within 1.5..8. */
export const ghostMapsLineWidth = (style) =>
clamp(style.lineWidth ?? 2, 1.5, 8);
/** Polygon outline width in pixels, within 1.5..6. */
export const ghostMapsOutlineWidth = (style) =>
clamp(style.lineWidth ?? 2, 1.5, 6);
const imageFromUrl = async (url) => {
const image = new Image();
image.src = url;
await image.decode();
return image;
};
// An item the contract accepts, or null (a degenerate KML ring or line).
function checked(kind, item) {
try {
normalizeGroundItem(kind, item);
return item;
} catch {
return null;
}
}
/**
* The items of one edition's features, by kind; each carries the feature
* index it belongs to (`report`), so a report can be dropped in place.
*/
function editionItems(productId, features, color, markerImage) {
const polygons = [];
const lines = [];
const pins = [];
for (const [index, feature] of features.entries()) {
const { style } = feature;
feature.geometries.forEach((geometry, part) => {
const id = `ghostmaps:${productId}:${index}:${part}`;
if (geometry.type === 'point') {
const url = style.icon || markerImage(color);
if (!url) return;
const [lon, lat] = geometry.position;
pins.push({
report: index,
id,
url,
// On the ellipsoid: movers have no ground clamp.
position: geo.cartesian3.fromDegrees(lon, lat),
horizon: geo.cartesian3.fromDegrees(lon, lat, HORIZON_LIFT_M),
scale: ghostMapsIconScale(style),
color: style.icon && style.iconColor ? [...style.iconColor] : WHITE,
show: true,
});
} else if (geometry.type === 'line') {
const item = checked('corridor', {
positions: geometry.positions,
color: colorOf(style.lineColor, color),
widthPx: ghostMapsLineWidth(style),
pickId: id,
});
if (item) lines.push({ report: index, item });
} else {
const fill =
style.fill === false
? TRANSPARENT
: colorOf(
style.polyColor,
color,
style.polyColor ? undefined : 0.25,
);
const outline =
style.outline === false
? null
: {
color: colorOf(style.lineColor, color),
widthPx: ghostMapsOutlineWidth(style),
};
const area = checked('polygon', {
rings: [geometry.outer, ...geometry.holes],
fill,
// The outline runs on the outer ring only: a polygon with holes
// gets it as an item of its own.
...(outline && !geometry.holes.length ? { outline } : {}),
pickId: id,
});
if (!area) return;
polygons.push({ report: index, item: area });
if (outline && geometry.holes.length)
polygons.push({
report: index,
item: {
rings: [geometry.outer],
outline,
pickId: `${id}:outline`,
},
});
}
});
}
return { polygons, lines, pins };
}
/**
* The atlas of `images` (url → decoded image): one square cell per image,
* the image centred in it. Returns the atlas and, per url, its cell and
* drawn side in pixels.
*/
function packIcons(images, createCanvas) {
const entries = [...images].map(([url, image], index) => {
const width = image.naturalWidth || image.width || 1;
const height = image.naturalHeight || image.height || 1;
const side = Math.max(width, height);
const cell = Math.min(MAX_CELL_PX, side);
return { url, image, width, height, side, key: String(index), cell };
});
const cell = Math.max(...entries.map((entry) => entry.cell));
const layout = imageAtlasLayout(
entries.map(({ key, cell: size }) => ({ key, width: size, height: size })),
{ cell: cell + 2 * CELL_PAD_PX, pad: CELL_PAD_PX },
);
const canvas = createCanvas();
canvas.width = layout.width;
canvas.height = layout.height;
const context = canvas.getContext('2d');
if (!context) throw new Error('GhostMaps icons need a canvas');
const lookup = new Map();
entries.forEach((entry, index) => {
const { x, y } = layout.rects[index];
const fit = entry.cell / entry.side;
const width = entry.width * fit;
const height = entry.height * fit;
context.drawImage(
entry.image,
x + (entry.cell - width) / 2,
y + (entry.cell - height) / 2,
width,
height,
);
lookup.set(entry.url, { key: entry.key, side: entry.side });
});
return { atlas: { canvas, cells: layout.cells }, lookup };
}
/**
* @param {import('../../../globe/contract.js').GlobeEngine} engine
* @param {{ loadImage?: (url: string) => Promise<object>,
* createCanvas?: () => object }} [options] Test seams: icon decoding and
* the atlas canvas.
*/
export function createGhostMapsDisplay(
engine,
{
loadImage = imageFromUrl,
createCanvas = () => document.createElement('canvas'),
} = {},
) {
if (!engine?.ground || !engine?.movers)
throw new TypeError('The GhostMaps display needs a globe engine');
const paints = new Set();
let sequence = 0;
let destroyed = false;
let removeCull = null;
const lastCamera = geo.cartesian3.create(Number.NaN, 0, 0);
const request = () => engine.render.request(LAYER_ID);
// Hides the placemarks beyond the horizon; true when any show changed.
function cull(paint) {
let changed = false;
paint.pins.forEach((pin, index) => {
const show = engine.projector.horizonVisible(pin.horizon);
if (show === pin.show) return;
pin.show = show;
paint.sprites?.set(index, { show });
changed = true;
});
if (changed) paint.sprites?.commit();
return changed;
}
function cullAll() {
let changed = false;
for (const paint of paints) changed = cull(paint) || changed;
if (changed) request();
}
// Culls again whenever the camera moved, while any placemark is drawn.
function syncCull() {
const wanted = [...paints].some((paint) => paint.pins.length);
if (!wanted) {
removeCull?.();
removeCull = null;
return;
}
removeCull ??= engine.frames.preRender.addEventListener(() => {
const live = engine.camera.livePosition;
if (geo.cartesian3.equals(live, lastCamera)) return;
geo.cartesian3.clone(live, lastCamera);
cullAll();
});
}
function writePins(paint) {
const { sprites, pins, lookup } = paint;
if (!sprites) return;
pins.forEach((pin, index) => {
const cell = lookup.get(pin.url);
sprites.set(index, {
position: pin.position,
cell: cell.key,
scale: (pin.scale * cell.side) / paint.sizePx,
color: pin.color,
show: pin.show,
pickId: pin.id,
});
});
sprites.setCount(pins.length);
sprites.commit();
}
function commitGround(paint) {
paint.polygonSet.replace(paint.polygons.map(({ item }) => item));
paint.polygonSet.commit();
paint.lineSet.replace(paint.lines.map(({ item }) => item));
paint.lineSet.commit();
}
async function drawPins(paint) {
const urls = [...new Set(paint.pins.map((pin) => pin.url))];
const decoded = await Promise.allSettled(urls.map((url) => loadImage(url)));
if (paint.disposed) return;
const images = new Map();
decoded.forEach((result, index) => {
if (result.status === 'fulfilled' && result.value)
images.set(urls[index], result.value);
});
// An icon that does not decode draws nothing, as a billboard without
// an image.
paint.pins = paint.pins.filter((pin) => images.has(pin.url));
if (!paint.pins.length) return;
const { atlas, lookup } = packIcons(images, createCanvas);
paint.lookup = lookup;
paint.sizePx = Math.max(...[...lookup.values()].map(({ side }) => side));
paint.sprites = engine.movers.createSet({
id: `${paint.prefix}:pins`,
kind: 'sprite',
capacity: paint.pins.length,
depthTest: 'always',
pickable: true,
sprite: { atlas, sizePx: paint.sizePx },
});
for (const pin of paint.pins)
pin.show = engine.projector.horizonVisible(pin.horizon);
writePins(paint);
syncCull();
}
return {
requestRender: request,
onClick: (run) =>
engine.input.on('click', (event) => run(event, () => event.picked), {
pick: true,
}),
draw(productId, features, color, markerImage) {
if (destroyed) throw new Error('The GhostMaps display was destroyed');
const prefix = `${LAYER_ID}:${productId}:${++sequence}`;
const { polygons, lines, pins } = editionItems(
productId,
features,
color,
markerImage,
);
const paint = {
prefix,
polygons,
lines,
pins,
lookup: new Map(),
sizePx: 1,
sprites: null,
disposed: false,
polygonSet: engine.ground.createSet({
id: `${prefix}:polygons`,
kind: 'polygon',
order: POLYGON_ORDER,
pickable: true,
}),
lineSet: engine.ground.createSet({
id: `${prefix}:lines`,
kind: 'corridor',
order: LINE_ORDER,
pickable: true,
}),
};
paints.add(paint);
const dispose = () => {
if (paint.disposed) return;
paint.disposed = true;
paints.delete(paint);
paint.polygonSet.destroy();
paint.lineSet.destroy();
paint.sprites?.destroy();
paint.sprites = null;
paint.pins = [];
syncCull();
request();
};
let ready;
try {
commitGround(paint);
ready = drawPins(paint).then(() => {
if (!paint.disposed) request();
});
} catch (error) {
dispose();
throw error;
}
return {
ready,
// Take one report off in place: an expired event leaves its
// edition's drawing, which stays for the reports that remain.
drop(index) {
if (paint.disposed) return true;
const keep = ({ report }) => report !== index;
const before = paint.polygons.length + paint.lines.length;
paint.polygons = paint.polygons.filter(keep);
paint.lines = paint.lines.filter(keep);
if (paint.polygons.length + paint.lines.length !== before)
commitGround(paint);
const pins = paint.pins.filter(keep);
if (pins.length !== paint.pins.length) {
paint.pins = pins;
writePins(paint);
syncCull();
}
request();
return true;
},
destroy: dispose,
};
},
destroy() {
if (destroyed) return;
destroyed = true;
removeCull?.();
removeCull = null;
paints.clear();
},
};
}