mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 09:42:21 +00:00
Upstream's layers and changes are carried onto the ports, with no Cesium outside src/render and no reach into the viewer: - Shipwrecks draw as one icon set, clicked through the input dispatcher. - News draws through draw sets, the camera port and the input dispatcher; its beacons pulse each frame through the frame port. - The scene occlusion probe moves into src/render/cesium and reaches detection through a new application hook, createOcclusionProbe; its private Cesium reads go through internals.js. - Flight and military trails, the stale and SIGNAL LOST cue, coasting and following the world clock run on the draw and frame ports. GPU icons follow the scene clock while the world clock is followed, and fade when stale. A report that holds is not planned again every tick. - Vessels are keyed by their record id. The stub boot now enables military, shipwrecks and news as well.
366 lines
13 KiB
JavaScript
366 lines
13 KiB
JavaScript
import { fireDetectionKey } from '../../data/firmsLabels.js';
|
|
import {
|
|
FIRMS_CONFIDENCE_MODES,
|
|
FRP_SLIDER_TICKS,
|
|
firePassesFilter,
|
|
frpForSliderPosition,
|
|
normalizeFireFilter,
|
|
rampTrackGradient,
|
|
sliderPositionForFrp,
|
|
} from '../../data/firmsIntensity.js';
|
|
import { formatNumber, formatUtcDayMonth, t } from '../../i18n/index.js';
|
|
import { LOD_LEVELS, REFRESH_INTERVAL_MS } from './policy.js';
|
|
|
|
/** Slider resolution: whole-percent positions along the log axis. */
|
|
const SLIDER_STEPS = 1000;
|
|
|
|
export function createQueries({
|
|
layerState,
|
|
services,
|
|
components,
|
|
config,
|
|
feed,
|
|
}) {
|
|
const { id, name, icon, source } = config;
|
|
|
|
/** Whole-megawatt label for a slider value or tick ("0", "20", "1 000"). */
|
|
function frpLabel(frp) {
|
|
return formatNumber(frp, { maximumFractionDigits: 0 });
|
|
}
|
|
|
|
const confidenceLabels = () => ({
|
|
all: t('All', { context: 'fire confidence filter' }),
|
|
nominal: t('Nominal+', { context: 'fire confidence filter' }),
|
|
high: t('High', { context: 'fire confidence filter' }),
|
|
});
|
|
|
|
const confidenceTitles = () => ({
|
|
all: t(
|
|
'Every detection — many of the strongest fires are rated low confidence',
|
|
),
|
|
nominal: t('Nominal and high confidence detections'),
|
|
high: t('High confidence detections only'),
|
|
});
|
|
|
|
const methods = {
|
|
/** Return the selected detection as a plain record for application consumers. */
|
|
getSelectedInfo() {
|
|
const fire = layerState._selectedFire;
|
|
if (!fire) return null;
|
|
return {
|
|
id: fireDetectionKey(fire),
|
|
// i18n-ignore: English entity label; the voice card translates it (shownEntityLabel)
|
|
label: `Fire · FRP ${components.model.formatFrp(fire.frp)} MW`,
|
|
latitude: fire.lat,
|
|
longitude: fire.lon,
|
|
frp: fire.frp,
|
|
confidencePct: Number.isFinite(fire.confidence)
|
|
? fire.confidence * 100
|
|
: null,
|
|
observedAt:
|
|
Number.isFinite(fire.acqMs) && fire.acqMs > 0 ? fire.acqMs : null,
|
|
source: fire.sensor || fire.satellite || null,
|
|
};
|
|
},
|
|
|
|
id,
|
|
|
|
name,
|
|
|
|
icon,
|
|
|
|
source,
|
|
|
|
// The one data-layer control a provider key gates: the proxy answers
|
|
// 503 {error:'no_key'} without a FIRMS key. Declared as a key-registry id
|
|
// rather than an env-var string, so the panel can name the key from the
|
|
// one place that owns what each key is called.
|
|
requiresKeyId: 'firms',
|
|
|
|
// Live layer: the manager calls update() every 10 minutes while enabled,
|
|
// which refetches through the /api/firms proxy (the proxy's 30 min TTL —
|
|
// not this interval — is what protects the upstream FIRMS quota).
|
|
updateInterval: REFRESH_INTERVAL_MS,
|
|
|
|
/**
|
|
* The intensity filter as layer options (share token `w`, owner
|
|
* `local-firms` in layerState.js).
|
|
* @returns {{minFrp: number, confidence: string}}
|
|
*/
|
|
getParams() {
|
|
return { ...layerState._filter };
|
|
},
|
|
|
|
/**
|
|
* Apply a (partial) intensity filter. Invalid fields keep their current
|
|
* value. The filter runs in one place (ingestion.applyFilter) and the LOD
|
|
* rebuild re-derives markers, cells, cards and context registrations from
|
|
* the shown set; a selected fire that no longer passes is deselected.
|
|
* @param {{minFrp?: number, confidence?: string}} params
|
|
* @returns {boolean} True — the request is always accepted.
|
|
*/
|
|
setParams(params = {}) {
|
|
const next = normalizeFireFilter(params, layerState._filter);
|
|
if (
|
|
next.minFrp === layerState._filter.minFrp &&
|
|
next.confidence === layerState._filter.confidence
|
|
)
|
|
return true;
|
|
layerState._filter = next;
|
|
if (!layerState._allFires.length) return true;
|
|
components.ingestion.applyFilter();
|
|
if (
|
|
layerState._selectedFire &&
|
|
!firePassesFilter(layerState._selectedFire, next)
|
|
) {
|
|
components.selection.clearFireSelection();
|
|
}
|
|
if (layerState._enabled) components.rendering.renderCurrentLod(true);
|
|
layerState._rowControlsListener?.();
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Row controls under the Active Fires row: the log-scale minimum-FRP
|
|
* slider whose track is painted with the intensity ramp (so it doubles as
|
|
* the legend), the All / Nominal+ / High confidence switch, and the
|
|
* "N of M shown" counter.
|
|
*/
|
|
getRowControls() {
|
|
const { minFrp, confidence } = layerState._filter;
|
|
const labels = confidenceLabels();
|
|
const titles = confidenceTitles();
|
|
const shown = layerState._count;
|
|
const total = layerState._totalCount;
|
|
return {
|
|
slider: {
|
|
id: 'min-frp',
|
|
label: t('Fire intensity (FRP)'),
|
|
ariaLabel: t('Minimum fire radiative power, megawatts'),
|
|
valueText:
|
|
minFrp > 0
|
|
? t('≥ {value} MW', { value: frpLabel(minFrp) })
|
|
: t('All', { context: 'fire intensity filter' }),
|
|
min: 0,
|
|
max: SLIDER_STEPS,
|
|
step: 1,
|
|
value: Math.round(sliderPositionForFrp(minFrp) * SLIDER_STEPS),
|
|
track: rampTrackGradient(),
|
|
ticks: FRP_SLIDER_TICKS.map((frp) => ({
|
|
at: sliderPositionForFrp(frp),
|
|
label: frpLabel(frp),
|
|
})),
|
|
params: (value) => ({
|
|
minFrp: frpForSliderPosition(Number(value) / SLIDER_STEPS),
|
|
}),
|
|
},
|
|
segmented: {
|
|
id: 'confidence',
|
|
label: t('Confidence'),
|
|
ariaLabel: t('Detection confidence'),
|
|
options: FIRMS_CONFIDENCE_MODES.map((mode) => ({
|
|
id: `confidence-${mode}`,
|
|
label: labels[mode],
|
|
title: titles[mode],
|
|
active: mode === confidence,
|
|
params: { confidence: mode },
|
|
})),
|
|
},
|
|
info: total
|
|
? t('{shown} of {total} shown', {
|
|
shown: formatNumber(shown),
|
|
total: formatNumber(total),
|
|
})
|
|
: '',
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Install the panel's "row controls changed" callback: a load or a filter
|
|
* change moves the counter, and nothing else repaints the row before the
|
|
* next scheduled refresh.
|
|
* @param {(() => void)|null} listener
|
|
*/
|
|
setRowControlsListener(listener) {
|
|
layerState._rowControlsListener =
|
|
typeof listener === 'function' ? listener : null;
|
|
},
|
|
|
|
/**
|
|
* Layer stats for the data panel. Degraded feed states surface through
|
|
* `error` (established qa-failstate pattern: a dead feed must never look
|
|
* like a healthy empty layer) with a matching human `loadingLabel`:
|
|
* 'LIVE · updated Xm ago' fresh, '24 h to MM-DD HH:MM UTC' for a
|
|
* snapshot that ends at a set time (`at`), 'STALE · cached Xh' when the
|
|
* proxy served past-TTL cache, 'KEY REQUIRED' keyless.
|
|
*/
|
|
getStats() {
|
|
const now = Date.now();
|
|
const staleText = layerState._lastUpdate
|
|
? t('STALE · cached {age}', {
|
|
age:
|
|
components.model.formatAgeLabel(now - layerState._lastUpdate) ||
|
|
t('<1h', { context: 'age' }),
|
|
})
|
|
: t('STALE');
|
|
let loadingLabel = '';
|
|
if (layerState._loading) {
|
|
loadingLabel = layerState._fires.length
|
|
? t('refreshing...')
|
|
: t('loading...');
|
|
} else if (layerState._keyRequired) {
|
|
loadingLabel = t('KEY REQUIRED');
|
|
} else if (layerState._stale) {
|
|
loadingLabel = staleText;
|
|
} else if (layerState._error) {
|
|
loadingLabel = layerState._error;
|
|
} else if (Number.isFinite(layerState._at)) {
|
|
loadingLabel = t('24 h to {day} {time} UTC', {
|
|
day: formatUtcDayMonth(layerState._at),
|
|
time: new Date(layerState._at).toISOString().slice(11, 16),
|
|
});
|
|
} else if (layerState._lastUpdate) {
|
|
loadingLabel = t('LIVE · updated {age}', {
|
|
age: components.model.formatAgoMinutes(now - layerState._lastUpdate),
|
|
});
|
|
}
|
|
return {
|
|
// Shown (filtered) detections; `total` is the loaded payload.
|
|
count: layerState._count,
|
|
total: layerState._totalCount,
|
|
cells: layerState._cellCount,
|
|
lastUpdate: layerState._lastUpdate,
|
|
loading: layerState._loading,
|
|
stale: layerState._stale,
|
|
// The end of the 24 hours shown when the snapshot ends at a set time;
|
|
// null for the trailing 24 hours to now. Such a snapshot is not live,
|
|
// so the row names the provider without the catalog's "LIVE".
|
|
at: Number.isFinite(layerState._at) ? layerState._at : null,
|
|
...(Number.isFinite(layerState._at) ? { source: 'NASA FIRMS' } : {}),
|
|
// The machine-readable half of the keyless state, ahead of the human
|
|
// strings below: without it "no key configured" is indistinguishable
|
|
// from a broken feed, and the row reads as a fault instead of a step
|
|
// the operator can take.
|
|
keyRequired: layerState._keyRequired,
|
|
error: layerState._keyRequired
|
|
? t('KEY REQUIRED')
|
|
: layerState._stale
|
|
? staleText
|
|
: layerState._error,
|
|
loadingLabel,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Strongest currently-loaded detection (by FRP) for voice targeting
|
|
* ("take me to the biggest fire").
|
|
* @returns {{latitude: number, longitude: number, frp: number, label: string}|null}
|
|
*/
|
|
getStrongestFire() {
|
|
const strongest = layerState._firesByFrp.length
|
|
? layerState._firesByFrp[0]
|
|
: null;
|
|
if (!strongest) return null;
|
|
return {
|
|
latitude: strongest.lat,
|
|
longitude: strongest.lon,
|
|
frp: strongest.frp,
|
|
// i18n-ignore: English entity label; the voice card translates it (shownEntityLabel)
|
|
label: `Fire · FRP ${components.model.formatFrp(strongest.frp)} MW`,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Detection-overlay seam, shaped like the other layers' detectable
|
|
* objects (traffic/flights). NOT yet registered in initDetection's layer
|
|
* list — wiring fires through the detection/label-arbiter pipeline is a
|
|
* deliberate post-PR#1 task; when that happens the arbiter replaces this
|
|
* layer's greedy declutter as the SELECTOR and the shared overlay remains
|
|
* the renderer. Walks the FRP-sorted index so the strongest fires come first.
|
|
* @param {{maxCount?: number}} [options]
|
|
* @returns {Array<{position: {x: number, y: number, z: number}, id: string, type: string}>}
|
|
* Positions are ECEF.
|
|
*/
|
|
getDetectableObjects(options = {}) {
|
|
if (!layerState._enabled || !layerState._firesByFrp.length) return [];
|
|
const maxCount = Number.isFinite(options.maxCount)
|
|
? Math.max(1, Math.floor(options.maxCount))
|
|
: 250;
|
|
const result = [];
|
|
for (const fire of layerState._firesByFrp) {
|
|
result.push({
|
|
position: components.model.firePosition(fire),
|
|
id: `FIRE-${String(fire.index).padStart(5, '0')}`,
|
|
type: 'FIRE',
|
|
});
|
|
if (result.length >= maxCount) break;
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* Snapshot the layer's in-memory fire records as plain JSON-safe
|
|
* objects for the analyst query engine. Walks the FRP-sorted index so
|
|
* truncation keeps the STRONGEST fires (200k+ detections can be live —
|
|
* the cap is load-bearing, not cosmetic). On-demand only (called at
|
|
* most once per spoken query) — zero per-frame cost, no listeners, no
|
|
* caching. Returns [] while the layer is disabled or empty.
|
|
* @param {number} [maxCount=2000] - Maximum records to return (truncation).
|
|
* @returns {Array<Object>} See mapAnalystRecord for the record shape.
|
|
*/
|
|
getAnalystRecords(maxCount = 2000) {
|
|
if (!layerState._enabled || !layerState._firesByFrp.length) return [];
|
|
const limit = Number.isFinite(maxCount)
|
|
? Math.max(1, Math.floor(maxCount))
|
|
: 2000;
|
|
const result = [];
|
|
for (const fire of layerState._firesByFrp) {
|
|
result.push(components.model.mapAnalystRecord(fire));
|
|
if (result.length >= limit) break;
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/** Test seam: render one named LOD band against a near-global view. */
|
|
_renderLodForTest(lodId) {
|
|
components.rendering.renderBand(
|
|
LOD_LEVELS.find((level) => level.id === lodId),
|
|
null,
|
|
);
|
|
},
|
|
|
|
/** Test seam: one frame of the hand-off fade at the current camera. */
|
|
_applyHandoffFadeForTest() {
|
|
components.rendering.applyHandoffFade();
|
|
},
|
|
|
|
/** Test seam: shapes drawn in the layer's own set (none: the heat is imagery). */
|
|
_entityCountForTest() {
|
|
return layerState._cells?.size() ?? 0;
|
|
},
|
|
|
|
/** Test seam that binds the production click path and indexes. */
|
|
_bindInteractionForTest(viewer, fires = []) {
|
|
layerState._viewer = viewer;
|
|
layerState._enabled = true;
|
|
layerState._allFires = fires;
|
|
layerState._allFiresByFrp = [...fires];
|
|
layerState._fires = fires;
|
|
layerState._firesByFrp = [...fires];
|
|
layerState._count = fires.length;
|
|
layerState._totalCount = fires.length;
|
|
layerState._pickIndexById.clear();
|
|
layerState._labelLodDistance = 1e7;
|
|
components.rendering.ensureDetectionCollections();
|
|
layerState._labelCandidates = fires.map((fire) => {
|
|
layerState._pickIndexById.set(`firms-${fire.index}`, fire);
|
|
return { fire, position: components.model.firePosition(fire) };
|
|
});
|
|
components.cards.rebuildAmbientLabels();
|
|
components.selection.installClickHandler();
|
|
},
|
|
};
|
|
|
|
return { methods };
|
|
}
|