Files
gods-eye-view/src/layers/cctv/geometryQueue.js
T

340 lines
12 KiB
JavaScript

import * as Cesium from 'cesium';
import {
GEO_PROGRESS_NOTIFY_INTERVAL_MS,
GEO_PROGRESS_NOTIFY_BATCH_LIMIT,
GEO_TRACKING_BATCH_SIZE,
GEO_TRACKING_BATCH_DELAY_MS,
GEO_LOAD_BATCH_SIZE,
GEO_LOAD_BATCH_DELAY_MS,
} from './policy.js';
export function createGeometryQueue({
state: layerState,
services,
parts,
source,
}) {
/**
* Stops the staggered geometry-load queue and optionally clears progress
* counters (kept when pausing mid-flight is not needed — we always clear).
* @param {boolean} [clearProgress=true]
*/
function stopGeometryLoadQueue(clearProgress = true) {
if (layerState._geoQueueTimer) {
clearTimeout(layerState._geoQueueTimer);
layerState._geoQueueTimer = 0;
}
layerState._geoQueue = [];
layerState._geoProgressNotifier = null;
if (clearProgress) {
layerState._geoLoading = false;
layerState._geoLoadTotal = 0;
layerState._geoLoadDone = 0;
}
}
/**
* Creates the notification coalescer used by a staggered geometry drain.
* Progress emits after roughly 300 ms or ten batches, whichever comes first;
* finish always emits once even when the last progress tick just fired.
*
* @param {Function} notify Notification callback.
* @param {Object} [options={}] Testable timing options.
* @param {() => number} [options.now] Monotonic clock returning milliseconds.
* @param {number} [options.intervalMs] Maximum progress-notification cadence.
* @param {number} [options.batchLimit] Maximum batches between progress ticks.
* @returns {{ progress: () => boolean, finish: () => void }} Drain notifier.
*/
function createGeometryProgressNotifier(notify, options = {}) {
const now = typeof options.now === 'function' ? options.now : Date.now;
const intervalMs = Number.isFinite(options.intervalMs)
? Math.max(0, options.intervalMs)
: GEO_PROGRESS_NOTIFY_INTERVAL_MS;
const batchLimit = Number.isFinite(options.batchLimit)
? Math.max(1, Math.floor(options.batchLimit))
: GEO_PROGRESS_NOTIFY_BATCH_LIMIT;
let lastNotifyAt = now();
let batchesSinceNotify = 0;
return {
progress() {
batchesSinceNotify += 1;
const current = now();
if (
current - lastNotifyAt < intervalMs &&
batchesSinceNotify < batchLimit
) {
return false;
}
batchesSinceNotify = 0;
lastNotifyAt = current;
notify?.();
return true;
},
finish() {
batchesSinceNotify = 0;
lastNotifyAt = now();
notify?.();
},
};
}
/**
* Processes one geometry-queue batch and routes progress/completion through
* the callbacks shared by production and the unit drain harness.
*
* @param {Object} options Batch inputs.
* @param {Object[]} options.queue Mutable record queue.
* @param {number} options.batchSize Maximum records to visit.
* @param {(record: Object) => void} options.visit Per-record geometry work.
* @param {() => void} options.progress Coalesced progress publication.
* @param {() => void} options.complete Unconditional completion publication.
* @returns {boolean} True when more records remain.
*/
function processCctvGeometryQueueBatch({
queue,
batchSize,
visit,
progress,
complete,
}) {
const safeQueue = Array.isArray(queue) ? queue : [];
const take = Number.isFinite(batchSize)
? Math.max(1, Math.floor(batchSize))
: 1;
const batch = safeQueue.splice(0, take);
for (const record of batch) visit?.(record);
if (safeQueue.length) {
progress?.();
return true;
}
complete?.();
return false;
}
/**
* Selects per-batch geometry-drain pacing from current camera ownership.
* Called for every batch so releasing tracking immediately restores normal
* throughput without restarting the queue.
*
* @param {Object} [ownership={}] Current camera-ownership state.
* @param {*} [ownership.trackedEntity] Cesium tracked entity, if any.
* @param {boolean} [ownership.cockpitActive] Whether cockpit owns the camera.
* @returns {{ batchSize: number, delayMs: number }} Drain pacing.
*/
function cctvGeometryDrainPacing({
trackedEntity = null,
cockpitActive = false,
} = {}) {
if (trackedEntity || cockpitActive) {
return {
batchSize: GEO_TRACKING_BATCH_SIZE,
delayMs: GEO_TRACKING_BATCH_DELAY_MS,
};
}
return { batchSize: GEO_LOAD_BATCH_SIZE, delayMs: GEO_LOAD_BATCH_DELAY_MS };
}
/**
* Processes one tracking-aware geometry-drain batch. Ownership is read inside
* every call so a mid-drain tracking/cockpit transition changes the very next
* batch's size and delay.
*
* @param {Object} options Batch inputs.
* @param {Object[]} options.queue Mutable record queue.
* @param {() => Object} [options.readOwnership] Current camera ownership.
* @param {(record: Object) => void} options.visit Per-record geometry work.
* @param {() => void} options.progress Coalesced progress publication.
* @param {() => void} options.complete Unconditional completion publication.
* @returns {{ hasMore: boolean, batchSize: number, delayMs: number }} Batch result and pacing.
*/
function processCctvGeometryDrainBatch({
queue,
readOwnership,
visit,
progress,
complete,
}) {
const pacing = cctvGeometryDrainPacing(readOwnership?.() || {});
const hasMore = processCctvGeometryQueueBatch({
queue,
batchSize: pacing.batchSize,
visit,
progress,
complete,
});
return { hasMore, ...pacing };
}
/**
* Moves the current active record to the front of a live drain queue.
* @param {Object[]} queue Mutable geometry queue.
* @param {Object|null} activeRecord Current active CCTV record.
* @returns {boolean} Whether the queue order changed.
*/
function prioritizeActiveCctvGeometryRecord(queue, activeRecord) {
if (!Array.isArray(queue) || !activeRecord) return false;
const index = queue.indexOf(activeRecord);
if (index <= 0) return false;
queue.splice(index, 1);
queue.unshift(activeRecord);
return true;
}
/**
* Processes one batch (GEO_LOAD_BATCH_SIZE records) of the geometry queue:
* full ground-sampled coverage geometry per record, then yields back to the
* event loop before the next batch so tile rendering never stalls. When the
* initial-load pass completes it clears the loading flag and refreshes styles.
*/
function processGeometryBatch() {
layerState._geoQueueTimer = 0;
if (!layerState._viewer) {
stopGeometryLoadQueue();
return;
}
// Active-camera-first is re-established every batch because the operator
// can select a new camera while a long catalog drain is in flight.
prioritizeActiveCctvGeometryRecord(
layerState._geoQueue,
parts.selection.getActiveRecord(),
);
const batchResult = processCctvGeometryDrainBatch({
queue: layerState._geoQueue,
readOwnership: () => ({
trackedEntity: layerState._viewer.trackedEntity,
cockpitActive:
typeof document !== 'undefined' &&
document.body?.classList.contains('cockpit-mode'),
}),
visit: (record) => {
try {
parts.geometry.updateRecordGeometry(record);
} catch (err) {
console.warn(
'[Data:CCTV] geometry refresh error:',
err?.message || err,
);
}
if (
layerState._geoLoading &&
layerState._geoLoadDone < layerState._geoLoadTotal
) {
layerState._geoLoadDone += 1;
}
},
progress: () => layerState._geoProgressNotifier?.progress(),
complete: () => {
const wasInitialLoad = layerState._geoLoading;
layerState._geoLoading = false;
if (wasInitialLoad) {
layerState._geoLoadDone = layerState._geoLoadTotal;
if (layerState._enabled) {
parts.rendering.refreshCoverageStyles();
// Geometry refinement may have replaced record.position objects — the
// one-shot drain completion re-anchors the card entries (event-driven,
// not a per-frame or timer pass).
parts.cards.refreshAmbientCards();
}
}
// Completion is never coalesced: subscribers must observe the final
// loading state even if the last progress tick just happened.
layerState._geoProgressNotifier?.finish();
layerState._geoProgressNotifier = null;
},
});
if (batchResult.hasMore) {
layerState._geoQueueTimer = setTimeout(
processGeometryBatch,
batchResult.delayMs,
);
return;
}
}
/**
* Appends records to the geometry queue (no progress tracking) and starts
* the batch timer if idle. Used by update()'s ONE-SHOT tiles-ready completion
* pass (records left `!groundResolved` by an enable-time drain that ran while
* tiles were still streaming) so it shares the same stagger machinery as the
* initial load. Fires at most once per enable — never on a recurring timer.
* @param {Object[]} records - Camera records needing geometry refresh.
*/
function enqueueGeometryRefresh(records) {
for (const record of records) {
if (!layerState._geoQueue.includes(record)) {
layerState._geoQueue.push(record);
}
}
if (!layerState._geoQueueTimer && layerState._geoQueue.length) {
layerState._geoProgressNotifier = createGeometryProgressNotifier(
parts.presentation.notifyListeners,
);
layerState._geoQueueTimer = setTimeout(processGeometryBatch, 0);
}
}
/**
* Starts the initial staggered load: orders all records active-camera-first,
* then by distance from the current viewer position (nearest first, so
* cameras likely in view refine before off-screen ones), and exposes
* loaded/total progress through uiState()/getStats() while running.
*/
function startGeometryLoadQueue() {
stopGeometryLoadQueue();
// Fresh drain → fresh one-shot completion pass: re-arm the tiles-ready
// latch so update() can complete any records this drain leaves unresolved.
layerState._tilesReadyReenqueued = false;
if (!layerState._records.length) return;
const active = parts.selection.getActiveRecord();
const carto = layerState._viewer?.camera?.positionCartographic;
const refLat = carto
? Cesium.Math.toDegrees(carto.latitude)
: (active?.camera.lat ?? 0);
const refLon = carto
? Cesium.Math.toDegrees(carto.longitude)
: (active?.camera.lon ?? 0);
const pending = layerState._records
.filter((record) => record !== active)
.map((record) => ({
record,
distKm: parts.model.haversineKm(
refLat,
refLon,
record.camera.lat,
record.camera.lon,
),
}))
.sort((a, b) => a.distKm - b.distKm)
.map((entry) => entry.record);
layerState._geoQueue = active ? [active, ...pending] : pending;
layerState._geoLoadTotal = layerState._geoQueue.length;
layerState._geoLoadDone = 0;
layerState._geoLoading = true;
layerState._geoProgressNotifier = createGeometryProgressNotifier(
parts.presentation.notifyListeners,
);
layerState._geoQueueTimer = setTimeout(processGeometryBatch, 0);
}
return {
stopGeometryLoadQueue,
createGeometryProgressNotifier,
processCctvGeometryQueueBatch,
cctvGeometryDrainPacing,
processCctvGeometryDrainBatch,
prioritizeActiveCctvGeometryRecord,
processGeometryBatch,
enqueueGeometryRefresh,
startGeometryLoadQueue,
};
}