wip(mobile): checkpoint the globe engine and vision mockup in progress

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01VVYRAqiQj9Y1V9ZfG1RcDH
This commit is contained in:
Claude committed 2026-10-19 02:49:15 +00:00
1 parent 8b7fcb09df
commit a644e797a7
36 files changed
+10296 -623

No files matched your search

+1
View File
@@ -176,6 +176,7 @@ export class AircraftLayer extends Layer {
.join(' · '),
lon,
lat,
...(r.emergency ? { labelDetail: `SQ ${r.squawk}` } : {}),
meta: {
layer: this.id,
icao24: r.id,
+4 -1
View File
@@ -8,6 +8,7 @@ import { createSkyLayers } from './air.js';
import { createOrbitLayers } from './orbit.js';
import { createHazardLayers } from './hazards.js';
import { createSeaLayers, createEyesLayers } from './sea.js';
import { createWeatherLayers } from './weather.js';
export const FAMILIES = Object.freeze([
'Sky',
@@ -62,7 +63,8 @@ export const CATALOG = Object.freeze([
['Weather', 'radar', 'Radar'],
['Weather', 'clouds', 'Clouds'],
['Weather', 'lightning', 'Lightning'],
['Weather', 'wind', 'Wind'],
['Weather', 'wind', 'Wind (10 m)'],
['Weather', 'jet', 'Jet stream (250 hPa)'],
['Weather', 'forecast', 'Forecast models'],
['Infra', 'datacenters', 'Datacenters'],
['Infra', 'dams', 'Dams'],
@@ -81,6 +83,7 @@ export function buildLayers(ctx, feeds) {
...createOrbitLayers(ctx, feeds),
...createHazardLayers(ctx, feeds),
...createEyesLayers(ctx, feeds),
...createWeatherLayers(ctx, feeds),
])
live.set(layer.id, layer);
const out = new Map();
+121 -3
View File
@@ -224,7 +224,7 @@ export function createHazardLayers(ctx, feeds) {
return [
quakes,
fires,
new CycloneLayer(ctx, { feed: feeds.cyclones }),
new CycloneLayer(ctx, { feed: feeds.cyclones, tcm: feeds.tcm }),
new FloodLayer(ctx, { feed: feeds.flood }),
volcanoes,
];
@@ -255,8 +255,55 @@ export function stormPositionAt(storm, ms) {
return null; // beyond the forecast
}
const SAFFIR = [
[137, 'CAT 5'],
[113, 'CAT 4'],
[96, 'CAT 3'],
[83, 'CAT 2'],
[64, 'CAT 1'],
[34, 'TS'],
[0, 'TD'],
];
/** Saffir-Simpson category (or TS/TD) for a 1-min sustained wind in kt. */
export function stormCategory(windKt) {
if (!Number.isFinite(windKt)) return '';
return SAFFIR.find(([kt]) => windKt >= kt)[1];
}
/** Ring of a quadrant wind-radii shape ([NE, SE, SW, NW] km) around a point. */
export function radiiRing(lon, lat, quadrantsKm, stepDeg = 6) {
const ring = [];
const cosLat = Math.max(0.05, Math.cos((lat * Math.PI) / 180));
for (let a = 0; a <= 360; a += stepDeg) {
const q = Math.min(3, Math.floor((a % 360) / 90));
const r = quadrantsKm[q];
const rad = (a * Math.PI) / 180;
ring.push([
lon + (r * Math.sin(rad)) / (111.32 * cosLat),
lat + (r * Math.cos(rad)) / 111.32,
]);
}
return ring;
}
export const RADII_COLORS = { 34: '#FFD84D', 50: '#FF9A3D', 64: '#FF3B30' };
/** Match an NHC TCM (wind radii) to a storm by position (≤ 250 km). */
export function radiiFor(storm, tcm) {
let best = null;
for (const t of tcm?.storms || []) {
const d = Math.hypot(
(t.lon - storm.lon) * Math.cos((storm.lat * Math.PI) / 180),
t.lat - storm.lat,
);
if (d < 2.3 && (!best || d < best.d)) best = { d, t };
}
return best?.t || null;
}
class CycloneLayer extends Layer {
constructor(ctx, { feed }) {
constructor(ctx, { feed, tcm }) {
super(ctx, {
id: 'cyclones',
family: 'Hazards',
@@ -264,6 +311,8 @@ class CycloneLayer extends Layer {
pollMs: 15 * 60_000,
});
this.feed = feed;
this.tcm = tcm;
this.fills = null;
this.renderer = new ContactRenderer(this.root, {
layerId: this.id,
tint: color('#FFFFFF'),
@@ -284,6 +333,64 @@ class CycloneLayer extends Layer {
this.fromFeed(this.feed);
}
this._draw(true);
// Wind radii arrive from a second source; the cone and track never wait.
this.tcm
?.get()
.then(() => this.on && this._fills(this.feed.data?.records || []))
.catch(() => {});
}
/** Filled cone of uncertainty and 34/50/64-kt wind-radii quadrants. */
_fills(storms) {
if (this.fills) this.root.remove(this.fills);
this.fills = null;
const instances = [];
const poly = (ring, css, alpha, height) => {
if (!ring || ring.length < 4) return;
instances.push(
new Cesium.GeometryInstance({
geometry: new Cesium.PolygonGeometry({
polygonHierarchy: new Cesium.PolygonHierarchy(
Cesium.Cartesian3.fromDegreesArray(ring.flat()),
),
height,
vertexFormat: Cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
}),
attributes: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
color(css, alpha),
),
},
}),
);
};
for (const s of storms) {
poly(outerRing(s.cone), '#FFFFFF', 0.1, 1500);
const tcm = radiiFor(s, this.tcm?.data);
if (tcm) s.radii = tcm.radii;
for (const r of [...(s.radii || [])].sort((a, b) => a.kt - b.kt)) {
if (!r.quadrantsKm.some((k) => k > 0)) continue;
poly(
radiiRing(s.lon, s.lat, r.quadrantsKm),
RADII_COLORS[r.kt] || '#FFD84D',
r.kt === 64 ? 0.26 : r.kt === 50 ? 0.18 : 0.12,
2500 + r.kt * 20,
);
}
}
if (!instances.length) return;
this.fills = this.root.add(
new Cesium.Primitive({
geometryInstances: instances,
appearance: new Cesium.PerInstanceColorAppearance({
flat: true,
translucent: true,
}),
asynchronous: true,
allowPicking: false,
}),
);
this.ctx.requestRender();
}
_draw(full) {
@@ -308,7 +415,10 @@ class CycloneLayer extends Layer {
}
this.count = items.length;
this.renderer.setItems(items);
if (full) this._lines(data.records);
if (full) {
this._lines(data.records);
this._fills(data.records);
}
}
_lines(storms) {
@@ -402,9 +512,17 @@ class CycloneLayer extends Layer {
.join(' · '),
lon: s.now.lon,
lat: s.now.lat,
labelDetail: [
stormCategory(s.now.windKt),
s.now.windKt ? `${Math.round(s.now.windKt)} KT` : null,
s.pressureHpa ? `${s.pressureHpa} HPA` : null,
]
.filter(Boolean)
.join(' · '),
meta: {
layer: this.id,
windKt: s.now.windKt ?? null,
radii: s.radii ?? null,
pressureHpa: s.pressureHpa ?? null,
movement: s.movement ?? null,
basin: s.basin,
+906
View File
@@ -0,0 +1,906 @@
/**
* Weather family (radar, satellite IR clouds, lightning, surface wind, jet
* stream) plus the round-two Ground/Infra/Hazards layers that share the same
* plumbing (transit vehicles, GNSS interference, air quality).
*
* Rasters come from NOAA nowCOAST through the app's /api/weather proxy as
* whole-extent frames and are drawn as one unlit, translucent rectangle each
* (a few kilometres above the ground, where the weather is), so the night
* side does not swallow them the way lit imagery layers would. Scrubbing the
* time ribbon swaps to the frame valid at that time (radar ≈ 50 min of 4-min
* frames, lightning 3 h of 15-min frames, IR 6 h of hourly frames). Wind uses
* the desktop app's GPU streamline renderer (src/layers/wind/gpuRendering.js).
*/
import * as Cesium from 'cesium';
import {
ContactRenderer,
Layer,
color,
FAMILY_COLORS,
inRect,
} from './base.js';
import { createWindGpuRendering } from '../../../src/layers/wind/gpuRendering.js';
import {
aqiColor,
frameAt,
gnssIntegrity,
GNSS_ANCHORS,
transitVehicles,
weatherImageUrl,
} from '../feedsWeather.js';
import { haversineKm, relTime } from '../geo.js';
const WX = FAMILY_COLORS.Weather;
/* ───────────────────────── Frame decoding (shared) ───────────────────────── */
const frameCache = new Map(); // url → Promise<canvas>
const FRAME_CACHE_MAX = 8;
/** Decode a same-origin weather frame into a canvas (IR gets an alpha key). */
async function decodeFrame(url, product) {
const response = await fetch(url);
if (!response.ok) throw new Error(`Weather frame HTTP ${response.status}`);
const bitmap = await createImageBitmap(await response.blob());
const canvas = document.createElement('canvas');
canvas.width = bitmap.width;
canvas.height = bitmap.height;
const g = canvas.getContext('2d', { willReadFrequently: true });
g.drawImage(bitmap, 0, 0);
bitmap.close?.();
if (product === 'clouds' || product === 'clouds-regional') {
// Key the IR to clouds: warm surfaces clear, cloud tops white with a
// soft ramp (the repo's cloud key is tuned for a lit globe; this one
// also has to read on the unlit night side).
const px = g.getImageData(0, 0, canvas.width, canvas.height);
const d = px.data;
for (let i = 0; i < d.length; i += 4) {
const l = d[i];
const t = Math.max(0, Math.min(1, (l - 95) / 95));
const a = t * t * (3 - 2 * t);
d[i + 3] = (d[i + 3] * a * 215) / 255;
// Unlit clouds must not blow out under bloom: grey-white body,
// coldest tops leaning icy blue.
const cold = Math.max(0, (l - 200) / 55);
d[i] = 168 + 42 * a - 22 * cold;
d[i + 1] = 176 + 40 * a - 6 * cold;
d[i + 2] = 192 + 36 * a + 10 * cold;
}
g.putImageData(px, 0, 0);
}
return canvas;
}
function cached(url, make, keep) {
let p = frameCache.get(url);
if (p) {
frameCache.delete(url);
frameCache.set(url, p);
return p;
}
p = make();
p.catch(() => frameCache.delete(url));
if (!keep) return p;
frameCache.set(url, p);
while (frameCache.size > FRAME_CACHE_MAX)
frameCache.delete(frameCache.keys().next().value);
return p;
}
/** Decode a same-origin weather frame into a canvas (IR gets a cloud key). */
export function loadWeatherFrame(
product,
time,
width = 2048,
{ keep = true } = {},
) {
const url = weatherImageUrl(product, time, width);
return cached(url, () => decodeFrame(url, product), keep);
}
/** A 2:1 detail window (0.25° grid) covering a view rect inside bounds. */
export function detailWindow(rect, bounds) {
if (!rect || rect.west > rect.east) return null;
const lonSpan = rect.east - rect.west;
const latSpan = rect.north - rect.south;
let width = Math.max(1, lonSpan * 1.1, latSpan * 2.2);
width = Math.ceil(width / 0.5) * 0.5;
const height = width / 2;
if (width >= bounds.east - bounds.west - 0.5) return null;
if (height >= bounds.north - bounds.south - 0.5) return null;
const snap = (v) => Math.round(v / 0.25) * 0.25;
const cLon = (rect.west + rect.east) / 2;
const cLat = (rect.south + rect.north) / 2;
const minW = Math.ceil(bounds.west / 0.25) * 0.25;
const maxW = Math.floor((bounds.east - width) / 0.25) * 0.25;
const minS = Math.ceil(bounds.south / 0.25) * 0.25;
const maxS = Math.floor((bounds.north - height) / 0.25) * 0.25;
const west = Math.max(minW, Math.min(maxW, snap(cLon - width / 2)));
const south = Math.max(minS, Math.min(maxS, snap(cLat - height / 2)));
return { west, south, east: west + width, north: south + height };
}
/** Decode a detail window of a frame (2048×1024). */
export function loadWeatherDetail(product, time, box) {
const url = `/api/weather/image?product=${product}&time=${encodeURIComponent(time)}&bbox=${box.west},${box.south},${box.east},${box.north}&size=2048x1024`;
return cached(url, () => decodeFrame(url, product), true);
}
/* ───────────────────────── Raster layer ───────────────────────── */
class WeatherRasterLayer extends Layer {
/**
* @param {object} ctx
* @param {object} def
* @param {{feed:object, product:string, heightM:number, alpha:number,
* width?:number}} opts
*/
constructor(ctx, def, opts) {
super(ctx, { pollMs: 2 * 60_000, ...def });
this.feed = opts.feed;
this.product = opts.product;
this.heightM = opts.heightM;
this.alpha = opts.alpha;
this.width = opts.width ?? 2048;
this.primitive = null;
this.material = null;
this.frame = null;
this._want = null;
}
async refresh() {
try {
await this.feed.get();
} finally {
this.fromFeed(this.feed);
}
await this._apply();
if (this.frame && this.feed.data)
this.message = `${this.feed.data.title} · ${relTime(this.frameTime, Date.now())}`;
else if (this.feed.data?.coverage) this.message ||= this.feed.data.coverage;
}
_ensurePrimitive(bounds) {
if (this.primitive) return;
this.material = Cesium.Material.fromType('Image', {
image: Cesium.Material.DefaultImageId,
color: new Cesium.Color(1, 1, 1, this.alpha),
});
const rect = Cesium.Rectangle.fromDegrees(
bounds.west,
bounds.south,
bounds.east,
bounds.north,
);
this.primitive = this.root.add(
new Cesium.Primitive({
geometryInstances: new Cesium.GeometryInstance({
geometry: new Cesium.RectangleGeometry({
rectangle: rect,
height: this.heightM,
granularity: Cesium.Math.toRadians(1),
vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
}),
}),
appearance: new Cesium.EllipsoidSurfaceAppearance({
material: this.material,
flat: true,
aboveGround: true,
translucent: true,
renderState: { depthMask: false },
}),
asynchronous: true,
allowPicking: false,
show: false,
}),
);
}
async _apply() {
const data = this.feed.data;
if (!data) return;
const time = frameAt(
data.times,
this.ctx.isLive() ? null : this.ctx.timeMs(),
);
this._want = time;
if (!time) {
if (this.primitive) this.primitive.show = false;
this.count = 0;
this.message = 'No observation at this time';
this.ctx.requestRender();
return;
}
if (time === this.frame) {
if (this.primitive) this.primitive.show = true;
return;
}
this._ensurePrimitive(data.bounds);
const canvas = await loadWeatherFrame(this.product, time, this.width);
if (this._want !== time || !this.on) return;
this.material.uniforms.image = canvas;
this.primitive.show = true;
this.frame = time;
this.frameCanvas = canvas;
this.frameTime = Date.parse(time);
this.message = `${data.title} · ${relTime(this.frameTime, Date.now())}`;
if (this.afterFrame) this.afterFrame(canvas, data);
else this.count = 1;
this._detail().catch(() => {});
this.ctx.requestRender();
}
/** Close in, a sharper window of the same frame is laid over the global one. */
onView(view) {
this.lastView = view;
if (!this.on) return;
clearTimeout(this._detailTimer);
this._detailTimer = setTimeout(
() => this._detail().catch((e) => console.warn(`[globe:${this.id}]`, e)),
350,
);
}
async _detail() {
const v = this.lastView;
const data = this.feed.data;
const box =
v && v.heightM < 3_500_000 && this.frame && data
? detailWindow(v.rect, data.bounds)
: null;
if (!box) {
if (this.detailPrim) this.detailPrim.show = false;
this._detailKey = null;
this.ctx.requestRender();
return;
}
const key = `${this.frame}|${box.west},${box.south},${box.east},${box.north}`;
if (key === this._detailKey) {
if (this.detailPrim) this.detailPrim.show = true;
return;
}
this._detailKey = key;
const canvas = await loadWeatherDetail(this.product, this.frame, box);
if (this._detailKey !== key || !this.on) return;
if (this.detailPrim) this.root.remove(this.detailPrim);
const material = Cesium.Material.fromType('Image', {
image: canvas,
color: new Cesium.Color(1, 1, 1, this.alpha),
});
this.detailPrim = this.root.add(
new Cesium.Primitive({
geometryInstances: new Cesium.GeometryInstance({
geometry: new Cesium.RectangleGeometry({
rectangle: Cesium.Rectangle.fromDegrees(
box.west,
box.south,
box.east,
box.north,
),
height: this.heightM + 60,
granularity: Cesium.Math.toRadians(0.25),
vertexFormat: Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
}),
}),
appearance: new Cesium.EllipsoidSurfaceAppearance({
material,
flat: true,
aboveGround: true,
translucent: true,
renderState: { depthMask: false },
}),
asynchronous: true,
allowPicking: false,
}),
);
// The coarse global frame stays underneath only where the window ends.
this.ctx.requestRender();
}
onTime() {
if (!this.on) return;
clearTimeout(this._timeTimer);
// Frames are whole-extent images: decode at most ~4 per second while
// the ribbon is being dragged.
this._timeTimer = setTimeout(
() => this._apply().catch((e) => console.warn(`[globe:${this.id}]`, e)),
250,
);
}
onHide() {
if (this.primitive) this.primitive.show = false;
if (this.detailPrim) this.detailPrim.show = false;
this._detailKey = null;
this.frame = null;
}
info() {
const i = super.info();
if (this.on && this.feed.data) i.frames = this.feed.data.times.length;
return i;
}
}
/* ───────────────────────── Lightning ───────────────────────── */
const STRIKE_BIN_DEG = 0.5;
const STRIKE_CAP = 1500;
/**
* Strike-density raster plus a glow per active 0.5° cell, so storms read as
* flickering points of light from orbit. nowCOAST's palette runs yellow →
* orange → red → magenta with density; the glow grades the same way.
*/
class LightningLayer extends WeatherRasterLayer {
constructor(ctx, opts) {
super(
ctx,
{ id: 'lightning', family: 'Weather', name: 'Lightning' },
{ ...opts, product: 'lightning', heightM: 9000, alpha: 0.95 },
);
this.renderer = new ContactRenderer(this.root, {
layerId: this.id,
tint: color('#FFF2A8'),
glyphName: 'bolt',
rotate: false,
lodHeightM: 1_500_000,
cap: 300,
dotScale: 0.55,
glyphScale: 0.42,
dotAlpha: 1,
});
this.cells = new Map();
}
onView(view) {
super.onView(view);
this.renderer.setView(view);
}
afterFrame(canvas, data) {
const cells = strikeCells(canvas, data.bounds);
this.cells = new Map(cells.map((c) => [c.key, c]));
this.count = cells.length;
this.renderer.setItems(
cells.map((c) => ({
key: c.key,
lon: c.lon,
lat: c.lat,
altM: 9500,
color: color(
c.level >= 3 ? '#FF8AE6' : c.level === 2 ? '#FFD27A' : '#FFF6C8',
),
dotScale: 0.32 + Math.min(0.55, c.pixels / 12),
glyphScale: 0.8 + c.level * 0.12,
})),
);
}
/** 1 Hz flicker: a few cells flare each second (cheap, no render loop). */
onTick() {
const n = this.renderer.dots.length;
if (!n) return false;
for (let k = 0; k < Math.min(24, n); k++) {
const i = Math.floor(Math.random() * n);
const bb = this.renderer.dots.get(i);
bb.scale = bb._base ??= bb.scale;
bb.scale = bb._base * (1.4 + Math.random() * 0.9);
setTimeout(() => {
if (this.renderer.dots.contains(bb)) bb.scale = bb._base;
}, 220);
}
setTimeout(() => this.ctx.requestRender(), 230);
return true;
}
locate(key) {
const c = this.cells.get(key);
return c ? [c.lon, c.lat, 9500] : null;
}
pick(key) {
const c = this.cells.get(key);
if (!c) return null;
return {
kind: 'lightning',
id: key,
title: 'Lightning',
subtitle: `Strike density class ${c.level} · ${relTime(this.frameTime, Date.now())}`,
lon: c.lon,
lat: c.lat,
meta: { layer: this.id, level: c.level, source: this.source },
};
}
}
/** Classify a nowCOAST lightning-density pixel 1 (low) .. 4 (extreme). */
export function strikeLevel(r, g, b) {
if (r > 200 && g > 200 && b < 140) return 1; // yellow
if (r > 200 && g > 90) return 2; // orange
if (r > 170 && b > 120) return 4; // magenta / pink
if (r > 150) return 3; // red
return 1;
}
/** Bin the lit pixels of a whole-extent lightning frame into 0.5° cells. */
export function strikeCells(canvas, bounds, bbox = null) {
const g = canvas.getContext('2d', { willReadFrequently: true });
const { width, height } = canvas;
const px = g.getImageData(0, 0, width, height).data;
const dLon = (bounds.east - bounds.west) / width;
const dLat = (bounds.north - bounds.south) / height;
const bins = new Map();
for (let y = 0; y < height; y++) {
const lat = bounds.north - (y + 0.5) * dLat;
if (bbox && (lat < bbox.south || lat > bbox.north)) continue;
for (let x = 0; x < width; x++) {
const i = (y * width + x) * 4;
if (px[i + 3] < 40) continue;
const lon = bounds.west + (x + 0.5) * dLon;
if (bbox && (lon < bbox.west || lon > bbox.east)) continue;
const level = strikeLevel(px[i], px[i + 1], px[i + 2]);
const key = `${Math.floor(lat / STRIKE_BIN_DEG)}:${Math.floor(lon / STRIKE_BIN_DEG)}`;
let c = bins.get(key);
if (!c)
bins.set(
key,
(c = { key, lat: 0, lon: 0, pixels: 0, level: 0, weight: 0 }),
);
c.lat += lat;
c.lon += lon;
c.pixels++;
c.weight += level;
c.level = Math.max(c.level, level);
}
}
const out = [];
for (const c of bins.values()) {
c.lat /= c.pixels;
c.lon /= c.pixels;
out.push(c);
}
out.sort((a, b) => b.weight - a.weight);
return out.slice(0, STRIKE_CAP);
}
/* ───────────────────────── Wind (GPU streamlines) ───────────────────────── */
class WindLayer extends Layer {
constructor(ctx, def, { feed }) {
super(ctx, { pollMs: 60 * 60_000, ...def });
this.feed = feed;
this.gpu = createWindGpuRendering({
cesium: Cesium,
getViewer: () => ctx.viewer,
});
this.field = null;
this.started = performance.now();
this._raf = 0;
this._lastFrame = 0;
const scene = ctx.scene;
this._pre = scene.preRender.addEventListener(() => {
if (!this.on || !this.field) return;
this.gpu.tick((performance.now() - this.started) / 1000);
this.gpu.updateVisibility(scene.camera);
});
}
async refresh() {
try {
await this.feed.get();
} finally {
this.fromFeed(this.feed);
}
const d = this.feed.data;
if (!d) return;
if (d.field !== this.field) {
this.field = d.field;
if (this.on) this.gpu.setField(this.field);
}
this.count = this.gpu.getParticleCount();
this.message = `${d.level} · ${d.source}`;
this._loop();
}
setOn(on) {
super.setOn(on);
if (on && this.field) {
this.gpu.setField(this.field);
this._loop();
}
}
onHide() {
this.gpu.clear();
cancelAnimationFrame(this._raf);
this._raf = 0;
}
/** Flowing streaks need frames: ~30 fps while on and visible, 0 otherwise. */
_loop() {
if (this._raf || !this.on) return;
const step = (t) => {
this._raf = 0;
if (!this.on) return;
if (this.ctx.active() && t - this._lastFrame > 33) {
this._lastFrame = t;
this.ctx.requestRender();
}
this._raf = requestAnimationFrame(step);
};
this._raf = requestAnimationFrame(step);
}
destroy() {
cancelAnimationFrame(this._raf);
this._pre?.();
this.gpu.destroy();
super.destroy();
}
}
/* ───────────────────────── Air quality ───────────────────────── */
class AirQualityLayer extends Layer {
constructor(ctx, { feed }) {
super(ctx, {
id: 'air-quality',
family: 'Hazards',
name: 'Air quality',
pollMs: 60 * 60_000,
});
this.feed = feed;
this.renderer = new ContactRenderer(this.root, {
layerId: this.id,
tint: color('#F2D33B'),
glyphName: 'aq',
rotate: false,
alwaysGlyph: true,
dotScale: 0.9,
glyphScale: 0.5,
});
this.records = new Map();
}
async refresh() {
try {
await this.feed.get();
} finally {
this.fromFeed(this.feed);
}
const recs = this.feed.data.records;
this.records = new Map(recs.map((r) => [r.id, r]));
this.count = recs.length;
this.renderer.setItems(
recs.map((r) => ({
key: r.id,
lon: r.lon,
lat: r.lat,
color: color(aqiColor(r.aqi)),
dotScale: 0.8 + Math.min(2, r.aqi / 100),
glyphScale: 0.55 + Math.min(0.6, r.aqi / 300),
})),
);
}
onView(view) {
this.renderer.setView(view);
}
locate(key) {
const r = this.records.get(key);
return r ? [r.lon, r.lat, 0] : null;
}
pick(key) {
const r = this.records.get(key);
if (!r) return null;
return {
kind: 'air-quality',
id: r.id,
title: `${r.name} · AQI ${Math.round(r.aqi)}`,
subtitle: `PM2.5 ${r.pm25?.toFixed(0) ?? '–'} µg/m³ · modelled (CAMS)`,
lon: r.lon,
lat: r.lat,
labelDetail: `AQI ${Math.round(r.aqi)}`,
meta: { layer: this.id, aqi: r.aqi, pm25: r.pm25, source: this.source },
};
}
}
/* ───────────────────────── GNSS interference ───────────────────────── */
const GNSS_COLORS = { high: '#FF3B6B', medium: '#FFB13D', low: '#4ADE80' };
class GnssLayer extends Layer {
constructor(ctx) {
super(ctx, {
id: 'gnss',
family: 'Infra',
name: 'GNSS interference',
pollMs: 2 * 60_000,
});
this.source = 'adsb.lol NIC/NACp (gpsjam.org bands)';
this.cellsPrim = null;
this.anchor = null;
this.cells = new Map();
}
_anchors() {
const v = this.lastView;
if (v && v.heightM < 3_000_000 && v.center)
return [{ id: 'view', lat: v.center.lat, lon: v.center.lon }];
return GNSS_ANCHORS;
}
async refresh() {
const anchors = this._anchors();
const results = await Promise.allSettled(
anchors.map((a) =>
gnssIntegrity.get(`${Math.round(a.lat)}:${Math.round(a.lon)}`, a),
),
);
const ok = results
.filter((r) => r.status === 'fulfilled')
.map((r) => r.value);
if (!ok.length) {
this.status = 'error';
this.message =
results[0]?.reason?.message || 'GNSS integrity source unavailable';
return;
}
this.status = 'live';
this.message = 'Low NIC/NACp is a proxy for jamming or spoofing, not proof';
const cells = new Map();
for (const snap of ok)
for (const c of snap.cells)
cells.set(`${c.lat.toFixed(2)}:${c.lon.toFixed(2)}`, c);
this.cells = cells;
this._draw();
}
_draw() {
if (this.cellsPrim) this.root.remove(this.cellsPrim);
this.cellsPrim = null;
const shown = [...this.cells.entries()].filter(
([, c]) => c.level !== 'low' || c.total >= 6,
);
this.count = shown.filter(([, c]) => c.level !== 'low').length;
if (!shown.length) return;
const instances = shown.map(([key, c]) => {
const h = 0.25;
return new Cesium.GeometryInstance({
id: { layer: this.id, key },
geometry: new Cesium.RectangleGeometry({
rectangle: Cesium.Rectangle.fromDegrees(
c.lon - h,
c.lat - h,
c.lon + h,
c.lat + h,
),
height: 2000,
vertexFormat: Cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
}),
attributes: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
color(GNSS_COLORS[c.level], c.level === 'low' ? 0.18 : 0.5),
),
},
});
});
this.cellsPrim = this.root.add(
new Cesium.Primitive({
geometryInstances: instances,
appearance: new Cesium.PerInstanceColorAppearance({
flat: true,
translucent: true,
}),
asynchronous: true,
}),
);
this.ctx.requestRender();
}
onView(view) {
const prev = this.lastView;
this.lastView = view;
const moved =
!prev ||
view.heightM < 3_000_000 !== prev.heightM < 3_000_000 ||
(view.heightM < 3_000_000 &&
haversineKm(
view.center.lat,
view.center.lon,
prev.center.lat,
prev.center.lon,
) > 150);
if (moved && this.on) this.kick();
}
locate(key) {
const c = this.cells.get(key);
return c ? [c.lon, c.lat, 0] : null;
}
pick(key) {
const c = this.cells.get(key);
if (!c) return null;
return {
kind: 'gnss',
id: key,
title: `GNSS ${c.level === 'high' ? 'interference likely' : c.level === 'medium' ? 'degraded' : 'nominal'}`,
subtitle: `${c.bad}/${c.total} aircraft with low NIC/NACp · ${c.percent.toFixed(0)}%`,
lon: c.lon,
lat: c.lat,
meta: { layer: this.id, ...c, source: this.source },
};
}
}
/* ───────────────────────── Transit ───────────────────────── */
function routeColor(routeId) {
let h = 0;
for (const ch of String(routeId)) h = (h * 31 + ch.charCodeAt(0)) >>> 0;
return `hsl(${h % 360} 85% 62%)`;
}
class TransitLayer extends Layer {
constructor(ctx, { catalog }) {
super(ctx, {
id: 'transit',
family: 'Ground',
name: 'Transit vehicles',
pollMs: 20_000,
});
this.catalog = catalog;
this.renderer = new ContactRenderer(this.root, {
layerId: this.id,
tint: color(FAMILY_COLORS.Ground),
glyphName: 'bus',
lodHeightM: 400_000,
cap: 600,
dotScale: 0.32,
glyphScale: 0.38,
});
this.records = new Map();
this.feedId = null;
}
async refresh() {
let cat;
try {
cat = await this.catalog.get();
} finally {
this.fromFeed(this.catalog);
}
const c = this.lastView?.center;
const feeds = cat.feeds;
let best = null;
for (const f of feeds) {
const d = c ? haversineKm(c.lat, c.lon, f.center.lat, f.center.lon) : 0;
if (!best || d - f.loadRadiusKm < best.d - best.f.loadRadiusKm)
best = { f, d };
}
if (
!best ||
(c && best.d > best.f.loadRadiusKm + 400 && this.lastView?.heightM < 3e6)
) {
this.count = 0;
this.message = 'No open transit feed near this view';
this.renderer.clear();
return;
}
// From orbit the nearest feed is arbitrary: show Helsinki's (busy, CC BY).
const feed =
this.lastView?.heightM >= 3e6
? feeds.find((f) => f.id === 'hsl-helsinki') || best.f
: best.f;
this.feedId = feed.id;
const snap = await transitVehicles.get(feed.id);
this.source = `${feed.name} · ${feed.attribution}`;
this.message = `${feed.region} · ${snap.vehicles.length} vehicles`;
this.status = 'live';
this.records = new Map(snap.vehicles.map((v) => [v.id, v]));
this.count = snap.vehicles.length;
this.renderer.setItems(
snap.vehicles.map((v) => ({
key: v.id,
lon: v.lon,
lat: v.lat,
heading: v.bearing ?? 0,
color: color(routeColor(v.routeId)),
})),
);
}
onView(view) {
const prev = this.lastView;
this.lastView = view;
this.renderer.setView(view);
if (
this.on &&
prev?.center &&
haversineKm(
view.center.lat,
view.center.lon,
prev.center.lat,
prev.center.lon,
) > 120
)
this.kick();
}
locate(key) {
const v = this.records.get(key);
return v ? [v.lon, v.lat, 0] : null;
}
pick(key) {
const v = this.records.get(key);
if (!v) return null;
return {
kind: 'transit',
id: v.id,
title: `Route ${v.routeId || '?'}`,
subtitle: [
v.speedMps != null ? `${Math.round(v.speedMps * 3.6)} km/h` : null,
v.status ? v.status.replace(/_/g, ' ').toLowerCase() : null,
]
.filter(Boolean)
.join(' · '),
lon: v.lon,
lat: v.lat,
meta: { layer: this.id, feedId: this.feedId, source: this.source },
};
}
contacts() {
return [...this.records.values()].map((v) => ({
kind: 'transit',
id: v.id,
title: `Route ${v.routeId}`,
lon: v.lon,
lat: v.lat,
altM: 0,
headingDeg: v.bearing ?? 0,
speedMps: v.speedMps,
layer: this.id,
}));
}
}
export { inRect };
export function createWeatherLayers(ctx, feeds) {
return [
new WeatherRasterLayer(
ctx,
{ id: 'radar', family: 'Weather', name: 'Radar' },
{ feed: feeds.radar, product: 'radar', heightM: 4000, alpha: 0.9 },
),
new WeatherRasterLayer(
ctx,
{
id: 'clouds',
family: 'Weather',
name: 'Clouds (satellite IR)',
pollMs: 10 * 60_000,
},
{ feed: feeds.clouds, product: 'clouds', heightM: 7000, alpha: 0.85 },
),
new LightningLayer(ctx, { feed: feeds.lightning, width: 2048 }),
new WindLayer(
ctx,
{ id: 'wind', family: 'Weather', name: 'Wind (10 m)' },
{ feed: feeds.wind },
),
new WindLayer(
ctx,
{ id: 'jet', family: 'Weather', name: 'Jet stream (250 hPa)' },
{ feed: feeds.jet },
),
new AirQualityLayer(ctx, { feed: feeds.airQuality }),
new GnssLayer(ctx),
new TransitLayer(ctx, { catalog: feeds.transitCatalog }),
];
}
export { WX };