mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
Aircraft, military, local ADS-B, vessel, transit and rail models come from the fleet model set, loaded up front and drawn life size through the draw port's models sets; no layer touches the viewer or Cesium outside src/render/cesium/. The models capability gains glTF bytes (gltf), a per-axis stretch (axisScale), a colour for tinted parts (maskColor) and a cut below the origin (clip: 'belowOrigin'), with conformance checks. Main's rail layer and Data Library are ported to the ports; the CCTV footprint probe keeps the globe-terrain clamp through the query port.
215 lines
7.2 KiB
JavaScript
215 lines
7.2 KiB
JavaScript
import {
|
|
PARTIAL_RETENTION_MS,
|
|
SELECTED_PIN_REFRESHES,
|
|
} from './recordPolicy.js';
|
|
|
|
/**
|
|
* Normalize AIS display fields without allocating scene resources. `id` is the
|
|
* vessel's key, the stable id its source gives; a row that names none (an
|
|
* AIS feed's own rows) is keyed by its MMSI. `mmsi` is only an attribute,
|
|
* shown when known: vessels can share one. A row with neither is unkeyed.
|
|
*/
|
|
export function normalizeVessel(row) {
|
|
const lat = Number(row.lat);
|
|
const lon = Number(row.lon);
|
|
if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
|
|
const mmsi = String(row.mmsi || '').trim();
|
|
const id = String(row.id ?? mmsi).trim();
|
|
return {
|
|
lat,
|
|
lon,
|
|
name: String(row.name || mmsi || 'VESSEL'),
|
|
id,
|
|
mmsi,
|
|
reference: row.reference ?? id,
|
|
imo: String(row.imo || ''),
|
|
type: String(row.type || ''),
|
|
destination: String(row.destination || ''),
|
|
// Hull length and beam (metres), null when unreported.
|
|
length: positiveNumber(row.length),
|
|
beam: positiveNumber(row.beam),
|
|
speed: finiteNumber(row.speed),
|
|
course: finiteNumber(row.course),
|
|
heading: finiteNumber(row.heading),
|
|
lastPositionUtc: String(row.last_position_UTC || ''),
|
|
lastPositionEpoch: finiteNumber(row.last_position_epoch),
|
|
missedRefreshes: 0,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Note when a fix was first received (`fixReceivedAtMs`, this client's
|
|
* clock) and the newest fix in that refresh (`fixFeedEpoch`, the feed's
|
|
* clock): its age is then read on each clock separately, so neither a
|
|
* skewed client clock nor a re-served cached row hides how old it is.
|
|
* `receivedAtMs` stays the time the row was last seen, for retention.
|
|
*/
|
|
function stampFix(record, receivedAtMs, feedLatestEpoch) {
|
|
record.fixReceivedAtMs = receivedAtMs;
|
|
record.fixFeedEpoch = feedLatestEpoch;
|
|
}
|
|
|
|
function positiveNumber(value) {
|
|
const number = finiteNumber(value);
|
|
return number !== null && number > 0 ? number : null;
|
|
}
|
|
|
|
function finiteNumber(value) {
|
|
if (value === null || value === undefined || value === '') return null;
|
|
const number = Number(value);
|
|
return Number.isFinite(number) ? number : null;
|
|
}
|
|
|
|
/**
|
|
* The move from a record's fix to the next row's, when the fix moves on in
|
|
* time; otherwise the move it was making, if the row repeats its fix.
|
|
*/
|
|
function motionBetween(record, next) {
|
|
const fromEpoch = record.lastPositionEpoch;
|
|
const toEpoch = next.lastPositionEpoch;
|
|
if (fromEpoch === toEpoch) return record.motion ?? null;
|
|
if (!Number.isFinite(fromEpoch) || !Number.isFinite(toEpoch)) return null;
|
|
if (!(toEpoch > fromEpoch)) return null;
|
|
return {
|
|
fromLat: record.lat,
|
|
fromLon: record.lon,
|
|
fromMs: fromEpoch * 1000,
|
|
toLat: next.lat,
|
|
toLon: next.lon,
|
|
toMs: toEpoch * 1000,
|
|
};
|
|
}
|
|
|
|
/** Own stable vessel records and bounded incomplete/selected retention. */
|
|
export class VesselRecords {
|
|
constructor({ now = () => Date.now() } = {}) {
|
|
this.now = now;
|
|
this.byId = new Map();
|
|
this.unkeyed = [];
|
|
this.all = [];
|
|
}
|
|
/**
|
|
* Fold a refresh into the records. Following the world clock (`follow`),
|
|
* a vessel whose fix moves on keeps where it moved from, so it can be drawn
|
|
* between the two (see motion.js). `replace`: the rows are the world at
|
|
* another time (the clock jumped), so they stand in for every vessel: one
|
|
* they lack is gone at once, selected or not, and none moves from where it
|
|
* was at the time the clock left.
|
|
*/
|
|
reconcile(
|
|
rows,
|
|
{
|
|
complete = true,
|
|
selectedRecord = null,
|
|
cap = Infinity,
|
|
replace = false,
|
|
follow = false,
|
|
},
|
|
effects,
|
|
) {
|
|
const receivedAtMs = this.now();
|
|
// The newest fix in the batch: the feed's own "now", so a fix's age can
|
|
// be read on the feed's clock rather than against this client's (see
|
|
// stampFix).
|
|
let feedLatestEpoch = null;
|
|
for (const row of rows) {
|
|
const epoch = finiteNumber(row?.last_position_epoch);
|
|
if (
|
|
epoch !== null &&
|
|
(feedLatestEpoch === null || epoch > feedLatestEpoch)
|
|
)
|
|
feedLatestEpoch = epoch;
|
|
}
|
|
for (const record of this.unkeyed) effects.remove(record, false);
|
|
this.unkeyed = [];
|
|
const seen = new Set();
|
|
for (const row of rows) {
|
|
const next = normalizeVessel(row);
|
|
if (!next) continue;
|
|
next.receivedAtMs = receivedAtMs;
|
|
stampFix(next, receivedAtMs, feedLatestEpoch);
|
|
if (!next.id) {
|
|
effects.add(next);
|
|
this.unkeyed.push(next);
|
|
continue;
|
|
}
|
|
if (seen.has(next.id)) continue;
|
|
seen.add(next.id);
|
|
const record = this.byId.get(next.id);
|
|
if (record) {
|
|
// A feed re-serving a cached row repeats its fix: the fix keeps the
|
|
// time it was first received, so it goes on ageing.
|
|
if (next.lastPositionEpoch !== record.lastPositionEpoch) {
|
|
record.fixReceivedAtMs = next.fixReceivedAtMs;
|
|
record.fixFeedEpoch = next.fixFeedEpoch;
|
|
}
|
|
if (replace) record.motion = null;
|
|
else if (follow) record.motion = motionBetween(record, next);
|
|
record.reference = next.reference;
|
|
record.mmsi = next.mmsi;
|
|
record.receivedAtMs = next.receivedAtMs;
|
|
record.lat = next.lat;
|
|
record.lon = next.lon;
|
|
record.name = next.name;
|
|
record.imo = next.imo;
|
|
record.type = next.type;
|
|
record.destination = next.destination;
|
|
record.length = next.length;
|
|
record.beam = next.beam;
|
|
record.speed = next.speed;
|
|
record.course = next.course;
|
|
record.heading = next.heading;
|
|
record.lastPositionUtc = next.lastPositionUtc;
|
|
record.lastPositionEpoch = next.lastPositionEpoch;
|
|
record.missedRefreshes = 0;
|
|
|
|
effects.updated(record);
|
|
} else {
|
|
effects.add(next);
|
|
this.byId.set(next.id, next);
|
|
}
|
|
}
|
|
for (const [id, record] of this.byId) {
|
|
if (seen.has(id)) continue;
|
|
if (replace) {
|
|
effects.remove(record, record === selectedRecord);
|
|
this.byId.delete(id);
|
|
effects.removed(id);
|
|
continue;
|
|
}
|
|
if (
|
|
!complete &&
|
|
Number.isFinite(record.receivedAtMs) &&
|
|
receivedAtMs - record.receivedAtMs < PARTIAL_RETENTION_MS
|
|
) {
|
|
if (record === selectedRecord) {
|
|
record.missedRefreshes = Math.max(1, record.missedRefreshes || 0);
|
|
effects.staleSelected(record);
|
|
}
|
|
continue;
|
|
}
|
|
if (record === selectedRecord) {
|
|
record.missedRefreshes = (record.missedRefreshes || 0) + 1;
|
|
if (complete && record.missedRefreshes <= SELECTED_PIN_REFRESHES) {
|
|
effects.staleSelected(record);
|
|
continue;
|
|
}
|
|
}
|
|
// Selection teardown still sees the record before its store entry is removed.
|
|
effects.remove(record, record === selectedRecord);
|
|
this.byId.delete(id);
|
|
effects.removed(id);
|
|
}
|
|
if (this.byId.size + this.unkeyed.length > cap) {
|
|
for (const [id, record] of this.byId) {
|
|
if (this.byId.size + this.unkeyed.length <= cap) break;
|
|
if (seen.has(id) || record === selectedRecord) continue;
|
|
effects.remove(record, false);
|
|
this.byId.delete(id);
|
|
effects.removed(id);
|
|
}
|
|
}
|
|
this.all = [...this.byId.values(), ...this.unkeyed];
|
|
}
|
|
}
|