mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Merge main into feat/rio-transit-gtfs-rt
This commit is contained in:
commit
e5dd7c71ac
53 files changed
+2649
-174
No files matched your search
@@ -45,7 +45,7 @@ test('buildFireCard: title carries FRP, detail carries conf/age/satellite', () =
|
||||
assert.equal(card.details.length, 1);
|
||||
assert.equal(card.details[0], 'high · 2h · N20');
|
||||
assert.equal(card.selected, false);
|
||||
assert.equal(card.accent, accentForSeverity('red'), 'FRP 1520 is red-hot');
|
||||
assert.equal(card.accent, accentForSeverity('white-hot'), 'FRP 1520 is white-hot');
|
||||
assert.deepEqual(card.position, { x: 1, y: 2, z: 3 }, 'uses the candidate position untouched');
|
||||
});
|
||||
|
||||
@@ -69,11 +69,27 @@ test('buildFireCard: power that rounds to 10 MW drops the decimal', () => {
|
||||
assert.equal(selected.title, 'FIRE · 10 MW');
|
||||
});
|
||||
|
||||
test('buildFireCard: SNPP satellite code renders as SNPP, weak fire is not red', () => {
|
||||
test('buildFireCard: SNPP satellite code renders as SNPP, weak fire is an ember', () => {
|
||||
const card = buildFireCard({ fire: fire({ satellite: 'N', frp: 0.8, confidence: 0.3 }), position: {} }, NOW);
|
||||
assert.match(card.details[0], /SNPP$/);
|
||||
assert.equal(card.title, '▲ 0.8 MW');
|
||||
assert.notEqual(card.accent, accentForSeverity('red'));
|
||||
assert.equal(card.accent, accentForSeverity('ember'));
|
||||
});
|
||||
|
||||
test('buildFireCard: accent steps through the FRP ramp at 5 · 20 · 50 · 100 · 300 MW', () => {
|
||||
const accentAt = (frp) =>
|
||||
buildFireCard({ fire: fire({ frp }), position: {} }, NOW).accent;
|
||||
assert.equal(accentAt(4.9), accentForSeverity('ember'));
|
||||
assert.equal(accentAt(5), accentForSeverity('red'));
|
||||
assert.equal(accentAt(20), accentForSeverity('flame'));
|
||||
assert.equal(accentAt(50), accentForSeverity('orange'));
|
||||
assert.equal(accentAt(100), accentForSeverity('gold'));
|
||||
assert.equal(accentAt(300), accentForSeverity('white-hot'));
|
||||
// Confidence never moves the color: a low-confidence 864 MW fire stays red.
|
||||
assert.equal(
|
||||
buildFireCard({ fire: fire({ frp: 864, confidence: 0.3 }), position: {} }, NOW).accent,
|
||||
accentForSeverity('white-hot'),
|
||||
);
|
||||
});
|
||||
|
||||
test('buildSelectedFireCard: full detail card with coords, selected flag, no fade', () => {
|
||||
@@ -93,12 +109,12 @@ test('buildCellCard: plural noun, max FRP and newest age, accent passthrough', (
|
||||
const candidate = {
|
||||
cell: { count: 14, maxFrp: 210.4, newestAcqMs: NOW - 3 * H, night: 2 },
|
||||
position: { x: 0, y: 0, z: 0 },
|
||||
accent: accentForSeverity('orange'),
|
||||
accent: accentForSeverity('gold'),
|
||||
};
|
||||
const card = buildCellCard(candidate, NOW);
|
||||
assert.equal(card.title, '14 FIRES');
|
||||
assert.equal(card.details[0], 'max 210 MW · new 3h');
|
||||
assert.equal(card.accent, accentForSeverity('orange'));
|
||||
assert.equal(card.accent, accentForSeverity('gold'));
|
||||
});
|
||||
|
||||
test('buildCellCard: the count picks the plural form of the language', () => {
|
||||
@@ -150,7 +166,7 @@ test('buildCellCard: singular noun and missing-age omission', () => {
|
||||
const card = buildCellCard(candidate, NOW);
|
||||
assert.equal(card.title, '1 FIRE');
|
||||
assert.equal(card.details[0], 'max 9.9 MW');
|
||||
assert.equal(card.accent, accentForSeverity('yellow'), 'missing accent defaults to yellow');
|
||||
assert.equal(card.accent, accentForSeverity('ember'), 'missing accent defaults to the weakest stop');
|
||||
});
|
||||
|
||||
test('FIRMS host policy keeps ambient cards bounded and selected cards protected', () => {
|
||||
|
||||
@@ -0,0 +1,209 @@
|
||||
/**
|
||||
* Snap Map–style heat raster for the Active Fires far-zoom bands: detections
|
||||
* are linearly binned on an equirectangular grid (row 0 = north, column
|
||||
* 0 = 180°W), blurred, normalized on a log scale and mapped through
|
||||
* HEAT_PALETTE. Pure: no Cesium, no DOM, so the whole pipeline is unit-tested
|
||||
* in node.
|
||||
*/
|
||||
|
||||
/** Below this normalized heat nothing is painted: empty land stays empty. */
|
||||
export const HEAT_FLOOR = 0.03;
|
||||
|
||||
/**
|
||||
* The FRP marker ramp as a continuous glow, from a red edge through orange
|
||||
* and gold to a pale white-hot core. The edge is a bright red, not the
|
||||
* markers' dark ember, and starts more than half opaque: most of the world
|
||||
* sits low on a scale set by the hottest regions, and a dark translucent red
|
||||
* vanishes into forest and savanna imagery.
|
||||
*/
|
||||
export const HEAT_PALETTE = Object.freeze([
|
||||
{ at: 0.0, rgb: [232, 58, 30], alpha: 0 },
|
||||
{ at: 0.08, rgb: [232, 58, 30], alpha: 0.58 },
|
||||
{ at: 0.25, rgb: [242, 86, 34], alpha: 0.7 },
|
||||
{ at: 0.45, rgb: [248, 122, 40], alpha: 0.76 },
|
||||
{ at: 0.65, rgb: [252, 166, 52], alpha: 0.82 },
|
||||
{ at: 0.82, rgb: [254, 208, 92], alpha: 0.87 },
|
||||
{ at: 1.0, rgb: [255, 245, 190], alpha: 0.92 },
|
||||
]);
|
||||
|
||||
export function heatColorAt(t) {
|
||||
if (!(t > HEAT_FLOOR)) return [0, 0, 0, 0];
|
||||
const v = Math.min(1, t);
|
||||
let i = 1;
|
||||
while (i < HEAT_PALETTE.length - 1 && HEAT_PALETTE[i].at < v) i += 1;
|
||||
const a = HEAT_PALETTE[i - 1];
|
||||
const b = HEAT_PALETTE[i];
|
||||
const k = (v - a.at) / (b.at - a.at || 1);
|
||||
const mix = (p, q) => Math.round(p + (q - p) * k);
|
||||
return [
|
||||
mix(a.rgb[0], b.rgb[0]),
|
||||
mix(a.rgb[1], b.rgb[1]),
|
||||
mix(a.rgb[2], b.rgb[2]),
|
||||
Math.round((a.alpha + (b.alpha - a.alpha) * k) * 255),
|
||||
];
|
||||
}
|
||||
|
||||
/** Weight of a detection with no or zero FRP, in megawatts. */
|
||||
export const HEAT_MIN_WEIGHT_MW = 0.5;
|
||||
|
||||
/**
|
||||
* Heat is radiated power, not a head count: each detection adds its FRP in
|
||||
* megawatts. Weak fires carry little power, so raising the minimum-FRP slider
|
||||
* removes most detections without dimming the areas where strong fires burn
|
||||
* (a count-based heat collapsed there and the hot spots faded).
|
||||
*/
|
||||
const defaultWeight = (fire) =>
|
||||
Math.max(HEAT_MIN_WEIGHT_MW, Number(fire.frp) || 0);
|
||||
|
||||
/**
|
||||
* Linear binning (Wand 1994): each detection's weight is shared between the
|
||||
* four pixel centres around it in proportion to closeness, instead of
|
||||
* dropping whole into one pixel. Spots then sit at the true position rather
|
||||
* than snapping by up to half a pixel (~10 km), and a lone weak fire blurs
|
||||
* into a round spot instead of a square or a plus sign. Longitude wraps;
|
||||
* rows beyond the poles fold back onto the edge row.
|
||||
*/
|
||||
export function binFires(fires, { width, height, weight = defaultWeight }) {
|
||||
const grid = new Float32Array(width * height);
|
||||
const row = (y) => Math.min(height - 1, Math.max(0, y)) * width;
|
||||
const col = (x) => ((x % width) + width) % width;
|
||||
for (const fire of fires) {
|
||||
if (!Number.isFinite(fire.lat) || !Number.isFinite(fire.lon)) continue;
|
||||
const fx = ((fire.lon + 180) / 360) * width - 0.5;
|
||||
const fy = ((90 - fire.lat) / 180) * height - 0.5;
|
||||
const x0 = Math.floor(fx);
|
||||
const y0 = Math.floor(fy);
|
||||
const tx = fx - x0;
|
||||
const ty = fy - y0;
|
||||
const w = weight(fire);
|
||||
const top = row(y0);
|
||||
const bottom = row(y0 + 1);
|
||||
const left = col(x0);
|
||||
const right = col(x0 + 1);
|
||||
grid[top + left] += w * (1 - tx) * (1 - ty);
|
||||
grid[top + right] += w * tx * (1 - ty);
|
||||
grid[bottom + left] += w * (1 - tx) * ty;
|
||||
grid[bottom + right] += w * tx * ty;
|
||||
}
|
||||
return grid;
|
||||
}
|
||||
|
||||
function kernel(sigma) {
|
||||
const radius = Math.max(1, Math.ceil(sigma * 3));
|
||||
const k = new Float32Array(radius * 2 + 1);
|
||||
let sum = 0;
|
||||
for (let i = -radius; i <= radius; i++) {
|
||||
k[i + radius] = Math.exp(-(i * i) / (2 * sigma * sigma));
|
||||
sum += k[i + radius];
|
||||
}
|
||||
for (let i = 0; i < k.length; i++) k[i] /= sum;
|
||||
return { k, radius };
|
||||
}
|
||||
|
||||
export function blurGaussian(grid, width, height, sigma) {
|
||||
const { k, radius } = kernel(sigma);
|
||||
const tmp = new Float32Array(grid.length);
|
||||
const out = new Float32Array(grid.length);
|
||||
for (let y = 0; y < height; y++) {
|
||||
const row = y * width;
|
||||
for (let x = 0; x < width; x++) {
|
||||
const v = grid[row + x];
|
||||
if (v === 0) continue;
|
||||
for (let i = -radius; i <= radius; i++) {
|
||||
const xx = (((x + i) % width) + width) % width; // longitude wraps
|
||||
tmp[row + xx] += v * k[i + radius];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (let y = 0; y < height; y++) {
|
||||
for (let x = 0; x < width; x++) {
|
||||
const v = tmp[y * width + x];
|
||||
if (v === 0) continue;
|
||||
for (let i = -radius; i <= radius; i++) {
|
||||
const yy = Math.min(height - 1, Math.max(0, y + i)); // poles clamp
|
||||
out[yy * width + x] += v * k[i + radius];
|
||||
}
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Bins of the log-density histogram used to find the reference quantile. */
|
||||
const QUANTILE_BINS = 4096;
|
||||
|
||||
/**
|
||||
* The p-quantile of the non-zero values, from a histogram of log1p(value):
|
||||
* one linear pass instead of sorting ~350k burning pixels (a sort cost
|
||||
* 200 ms+ and dominated the build). Bin width on the log axis is
|
||||
* max/4096, far finer than the 256-step palette it feeds.
|
||||
*/
|
||||
function percentileOfNonZero(values, p) {
|
||||
let count = 0;
|
||||
let max = 0;
|
||||
for (let i = 0; i < values.length; i++) {
|
||||
const v = values[i];
|
||||
if (v > 0) {
|
||||
count += 1;
|
||||
if (v > max) max = v;
|
||||
}
|
||||
}
|
||||
if (!count) return 0;
|
||||
const logMax = Math.log1p(max);
|
||||
const bins = new Uint32Array(QUANTILE_BINS);
|
||||
const toBin = (QUANTILE_BINS - 1) / logMax;
|
||||
for (let i = 0; i < values.length; i++) {
|
||||
const v = values[i];
|
||||
if (v > 0) bins[Math.floor(Math.log1p(v) * toBin)] += 1;
|
||||
}
|
||||
const target = Math.floor(p * (count - 1));
|
||||
let seen = 0;
|
||||
for (let b = 0; b < QUANTILE_BINS; b++) {
|
||||
seen += bins[b];
|
||||
if (seen > target) return Math.expm1((b + 1) / toBin);
|
||||
}
|
||||
return max;
|
||||
}
|
||||
|
||||
/** HEAT_PALETTE sampled at 256 steps, so the per-pixel walk is one lookup. */
|
||||
const LUT_STEPS = 256;
|
||||
let paletteLut = null;
|
||||
function heatLut() {
|
||||
if (!paletteLut) {
|
||||
paletteLut = new Uint8ClampedArray(LUT_STEPS * 4);
|
||||
for (let i = 0; i < LUT_STEPS; i++) {
|
||||
paletteLut.set(heatColorAt(i / (LUT_STEPS - 1)), i * 4);
|
||||
}
|
||||
}
|
||||
return paletteLut;
|
||||
}
|
||||
|
||||
export function buildHeatRaster(
|
||||
fires,
|
||||
{ width, height, sigmaPx, percentile = 0.995 },
|
||||
) {
|
||||
const density = blurGaussian(
|
||||
binFires(fires, { width, height }),
|
||||
width,
|
||||
height,
|
||||
sigmaPx,
|
||||
);
|
||||
const reference = percentileOfNonZero(density, percentile);
|
||||
const rgba = new Uint8ClampedArray(width * height * 4);
|
||||
if (reference > 0) {
|
||||
const lut = heatLut();
|
||||
const scale = (LUT_STEPS - 1) / Math.log1p(reference);
|
||||
for (let i = 0; i < density.length; i++) {
|
||||
const d = density[i];
|
||||
if (d <= 0) continue;
|
||||
const step = Math.min(LUT_STEPS - 1, Math.round(Math.log1p(d) * scale));
|
||||
const l = step * 4;
|
||||
if (lut[l + 3] === 0) continue;
|
||||
const o = i * 4;
|
||||
rgba[o] = lut[l];
|
||||
rgba[o + 1] = lut[l + 1];
|
||||
rgba[o + 2] = lut[l + 2];
|
||||
rgba[o + 3] = lut[l + 3];
|
||||
}
|
||||
}
|
||||
return { width, height, rgba, reference };
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
HEAT_MIN_WEIGHT_MW,
|
||||
HEAT_PALETTE,
|
||||
heatColorAt,
|
||||
binFires,
|
||||
blurGaussian,
|
||||
buildHeatRaster,
|
||||
} from './firmsHeatRaster.js';
|
||||
|
||||
const fire = (lat, lon, frp = 10) => ({ lat, lon, frp });
|
||||
|
||||
test('palette runs ember to white-hot and starts fully transparent', () => {
|
||||
assert.equal(HEAT_PALETTE[0].at, 0);
|
||||
assert.equal(HEAT_PALETTE.at(-1).at, 1);
|
||||
assert.deepEqual(heatColorAt(0), [0, 0, 0, 0]);
|
||||
assert.equal(heatColorAt(0.01)[3], 0, 'below the floor nothing is painted');
|
||||
const low = heatColorAt(0.15);
|
||||
const high = heatColorAt(1);
|
||||
assert.ok(low[0] > low[1] && low[1] > low[2], 'low heat is red');
|
||||
assert.ok(low[3] >= 0.5 * 255, 'low heat stays visible on any imagery');
|
||||
assert.ok(high[1] > low[1] && high[2] > low[2], 'the core is paler');
|
||||
assert.ok(high[3] > low[3], 'hotter is more opaque');
|
||||
for (let i = 1; i <= 100; i++) {
|
||||
const [r, , b] = heatColorAt(i / 100);
|
||||
assert.ok(r >= b, `no cold hue at ${i}%`);
|
||||
}
|
||||
});
|
||||
|
||||
test('binFires puts a detection at a pixel centre wholly in that pixel', () => {
|
||||
// 4×2 grid: pixel centres at lon −135/−45/45/135, lat ±45.
|
||||
const grid = binFires([fire(45, -135, 1), fire(-45, 135, 1)], {
|
||||
width: 4,
|
||||
height: 2,
|
||||
});
|
||||
assert.equal(grid[0], 1, 'north-west pixel');
|
||||
assert.equal(grid[7], 1, 'south-east pixel');
|
||||
assert.equal(
|
||||
grid.reduce((a, b) => a + b, 0),
|
||||
2,
|
||||
);
|
||||
});
|
||||
|
||||
test('binFires shares a detection between the pixels around it', () => {
|
||||
const between = binFires([fire(45, 0, 1)], { width: 4, height: 2 });
|
||||
assert.equal(between[1], 0.5, 'half to the pixel west of it');
|
||||
assert.equal(between[2], 0.5, 'half to the pixel east of it');
|
||||
const quarter = binFires([fire(45, -112.5, 1)], { width: 4, height: 2 });
|
||||
assert.equal(quarter[0], 0.75, 'closer centre takes more');
|
||||
assert.equal(quarter[1], 0.25);
|
||||
const wrapped = binFires([fire(45, 180, 1)], { width: 4, height: 2 });
|
||||
assert.equal(wrapped[3], 0.5, 'the antimeridian wraps');
|
||||
assert.equal(wrapped[0], 0.5);
|
||||
const polar = binFires([fire(90, -135, 1)], { width: 4, height: 2 });
|
||||
assert.equal(polar[0], 1, 'beyond the last row folds back onto it');
|
||||
});
|
||||
|
||||
test('binFires weights each detection by its radiative power', () => {
|
||||
const grid = binFires(
|
||||
[fire(45, 45, 250), fire(45, 45, 0), fire(45, 45, Number.NaN)],
|
||||
{ width: 4, height: 2 },
|
||||
);
|
||||
assert.equal(grid[2], 250 + 2 * HEAT_MIN_WEIGHT_MW);
|
||||
});
|
||||
|
||||
test('filtering out weak fires keeps a strong fire hot', () => {
|
||||
const strong = fire(0.1, 0.1, 300);
|
||||
const weak = Array.from({ length: 40 }, () => fire(0.1, 0.1, 2));
|
||||
const reference = Array.from({ length: 10 }, () => fire(20.1, 20.1, 100));
|
||||
const options = { width: 360, height: 180, sigmaPx: 2 };
|
||||
const pixel = ((90 - 0.1) | 0) * 360 + ((0.1 + 180) | 0);
|
||||
const red = (r) => r.rgba[pixel * 4];
|
||||
const alpha = (r) => r.rgba[pixel * 4 + 3];
|
||||
const unfiltered = buildHeatRaster([strong, ...weak, ...reference], options);
|
||||
const filtered = buildHeatRaster([strong, ...reference], options);
|
||||
assert.ok(alpha(filtered) > 0);
|
||||
assert.ok(
|
||||
alpha(filtered) >= alpha(unfiltered) * 0.9,
|
||||
`alpha ${alpha(unfiltered)} -> ${alpha(filtered)}`,
|
||||
);
|
||||
assert.ok(
|
||||
red(filtered) >= red(unfiltered) * 0.9,
|
||||
`red ${red(unfiltered)} -> ${red(filtered)}`,
|
||||
);
|
||||
});
|
||||
|
||||
test('blurGaussian keeps mass and wraps across the antimeridian', () => {
|
||||
const w = 16;
|
||||
const h = 8;
|
||||
const grid = new Float32Array(w * h);
|
||||
grid[3 * w + 0] = 1;
|
||||
const out = blurGaussian(grid, w, h, 1.5);
|
||||
const sum = out.reduce((a, b) => a + b, 0);
|
||||
assert.ok(Math.abs(sum - 1) < 1e-3, `mass ${sum}`);
|
||||
assert.ok(out[3 * w + (w - 1)] > 0, 'spills to the east edge');
|
||||
});
|
||||
|
||||
test('buildHeatRaster is transparent where there are no fires', () => {
|
||||
const r = buildHeatRaster([fire(40, -120), fire(40.1, -120.1)], {
|
||||
width: 360,
|
||||
height: 180,
|
||||
sigmaPx: 2,
|
||||
});
|
||||
assert.equal(r.rgba.length, 360 * 180 * 4);
|
||||
const alphaAt = (lat, lon) => {
|
||||
const x = Math.floor(((lon + 180) / 360) * 360);
|
||||
const y = Math.floor(((90 - lat) / 180) * 180);
|
||||
return r.rgba[(y * 360 + x) * 4 + 3];
|
||||
};
|
||||
assert.ok(alphaAt(40, -120) > 0, 'blob over the fires');
|
||||
assert.equal(alphaAt(-30, 60), 0, 'empty far away');
|
||||
});
|
||||
|
||||
test('buildHeatRaster with no fires is fully transparent', () => {
|
||||
const r = buildHeatRaster([], { width: 8, height: 4, sigmaPx: 1 });
|
||||
assert.ok(r.rgba.every((v) => v === 0));
|
||||
});
|
||||
@@ -0,0 +1,212 @@
|
||||
/**
|
||||
* @module firmsIntensity
|
||||
* @description Fire intensity policy shared by the Active Fires layer and the
|
||||
* agent fire tool: the six-stop ember → white-hot FRP color ramp, the log-scale
|
||||
* slider that doubles as its legend, and the one filter every consumer
|
||||
* (markers, cards, heat cells, the top-fires query, `get_active_fires`) runs
|
||||
* before anything is rendered or selected. Pure — no Cesium, no DOM.
|
||||
*
|
||||
* The ramp (`FRP_RAMP`, stepped, not interpolated) runs like a fire cooling
|
||||
* down: a dim ember for weak fires through red, orange and gold to a pale
|
||||
* white-hot core, lightness rising with power, so the brightest marks are the
|
||||
* strongest fires. No cold hues: ~90% of detections are under 20 MW and a
|
||||
* blue start painted most of the map blue. The thresholds are GEV's own, set
|
||||
* on a real week's percentiles so every color appears: Portolan's
|
||||
* 0/10/50/200/500/1000 MW leaves one hottest fire a week (HAL-675).
|
||||
*/
|
||||
|
||||
/**
|
||||
* Stepped FRP ramp, weakest first. A detection takes the LAST stop whose
|
||||
* `minFrp` it reaches. Names key the glow-sprite cache and the card accents.
|
||||
*/
|
||||
export const FRP_RAMP = Object.freeze([
|
||||
Object.freeze({ name: 'ember', minFrp: 0, hex: '#9e2a1b' }),
|
||||
Object.freeze({ name: 'red', minFrp: 5, hex: '#d2401f' }),
|
||||
Object.freeze({ name: 'flame', minFrp: 20, hex: '#f06a28' }),
|
||||
Object.freeze({ name: 'orange', minFrp: 50, hex: '#fb9a2e' }),
|
||||
Object.freeze({ name: 'gold', minFrp: 100, hex: '#fdc84a' }),
|
||||
Object.freeze({ name: 'white-hot', minFrp: 300, hex: '#fff3b0' }),
|
||||
]);
|
||||
|
||||
/** Slider ticks: the ramp thresholds, so slider, legend and markers agree. */
|
||||
export const FRP_SLIDER_TICKS = Object.freeze(
|
||||
FRP_RAMP.map((stop) => stop.minFrp),
|
||||
);
|
||||
|
||||
/** Minimum-FRP values the share codec accepts, in whole megawatts. */
|
||||
export const MIN_FRP_MW_MIN = 0;
|
||||
export const MIN_FRP_MW_MAX = 10_000;
|
||||
|
||||
/** Confidence switch positions; VIIRS reports only low / nominal / high. */
|
||||
export const FIRMS_CONFIDENCE_MODES = Object.freeze(['all', 'nominal', 'high']);
|
||||
|
||||
/**
|
||||
* Normalized-confidence floor for a switch position. The thresholds match
|
||||
* `confidenceBucket` in the layer model (0.3 / 0.6 / 0.9 after firmsAdapt).
|
||||
*/
|
||||
const CONFIDENCE_FLOOR = Object.freeze({ all: 0, nominal: 0.45, high: 0.75 });
|
||||
|
||||
export const DEFAULT_FIRE_FILTER = Object.freeze({
|
||||
minFrp: 0,
|
||||
confidence: 'all',
|
||||
});
|
||||
|
||||
/**
|
||||
* The ramp stop for a fire radiative power.
|
||||
* @param {number} frp Megawatts; non-finite or negative reads as 0.
|
||||
* @returns {{name: string, minFrp: number, hex: string}}
|
||||
*/
|
||||
export function frpRampStop(frp) {
|
||||
const value = Number.isFinite(frp) ? Math.max(0, frp) : 0;
|
||||
let stop = FRP_RAMP[0];
|
||||
for (const candidate of FRP_RAMP) {
|
||||
if (value >= candidate.minFrp) stop = candidate;
|
||||
else break;
|
||||
}
|
||||
return stop;
|
||||
}
|
||||
|
||||
/** `#rrggbb` → `[r, g, b]` in 0..255. */
|
||||
export function hexToRgb(hex) {
|
||||
const text = String(hex).replace('#', '');
|
||||
return [0, 2, 4].map((offset) =>
|
||||
Number.parseInt(text.slice(offset, offset + 2), 16),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Log-scale slider axis: position 0 means "no minimum" (0 MW), and the rest
|
||||
* of the track runs 1 MW → SLIDER_MAX_MW logarithmically. The axis floor is 1
|
||||
* MW because the median detection is ~6 MW and a sub-megawatt floor hides
|
||||
* nothing worth a tick.
|
||||
*/
|
||||
export const SLIDER_MAX_MW = 1000;
|
||||
const LOG_MAX = Math.log10(SLIDER_MAX_MW);
|
||||
|
||||
/**
|
||||
* Track position in 0..1 for a minimum FRP.
|
||||
* @param {number} minFrp Megawatts.
|
||||
* @returns {number}
|
||||
*/
|
||||
export function sliderPositionForFrp(minFrp) {
|
||||
if (!Number.isFinite(minFrp) || minFrp < 1) return 0;
|
||||
return Math.min(1, Math.log10(minFrp) / LOG_MAX);
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimum FRP for a track position, rounded to whole megawatts so a slider
|
||||
* value and its share-link form are the same number.
|
||||
* @param {number} position 0..1.
|
||||
* @returns {number}
|
||||
*/
|
||||
export function frpForSliderPosition(position) {
|
||||
const p = Number.isFinite(position) ? Math.max(0, Math.min(1, position)) : 0;
|
||||
if (p <= 0) return 0;
|
||||
const frp = Math.pow(10, p * LOG_MAX);
|
||||
return Math.max(1, Math.round(frp));
|
||||
}
|
||||
|
||||
/**
|
||||
* CSS `linear-gradient` painting the stepped ramp along the log axis, so the
|
||||
* slider track IS the legend: the color under the thumb is the color of the
|
||||
* weakest fire still shown.
|
||||
* @returns {string}
|
||||
*/
|
||||
export function rampTrackGradient() {
|
||||
const parts = [];
|
||||
FRP_RAMP.forEach((stop, index) => {
|
||||
const start = sliderPositionForFrp(stop.minFrp) * 100;
|
||||
const next = FRP_RAMP[index + 1];
|
||||
const end = next ? sliderPositionForFrp(next.minFrp) * 100 : 100;
|
||||
parts.push(`${stop.hex} ${start.toFixed(2)}% ${end.toFixed(2)}%`);
|
||||
});
|
||||
return `linear-gradient(90deg, ${parts.join(', ')})`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimum FRP → whole megawatts inside the codec bounds, or null.
|
||||
* @param {*} value
|
||||
* @returns {?number}
|
||||
*/
|
||||
export function normalizeMinFrp(value) {
|
||||
const number =
|
||||
typeof value === 'number'
|
||||
? value
|
||||
: typeof value === 'string' && value.trim() !== ''
|
||||
? Number(value)
|
||||
: NaN;
|
||||
if (!Number.isFinite(number)) return null;
|
||||
const rounded = Math.round(number);
|
||||
return rounded >= MIN_FRP_MW_MIN && rounded <= MIN_FRP_MW_MAX
|
||||
? rounded
|
||||
: null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Confidence mode → one of FIRMS_CONFIDENCE_MODES, or null.
|
||||
* @param {*} value
|
||||
* @returns {?string}
|
||||
*/
|
||||
export function normalizeConfidenceMode(value) {
|
||||
const text = String(value ?? '')
|
||||
.trim()
|
||||
.toLowerCase();
|
||||
return FIRMS_CONFIDENCE_MODES.includes(text) ? text : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize a partial filter against the current one; unknown or invalid
|
||||
* fields keep their current value.
|
||||
* @param {Object} [params]
|
||||
* @param {{minFrp: number, confidence: string}} [current]
|
||||
* @returns {{minFrp: number, confidence: string}}
|
||||
*/
|
||||
export function normalizeFireFilter(
|
||||
params = {},
|
||||
current = DEFAULT_FIRE_FILTER,
|
||||
) {
|
||||
const minFrp = normalizeMinFrp(params?.minFrp);
|
||||
const confidence = normalizeConfidenceMode(params?.confidence);
|
||||
return {
|
||||
minFrp: minFrp === null ? current.minFrp : minFrp,
|
||||
confidence: confidence === null ? current.confidence : confidence,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether one fire passes the filter. `confidence` is the normalized 0..1
|
||||
* value firmsAdapt produces; `frp` is megawatts.
|
||||
* @param {{frp: number, confidence: number}} fire
|
||||
* @param {{minFrp: number, confidence: string}} filter
|
||||
* @returns {boolean}
|
||||
*/
|
||||
export function firePassesFilter(fire, filter = DEFAULT_FIRE_FILTER) {
|
||||
const frp = Number.isFinite(fire?.frp) ? fire.frp : 0;
|
||||
if (frp < (filter.minFrp || 0)) return false;
|
||||
const floor = CONFIDENCE_FLOOR[filter.confidence] ?? 0;
|
||||
if (floor <= 0) return true;
|
||||
const confidence = Number.isFinite(fire?.confidence) ? fire.confidence : 0;
|
||||
return confidence >= floor;
|
||||
}
|
||||
|
||||
/**
|
||||
* The fires that pass the filter, in input order. Returns the SAME array when
|
||||
* the filter is the default, so callers can tell "nothing hidden" cheaply.
|
||||
* @template T
|
||||
* @param {Array<T>} fires Internal records (normalized confidence).
|
||||
* @param {{minFrp: number, confidence: string}} filter
|
||||
* @returns {Array<T>}
|
||||
*/
|
||||
export function filterFires(fires, filter = DEFAULT_FIRE_FILTER) {
|
||||
if (!Array.isArray(fires)) return [];
|
||||
if (isDefaultFireFilter(filter)) return fires;
|
||||
return fires.filter((fire) => firePassesFilter(fire, filter));
|
||||
}
|
||||
|
||||
/** True when the filter hides nothing. */
|
||||
export function isDefaultFireFilter(filter) {
|
||||
return (
|
||||
!(filter?.minFrp > 0) &&
|
||||
(filter?.confidence === 'all' || filter?.confidence == null)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,221 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
DEFAULT_FIRE_FILTER,
|
||||
FIRMS_CONFIDENCE_MODES,
|
||||
FRP_RAMP,
|
||||
FRP_SLIDER_TICKS,
|
||||
filterFires,
|
||||
firePassesFilter,
|
||||
frpForSliderPosition,
|
||||
frpRampStop,
|
||||
hexToRgb,
|
||||
isDefaultFireFilter,
|
||||
normalizeConfidenceMode,
|
||||
normalizeFireFilter,
|
||||
normalizeMinFrp,
|
||||
rampTrackGradient,
|
||||
sliderPositionForFrp,
|
||||
} from './firmsIntensity.js';
|
||||
|
||||
test('the ramp has six ember → white-hot stops at 0 · 5 · 20 · 50 · 100 · 300 MW', () => {
|
||||
assert.deepEqual(
|
||||
FRP_RAMP.map((stop) => [stop.name, stop.minFrp, stop.hex]),
|
||||
[
|
||||
['ember', 0, '#9e2a1b'],
|
||||
['red', 5, '#d2401f'],
|
||||
['flame', 20, '#f06a28'],
|
||||
['orange', 50, '#fb9a2e'],
|
||||
['gold', 100, '#fdc84a'],
|
||||
['white-hot', 300, '#fff3b0'],
|
||||
],
|
||||
);
|
||||
assert.deepEqual([...FRP_SLIDER_TICKS], [0, 5, 20, 50, 100, 300]);
|
||||
assert.ok(Object.isFrozen(FRP_RAMP));
|
||||
});
|
||||
|
||||
test('every stop is warm and each is lighter than the one below', () => {
|
||||
const luma = ([r, g, b]) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
||||
let previous = -1;
|
||||
for (const stop of FRP_RAMP) {
|
||||
const rgb = hexToRgb(stop.hex);
|
||||
assert.ok(rgb[0] >= rgb[2], `${stop.name} has no cold hue`);
|
||||
assert.ok(
|
||||
luma(rgb) > previous,
|
||||
`${stop.name} is lighter than the stop below`,
|
||||
);
|
||||
previous = luma(rgb);
|
||||
}
|
||||
});
|
||||
|
||||
test('a detection takes the last stop it reaches; garbage reads as 0 MW', () => {
|
||||
assert.equal(frpRampStop(0).name, 'ember');
|
||||
assert.equal(frpRampStop(4.99).name, 'ember');
|
||||
assert.equal(frpRampStop(5).name, 'red');
|
||||
assert.equal(frpRampStop(19.9).name, 'red');
|
||||
assert.equal(frpRampStop(20).name, 'flame');
|
||||
assert.equal(frpRampStop(50).name, 'orange');
|
||||
assert.equal(frpRampStop(100).name, 'gold');
|
||||
assert.equal(frpRampStop(299.9).name, 'gold');
|
||||
assert.equal(frpRampStop(300).name, 'white-hot');
|
||||
assert.equal(frpRampStop(1246).name, 'white-hot');
|
||||
assert.equal(frpRampStop(NaN).name, 'ember');
|
||||
assert.equal(frpRampStop(-3).name, 'ember');
|
||||
assert.equal(frpRampStop(undefined).name, 'ember');
|
||||
});
|
||||
|
||||
test('hex stops convert to the "r, g, b" accents the cards paint', () => {
|
||||
assert.deepEqual(hexToRgb('#9e2a1b'), [158, 42, 27]);
|
||||
assert.deepEqual(hexToRgb('d1382a'), [209, 56, 42]);
|
||||
});
|
||||
|
||||
test('the log slider pins 0 MW at the left and runs 1 → 1000 MW; values round-trip', () => {
|
||||
assert.equal(sliderPositionForFrp(0), 0);
|
||||
assert.equal(sliderPositionForFrp(0.5), 0);
|
||||
assert.equal(sliderPositionForFrp(1), 0);
|
||||
assert.ok(Math.abs(sliderPositionForFrp(10) - 1 / 3) < 1e-9);
|
||||
assert.ok(Math.abs(sliderPositionForFrp(100) - 2 / 3) < 1e-9);
|
||||
assert.equal(sliderPositionForFrp(1000), 1);
|
||||
assert.equal(sliderPositionForFrp(5000), 1, 'clamped past the axis end');
|
||||
assert.equal(frpForSliderPosition(0), 0);
|
||||
assert.equal(frpForSliderPosition(1), 1000);
|
||||
assert.equal(frpForSliderPosition(-1), 0);
|
||||
assert.equal(frpForSliderPosition(2), 1000);
|
||||
for (const frp of FRP_SLIDER_TICKS) {
|
||||
assert.equal(
|
||||
frpForSliderPosition(sliderPositionForFrp(frp)),
|
||||
frp,
|
||||
`tick ${frp} MW round-trips through the axis`,
|
||||
);
|
||||
}
|
||||
// Ticks spread along the track instead of bunching at one end.
|
||||
const positions = FRP_SLIDER_TICKS.map(sliderPositionForFrp);
|
||||
for (let i = 1; i < positions.length; i += 1) {
|
||||
assert.ok(positions[i] - positions[i - 1] >= 0.09, `tick gap ${i}`);
|
||||
}
|
||||
});
|
||||
|
||||
test('the track gradient is the stepped ramp on the log axis, so it doubles as the legend', () => {
|
||||
const gradient = rampTrackGradient();
|
||||
assert.match(gradient, /^linear-gradient\(90deg, /);
|
||||
assert.match(gradient, /#9e2a1b 0\.00% 23\.3\d%/);
|
||||
assert.match(gradient, /#d2401f 23\.3\d% 43\.3\d%/);
|
||||
assert.match(gradient, /#fff3b0 82\.5\d% 100\.00%\)$/);
|
||||
assert.equal(gradient.match(/#/g).length, FRP_RAMP.length);
|
||||
});
|
||||
|
||||
test('minimum FRP normalizes to whole megawatts inside the codec bounds', () => {
|
||||
assert.equal(normalizeMinFrp(0), 0);
|
||||
assert.equal(normalizeMinFrp(19.6), 20);
|
||||
assert.equal(normalizeMinFrp('100'), 100);
|
||||
assert.equal(normalizeMinFrp(10000), 10000);
|
||||
assert.equal(normalizeMinFrp(10001), null);
|
||||
assert.equal(normalizeMinFrp(-1), null);
|
||||
assert.equal(normalizeMinFrp('abc'), null);
|
||||
assert.equal(normalizeMinFrp(''), null);
|
||||
assert.equal(normalizeMinFrp(null), null);
|
||||
assert.equal(normalizeMinFrp(NaN), null);
|
||||
});
|
||||
|
||||
test('confidence modes are exactly all / nominal / high', () => {
|
||||
assert.deepEqual([...FIRMS_CONFIDENCE_MODES], ['all', 'nominal', 'high']);
|
||||
assert.equal(normalizeConfidenceMode(' High '), 'high');
|
||||
assert.equal(normalizeConfidenceMode('nominal'), 'nominal');
|
||||
assert.equal(normalizeConfidenceMode('low'), null);
|
||||
assert.equal(normalizeConfidenceMode(0.9), null);
|
||||
assert.equal(normalizeConfidenceMode(undefined), null);
|
||||
});
|
||||
|
||||
test('a partial filter patches the current one and invalid fields keep their value', () => {
|
||||
assert.deepEqual(normalizeFireFilter(), DEFAULT_FIRE_FILTER);
|
||||
assert.deepEqual(normalizeFireFilter({ minFrp: 20 }), {
|
||||
minFrp: 20,
|
||||
confidence: 'all',
|
||||
});
|
||||
assert.deepEqual(
|
||||
normalizeFireFilter(
|
||||
{ confidence: 'high' },
|
||||
{ minFrp: 50, confidence: 'all' },
|
||||
),
|
||||
{ minFrp: 50, confidence: 'high' },
|
||||
);
|
||||
assert.deepEqual(
|
||||
normalizeFireFilter(
|
||||
{ minFrp: 'nope', confidence: 'medium' },
|
||||
{ minFrp: 50, confidence: 'nominal' },
|
||||
),
|
||||
{ minFrp: 50, confidence: 'nominal' },
|
||||
);
|
||||
assert.equal(isDefaultFireFilter(DEFAULT_FIRE_FILTER), true);
|
||||
assert.equal(isDefaultFireFilter({ minFrp: 0, confidence: 'all' }), true);
|
||||
assert.equal(isDefaultFireFilter({ minFrp: 1, confidence: 'all' }), false);
|
||||
assert.equal(isDefaultFireFilter({ minFrp: 0, confidence: 'high' }), false);
|
||||
});
|
||||
|
||||
test('the filter keeps a fire at or above the floor and at or above the confidence mode', () => {
|
||||
const low = { frp: 864, confidence: 0.3 };
|
||||
const nominal = { frp: 20, confidence: 0.6 };
|
||||
const high = { frp: 2, confidence: 0.9 };
|
||||
assert.equal(firePassesFilter(low), true, 'default shows everything');
|
||||
assert.equal(
|
||||
firePassesFilter(nominal, { minFrp: 20, confidence: 'all' }),
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
firePassesFilter(nominal, { minFrp: 21, confidence: 'all' }),
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
firePassesFilter(low, { minFrp: 0, confidence: 'nominal' }),
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
firePassesFilter(nominal, { minFrp: 0, confidence: 'nominal' }),
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
firePassesFilter(high, { minFrp: 0, confidence: 'nominal' }),
|
||||
true,
|
||||
);
|
||||
assert.equal(
|
||||
firePassesFilter(nominal, { minFrp: 0, confidence: 'high' }),
|
||||
false,
|
||||
);
|
||||
assert.equal(firePassesFilter(high, { minFrp: 0, confidence: 'high' }), true);
|
||||
assert.equal(
|
||||
firePassesFilter(high, { minFrp: 5, confidence: 'high' }),
|
||||
false,
|
||||
);
|
||||
// Missing numbers read as 0, never as a pass-through.
|
||||
assert.equal(firePassesFilter({}, { minFrp: 1, confidence: 'all' }), false);
|
||||
assert.equal(
|
||||
firePassesFilter({ frp: 10 }, { minFrp: 0, confidence: 'nominal' }),
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
test('filterFires returns the same array for the default filter and preserves order otherwise', () => {
|
||||
const fires = [
|
||||
{ frp: 864, confidence: 0.3 },
|
||||
{ frp: 20, confidence: 0.6 },
|
||||
{ frp: 2, confidence: 0.9 },
|
||||
{ frp: 120, confidence: 0.9 },
|
||||
];
|
||||
assert.equal(filterFires(fires), fires);
|
||||
assert.equal(filterFires(fires, { minFrp: 0, confidence: 'all' }), fires);
|
||||
assert.deepEqual(
|
||||
filterFires(fires, { minFrp: 20, confidence: 'all' }).map((f) => f.frp),
|
||||
[864, 20, 120],
|
||||
);
|
||||
assert.deepEqual(
|
||||
filterFires(fires, { minFrp: 0, confidence: 'high' }).map((f) => f.frp),
|
||||
[2, 120],
|
||||
);
|
||||
assert.deepEqual(
|
||||
filterFires(fires, { minFrp: 100, confidence: 'nominal' }).map(
|
||||
(f) => f.frp,
|
||||
),
|
||||
[120],
|
||||
);
|
||||
assert.deepEqual(filterFires(null, { minFrp: 1, confidence: 'all' }), []);
|
||||
});
|
||||
@@ -15,6 +15,7 @@ import { WORLD_FOCUS_REQUEST_EVENT } from '../worldFocus.js';
|
||||
import { readLayerSource } from '../testSupport/readLayerSource.mjs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { HEAT_REBUILD_MS } from '../layers/firms/policy.js';
|
||||
|
||||
const LAYER_SOURCE = readLayerSource(
|
||||
path.join(path.dirname(fileURLToPath(import.meta.url)), 'firmsHeatmap.js'),
|
||||
@@ -392,3 +393,153 @@ test('disable cancels a pending source and a late response cannot repopulate the
|
||||
assert.equal(h.layer.getStats().loading, false);
|
||||
} finally { h.layer.destroy(h.viewer); h.cleanup(); }
|
||||
});
|
||||
|
||||
test('the heatmap is preloaded under the markers before the first zoom-out', (t) => {
|
||||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||||
const priorDocument = globalThis.document;
|
||||
globalThis.document = {
|
||||
createElement: () => ({
|
||||
getContext: () => ({
|
||||
createImageData: (w, hh) => ({ data: new Uint8ClampedArray(w * hh * 4) }),
|
||||
putImageData() {},
|
||||
createRadialGradient: () => ({ addColorStop() {} }),
|
||||
fillRect() {},
|
||||
}),
|
||||
toDataURL: () => 'data:image/png;base64,AAAA',
|
||||
}),
|
||||
};
|
||||
const h = harness({
|
||||
withDataSource: true,
|
||||
cameraPosition: Cesium.Cartesian3.fromDegrees(-98, 30, 1_000_000),
|
||||
});
|
||||
h.viewer.camera = { positionCartographic: { height: 1_000_000 } };
|
||||
h.viewer.scene.primitives = { add() {}, remove() {}, raiseToTop() {}, contains: () => true };
|
||||
h.viewer.scene.frameState = { mode: Cesium.SceneMode.SCENE3D };
|
||||
const added = [];
|
||||
try {
|
||||
h.layer.attachShellServices({
|
||||
imageryHost: () => ({
|
||||
kind: 'globe',
|
||||
collection: {
|
||||
addImageryProvider: (provider) => {
|
||||
const layer = { provider, show: true, alpha: 1 };
|
||||
added.push(layer);
|
||||
return layer;
|
||||
},
|
||||
remove() {},
|
||||
raiseToTop() {},
|
||||
},
|
||||
}),
|
||||
});
|
||||
h.layer._renderLodForTest('close');
|
||||
assert.equal(added.length, 0, 'the markers paint first; the build trails');
|
||||
t.mock.timers.tick(HEAT_REBUILD_MS);
|
||||
assert.equal(added.length, 1, 'then the heatmap is draped');
|
||||
assert.equal(added[0].alpha, 0, 'invisible until the hand-off');
|
||||
assert.equal(added[0].show, true, 'but mapped onto the globe tiles');
|
||||
} finally {
|
||||
h.layer.destroy(h.viewer);
|
||||
h.cleanup();
|
||||
if (priorDocument === undefined) delete globalThis.document;
|
||||
else globalThis.document = priorDocument;
|
||||
}
|
||||
});
|
||||
|
||||
test('far zoom drapes one heatmap and the hand-off cross-fades it with the markers', () => {
|
||||
// A canvas stub for the heat drape and the detection glow sprites.
|
||||
const priorDocument = globalThis.document;
|
||||
const restoreDocument = () => {
|
||||
if (priorDocument === undefined) delete globalThis.document;
|
||||
else globalThis.document = priorDocument;
|
||||
};
|
||||
globalThis.document = {
|
||||
createElement: () => ({
|
||||
getContext: () => ({
|
||||
createImageData: (w, hh) => ({
|
||||
data: new Uint8ClampedArray(w * hh * 4),
|
||||
}),
|
||||
putImageData() {},
|
||||
createRadialGradient: () => ({ addColorStop() {} }),
|
||||
fillRect() {},
|
||||
}),
|
||||
toDataURL: () => 'data:image/png;base64,AAAA',
|
||||
}),
|
||||
};
|
||||
const h = harness({
|
||||
fires: [makeFire(), makeFire({ index: 8, lat: 30.6, lon: -98.3, frp: 12 })],
|
||||
withDataSource: true,
|
||||
cameraPosition: Cesium.Cartesian3.fromDegrees(-98, 30, 12_000_000),
|
||||
});
|
||||
const added = [];
|
||||
const removed = [];
|
||||
let markers = null;
|
||||
// The fade reads the camera height; the cull reads scene.camera.
|
||||
const setHeight = (height) => {
|
||||
h.viewer.camera = { positionCartographic: { height } };
|
||||
};
|
||||
setHeight(12_000_000);
|
||||
h.viewer.scene.primitives = {
|
||||
add(primitive) {
|
||||
markers = primitive;
|
||||
},
|
||||
remove() {},
|
||||
raiseToTop() {},
|
||||
contains: () => true,
|
||||
};
|
||||
h.viewer.scene.frameState = { mode: Cesium.SceneMode.SCENE3D };
|
||||
try {
|
||||
const collection = {
|
||||
addImageryProvider: (provider) => {
|
||||
const layer = { provider, show: true, alpha: 1 };
|
||||
added.push(layer);
|
||||
return layer;
|
||||
},
|
||||
remove: (layer, destroy) => removed.push({ layer, destroy }),
|
||||
raiseToTop() {},
|
||||
};
|
||||
h.layer.attachShellServices({
|
||||
imageryHost: () => ({ kind: 'globe', collection }),
|
||||
});
|
||||
h.layer._renderLodForTest('global');
|
||||
assert.equal(added.length, 1, 'one heat imagery layer');
|
||||
assert.equal(added[0].show, true);
|
||||
assert.equal(added[0].alpha, 1);
|
||||
assert.equal(h.layer._entityCountForTest(), 0, 'no rectangle entities');
|
||||
assert.ok(h.published.length > 0, 'the far band still paints cards');
|
||||
assert.equal(markers.length, 2, 'the markers are built under the heatmap');
|
||||
assert.equal(markers.show, false, 'and hidden while the heatmap is whole');
|
||||
|
||||
h.layer._renderLodForTest('regional');
|
||||
assert.equal(added.length, 1, 'switching far bands reuses the raster');
|
||||
|
||||
setHeight(1_000_000);
|
||||
h.layer._renderLodForTest('close');
|
||||
assert.equal(added.length, 1, 'the markers band keeps the same heat layer');
|
||||
assert.equal(added[0].show, true, 'still mapped onto the globe tiles');
|
||||
assert.equal(added[0].alpha, 0, 'faded out under the markers');
|
||||
assert.equal(markers.show, true);
|
||||
assert.equal(markers.get(0).color.alpha, 1);
|
||||
|
||||
// Mid hand-off both are drawn, half each, in either band.
|
||||
setHeight(4_500_000);
|
||||
h.layer._applyHandoffFadeForTest();
|
||||
assert.equal(added[0].alpha, 0.5);
|
||||
assert.equal(markers.show, true);
|
||||
assert.equal(markers.get(0).color.alpha, 0.5);
|
||||
h.layer._renderLodForTest('regional');
|
||||
assert.equal(added[0].alpha, 0.5);
|
||||
assert.equal(markers.get(1).color.alpha, 0.5, 'rebuilt markers get the fade');
|
||||
|
||||
h.layer.disable();
|
||||
assert.equal(added[0].show, false, 'disable hides the heatmap');
|
||||
|
||||
h.layer.destroy(h.viewer);
|
||||
assert.deepEqual(
|
||||
removed.map((entry) => [entry.layer, entry.destroy]),
|
||||
[[added[0], true]],
|
||||
);
|
||||
} finally {
|
||||
h.cleanup();
|
||||
restoreDocument();
|
||||
}
|
||||
});
|
||||
+14
-9
@@ -4,6 +4,8 @@
|
||||
* dedicated card canvas moved into the shared world-overlay host.
|
||||
*/
|
||||
|
||||
import { FRP_RAMP, hexToRgb } from './firmsIntensity.js';
|
||||
|
||||
/** Shipped ambient FIRMS card ceiling. Selected fires bypass this cohort. */
|
||||
export const FIRMS_AMBIENT_COHORT_LIMIT = 18;
|
||||
export const FIRMS_OVERLAY_SOURCE_ID = 'firms';
|
||||
@@ -23,20 +25,23 @@ export function fireDetectionKey(fire) {
|
||||
return `firms:${lat}:${lon}:${acq}:${source}`;
|
||||
}
|
||||
|
||||
/** Severity accent palette — matches the FIRMS glow-sprite color stops. */
|
||||
const ACCENT_RGB = Object.freeze({
|
||||
red: '224, 82, 82',
|
||||
orange: '240, 178, 62',
|
||||
yellow: '244, 227, 108',
|
||||
});
|
||||
/**
|
||||
* Severity accent palette — the FIRMS glow-sprite color stops (the six-stop
|
||||
* FRP ramp in firmsIntensity.js) as "r, g, b" strings for card accents.
|
||||
*/
|
||||
const ACCENT_RGB = Object.freeze(
|
||||
Object.fromEntries(
|
||||
FRP_RAMP.map((stop) => [stop.name, hexToRgb(stop.hex).join(', ')]),
|
||||
),
|
||||
);
|
||||
|
||||
/**
|
||||
* Severity stop name → "r, g, b" accent string (defaults to yellow).
|
||||
* @param {string} stopName - 'red' | 'orange' | 'yellow'.
|
||||
* Severity stop name → "r, g, b" accent string (defaults to the weakest stop).
|
||||
* @param {string} stopName - A FRP_RAMP stop name ('ember' … 'white-hot').
|
||||
* @returns {string}
|
||||
*/
|
||||
export function accentForSeverity(stopName) {
|
||||
return ACCENT_RGB[stopName] || ACCENT_RGB.yellow;
|
||||
return ACCENT_RGB[stopName] || ACCENT_RGB[FRP_RAMP[0].name];
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -9,11 +9,16 @@ import {
|
||||
formatFrpMw,
|
||||
} from './firmsLabels.js';
|
||||
|
||||
test('FIRMS formatting helpers retain the shipped severity palette', () => {
|
||||
assert.equal(accentForSeverity('red'), '224, 82, 82');
|
||||
assert.equal(accentForSeverity('orange'), '240, 178, 62');
|
||||
assert.equal(accentForSeverity('yellow'), '244, 227, 108');
|
||||
assert.equal(accentForSeverity('chartreuse'), accentForSeverity('yellow'));
|
||||
test('FIRMS card accents are the six FRP ramp stops, weakest as the fallback', () => {
|
||||
// Ember #9e2a1b … white-hot #fff3b0, lightness rising with power.
|
||||
assert.equal(accentForSeverity('ember'), '158, 42, 27');
|
||||
assert.equal(accentForSeverity('red'), '210, 64, 31');
|
||||
assert.equal(accentForSeverity('flame'), '240, 106, 40');
|
||||
assert.equal(accentForSeverity('orange'), '251, 154, 46');
|
||||
assert.equal(accentForSeverity('gold'), '253, 200, 74');
|
||||
assert.equal(accentForSeverity('white-hot'), '255, 243, 176');
|
||||
assert.equal(accentForSeverity('blue'), accentForSeverity('ember'));
|
||||
assert.equal(accentForSeverity('chartreuse'), accentForSeverity('ember'));
|
||||
});
|
||||
|
||||
test('FIRMS power that rounds to 10 MW drops the decimal', () => {
|
||||
|
||||
+20
-1
@@ -298,6 +298,20 @@ function satelliteFilterOption() {
|
||||
}
|
||||
|
||||
const OPTION_GROUPS = Object.freeze({
|
||||
// Active Fires intensity filter (HAL-676). `minFrp` is whole megawatts on
|
||||
// the codec side; the panel's log slider rounds to it. Both default to
|
||||
// "show everything": many of the strongest fires are rated low confidence.
|
||||
// The bounds and modes mirror MIN_FRP_MW_MAX / FIRMS_CONFIDENCE_MODES in
|
||||
// firmsIntensity.js (pinned by layerState.test); spelled out here because
|
||||
// this file runs in isolation in the token-ledger tests.
|
||||
'local-firms': Object.freeze([
|
||||
boundedIntegerOption('minFrp', 'f', 0, { min: 0, max: 10000 }),
|
||||
enumOption('confidence', 'c', 'all', ['all', 'nominal', 'high'], {
|
||||
all: 'a',
|
||||
nominal: 'n',
|
||||
high: 'h',
|
||||
}),
|
||||
]),
|
||||
traffic: Object.freeze([
|
||||
enumOption('roadMode', 'r', null, ['tomtom', 'osm', 'hybrid'], {
|
||||
tomtom: 't',
|
||||
@@ -626,7 +640,12 @@ export const LAYER_STATE_REGISTRY = Object.freeze([
|
||||
token: 'd',
|
||||
disposition: 'enabled-only',
|
||||
}),
|
||||
Object.freeze({ id: 'local-firms', token: 'w', disposition: 'enabled-only' }),
|
||||
Object.freeze({
|
||||
id: 'local-firms',
|
||||
token: 'w',
|
||||
disposition: 'enabled+options',
|
||||
optionOwner: 'local-firms',
|
||||
}),
|
||||
Object.freeze({
|
||||
id: 'military',
|
||||
token: 'm',
|
||||
|
||||
@@ -29,6 +29,7 @@ import radioLayer from './radio.js';
|
||||
import { stampInitialShareGesture } from '../navigationPolicy.js';
|
||||
import { MAX_SINCE_DAYS } from '../layers/streetLevel/policy.js';
|
||||
import { SINCE_STOPS } from '../ui/streetLevelPresentation.js';
|
||||
import { FIRMS_CONFIDENCE_MODES, MIN_FRP_MW_MAX } from './firmsIntensity.js';
|
||||
|
||||
function deferred() {
|
||||
let resolve;
|
||||
@@ -3007,9 +3008,89 @@ test('Clear All cancels a saved restore still waiting to start', async () => {
|
||||
gate.resolve();
|
||||
const results = await restore;
|
||||
for (const id of ['earthquakes', 'flights']) {
|
||||
assert.equal(results.find((result) => result.layerId === id).succeeded, false);
|
||||
assert.equal(
|
||||
results.find((result) => result.layerId === id).succeeded,
|
||||
false,
|
||||
);
|
||||
}
|
||||
assert.deepEqual([...manager.getEnabledLayerIds()], []);
|
||||
assert.equal(enabledLayerParam(sink), '');
|
||||
coordinator.destroy();
|
||||
});
|
||||
|
||||
/** Active Fires options decoded from a v2 link with these `lo` assignments. */
|
||||
function firmsOptions(lo) {
|
||||
const params = new URLSearchParams([
|
||||
['v', '2'],
|
||||
['l', 'w'],
|
||||
]);
|
||||
if (lo) params.set('lo', lo);
|
||||
return decodeLayerStateParams(params).options['local-firms'];
|
||||
}
|
||||
|
||||
test('Active Fires: the intensity filter rides share token w and round-trips', () => {
|
||||
const state = createDefaultLayerState();
|
||||
assert.deepEqual(state.options['local-firms'], {
|
||||
minFrp: 0,
|
||||
confidence: 'all',
|
||||
});
|
||||
state.enabledLayerIds = ['local-firms'];
|
||||
state.options['local-firms'] = { minFrp: 20, confidence: 'high' };
|
||||
const encoded = encode(state);
|
||||
assert.equal(new URLSearchParams(encoded).get('l'), 'w');
|
||||
// Other owners write their own explicit defaults into `lo` too (flights 3D,
|
||||
// wind overlay); the fire assignments ride beside them.
|
||||
const assignments = new URLSearchParams(encoded).get('lo').split('_');
|
||||
assert.ok(assignments.includes('w.f.20'), assignments.join(' '));
|
||||
assert.ok(assignments.includes('w.c.h'), assignments.join(' '));
|
||||
const decoded = decodeLayerStateParams(new URLSearchParams(encoded));
|
||||
assert.deepEqual(decoded.options['local-firms'], {
|
||||
minFrp: 20,
|
||||
confidence: 'high',
|
||||
});
|
||||
assert.deepEqual(
|
||||
parseStoredLayerState(serializeStoredLayerState(state)).options[
|
||||
'local-firms'
|
||||
],
|
||||
state.options['local-firms'],
|
||||
);
|
||||
// Defaults are omitted from the link: a plain `l=w` is "show everything".
|
||||
const plain = createDefaultLayerState();
|
||||
plain.enabledLayerIds = ['local-firms'];
|
||||
assert.equal(
|
||||
new URLSearchParams(encode(plain))
|
||||
.get('lo')
|
||||
.split('_')
|
||||
.filter((assignment) => assignment.startsWith('w.')).length,
|
||||
0,
|
||||
);
|
||||
assert.deepEqual(firmsOptions(''), { minFrp: 0, confidence: 'all' });
|
||||
});
|
||||
|
||||
test('Active Fires: the codec accepts whole megawatts in bounds and the three confidence codes', () => {
|
||||
// The codec spells its bounds out (it runs in isolation in the ledger
|
||||
// tests); they must stay the layer's.
|
||||
assert.equal(MIN_FRP_MW_MAX, 10000);
|
||||
assert.deepEqual([...FIRMS_CONFIDENCE_MODES], ['all', 'nominal', 'high']);
|
||||
assert.equal(firmsOptions('w.f.300').minFrp, 300);
|
||||
assert.equal(firmsOptions('w.f.10000').minFrp, 10000);
|
||||
assert.equal(firmsOptions('w.f.10001').minFrp, 0, 'out of bounds → default');
|
||||
assert.equal(firmsOptions('w.f.-5').minFrp, 0);
|
||||
assert.equal(
|
||||
firmsOptions('w.f.2.5').minFrp,
|
||||
0,
|
||||
'a third segment is rejected',
|
||||
);
|
||||
assert.equal(firmsOptions('w.c.a').confidence, 'all');
|
||||
assert.equal(firmsOptions('w.c.n').confidence, 'nominal');
|
||||
assert.equal(firmsOptions('w.c.h').confidence, 'high');
|
||||
assert.equal(
|
||||
firmsOptions('w.c.x').confidence,
|
||||
'all',
|
||||
'unknown code → default',
|
||||
);
|
||||
assert.deepEqual(firmsOptions('w.c.n_w.f.5'), {
|
||||
minFrp: 5,
|
||||
confidence: 'nominal',
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user