Compare commits

..
Author SHA1 Message Date
Mazeyar Moeini FeizabadiandClaude Fable 5.2 63c9e80a40 docs(changelog): add the #1722 fragment
Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 18:03:35 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2 1923547d43 perf(cables): draw with batched primitives instead of entities
The layer loaded two GeoJsonDataSources and a CustomDataSource: 6,459
entities. Every enable rebuilt them (a 100-250 ms task or three and
about 1 GB of heap that stayed until the next collection), every disable
removed them in a 130-150 ms task, and each horizon sweep that showed a
landing marker made Cesium create its billboard again and read the
terrain height under it once more.

The layer now makes the primitives Cesium built from those entities
itself: one GroundPolylinePrimitive for every line, one
BillboardCollection for the point markers, one PointPrimitiveCollection
for the reference tips and one static polyline Primitive for the stems
in view, rebuilt in a worker when a sweep moves a tip. A disable hides
them and an enable shows them again, so only the first enable builds
anything. A marker is clamped to the ground once, 48 per frame as
before; after that Cesium follows the terrain within its own time budget
and hiding or showing the marker reads nothing. A map-stack change
re-classifies the lines in place.

Lines keep the distance-display attribute the entity display gave them:
with a float attribute present Cesium keeps the 2.5 px width, and
without one it is stored as a byte and drawn 2 px.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 17:59:47 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2 b6c241a68e docs(changelog): add the #1707 fragment
Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 16:05:57 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2 f42980a04d perf(cables): show landing markers a few per frame
Switching Submarine cables on after the globe had loaded held the page
for about 1.4 s in one task. 1.2 s of it was Cesium reading the terrain
height for each of the 1,917 ground-clamped landing markers as it created
them, all in the first frame, including the ones behind the globe that
the horizon sweep hid a moment later. The markers now start hidden and
the sweep shows the visible ones 48 per rendered frame.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 15:05:54 +01:00
22 changed files with 1365 additions and 1908 deletions

No files matched your search

@@ -0,0 +1,3 @@
- Shorten the freeze when Submarine cables is switched on from about 1.4 s to
about 0.2 s. Landing markers are now shown a few dozen per frame instead of
all at once (mazy1998, #1707).
@@ -1,4 +0,0 @@
- Make a whole-globe view of Live Flights about three times faster on a slow
CPU. Aircraft at cruise altitude no longer ask for the ground under them on
every pass, and a ground floor read no longer formats numbers into text
(mazy1998, #1708).
@@ -0,0 +1,4 @@
- Submarine cables draw from a few batched primitives instead of thousands of
entities. Switching the layer off and back on, and zooming with it on, no
longer stall the page, and it holds about 900 MB less memory. Double-click
no longer starts Cesium's entity tracking on a cable (mazy1998, #1722).
+32 -16
View File
@@ -1541,12 +1541,14 @@ query. Movement within an accepted or pending query reuses it. Markers retain
their Cesium identity while their geometry is unchanged; refreshes preserve
selection without replaying a click event.
Data Centers, Dams and Submarine Cables release their built Cesium data sources
Data Centers and Dams release their built Cesium data sources
and record references when disabled. Parsed datasets remain cached for the layer
lifetime, so re-enable rebuilds entities without downloading or parsing again;
this can take longer than simply revealing hidden entities. Destruction clears
the parsed cache as well. A disable during loading cannot leave a completed
build hidden in the scene.
build hidden in the scene. Submarine Cables draws with its own primitives
instead of entities and only hides them when disabled (see "Bundled geography
and submarine cable components").
CCTV exposes a factory through `./layers/cctv`. Catalog and health requests,
frame/media URLs, camera records, ground placement, geometry queues, playback,
@@ -2949,13 +2951,7 @@ visits to one place share a key but does not bound how many distinct places a
session visits, and the cache previously had no eviction, so a long session
retained every coordinate it ever resolved. Eviction is least-recently-used:
a consumer read, including a warm hit in a batch lookup, promotes its entry, so
the cell being watched is not dropped for having been resolved early. A
synchronous read (`cachedEllipsoidalGround`, `cachedRealEllipsoidalGround`)
promotes its entry only once half the bound's worth of stores and promotions
have passed since the entry was last newest, so an entry read at least that
often is still never evicted while the per-frame floor reads no longer rewrite
the cache; those reads find entries through a numeric key and format no
strings. The bound sits far above a city-scale session, so
the cell being watched is not dropped for having been resolved early. The bound sits far above a city-scale session, so
normal use never evicts and issues no additional proxy requests. A batch's
results are assembled from what that call resolved or found warm, so eviction
during a large batch cannot report one of its points as unresolved. Re:Earth and
@@ -8153,17 +8149,37 @@ an error. Without feeds it keeps the WebUSB statuses. See
Submarine cables use separate source, geometry, rendering, interaction and
lifecycle modules. The layer factory accepts cable and landing-point GeoJSON
collections from a source with `fetch(signal)` and a display label. The default
source loads the same bundled TeleGeography files. Disabling still removes all
three Cesium data sources; enabling rebuilds from the accepted parsed cache,
and destroying clears it. Load ownership prevents cancelled work from adding
entities after teardown.
source loads the same bundled TeleGeography files. Load ownership prevents
cancelled work from adding anything to the scene after teardown: the fetch is
the load's only await, and everything is built in the turn after it.
Every Cesium entity from multipart cable or landing-point geometry stays tied
to its source feature, including generated IDs and IDs that collide with
Cesium's multipart suffixes. Each segment gets its own feature's styling, click
The layer draws with four Cesium primitives of its own and creates no entity
or data source. Every line is one instance of a single
`GroundPolylinePrimitive` (per-line colour and show flag, rhumb lines,
tessellated in a worker; a map-stack change re-classifies it in place). Every
point is a billboard in one `BillboardCollection`. Reference tips are one
`PointPrimitiveCollection`, and the stems of the references in view are one
static polyline `Primitive`: a horizon sweep that moved a tip or changed which
references are in view builds a replacement in a worker, and it replaces the
shown stems once it is ready. Disabling hides the lines, markers and tips and
keeps them, so enabling again neither fetches nor builds them (only the stems
are redrawn, for the new view); destroying removes everything. These are
the same primitives Cesium built from the layer's entities, so the layer looks
the same. Polygon geometry in a custom source is not drawn, and GeoJSON
simplestyle properties (`marker-color`, `stroke` and the like) are not read.
Every line and marker from multipart cable or landing-point geometry stays tied
to its source feature. Each part gets its own feature's styling, click
destination and horizon-culling reference, and each source feature has one
reference stem. The source collections are not modified.
Landing markers are ground-clamped billboards. A marker starts hidden and
unclamped; the horizon sweep clamps and shows the visible ones 48 per rendered
frame (`CABLE_LANDING_REVEALS_PER_FRAME`), so the terrain height reads are
never one task. A marker is clamped once: Cesium then keeps it on the surface
as terrain loads, and hiding or showing it again reads nothing; hiding is
immediate.
Natural Earth regions and neighborhood polygon lookup are package exports.
Their existing lazy loaders, retry behavior, bundled datasets and attribution
are unchanged. The cable dataset remains CC BY-NC-SA 3.0 and is not covered by
-34
View File
@@ -311,10 +311,6 @@ export const COAST_FLOOR_LIFT_M = 1.5;
*/
export function floorCoastedPosition(position, cachedGroundFloor) {
if (typeof cachedGroundFloor !== 'function') return position;
// Most coasting contacts are at cruise, and this runs for each of them on
// every fleet pass. One above COAST_FLOOR_CEILING_M cannot be lifted by any
// ground, so it needs neither the geodetic conversion nor the floor read.
if (clearOfAllGround(position)) return position;
const carto = Cesium.Cartographic.fromCartesian(
position,
Cesium.Ellipsoid.WGS84,
@@ -338,36 +334,6 @@ export function floorCoastedPosition(position, cachedGroundFloor) {
const _coastCarto = new Cesium.Cartographic();
/**
* @constant {number} No ground reaches this height above the ellipsoid:
* Everest's summit is about 8,821 m (8,849 m above a geoid that sits 28 m
* below the ellipsoid there).
*/
export const COAST_FLOOR_CEILING_M = 9000;
const _oneOverRadiiSq = Cesium.Ellipsoid.WGS84.oneOverRadiiSquared;
const COAST_CLEAR_SCALED_SQ =
(1 + COAST_FLOOR_CEILING_M / Cesium.Ellipsoid.WGS84.minimumRadius) ** 2;
/**
* Whether a position is certainly more than COAST_FLOOR_CEILING_M above the
* ellipsoid, from three multiplications. Scale the axes so the ellipsoid is
* the unit sphere: a point h metres up its surface normal is then at most
* 1 + h / (polar radius) from the centre, so one further out than
* 1 + ceiling / (polar radius) is above the ceiling. At the equator this
* answers yes from about 30 m above the ceiling; at the poles, from the
* ceiling itself.
* @param {Cesium.Cartesian3} position
* @returns {boolean}
*/
function clearOfAllGround(position) {
return (
position.x * position.x * _oneOverRadiiSq.x +
position.y * position.y * _oneOverRadiiSq.y +
position.z * position.z * _oneOverRadiiSq.z >
COAST_CLEAR_SCALED_SQ
);
}
/**
* Seconds to coast past the last report: the elapsed time, bounded by the
* source's coast limit and STALE_COAST_MAX_SEC; none for a contact that
-77
View File
@@ -10,7 +10,6 @@ import {
liftRepeatedGroundFix, synthesizeForwardKinematicsFix,
projectGroundArcLatLon, corridorPathLatLon,
COURSE_TRACK_ONLY_MPS, COURSE_CHORD_ONLY_MPS, COURSE_MIN_DPS, TURN_MIN_SPEED_MPS,
floorCoastedPosition, COAST_FLOOR_CEILING_M, COAST_FLOOR_LIFT_M,
} from './motionModel.js';
const AUSTIN = { lat: 30.2672, lon: -97.7431, alt: 9000 };
@@ -342,79 +341,3 @@ test('corridorPathLatLon returns nothing without a display position', () => {
extrapolating: true, displayLat: NaN, displayLon: -97.66, courseDeg: 0, speedMps: 10, lookaheadSec: 60,
}), []);
});
/** floorCoastedPosition as it was before the cruise skip: always converts and reads. */
function floorCoastedReference(position, groundAt) {
const carto = Cesium.Cartographic.fromCartesian(position);
if (!carto) return position;
const ground = groundAt(
Cesium.Math.toDegrees(carto.latitude),
Cesium.Math.toDegrees(carto.longitude),
);
if (!Number.isFinite(ground) || carto.height >= ground + COAST_FLOOR_LIFT_M)
return position;
return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, ground + COAST_FLOOR_LIFT_M);
}
test('a coasting contact above any terrain is not looked up against the ground', () => {
let reads = 0;
const ground = () => {
reads += 1;
return 8821; // Everest's summit, the highest floor there is
};
// Just over the ceiling and at cruise, from pole to equator.
for (let lat = -90; lat <= 90; lat += 7.5) {
for (const lon of [0, 86.925, -78.8, 179.9]) {
for (const height of [COAST_FLOOR_CEILING_M + 35, 10_000, 12_500, 40_000]) {
const position = Cesium.Cartesian3.fromDegrees(lon, lat, height);
const before = Cesium.Cartesian3.clone(position);
assert.equal(floorCoastedPosition(position, ground), position);
assert.ok(Cesium.Cartesian3.equals(position, before));
}
}
}
assert.equal(reads, 0);
});
test('below the ceiling a coast is floored exactly as before', () => {
// Terrain that rises under the coast, known in some places and not others.
const ground = (lat, lon) => (Math.floor(lat * 10 + lon) % 3 === 0 ? null : 1500 + ((lat * 7 + lon * 3) % 900));
let lifted = 0;
let checked = 0;
for (let lat = -89; lat <= 89; lat += 5.5) {
for (let lon = -180; lon < 180; lon += 17) {
for (const height of [-40, 0, 800, 1499, 1501.4, 2399, 2402, 5000, 8990, 9000, 9010, 11_000, 30_000]) {
const position = Cesium.Cartesian3.fromDegrees(lon, lat, height);
const expected = floorCoastedReference(Cesium.Cartesian3.clone(position), ground);
const actual = floorCoastedPosition(position, ground);
assert.ok(
Cesium.Cartesian3.equals(actual, expected),
`coast at ${lat}, ${lon}, ${height} m`,
);
checked += 1;
if (!Cesium.Cartesian3.equals(expected, Cesium.Cartesian3.fromDegrees(lon, lat, height))) lifted += 1;
}
}
}
assert.ok(lifted > 500, `${lifted} of ${checked} coasts were lifted onto the ground`);
});
test('nothing at or below the ceiling skips the ground', () => {
let reads = 0;
const ground = () => {
reads += 1;
return null;
};
let asked = 0;
for (let lat = -90; lat <= 90; lat += 2.5) {
for (const height of [-400, 0, 4000, 8821, COAST_FLOOR_CEILING_M - 1, COAST_FLOOR_CEILING_M]) {
floorCoastedPosition(Cesium.Cartesian3.fromDegrees(33, lat, height), ground);
asked += 1;
}
}
assert.equal(reads, asked);
});
test('the ceiling clears the highest ground with room to spare', () => {
assert.ok(COAST_FLOOR_CEILING_M > 8849 + 100);
});
-1
View File
@@ -24,7 +24,6 @@ export {
createCableOverlayEntry,
cableClassificationTypeForStack,
cableClassificationTypeForScene,
applyTranslucentMarkerBlend,
createCableReferenceSweepGate,
updateCableReferenceStem,
} from '../layers/submarineCables/index.js';
File diff suppressed because it is too large. Load diff
+55
View File
@@ -77,3 +77,58 @@ export function normalizeFeatures(json, kind) {
};
});
}
function partPosition(value) {
if (!Array.isArray(value)) return null;
const lon = Number(value[0]);
const lat = Number(value[1]);
if (!Number.isFinite(lon) || !Number.isFinite(lat)) return null;
const height = Number(value[2]);
return Number.isFinite(height) ? [lon, lat, height] : [lon, lat];
}
function collectParts(geometry, out) {
const coordinates = geometry?.coordinates;
switch (geometry?.type) {
case 'Point': {
const point = partPosition(coordinates);
if (point) out.points.push(point);
break;
}
case 'MultiPoint':
for (const value of coordinates || []) {
const point = partPosition(value);
if (point) out.points.push(point);
}
break;
case 'LineString': {
const line = (coordinates || []).map(partPosition).filter(Boolean);
if (line.length >= 2) out.lines.push(line);
break;
}
case 'MultiLineString':
for (const part of coordinates || []) {
const line = (part || []).map(partPosition).filter(Boolean);
if (line.length >= 2) out.lines.push(line);
}
break;
case 'GeometryCollection':
for (const child of geometry.geometries || []) collectParts(child, out);
break;
default:
break;
}
}
/**
* The parts of a feature the layer draws: every line of a LineString or
* MultiLineString and every point of a Point or MultiPoint, also inside a
* GeometryCollection. Each is [lon, lat] or [lon, lat, height] in degrees
* and metres. Polygons are not drawn.
* @returns {{lines:number[][][],points:number[][]}}
*/
export function featureParts(feature) {
const out = { lines: [], points: [] };
collectParts(feature?.geometry, out);
return out;
}
+2 -1
View File
@@ -10,6 +10,7 @@ export function createSubmarineCableLayer({
screenSpaceEventHandlerFactory,
mapStackEventTarget = null,
sweepClock = defaultSweepClock,
createMarkerImage,
}) {
if (!source?.fetch || !source.label)
throw new TypeError(
@@ -23,6 +24,7 @@ export function createSubmarineCableLayer({
source,
screenSpaceEventHandlerFactory,
mapStackEventTarget,
createMarkerImage,
};
parts.rendering = createRendering(context);
parts.ingestion = createIngestion(context);
@@ -40,7 +42,6 @@ export {
export {
cableClassificationTypeForStack,
cableClassificationTypeForScene,
applyTranslucentMarkerBlend,
} from './surface.js';
export {
CABLE_REFERENCE_LABEL_WINNER_CAP,
+93 -174
View File
@@ -1,27 +1,82 @@
import { msg, t } from '../../i18n/index.js';
import {
featureLabel,
featureParts,
featureReference,
normalizeFeatures,
} from './geometry.js';
import * as Cesium from 'cesium';
const SOURCE_FEATURE_INDEX = '__gevSourceFeatureIndex';
function indexedCollection(features) {
return {
type: 'FeatureCollection',
features: features.map((feature, index) => ({
...feature,
properties: {
...feature.properties,
[SOURCE_FEATURE_INDEX]: index,
},
})),
};
}
const toCartesian = ([lon, lat, height]) =>
Cesium.Cartesian3.fromDegrees(lon, lat, height ?? 0);
export function createIngestion({ state, parts, source }) {
/**
* Turn the two feature collections into what rendering draws. Every part
* of a multipart feature is its own line or marker with its own pick
* record, all sharing the feature's reference; a feature gets one
* reference stem however many parts it has.
*/
function describeScene(cableFeatures, landingFeatures) {
const lines = [];
const markers = [];
const references = [];
const add = (features, kind, style) => {
for (const feature of features) {
const reference = featureReference(feature);
if (!reference) continue;
const label = featureLabel(feature);
const base = Cesium.Cartesian3.fromDegrees(
reference.lon,
reference.lat,
0,
);
const drawn = featureParts(feature);
const pick = () =>
parts.interaction.registerPick({ kind, reference, label });
for (const line of drawn.lines)
lines.push({
info: pick(),
base,
positions: line.map(toCartesian),
color: style.lineColor(feature),
width: style.lineWidth,
});
for (const point of drawn.points)
markers.push({
info: pick(),
base,
position: toCartesian(point),
hasHeight: point.length > 2,
color: style.color,
});
references.push({
reference,
label,
kind,
color: style.color,
feature,
});
}
};
add(cableFeatures, 'cable', {
color: state.cableColor,
lineWidth: 2.5,
lineColor: (feature) => {
const css = feature?.properties?.color;
const color = css && Cesium.Color.fromCssColorString(String(css));
return (color || state.cableColor).withAlpha(0.92);
},
});
const landingLine = state.landingColor.withAlpha(0.9);
add(landingFeatures, 'landing-point', {
color: state.landingColor,
lineWidth: 2,
lineColor: () => landingLine,
});
return { lines, markers, references };
}
async function load(viewer) {
if (state._loading || state._loaded) return;
@@ -30,10 +85,10 @@ export function createIngestion({ state, parts, source }) {
state._loadingLabel = t('loading...');
// Ownership token (the militaryAwareness activationId pattern): a
// disable/abort followed by a fresh enable starts a NEWER load while this
// one is still settling. The stale load must bail after every await and
// one is still settling. The stale load must bail after its await and
// must never touch shared lifecycle state or the viewer it no longer
// owns — clearing `_loading`/`_abort` for the successor is how duplicate
// or post-destroy data sources got added.
// or post-destroy primitives would get added.
const generation = ++state._loadGeneration;
const abort = new AbortController();
state._abort = abort;
@@ -41,170 +96,34 @@ export function createIngestion({ state, parts, source }) {
generation === state._loadGeneration && !abort.signal.aborted;
try {
let cableJson = state._cachedCableJson;
let landingJson = state._cachedLandingJson;
if (!cableJson || !landingJson) {
({ cables: cableJson, landingPoints: landingJson } = await source.fetch(
abort.signal,
));
if (!owns()) return;
if (
!Array.isArray(cableJson?.features) ||
!Array.isArray(landingJson?.features)
) {
throw new TypeError(
'A cable source must return cables and landingPoints GeoJSON collections',
);
}
state._cachedCableJson = cableJson;
state._cachedLandingJson = landingJson;
const { cables: cableJson, landingPoints: landingJson } =
await source.fetch(abort.signal);
// The fetch is the only await: everything after it runs in this one
// turn, so no disable or destroy can land between the ownership check
// and the primitives reaching the scene.
if (!owns()) return;
if (
!Array.isArray(cableJson?.features) ||
!Array.isArray(landingJson?.features)
) {
throw new TypeError(
'A cable source must return cables and landingPoints GeoJSON collections',
);
}
const cableFeatures = normalizeFeatures(cableJson, 'cable');
const landingFeatures = normalizeFeatures(landingJson, 'landing');
const cableDataSource = await Cesium.GeoJsonDataSource.load(
indexedCollection(cableFeatures),
{
clampToGround: true,
stroke: state.cableColor.withAlpha(0.95),
fill: state.cableColor.withAlpha(0.18),
strokeWidth: 2,
markerColor: state.cableColor,
markerSize: 6,
},
);
if (!owns()) return;
const landingDataSource = await Cesium.GeoJsonDataSource.load(
indexedCollection(landingFeatures),
{
clampToGround: true,
stroke: state.landingColor.withAlpha(0.9),
fill: state.landingColor.withAlpha(0.35),
strokeWidth: 2,
markerColor: state.landingColor,
markerSize: 6,
},
);
if (!owns()) return;
cableDataSource.name = `${source.label} Submarine Cables`;
landingDataSource.name = `${source.label} Landing Points`;
const referenceDataSource = new Cesium.CustomDataSource(
`${source.label} Cable References`,
);
const addedSources = [
cableDataSource,
landingDataSource,
referenceDataSource,
];
// dataSources.add() is itself an await point: Cesium mutates the
// collection on a DEFERRED tick, so a disable/destroy racing this
// window finds nothing to remove and the adds still materialize
// afterwards. Await every add to settlement (allSettled so a partial
// failure cannot leave an unawaited add materializing later), then
// re-check ownership. Pinned teardown mechanism: disable/destroy never
// wait for in-flight adds — the stale generation's own post-await
// check here guarantees cleanup by removing exactly the sources THIS
// generation added.
const addResults = await Promise.allSettled([
viewer.dataSources.add(cableDataSource),
viewer.dataSources.add(landingDataSource),
viewer.dataSources.add(referenceDataSource),
]);
const rejectedAdd = addResults.find(
(result) => result.status === 'rejected',
);
if (!owns() || rejectedAdd) {
// Compensate: every add has settled by now, so removal is effective
// (a remove inside the deferred window would have been a no-op).
// Remove EVERY generation-local source regardless of settle status:
// Cesium's add() pushes into the collection BEFORE raising
// dataSourceAdded, so a REJECTED add may still have landed its
// mutation. remove() of a never-added source is a harmless no-op.
for (const source of addedSources) {
try {
viewer.dataSources.remove(source, true);
} catch {
/* collection gone */
}
}
if (owns() && rejectedAdd) throw rejectedAdd.reason;
return;
try {
parts.rendering.buildScene(
viewer,
describeScene(cableFeatures, landingFeatures),
);
} catch (error) {
// Leave nothing half built in the scene.
parts.rendering.destroyScene(viewer);
throw error;
}
// Await-free commit: the viewer accepted all three sources and this
// load still owns the lifecycle.
state._cableDataSource = cableDataSource;
state._landingDataSource = landingDataSource;
state._referenceDataSource = referenceDataSource;
const cableEntities = state._cableDataSource.entities.values;
const landingEntities = state._landingDataSource.entities.values;
state._pickByEntity = new WeakMap();
state._referenceRecords = [];
state._surfaceRecords = [];
// Cesium expands multipart geometry into several entities and suffixes
// colliding IDs. Its copied properties retain this source index even
// when a provider has no ID, so every segment keeps the right owner.
const cableReferences = new Set();
cableEntities.forEach((entity) => {
const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
const feature = cableFeatures[index];
const reference = featureReference(feature);
if (!reference) return;
parts.rendering.styleCableEntity(entity, feature);
parts.interaction.registerPickEntity(entity, {
kind: 'cable',
reference,
label: featureLabel(feature),
});
state._surfaceRecords.push({
entity,
base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
});
if (cableReferences.has(index)) return;
cableReferences.add(index);
parts.rendering.addReferenceStem({
reference,
label: featureLabel(feature),
kind: 'cable',
color: state.cableColor,
feature,
});
});
const landingReferences = new Set();
landingEntities.forEach((entity) => {
const index = entity.properties?.[SOURCE_FEATURE_INDEX]?.getValue();
const feature = landingFeatures[index];
const reference = featureReference(feature);
if (!reference) return;
parts.rendering.styleLandingEntity(entity, feature);
parts.interaction.registerPickEntity(entity, {
kind: 'landing-point',
reference,
label: featureLabel(feature),
});
state._surfaceRecords.push({
entity,
base: Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0),
});
if (landingReferences.has(index)) return;
landingReferences.add(index);
parts.rendering.addReferenceStem({
reference,
label: featureLabel(feature),
kind: 'landing-point',
color: state.landingColor,
feature,
});
});
state._count = cableFeatures.length + landingFeatures.length;
state._loaded = true;
state._lastUpdate = Date.now();
+7 -30
View File
@@ -2,9 +2,10 @@ import * as Cesium from 'cesium';
import { isPointerFree } from '../../data/inputOwnership.js';
export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
function registerPickEntity(entity, info) {
entity.__gevTeleGeography = info;
state._pickByEntity.set(entity, info);
/** Every drawn part carries its own record as the Cesium pick id. */
function registerPick(info) {
state._pickRecords.add(info);
return info;
}
function beginInteraction(viewer) {
@@ -22,32 +23,8 @@ export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
}
function resolvePickRecord(picked) {
if (!picked) return null;
const primitive = picked.primitive;
if (primitive) {
const primitiveInfo = state._pickByEntity.get(primitive);
if (primitiveInfo) return primitiveInfo;
if (primitive.__gevTeleGeography) return primitive.__gevTeleGeography;
if (
primitive.id &&
typeof primitive.id === 'object' &&
primitive.id.reference
) {
return primitive.id;
}
}
const entity = picked.id;
if (entity) {
const entityInfo = state._pickByEntity.get(entity);
if (entityInfo) return entityInfo;
if (entity.__gevTeleGeography) return entity.__gevTeleGeography;
if (entity.id && typeof entity.id === 'object' && entity.id.reference) {
return entity.id;
}
}
return null;
const info = picked?.id;
return info && state._pickRecords.has(info) ? info : null;
}
function flyToReference(viewer, reference) {
@@ -70,7 +47,7 @@ export function createInteraction({ state, screenSpaceEventHandlerFactory }) {
});
}
return {
registerPickEntity,
registerPick,
beginInteraction,
resolvePickRecord,
flyToReference,
+17 -23
View File
@@ -38,12 +38,13 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
// never emit moveEnd — reach the motion fallback. No render is
// requested for a fallback sweep: it only fires while the camera is
// already moving, so frames are flowing by construction.
if (
!state._enabled ||
!state._loaded ||
!state._referenceSweepGate.shouldRun(viewer.camera)
)
return;
if (!state._enabled || !state._loaded) return;
// Markers left over from the last sweep, a few per frame; line
// shows and rebuilt stems waiting for their geometry.
parts.rendering.revealLandingMarkers();
parts.rendering.syncLineShow();
parts.rendering.settleStems();
if (!state._referenceSweepGate.shouldRun(viewer.camera)) return;
parts.rendering.updateReferenceVisibility();
},
);
@@ -80,10 +81,15 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
state._loading = false;
state._loadingLabel = '';
}
// Free the entities rather than hide them; enable() rebuilds from the
// cached JSON. An in-flight load's own post-await ownership check
// removes whatever that stale generation adds later.
parts.rendering.releaseDataSources(state._viewer);
// Hide what is built and keep it: a hidden primitive is skipped by
// the scene, so it costs nothing per frame, and the next enable shows
// it again without a rebuild. Only the stems go: they are sized for
// the view and the next sweep redraws them in a worker. An in-flight load's own post-await
// ownership check stops that stale generation from building anything.
state._pendingLandingReveals.length = 0;
parts.rendering.dropStems();
parts.rendering.updateVisibility();
state._viewer?.scene?.requestRender?.();
},
update(viewer) {
@@ -92,9 +98,7 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
destroy(viewer) {
if (state._abort) state._abort.abort();
parts.rendering.releaseDataSources(viewer || state._viewer);
state._cachedCableJson = null;
state._cachedLandingJson = null;
parts.rendering.destroyScene(viewer || state._viewer);
// hide() clears every published host entry and goes invisible while
// keeping the publisher reusable — the legacy layer supported re-init
// after destroy, and hidden publishers already drop late publishes.
@@ -128,16 +132,6 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
state._error = null;
state._lastUpdate = null;
state._loadingLabel = '';
state._cableDataSource = null;
state._landingDataSource = null;
state._referenceDataSource = null;
state._referenceRecords = [];
state._surfaceRecords = [];
state._pickByEntity = new WeakMap();
state._referenceLabelCount = 0;
state._publishScratch.length = 0;
state._markerBlendDone = false;
state._markerBlendInvariantWarned = false;
parts.rendering.resetPublishSignature();
state._referenceSweepGate.reset();
},
+8 -15
View File
@@ -41,7 +41,7 @@ export function selectCableReferenceLabelWinners(
.sort(
(a, b) =>
a.distanceM - b.distanceM ||
String(a.entity?.id || '').localeCompare(String(b.entity?.id || '')),
String(a.id || '').localeCompare(String(b.id || '')),
)
.slice(0, cap);
}
@@ -248,16 +248,15 @@ export function createCableReferenceSweepGate({
}
/**
* Recompute one staticized stem on the sweep cadence. Replaces the former
* per-frame `CallbackProperty` pair: constant properties are redefined only
* when the camera-scaled tip moved beyond the settle epsilon, and the two
* preallocated position buffers alternate so each real change raises exactly
* one geometry notification (the localGeojson double-buffer pattern).
* @param {object} record Reference record with entity/base/tip/nextTip/buffers.
* Recompute one stem tip on the sweep cadence. The tip is moved in place, so
* the label entry keeps pointing at it, and only when the camera-scaled tip
* moved beyond the settle epsilon; the tip point follows with one buffer
* write, and the caller redraws the stems when any tip moved.
* @param {object} record Reference record with point/base/tip/nextTip.
* @param {Cesium.Cartesian3} cameraPositionWC
* @param {number} canvasHeight CSS-pixel canvas height.
* @param {number} fov Camera frustum field of view (radians).
* @returns {boolean} True when the stem geometry was redefined.
* @returns {boolean} True when the tip moved.
*/
export function updateCableReferenceStem(
@@ -289,13 +288,7 @@ export function updateCableReferenceStem(
return false;
}
Cesium.Cartesian3.clone(record.nextTip, record.tip);
record.stemPositionBufferIndex = 1 - record.stemPositionBufferIndex;
const stemPositions =
record.stemPositionBuffers[record.stemPositionBufferIndex];
stemPositions[0] = record.base;
stemPositions[1] = record.tip;
record.entity.position.setValue(record.tip);
record.entity.polyline.positions.setValue(stemPositions);
record.point.position = record.tip;
return true;
}
+16 -15
View File
@@ -1,5 +1,3 @@
import * as Cesium from 'cesium';
export const BASE_CABLE_COLOR = '#39d5ff';
export const BASE_LANDING_COLOR = '#8fffd2';
@@ -66,6 +64,22 @@ export const CABLE_LABEL_DEPTH_DECISION = Object.freeze({
depthTested: false,
});
/**
* Landing markers clamped to the ground per rendered frame. A marker is put
* on the surface the first time it comes into view, and that reads the
* terrain height under it. Doing it for all 1,917 in the frame after the
* layer was switched on was a single task (measured 1.2 s on a loaded
* globe); a few dozen per frame keeps each frame short and the markers still
* fill in within a second. A marker is clamped once: after that Cesium moves
* it as terrain loads, and hiding or showing it reads nothing.
*/
export const CABLE_LANDING_REVEALS_PER_FRAME = 48;
/** Pixel size of the marker drawn for point geometry (GeoJSON's small pin). */
export const CABLE_MARKER_SIZE = 6;
/**
* `MAP_STACKS` ids that render imagery on the SHOWN Cesium globe (the ion
* Bing stacks + OSM). Deliberately an explicit allowlist, not "anything that
@@ -81,19 +95,6 @@ export const CABLE_GLOBE_STACK_IDS = Object.freeze(
new Set(['bing-aerial', 'bing-labels', 'esri-imagery', 'osm']),
);
/** EntityCluster's private marker collections and their required types. */
export const MARKER_COLLECTION_EXPECTATIONS = Object.freeze([
Object.freeze({
key: '_billboardCollection',
type: Cesium.BillboardCollection,
}),
Object.freeze({
key: '_pointCollection',
type: Cesium.PointPrimitiveCollection,
}),
]);
/**
* Monotonic clock for the sweep gate's motion probe. A hoisted declaration:
* the module's `export default createTeleGeographySubmarineCableLayer()`
+378 -162
View File
@@ -1,8 +1,8 @@
import * as Cesium from 'cesium';
import {
probeTranslucentMarkerBlend,
commitTranslucentMarkerBlend,
} from './surface.js';
CABLE_LANDING_REVEALS_PER_FRAME,
CABLE_MARKER_SIZE,
} from './policy.js';
import {
clampLabel,
createCableOverlayEntry,
@@ -11,7 +11,13 @@ import {
cableReferencePriority,
} from './overlay.js';
export function createRendering({ state }) {
const defaultMarkerImage = (color) =>
new Cesium.PinBuilder().fromColor(color, CABLE_MARKER_SIZE);
export function createRendering({
state,
createMarkerImage = defaultMarkerImage,
}) {
function resetPublishSignature() {
state._lastPublishedIds.length = 0;
state._lastPublishedPriorities.length = 0;
@@ -19,129 +25,131 @@ export function createRendering({ state }) {
}
/**
* Remove the three data sources from the viewer and forget the built
* entities. Hiding them (`show = false`) is NOT enough: Cesium's
* DataSourceDisplay still walks every visualizer of a hidden source on
* every frame, and the thousands of hidden polylines/billboards keep
* costing CPU and GC pressure long after the user toggled the layer off —
* that is the "everything gets sluggish after I turn layers off" report.
* The fetched JSON stays cached, so the next enable rebuilds without a
* network round trip or a re-parse.
* Build everything the layer draws, in one synchronous pass with no entity
* per feature. The layer used to load two GeoJsonDataSources and a
* CustomDataSource: 6,459 entities whose creation held about 1 GB of
* short-lived heap, whose visualizers ran 100–250 ms tasks whenever shows
* or stems changed, and whose removal on disable was a 150 ms task. These
* are the primitives Cesium built from those entities, made directly:
*
* - lines: one GroundPolylinePrimitive, a colour and a show flag per line
* (Cesium's own batch for clamped colour polylines), tessellated in a
* worker;
* - point markers: one BillboardCollection, each billboard hidden and
* unclamped until revealLandingMarkers puts it on the ground;
* - references: one PointPrimitiveCollection for the tips, whose positions
* and shows are plain buffer writes, and one Primitive of polylines for
* the stems (see rebuildStems).
*
* `lines`, `markers` and `references` come from ingestion; each line and
* marker carries the pick record Cesium returns as the pick id.
*/
function releaseDataSources(viewer) {
const sources = [
state._cableDataSource,
state._landingDataSource,
state._referenceDataSource,
];
state._cableDataSource = null;
state._landingDataSource = null;
state._referenceDataSource = null;
function buildScene(viewer, { lines, markers, references }) {
const scene = viewer.scene;
state._lineRecords = [];
state._markerRecords = [];
state._referenceRecords = [];
state._surfaceRecords = [];
state._pickByEntity = new WeakMap();
state._referenceLabelCount = 0;
state._publishScratch.length = 0;
// The blend pass targets the collections being dropped; the rebuilt
// sources need their own pass.
state._markerBlendDone = false;
state._loaded = false;
state._referenceSweepGate.reset();
for (const source of sources) {
if (!source) continue;
try {
viewer?.dataSources?.remove(source, true);
} catch {
/* collection gone */
}
}
}
state._pendingLandingReveals.length = 0;
function updateVisibility() {
if (state._cableDataSource) state._cableDataSource.show = state._enabled;
if (state._landingDataSource)
state._landingDataSource.show = state._enabled;
if (state._referenceDataSource)
state._referenceDataSource.show = state._enabled;
}
function styleCableEntity(entity, feature) {
if (!entity?.polyline) return;
const color = feature?.properties?.color
? Cesium.Color.fromCssColorString(String(feature.properties.color))
: state.cableColor;
entity.polyline.material = color.withAlpha(0.92);
entity.polyline.width = 2.5;
entity.polyline.clampToGround = true;
entity.polyline.classificationType = state._classificationType;
entity.show = true;
}
/**
* Apply the single translucent blend pass to the landing-billboard and
* reference-point collections. Landing entities carry only billboards and
* reference entities only points, so completion is one applied collection
* per source; a failed shape probe disables the optimization permanently
* for this session and says so loudly in dev builds.
* Both sources are probed BEFORE either is committed, so the helper's
* "defaults untouched on shape drift" fallback holds across the pair too —
* a reference-source failure can never leave the landing source already
* forced to TRANSLUCENT.
*/
function applyMarkerBlendOnce() {
const landing = probeTranslucentMarkerBlend(state._landingDataSource);
const reference = probeTranslucentMarkerBlend(state._referenceDataSource);
if (landing.invariantFailed || reference.invariantFailed) {
state._markerBlendDone = true;
if (!state._markerBlendInvariantWarned && import.meta.env?.DEV === true) {
state._markerBlendInvariantWarned = true;
console.error(
'[Data:telegeography-submarine-cables] EntityCluster marker-collection ' +
'shape changed — single-pass translucent blend skipped; markers fall ' +
"back to Cesium's default two-pass blend.",
if (lines.length) {
// The entity display gave every line this attribute too. It is a float
// attribute, and with one present Cesium keeps the per-line width as a
// float; without it the 2.5 px width is stored as a byte and draws 2 px.
const always =
Cesium.DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
new Cesium.DistanceDisplayCondition(),
);
const instances = lines.map(
(line) =>
new Cesium.GeometryInstance({
id: line.info,
geometry: new Cesium.GroundPolylineGeometry({
positions: line.positions,
width: line.width,
// GeoJSON lines are rhumb lines (GeoJsonDataSource's choice).
arcType: Cesium.ArcType.RHUMB,
}),
attributes: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
line.color,
),
show: new Cesium.ShowGeometryInstanceAttribute(true),
distanceDisplayCondition: always,
},
}),
);
state._cablePrimitive = scene.groundPrimitives.add(
new Cesium.GroundPolylinePrimitive({
geometryInstances: instances,
appearance: new Cesium.PolylineColorAppearance(),
classificationType: state._classificationType,
asynchronous: true,
show: state._enabled,
}),
);
for (const line of lines)
state._lineRecords.push({
info: line.info,
base: line.base,
visible: true,
shown: true,
attributes: null,
});
}
if (markers.length) {
// Every marker is translucent, so one blend pass, not Cesium's two.
const billboards = scene.primitives.add(
new Cesium.BillboardCollection({
scene,
blendOption: Cesium.BlendOption.TRANSLUCENT,
show: state._enabled,
}),
);
state._markerBillboards = billboards;
const images = new Map();
for (const marker of markers) {
const key = marker.color.toCssHexString();
let image = images.get(key);
if (!image) {
image = {
id: `gev-cable-marker-${key}`,
source: createMarkerImage(marker.color),
};
images.set(key, image);
}
const billboard = billboards.add({
id: marker.info,
position: marker.position,
verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
show: false,
});
billboard.setImage(image.id, image.source);
state._markerRecords.push({
info: marker.info,
marker: billboard,
base: marker.base,
// A position with its own height is drawn there, as before.
clamped: marker.hasHeight,
visible: false,
});
}
return;
}
const landingBlend = commitTranslucentMarkerBlend(landing);
const referenceBlend = commitTranslucentMarkerBlend(reference);
if (landingBlend.applied > 0 && referenceBlend.applied > 0)
state._markerBlendDone = true;
}
/**
* Re-classify every cable ground line for the active surface. One batched
* ground-primitive rebuild per stack switch — never per frame.
* @param {Cesium.ClassificationType} next
*/
function applyCableClassification(next) {
if (next === undefined || next === state._classificationType) return;
state._classificationType = next;
if (!state._cableDataSource) return;
const entities = state._cableDataSource.entities.values;
for (let i = 0; i < entities.length; i++) {
const polyline = entities[i].polyline;
if (polyline) polyline.classificationType = next;
if (references.length) {
state._referencePoints = scene.primitives.add(
new Cesium.PointPrimitiveCollection({
blendOption: Cesium.BlendOption.TRANSLUCENT,
show: state._enabled,
}),
);
for (const reference of references) addReferenceStem(reference);
}
state._viewer?.scene?.requestRender?.();
}
function styleLandingEntity(entity, feature) {
if (!entity?.point) return;
entity.point.color = state.landingColor.withAlpha(0.92);
entity.point.pixelSize = feature?.properties?.is_tbd ? 6 : 7;
entity.point.outlineColor = state.cableOutline;
entity.point.outlineWidth = 1;
entity.point.disableDepthTestDistance = 0;
entity.show = true;
state._lineShowDirty = false;
}
function addReferenceStem({ reference, label, kind, color, feature }) {
if (!state._referenceDataSource || !reference) return;
const base = Cesium.Cartesian3.fromDegrees(reference.lon, reference.lat, 0);
const tip = Cesium.Cartesian3.fromDegrees(
reference.lon,
@@ -154,42 +162,31 @@ export function createRendering({ state }) {
label,
featureId: feature?.id || feature?.properties?.id || null,
};
state._pickRecords.add(info);
const pointColor = color.withAlpha(kind === 'cable' ? 0.84 : 0.94);
const stemColor = color.withAlpha(kind === 'cable' ? 0.58 : 0.68);
// Constant properties on the sweep cadence, never per-frame callbacks:
// the sweep redefines them through the alternating buffers below.
const stemPositionBuffers = [
[base, tip],
[base, tip],
];
const entity = state._referenceDataSource.entities.add({
id: `${kind}-reference-${state._referenceRecords.length}-${info.featureId || 'feature'}`,
// The tip is moved in place on the sweep cadence (overlay.js), never by a
// per-frame callback.
const point = state._referencePoints.add({
id: info,
position: tip,
polyline: {
positions: stemPositionBuffers[0],
width: kind === 'cable' ? 2 : 2.4,
material: new Cesium.ColorMaterialProperty(stemColor),
},
point: {
pixelSize: kind === 'cable' ? 7 : 8,
color: pointColor,
outlineColor: Cesium.Color.BLACK.withAlpha(0.65),
outlineWidth: 1,
disableDepthTestDistance: 0,
},
pixelSize: kind === 'cable' ? 7 : 8,
color: pointColor,
outlineColor: Cesium.Color.BLACK.withAlpha(0.65),
outlineWidth: 1,
disableDepthTestDistance: 0,
show: false,
});
entity.__gevTeleGeography = info;
state._pickByEntity.set(entity, info);
const record = {
id: entity.id,
entity,
id: `${kind}-reference-${state._referenceRecords.length}-${info.featureId || 'feature'}`,
info,
point,
base,
tip,
nextTip: Cesium.Cartesian3.clone(tip),
stemPositionBuffers,
stemPositionBufferIndex: 0,
stemColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
color.withAlpha(kind === 'cable' ? 0.58 : 0.68),
),
stemWidth: kind === 'cable' ? 2 : 2.4,
reference,
kind,
label: clampLabel(label),
@@ -201,6 +198,212 @@ export function createRendering({ state }) {
state._referenceRecords.push(record);
}
/**
* Draw the stems of the references now in view, base to tip. Stems are one
* static polyline primitive, as the entity display batched them: nothing
* runs for it per frame, and a stem's length cannot change without new
* geometry. So a sweep that moved a tip or changed which references are
* in view builds a replacement in a worker, and settleStems swaps it in
* once it is ready; the previous stems stay until then. A sweep that
* changed nothing builds nothing.
*/
function rebuildStems() {
const primitives = state._viewer?.scene?.primitives;
if (!primitives) return;
if (state._stemPrimitivePending) {
// Superseded before it was ever shown.
primitives.remove(state._stemPrimitivePending);
state._stemPrimitivePending = null;
}
const instances = [];
for (const record of state._referenceRecords) {
if (!record.visible) continue;
instances.push(
new Cesium.GeometryInstance({
id: record.info,
geometry: new Cesium.PolylineGeometry({
positions: [record.base, record.tip],
width: record.stemWidth,
vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT,
}),
attributes: { color: record.stemColor },
}),
);
}
state._stemsDirty = false;
if (!instances.length) {
if (state._stemPrimitive) primitives.remove(state._stemPrimitive);
state._stemPrimitive = null;
return;
}
state._stemPrimitivePending = primitives.add(
new Cesium.Primitive({
geometryInstances: instances,
appearance: new Cesium.PolylineColorAppearance({ translucent: true }),
asynchronous: true,
// Hidden while it builds; settleStems shows it.
show: false,
}),
);
state._viewer.scene.requestRender?.();
}
/** Swap in rebuilt stems once their geometry is ready; called per frame. */
function settleStems() {
const pending = state._stemPrimitivePending;
if (!pending) return;
const scene = state._viewer?.scene;
if (!pending.ready) {
// Keep frames coming until the geometry is in.
scene?.requestRender?.();
return;
}
pending.show = state._enabled;
if (state._stemPrimitive) scene?.primitives?.remove(state._stemPrimitive);
state._stemPrimitive = pending;
state._stemPrimitivePending = null;
scene?.requestRender?.();
}
/** Remove and destroy everything buildScene made. Only destroy() does this;
* a disable hides the primitives and keeps them for the next enable. */
function destroyScene(viewer) {
const scene = viewer?.scene;
const owned = [
[scene?.groundPrimitives, state._cablePrimitive],
[scene?.primitives, state._markerBillboards],
[scene?.primitives, state._stemPrimitive],
[scene?.primitives, state._stemPrimitivePending],
[scene?.primitives, state._referencePoints],
];
state._cablePrimitive = null;
state._markerBillboards = null;
state._stemPrimitive = null;
state._stemPrimitivePending = null;
state._stemsDirty = false;
state._referencePoints = null;
state._referenceRecords = [];
state._lineRecords = [];
state._markerRecords = [];
state._lineShowDirty = false;
state._pendingLandingReveals.length = 0;
state._pickRecords = new WeakSet();
state._referenceLabelCount = 0;
state._publishScratch.length = 0;
state._loaded = false;
state._referenceSweepGate.reset();
for (const [collection, primitive] of owned) {
if (!primitive) continue;
try {
// A collection destroys what it removes; one that is already gone
// has destroyed it too.
if (!collection?.remove?.(primitive) && !primitive.isDestroyed())
primitive.destroy();
} catch {
/* collection gone */
}
}
}
/**
* Drop the stems, shown and building, so the next sweep draws them afresh.
* A disable does this: stems kept from the view the layer was switched off
* in would show at their old lengths until the rebuild for the new view
* was ready.
*/
function dropStems() {
const primitives = state._viewer?.scene?.primitives;
for (const primitive of [state._stemPrimitive, state._stemPrimitivePending])
if (primitive) primitives?.remove(primitive);
state._stemPrimitive = null;
state._stemPrimitivePending = null;
state._stemsDirty = true;
}
function updateVisibility() {
for (const primitive of [
state._cablePrimitive,
state._markerBillboards,
state._stemPrimitive,
state._referencePoints,
])
if (primitive) primitive.show = state._enabled;
}
/**
* Re-classify the cable ground lines for the active surface. The primitive
* reads its classification as it queues commands, so this is one
* assignment per stack switch and no rebuild.
* @param {Cesium.ClassificationType} next
*/
function applyCableClassification(next) {
if (next === undefined || next === state._classificationType) return;
state._classificationType = next;
if (!state._cablePrimitive) return;
state._cablePrimitive.classificationType = next;
state._viewer?.scene?.requestRender?.();
}
/**
* Write the line show states the last sweep worked out. The primitive
* builds its geometry in a worker and has no per-line attributes until it
* is ready, so the states wait in the records until then.
*/
function syncLineShow() {
if (!state._lineShowDirty) return;
const primitive = state._cablePrimitive;
if (!primitive?.ready) {
// Keep frames coming until the geometry is in.
if (primitive) state._viewer?.scene?.requestRender?.();
return;
}
for (const record of state._lineRecords) {
if (record.shown === record.visible) continue;
record.attributes ??= primitive.getGeometryInstanceAttributes(
record.info,
);
if (!record.attributes) continue;
record.attributes.show = Cesium.ShowGeometryInstanceAttribute.toValue(
record.visible,
record.attributes.show,
);
record.shown = record.visible;
}
state._lineShowDirty = false;
}
/**
* Put the next few markers the last sweep found visible on the ground and
* show them, and ask for another frame while any are left. Called from the
* sweep and then once per rendered frame, so a parked camera costs nothing
* once the list is empty. Clamping is what reads the terrain height, once
* per marker; Cesium then keeps the marker on the surface as terrain loads,
* within its own per-frame time budget.
*/
function revealLandingMarkers() {
const pending = state._pendingLandingReveals;
if (!pending.length) return;
let budget = CABLE_LANDING_REVEALS_PER_FRAME;
while (pending.length && budget > 0) {
const record = pending.pop();
if (!record.visible || record.marker.show) continue;
if (!record.clamped) {
record.marker.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
record.clamped = true;
budget--;
}
record.marker.show = true;
}
if (pending.length) state._viewer?.scene?.requestRender?.();
}
function updateReferenceVisibility() {
if (!state._enabled || !state._viewer?.camera) return;
const cameraPos = state._viewer.camera.positionWC;
@@ -216,20 +419,35 @@ export function createRendering({ state }) {
const visible = occluder.isPointVisible(record.base);
record.visible = visible;
record.distanceM = Cesium.Cartesian3.distance(cameraPos, record.base);
if (record.entity.show !== visible) {
record.entity.show = visible;
if (record.point.show !== visible) {
record.point.show = visible;
state._stemsDirty = true;
}
// Hidden stems keep their last geometry; this same sweep refreshes them
// in the pass where they turn visible again.
if (visible)
updateCableReferenceStem(record, cameraPos, canvasHeight, fov);
// Hidden stems keep their last tip; this same sweep refreshes them in
// the pass where they turn visible again.
if (
visible &&
updateCableReferenceStem(record, cameraPos, canvasHeight, fov)
)
state._stemsDirty = true;
}
for (const record of state._surfaceRecords) {
if (state._stemsDirty) rebuildStems();
for (const record of state._lineRecords) {
record.visible = occluder.isPointVisible(record.base);
if (record.visible !== record.shown) state._lineShowDirty = true;
}
syncLineShow();
state._pendingLandingReveals.length = 0;
for (const record of state._markerRecords) {
const visible = occluder.isPointVisible(record.base);
if (record.entity.show !== visible) {
record.entity.show = visible;
}
record.visible = visible;
if (record.marker.show === visible) continue;
// A marker not yet on the ground waits its turn; one that already is
// shows at once, and hiding is immediate.
if (visible && !record.clamped) state._pendingLandingReveals.push(record);
else record.marker.show = visible;
}
revealLandingMarkers();
const winners = selectCableReferenceLabelWinners(state._referenceRecords);
let changed = winners.length !== state._lastPublishedCount;
for (let i = 0; i < winners.length; i++) {
@@ -247,9 +465,6 @@ export function createRendering({ state }) {
}
state._publishScratch.length = winners.length;
state._referenceLabelCount = winners.length;
// The marker collections are created lazily by the visualizers, so the
// single-pass blend is applied on the sweep cadence until both landed.
if (!state._markerBlendDone) applyMarkerBlendOnce();
if (!changed) return;
state._overlayPublisher.publish(state._publishScratch);
state._lastPublishedCount = winners.length;
@@ -262,13 +477,14 @@ export function createRendering({ state }) {
}
return {
resetPublishSignature,
releaseDataSources,
buildScene,
destroyScene,
updateVisibility,
styleCableEntity,
applyMarkerBlendOnce,
applyCableClassification,
styleLandingEntity,
addReferenceStem,
syncLineShow,
settleStems,
dropStems,
revealLandingMarkers,
updateReferenceVisibility,
};
}
+37 -21
View File
@@ -30,26 +30,50 @@ export function createState({ sweepClock, overlayHost }) {
state._loadGeneration = 0;
state._cableDataSource = null;
state._landingDataSource = null;
state._referenceDataSource = null;
/**
* Fetched cable/landing JSON kept across disable/enable. A disable RELEASES
* the three data sources (see releaseDataSources) instead of hiding them,
* so a re-enable has to rebuild the entities; the network/parse half of
* that rebuild is the expensive part users would notice, so it is cached.
* What the layer draws, built once per load and kept across disable/enable
* (a disable only hides them, which costs nothing per frame):
* one ground polyline primitive for every line, one billboard collection
* for every point marker, a point collection for the reference tips and
* one polyline primitive for the reference stems.
*/
state._cachedCableJson = null;
state._cablePrimitive = null;
state._cachedLandingJson = null;
state._markerBillboards = null;
state._referencePoints = null;
/** The stems now drawn, and their replacement while it builds. */
state._stemPrimitive = null;
state._stemPrimitivePending = null;
state._stemsDirty = false;
state._referenceRecords = [];
state._surfaceRecords = [];
/** One record per drawn line: its pick record, horizon base and show state. */
state._lineRecords = [];
/** Line show states still to be written once the primitive is ready. */
state._lineShowDirty = false;
/** One record per point marker: its billboard and horizon base. */
state._markerRecords = [];
/** Markers the last sweep found visible but not on the ground yet; drained
* a few per frame (CABLE_LANDING_REVEALS_PER_FRAME). */
state._pendingLandingReveals = [];
/** The pick records handed to Cesium as ids, so a pick is known to be ours. */
state._pickRecords = new WeakSet();
state._clickHandler = null;
@@ -63,14 +87,6 @@ export function createState({ sweepClock, overlayHost }) {
state._classificationType = Cesium.ClassificationType.BOTH;
/** True once both marker collections blend translucent (or the shape probe failed). */
state._markerBlendDone = false;
state._markerBlendInvariantWarned = false;
state._pickByEntity = new WeakMap();
state._referenceLabelCount = 0;
state._referenceSweepGate = createCableReferenceSweepGate({
+2 -89
View File
@@ -1,8 +1,5 @@
import * as Cesium from 'cesium';
import {
CABLE_GLOBE_STACK_IDS,
MARKER_COLLECTION_EXPECTATIONS,
} from './policy.js';
import { CABLE_GLOBE_STACK_IDS } from './policy.js';
/**
* Ground-line classification for one map stack. The photoreal stack renders
@@ -10,7 +7,7 @@ import {
* need the 3D-tile classification pass there; every other known stack (the
* bing stacks and osm) renders imagery on the shown globe, so only the
* terrain pass applies.
* Classifying against just the active surface halves the batched
* Classifying against just the active surface halves the
* GroundPolylinePrimitive's emitted command sets. BOTH is the safe fallback
* for an unknown stack — it renders on every surface, exactly the shipped
* pre-optimization behavior.
@@ -40,87 +37,3 @@ export function cableClassificationTypeForScene(scene) {
? Cesium.ClassificationType.CESIUM_3D_TILE
: Cesium.ClassificationType.TERRAIN;
}
/**
* Validate one data source's marker collections WITHOUT mutating anything.
* Splitting validation from mutation is what makes the fallback honest: a
* shape failure on the SECOND collection (or the second data source) must
* not leave the first one already forced to TRANSLUCENT.
* @param {Cesium.DataSource|null|undefined} dataSource
* @returns {{ready:object[],pending:number,invariantFailed:boolean}}
*/
export function probeTranslucentMarkerBlend(dataSource) {
const cluster = dataSource?.clustering;
if (!cluster) return { ready: [], pending: 0, invariantFailed: true };
const ready = [];
let pending = 0;
let invariantFailed = false;
for (const { key, type } of MARKER_COLLECTION_EXPECTATIONS) {
if (!(key in cluster)) {
invariantFailed = true;
continue;
}
const collection = cluster[key];
if (collection === undefined || collection === null) {
pending++;
continue;
}
if (!(collection instanceof type) || !('blendOption' in collection)) {
invariantFailed = true;
continue;
}
ready.push(collection);
}
// Any failure discards every collected target: nothing is mutated at all.
if (invariantFailed) return { ready: [], pending: 0, invariantFailed: true };
return { ready, pending, invariantFailed: false };
}
/**
* Commit a clean probe. Only ever called once every probe in the batch has
* passed, so this cannot land a partial application.
* @param {{ready:object[],pending:number}} probe
* @returns {{applied:number,pending:number,invariantFailed:boolean}}
*/
export function commitTranslucentMarkerBlend(probe) {
for (const collection of probe.ready) {
if (collection.blendOption !== Cesium.BlendOption.TRANSLUCENT) {
collection.blendOption = Cesium.BlendOption.TRANSLUCENT;
}
}
return {
applied: probe.ready.length,
pending: probe.pending,
invariantFailed: false,
};
}
/**
* Force one translucent draw pass for a data source's marker collections.
* The default `OPAQUE_AND_TRANSLUCENT` blend emits two draw commands per
* collection, and every cable marker is translucent (alpha < 1), so the
* opaque pass is pure overhead across 1,917 landing billboards + 2,629
* reference points. Cesium has no public accessor for the entity-backed
* collections, so this reaches through EntityCluster's private fields under
* a SHAPE INVARIANT the caller must honor loudly: the constructor
* pre-assigns `_billboardCollection`/`_pointCollection` (= undefined until a
* visualizer lazily creates them), so a missing PROPERTY means Cesium's
* shape changed — report `invariantFailed` and never touch anything —
* while a present-but-undefined value only means "not created yet"
* (`pending`). Wrong instance types also fail the invariant. The cables
* sources never enable clustering, so created collections persist.
* VALIDATE-ALL-THEN-MUTATE-ALL: every field/type check runs before the first
* assignment, so a failure anywhere leaves BOTH collections on Cesium's
* default blend — the fallback this helper promises.
* @param {Cesium.DataSource|null|undefined} dataSource
* @returns {{applied:number,pending:number,invariantFailed:boolean}}
*/
export function applyTranslucentMarkerBlend(dataSource) {
const probe = probeTranslucentMarkerBlend(dataSource);
if (probe.invariantFailed)
return { applied: 0, pending: 0, invariantFailed: true };
return commitTranslucentMarkerBlend(probe);
}
+11 -55
View File
@@ -45,39 +45,6 @@ export function createGroundFloor({ terrain, signal }) {
return { lat: Number(lat.toFixed(3)), lon: Number(lon.toFixed(3)) };
}
/**
* One coordinate's coarse cell as an integer: `Number(deg.toFixed(3))` in
* thousandths of a degree, without the trip through a string. The floor is
* read for every aircraft on every fleet pass, and `coarseFloorCoord`'s two
* `toFixed` calls and the string keys built from them were most of the cost.
* `toFixed` rounds the exact decimal value; `deg * 1000` is within 1e-10 of
* it for |deg| < 1000, so the two can only round differently right at a
* half, and there the string decides.
* @param {number} deg
* @returns {number}
*/
function coarseCellIndex(deg) {
const scaled = deg * 1000;
if (
!(Math.abs(deg) < 1000) ||
Math.abs(scaled - Math.floor(scaled) - 0.5) < 1e-6
)
return Math.round(Number(deg.toFixed(3)) * 1000);
return Math.round(scaled);
}
/**
* Key of a coarse cell in `_meshCells`: the two indices packed into one
* number, or the text form for a longitude too far out of range to pack.
* @param {number} latIndex @param {number} lonIndex
* @returns {number|string}
*/
function meshCellKey(latIndex, lonIndex) {
return Math.abs(lonIndex) < 500_000 && Math.abs(latIndex) < 1e9
? latIndex * 1_000_000 + lonIndex
: `${latIndex},${lonIndex}`;
}
/**
* Pure floor clamp.
* - finite alt + finite ground → max(alt, ground + lift)
@@ -457,8 +424,8 @@ export function createGroundFloor({ terrain, signal }) {
// reported here by meshFloorSampler.js. Design principle (owner): NEVER
// below the visible surface; slightly above is always fine. The DEM stays
// the instant global prior/fallback and the sanity gate for samples.
/** @type {Map<number|string, Array<{lat: number, lon: number, h: number}>>}
* coarse cell key (`meshCellKey`) -> rendered-surface readings (m, ellipsoidal), each kept
/** @type {Map<string, Array<{lat: number, lon: number, h: number}>>}
* coarse cell key -> rendered-surface readings (m, ellipsoidal), each kept
* at the point it was probed. A read answers from the reading nearest the
* asked point, so a viaduct and the street beside it in one cell keep their
* own heights. */
@@ -501,7 +468,8 @@ export function createGroundFloor({ terrain, signal }) {
!Number.isFinite(heightM)
)
return;
const key = meshCellKey(coarseCellIndex(lat), coarseCellIndex(lon));
const c = coarseFloorCoord(lat, lon);
const key = `${c.lat},${c.lon}`;
if (!_meshCells.has(key)) _meshCells.set(key, [{ lat, lon, h: heightM }]);
}
@@ -529,7 +497,7 @@ export function createGroundFloor({ terrain, signal }) {
const cell = coarseFloorCoord(lat, lon);
const prior = cachedRealEllipsoidalGround(cell.lat, cell.lon);
if (!meshFloorSampleWithinPrior(heightM, prior)) return false;
const key = meshCellKey(coarseCellIndex(lat), coarseCellIndex(lon));
const key = `${cell.lat},${cell.lon}`;
const readings = _meshCells.get(key);
if (!readings) {
_meshCells.set(key, [{ lat, lon, h: heightM }]);
@@ -570,16 +538,8 @@ export function createGroundFloor({ terrain, signal }) {
function cachedMeshFloor(lat, lon) {
if (!_meshPreferred) return null;
if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
return meshFloorInCell(
lat,
lon,
meshCellKey(coarseCellIndex(lat), coarseCellIndex(lon)),
);
}
/** `cachedMeshFloor` for a caller that already has the point's cell key. */
function meshFloorInCell(lat, lon, key) {
const readings = _meshCells.get(key);
const c = coarseFloorCoord(lat, lon);
const readings = _meshCells.get(`${c.lat},${c.lon}`);
if (!readings) return null;
if (readings.length === 1) return readings[0].h;
const k = Math.cos((lat * Math.PI) / 180) ** 2;
@@ -612,14 +572,10 @@ export function createGroundFloor({ terrain, signal }) {
*/
function cachedGroundFloor(lat, lon) {
if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
// The cell is worked out once, as integers, for both reads.
const latIndex = coarseCellIndex(lat);
const lonIndex = coarseCellIndex(lon);
if (_meshPreferred) {
const mesh = meshFloorInCell(lat, lon, meshCellKey(latIndex, lonIndex));
if (mesh != null) return mesh;
}
return cachedRealEllipsoidalGround(latIndex / 1000, lonIndex / 1000);
const mesh = cachedMeshFloor(lat, lon);
if (mesh != null) return mesh;
const c = coarseFloorCoord(lat, lon);
return cachedRealEllipsoidalGround(c.lat, c.lon);
}
/**
-176
View File
@@ -1,176 +0,0 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createGroundFloor } from './groundFloor.js';
import { createTerrainHeights } from './terrainHeights.js';
/** Counts Number.prototype.toFixed calls made while `run` executes. */
function countToFixed(run) {
const original = Number.prototype.toFixed;
let calls = 0;
Number.prototype.toFixed = function (...args) {
calls += 1;
return original.apply(this, args);
};
try {
run();
} finally {
Number.prototype.toFixed = original;
}
return calls;
}
/**
* The floor read as it was before the cell became an integer: the coarse cell
* through `toFixed(3)`, mesh cells and DEM cells under string keys.
*/
function referenceFloor() {
const mesh = new Map();
const dem = new Map();
const coarse = (lat, lon) => ({
lat: Number(lat.toFixed(3)),
lon: Number(lon.toFixed(3)),
});
const demKey = (lat, lon) => `${lat.toFixed(5)},${lon.toFixed(5)}`;
return {
reportMesh(lat, lon, h) {
const c = coarse(lat, lon);
const key = `${c.lat},${c.lon}`;
if (!mesh.has(key)) mesh.set(key, [{ lat, lon, h }]);
},
storeDem(lat, lon, h) {
dem.set(demKey(lat, lon), h);
},
read(lat, lon, meshPreferred = true) {
if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
const c = coarse(lat, lon);
const readings = meshPreferred ? mesh.get(`${c.lat},${c.lon}`) : null;
if (readings) return readings[0].h;
return dem.get(demKey(c.lat, c.lon)) ?? null;
},
};
}
/** A real terrain cache whose every resolved point takes the height asked for. */
async function warmTerrain(points) {
const heights = new Map(points.map((p) => [`${p.lat},${p.lon}`, p.h]));
const terrain = createTerrainHeights({
source: {
async getHeights(chunk) {
return chunk.map((item) => ({
ellipsoid: heights.get(`${item.lat},${item.lon}`),
}));
},
},
});
await terrain.resolveEllipsoidalGround(
points.map(({ lat, lon }) => ({ lat, lon })),
);
return terrain;
}
/** Deterministic pseudo-random numbers in [0, 1). */
function random(seed) {
let state = seed;
return () => {
state = (state * 1664525 + 1013904223) % 4294967296;
return state / 4294967296;
};
}
/** Coordinates that land on, and just either side of, a coarse-cell edge. */
function edgeCoordinates() {
const out = [];
for (const base of [0, 0.0005, -0.0005, 12.3455, -12.3455, 89.9995, 179.9995])
for (const nudge of [0, 1e-13, -1e-13, 1e-9, -1e-9, 1e-7, -1e-7, 4e-4])
out.push(base + nudge);
// Thousandths whose doubles sit a hair either side of the half.
for (let k = -40; k <= 40; k += 1) out.push((k + 0.5) / 1000);
out.push(-0, 1.0005, 1.0015, 2.5, -2.5, 1e-7, -1e-7);
return out;
}
test('the floor read answers exactly as the string-keyed read did', async () => {
const next = random(20261113);
const cells = [];
for (let i = 0; i < 400; i += 1) {
cells.push({
lat: Number((next() * 170 - 85).toFixed(3)),
lon: Number((next() * 360 - 180).toFixed(3)),
h: Math.round(next() * 4000),
});
}
// Cells along the equator and the prime meridian, where a cell index is 0.
for (const edge of edgeCoordinates()) {
const lat = Number(edge.toFixed(3));
cells.push({ lat: Math.max(-89, Math.min(89, lat)), lon: 10, h: 77 });
cells.push({ lat: 10, lon: lat, h: 88 });
}
const reference = referenceFloor();
for (const c of cells) reference.storeDem(c.lat, c.lon, c.h);
const terrain = await warmTerrain(cells);
const groundFloor = createGroundFloor({ terrain });
// A rendered-surface reading in every seventh cell, taken off its centre.
cells.forEach((c, i) => {
if (i % 7) return;
const lat = c.lat + 0.0002;
const lon = c.lon - 0.0003;
reference.reportMesh(lat, lon, c.h + 3);
groundFloor.reportMeshFloorCell(lat, lon, c.h + 3);
});
const probes = [];
for (const c of cells) {
probes.push([c.lat, c.lon]);
probes.push([c.lat + (next() - 0.5) * 0.002, c.lon + (next() - 0.5) * 0.002]);
}
for (const a of edgeCoordinates())
for (const b of [10, 10.0004, -0, 0.0005, -0.0005]) {
probes.push([a, b]);
probes.push([b, a]);
}
probes.push([NaN, 1], [1, Infinity], [95, 400], [10, 720.1234]);
for (const meshPreferred of [true, false]) {
groundFloor.setMeshFloorPreferred(meshPreferred);
let hits = 0;
for (const [lat, lon] of probes) {
const expected = reference.read(lat, lon, meshPreferred);
assert.equal(
groundFloor.cachedGroundFloor(lat, lon),
expected,
`floor at ${lat}, ${lon} (mesh ${meshPreferred})`,
);
if (expected !== null) hits += 1;
}
assert.ok(hits > 400, `${hits} probes found a floor`);
}
});
test('reading a floor formats no numbers, hit or miss', async () => {
const cell = { lat: 51.47, lon: -0.454, h: 25 };
const terrain = await warmTerrain([cell]);
const groundFloor = createGroundFloor({ terrain });
groundFloor.reportMeshFloorCell(48.3537, 11.7861, 453);
const calls = countToFixed(() => {
// The DEM cell, a rendered-surface cell, and open ocean with neither.
assert.equal(groundFloor.cachedGroundFloor(51.4702, -0.4541), 25);
assert.equal(groundFloor.cachedGroundFloor(48.3538, 11.7862), 453);
for (let i = 0; i < 1000; i += 1)
assert.equal(groundFloor.cachedGroundFloor(30 + i * 0.011, -40.2), null);
});
// Before, each read made six toFixed calls (the cell twice, the DEM key).
assert.equal(calls, 0);
});
test('a reading reported at a point is found from anywhere in its cell', async () => {
const terrain = await warmTerrain([{ lat: 41.5, lon: -97.66, h: 120 }]);
const groundFloor = createGroundFloor({ terrain });
assert.equal(groundFloor.reportValidatedMeshFloorCell(41.5003, -97.6602, 129), true);
assert.equal(groundFloor.cachedMeshFloor(41.4996, -97.6598), 129);
assert.equal(groundFloor.cachedGroundFloor(41.4996, -97.6598), 129);
// The next cell over has no reading and no DEM entry.
assert.equal(groundFloor.cachedMeshFloor(41.5006, -97.6602), null);
assert.equal(groundFloor.cachedGroundFloor(41.5006, -97.6602), null);
});
+3 -125
View File
@@ -86,89 +86,6 @@ export function createTerrainHeights({
*/
const cache = new Map();
/**
* The same entries under a numeric key, for the synchronous reads. Those run
* for every aircraft on every fleet pass (about 94,000 a second with 7,500
* aircraft in view), nearly all of them misses, and building the string key
* (two `toFixed` calls and a concatenation) was most of what a read cost.
* Kept in step with `cache` by `cacheStore`, eviction and the abort handler.
* `at` is the value of `moves` when the entry last became the newest.
* @type {Map<number, {key: string, entry: object, at: number}>}
*/
const cells = new Map();
/** Counts every move to the newest end of `cache`: stores and promotions. */
let moves = 0;
/**
* A read promotes its entry only once this many moves have passed since it
* was last the newest. An entry cannot reach the cold end in fewer than
* CACHE_MAX_ENTRIES - 1 moves, so one read at least this often is never
* evicted, without rewriting the Map on every read.
*/
const PROMOTE_AFTER_MOVES = Math.floor(CACHE_MAX_ENTRIES / 2);
/**
* `value.toFixed(5)` as an integer count of 1e-5 steps, or null when the
* fast arithmetic cannot be trusted to match it. `toFixed` rounds the exact
* decimal value; `value * 1e5` is within 2e-8 of it for |value| < 1000, so
* the two can only round differently this close to a half. A negative value
* that rounds to zero is left to the string too: it formats as "-0.00000",
* a different key from "0.00000".
* @param {number} value
* @returns {number|null}
*/
function fixed5Index(value) {
if (!(Math.abs(value) < 1000)) return null;
const scaled = value * 1e5;
if (Math.abs(scaled - Math.floor(scaled) - 0.5) < 1e-6) return null;
const index = Math.round(scaled);
return Object.is(index, -0) ? null : index;
}
/** Indices at or past this (500 degrees) do not pack into one integer. */
const CELL_INDEX_LIMIT = 5e7;
/**
* The numeric key for a coordinate: its two 5-decimal indices packed into
* one integer (below 2^53), or null when the coordinate has to go through
* its string key instead.
* @param {number} lat
* @param {number} lon
* @returns {number|null}
*/
function cellKey(lat, lon) {
const latIndex = fixed5Index(lat);
const lonIndex = fixed5Index(lon);
if (
latIndex === null ||
lonIndex === null ||
Math.abs(latIndex) >= CELL_INDEX_LIMIT ||
Math.abs(lonIndex) >= CELL_INDEX_LIMIT
)
return null;
return latIndex * 1e8 + lonIndex;
}
/**
* The numeric key of a stored string key. The text is the rounded
* coordinate itself, so this is exact. Null for a key `cellKey` never
* produces; such a key is only ever read through its string.
* @param {string} key
* @returns {number|null}
*/
function cellKeyOf(key) {
const comma = key.indexOf(',');
const latIndex = Math.round(Number(key.slice(0, comma)) * 1e5);
const lonIndex = Math.round(Number(key.slice(comma + 1)) * 1e5);
if (
!(Math.abs(latIndex) < CELL_INDEX_LIMIT) ||
!(Math.abs(lonIndex) < CELL_INDEX_LIMIT) ||
Object.is(latIndex, -0) ||
Object.is(lonIndex, -0)
)
return null;
return latIndex * 1e8 + lonIndex;
}
/**
* Store an entry and drop the coldest ones once past the cap. `Map` iterates
* in insertion order, so deleting the first key evicts the least recently
@@ -184,15 +101,10 @@ export function createTerrainHeights({
function cacheStore(key, entry) {
cache.delete(key);
cache.set(key, entry);
moves += 1;
const cell = cellKeyOf(key);
if (cell !== null) cells.set(cell, { key, entry, at: moves });
while (cache.size > CACHE_MAX_ENTRIES) {
const coldest = cache.keys().next().value;
if (coldest === undefined) break;
cache.delete(coldest);
const coldestCell = cellKeyOf(coldest);
if (coldestCell !== null) cells.delete(coldestCell);
}
}
@@ -207,36 +119,9 @@ export function createTerrainHeights({
if (entry === undefined) return undefined;
cache.delete(key);
cache.set(key, entry);
moves += 1;
const cell = cellKeyOf(key);
const held = cell === null ? undefined : cells.get(cell);
if (held) held.at = moves;
return entry;
}
/**
* The synchronous read: the entry for a coordinate, or undefined on a miss.
* Same answer as `cacheTouch(cacheKey(lat, lon))`, without building the
* string, and promoting only an entry that has drifted towards the cold end
* (see PROMOTE_AFTER_MOVES).
* @param {number} lat
* @param {number} lon
* @returns {{ellipsoid: number, source: 'reearth'|'geoid-fallback', retryAt?: number}|undefined}
*/
function cacheRead(lat, lon) {
const cell = cellKey(lat, lon);
if (cell === null) return cacheTouch(cacheKey(lat, lon));
const held = cells.get(cell);
if (held === undefined) return undefined;
if (moves - held.at > PROMOTE_AFTER_MOVES) {
cache.delete(held.key);
cache.set(held.key, held.entry);
moves += 1;
held.at = moves;
}
return held.entry;
}
/**
* Builds the rounded cache key shared between the in-memory cache and the
* `points` string sent to the proxy (see file header, point 2).
@@ -257,7 +142,7 @@ export function createTerrainHeights({
* @returns {number|null}
*/
function cachedEllipsoidalGround(lat, lon) {
const entry = cacheRead(lat, lon);
const entry = cacheTouch(cacheKey(lat, lon));
return entry ? entry.ellipsoid : null;
}
@@ -274,7 +159,7 @@ export function createTerrainHeights({
* @returns {number|null}
*/
function cachedRealEllipsoidalGround(lat, lon) {
const entry = cacheRead(lat, lon);
const entry = cacheTouch(cacheKey(lat, lon));
return entry && entry.source === 'reearth' ? entry.ellipsoid : null;
}
@@ -485,14 +370,7 @@ export function createTerrainHeights({
});
}
signal?.addEventListener(
'abort',
() => {
cache.clear();
cells.clear();
},
{ once: true },
);
signal?.addEventListener('abort', () => cache.clear(), { once: true });
return {
cachedEllipsoidalGround,
cachedRealEllipsoidalGround,
-148
View File
@@ -169,151 +169,3 @@ test('an out-of-range cache bound falls back to the default instead of disabling
);
}
});
/** Counts Number.prototype.toFixed calls made while `run` executes. */
function countToFixed(run) {
const original = Number.prototype.toFixed;
let calls = 0;
Number.prototype.toFixed = function (...args) {
calls += 1;
return original.apply(this, args);
};
try {
run();
} finally {
Number.prototype.toFixed = original;
}
return calls;
}
test('a synchronous read finds exactly the entry its 5-decimal key names', async () => {
// Stored coordinates, and for each the reads that must and must not reach it.
// The expectation is the string key the cache has always used.
const stored = [
[0, 0.001],
[51.47, -0.454],
[-33.94611, 151.17722],
[0.00001, 0.00002],
[-0.00001, 0.00003],
[89.99999, 179.99999],
[-89.99999, -179.99999],
[12.345675, 98.765435],
[1e-7, 5],
[-1e-7, 6],
[7, -1e-7],
[200.5, 361.25],
[10, 500],
[10, 499.999999],
];
const key = (lat, lon) => `${lat.toFixed(5)},${lon.toFixed(5)}`;
const heights = new Map(
stored.map(([lat, lon], i) => [key(lat, lon), 100 + i]),
);
const terrain = createTerrainHeights({
source: {
async getHeights(chunk) {
return chunk.map((item) => ({ ellipsoid: heights.get(item.key) }));
},
},
});
await terrain.resolveEllipsoidalGround(
stored.map(([lat, lon]) => ({ lat, lon })),
);
const probes = [];
const nudges = [
0, 1e-13, -1e-13, 1e-9, -1e-9, 4e-6, -4e-6, 4.9999e-6, 5e-6, -5e-6,
5.0001e-6, 1e-5, -1e-5,
];
for (const [lat, lon] of stored)
for (const a of nudges)
for (const b of [0, 4e-6, -5e-6])
probes.push([lat + a, lon + b], [lat + b, lon + a]);
probes.push([0, 0], [-0, 0.001], [0, -0], [NaN, 1], [1, Infinity], [1e21, 2]);
let hits = 0;
for (const [lat, lon] of probes) {
const expected = heights.get(key(lat, lon)) ?? null;
assert.equal(
terrain.cachedEllipsoidalGround(lat, lon),
expected,
`plain read at ${lat}, ${lon}`,
);
assert.equal(
terrain.cachedRealEllipsoidalGround(lat, lon),
expected,
`real read at ${lat}, ${lon}`,
);
if (expected !== null) hits += 1;
}
assert.ok(
hits > 100 && hits < probes.length,
`${hits} of ${probes.length} reads hit`,
);
});
test('a synchronous read of an ordinary coordinate formats no numbers', async () => {
const terrain = createTerrainHeights({ source: stubSource() });
await terrain.resolveEllipsoidalGround([pointAt(1), pointAt(2)]);
const calls = countToFixed(() => {
assert.equal(
terrain.cachedRealEllipsoidalGround(0, lonAt(1)),
heightAt(lonAt(1)),
);
assert.equal(
terrain.cachedEllipsoidalGround(0, lonAt(2)),
heightAt(lonAt(2)),
);
// Misses are the common case: an aircraft over a cell nobody resolved.
for (let i = 10; i < 1010; i += 1)
assert.equal(terrain.cachedRealEllipsoidalGround(45.123, lonAt(i)), null);
});
// Before, every read built its key with two toFixed calls.
assert.equal(calls, 0);
});
test('an entry read again and again is not rewritten on each read, and still outlives the rest', async () => {
const terrain = createTerrainHeights({
source: stubSource(),
maxCacheEntries: 8,
});
for (let i = 0; i < 8; i += 1)
await terrain.resolveEllipsoidalGround([pointAt(i)]);
// Coordinate 0 is the coldest. Read it between stores, as a parked contact
// would; the seven newer ones are never read.
for (let i = 8; i < 15; i += 1) {
for (let read = 0; read < 50; read += 1)
assert.equal(
terrain.cachedEllipsoidalGround(0, lonAt(0)),
heightAt(lonAt(0)),
);
await terrain.resolveEllipsoidalGround([pointAt(i)]);
}
assert.equal(
terrain.cachedEllipsoidalGround(0, lonAt(0)),
heightAt(lonAt(0)),
);
for (let i = 1; i < 8; i += 1)
assert.equal(
terrain.cachedEllipsoidalGround(0, lonAt(i)),
null,
`unread coordinate ${i} was evicted`,
);
});
test('an evicted coordinate is gone from the synchronous read too', async () => {
const terrain = createTerrainHeights({
source: stubSource(),
maxCacheEntries: 2,
});
for (let i = 0; i < 5; i += 1)
await terrain.resolveEllipsoidalGround([pointAt(i)]);
for (let i = 0; i < 3; i += 1)
assert.equal(terrain.cachedRealEllipsoidalGround(0, lonAt(i)), null);
for (let i = 3; i < 5; i += 1)
assert.equal(
terrain.cachedRealEllipsoidalGround(0, lonAt(i)),
heightAt(lonAt(i)),
);
});