mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 00:02:25 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
63c9e80a40 | ||
|
|
1923547d43 | ||
|
|
b6c241a68e | ||
|
|
f42980a04d |
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
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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
@@ -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;
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
},
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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()`
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
}
|
||||
@@ -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({
|
||||
|
||||
@@ -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
@@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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,
|
||||
|
||||
@@ -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)),
|
||||
);
|
||||
});
|
||||
Reference in new issue
Block a user