Files
gods-eye-view/src/layers/wind/fields.js
T
German KhokhlovandClaude Opus 5.5 20f4cf3763 i18n: fix the LGTM review findings and tidy the branch texts
- i18n scanner: lastError sink, no false sinks on defaults and ternaries
- shared src/i18n/marker.js for modules that only mark strings
- wind field messages move to wind/fields.js; CITY_POIS imports from cityPois.js
- drop review IDs, change history and stale references from comments and docs

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 21:00:28 +04:00

183 lines
5.8 KiB
JavaScript

import { msg } from '../../i18n/marker.js';
import { normalizeLongitude, sampleWind } from './model.js';
// Imported by src/tools: the catalog-free marker, not src/i18n/index.js. The
// texts stay English data and the wind layer and layer panel show them
// translated.
/** Status of a scalar overlay the provider could not supply, by overlay. */
export const SCALAR_UNAVAILABLE = Object.freeze({
temperature: msg('Temperature field unavailable'),
pressure: msg('Mean sea level pressure field unavailable'),
});
/** Fixed physical scales shared by imagery and the field legend. */
export const WIND_FIELDS = Object.freeze({
speed: Object.freeze({
label: 'Wind speed', // i18n-ignore: internal field name; the shown label comes from index.js
units: 'm/s',
min: 0,
max: 30,
stops: ['#133a67', '#2876a3', '#66c9d1', '#c8dfac', '#f1cf79', '#ee9761'],
}),
temperature: Object.freeze({
label: '2 m air temperature', // i18n-ignore: internal field name; the shown label comes from index.js
units: '°C',
min: -40,
max: 50,
// Fixed 10°C anchors keep model comparisons honest while making everyday
// temperature gradients distinguishable from the underlying basemap.
stops: [
'#31235b',
'#403b92',
'#315fc1',
'#268fce',
'#31bdd0',
'#8ad4aa',
'#f0d255',
'#ee8a34',
'#d74638',
'#9f274d',
],
}),
pressure: Object.freeze({
label: 'Mean sea-level pressure', // i18n-ignore: internal field name; the shown label comes from index.js
units: 'hPa',
min: 960,
max: 1050,
stops: ['#705ca0', '#6985b4', '#a5c3cd', '#d8c99a', '#dbad61'],
}),
});
function palette(stops) {
const rgb = stops.map((color) =>
color.match(/\w\w/g).map((value) => parseInt(value, 16)),
);
return Array.from({ length: 128 }, (_, i) => {
const p = (i / 127) * (rgb.length - 1);
const a = Math.min(rgb.length - 2, Math.floor(p));
return rgb[a].map((value, channel) =>
Math.round(value + (rgb[a + 1][channel] - value) * (p - a)),
);
});
}
const PALETTES = Object.fromEntries(
Object.entries(WIND_FIELDS).map(([kind, spec]) => [
kind,
palette(spec.stops),
]),
);
const WIND_COLORS = PALETTES.speed.map((rgb) => `rgb(${rgb.join(',')})`);
const clamp = (x, low, high) => Math.max(low, Math.min(high, x));
/** No parsing, arrays or CSS interpolation in the particle loop. */
export function windTrailColor(speed) {
return WIND_COLORS[
Math.round((clamp(Number.isFinite(speed) ? speed : 0, 0, 30) / 30) * 127)
];
}
/** Decay is a function of elapsed time, independent of refresh rate. */
export function trailEraseAlpha(seconds, halfLife = 0.65) {
return 1 - Math.pow(0.5, Math.max(0, seconds) / halfLife);
}
/** Scalar units are already normalized by the source; do not convert twice. */
export function sampleScalar(
snapshot,
lon,
lat,
kind = snapshot?.scalar?.kind ?? 'speed',
) {
const grid = snapshot?.grid ?? snapshot;
if (!grid || !Number.isFinite(lon) || !Number.isFinite(lat)) return null;
if (kind === 'speed') {
const wind = sampleWind(
grid === snapshot ? grid : { ...grid, u: snapshot.u, v: snapshot.v },
lon,
lat,
);
const speed = Math.hypot(wind.u, wind.v);
return Number.isFinite(speed) ? speed : null;
}
const scalar = snapshot.scalar;
if (
!WIND_FIELDS[kind] ||
scalar?.kind !== kind ||
scalar.units !== WIND_FIELDS[kind].units ||
!scalar.values
)
return null;
const { nx, ny, lo1, la1, dx, dy } = grid;
const x = ((normalizeLongitude(lon - lo1) + 360) % 360) / dx;
const y = clamp((la1 - lat) / dy, 0, ny - 1);
const x0 = Math.floor(x);
const y0 = Math.floor(y);
const tx = x - x0;
const ty = y - y0;
const col = (n) => ((n % nx) + nx) % nx;
const y1 = Math.min(y0 + 1, ny - 1);
const a = scalar.values[y0 * nx + col(x0)];
const b = scalar.values[y0 * nx + col(x0 + 1)];
const c = scalar.values[y1 * nx + col(x0)];
const d = scalar.values[y1 * nx + col(x0 + 1)];
const value =
(a * (1 - tx) + b * tx) * (1 - ty) + (c * (1 - tx) + d * tx) * ty;
return Number.isFinite(value) ? value : null;
}
/** One bounded geographic texture per installed field, never per render frame. */
export function createFieldRaster(snapshot, kind, width = 360, height = 181) {
const spec = WIND_FIELDS[kind];
if (
!spec ||
!snapshot ||
!Number.isInteger(width) ||
!Number.isInteger(height) ||
width < 2 ||
height < 2 ||
width > 720 ||
height > 362
)
return null;
if (
kind !== 'speed' &&
(snapshot.scalar?.kind !== kind || snapshot.scalar.units !== spec.units)
)
return null;
const rgba = new Uint8ClampedArray(width * height * 4);
const flat = snapshot.grid
? {
...snapshot.grid,
u: snapshot.u,
v: snapshot.v,
scalar: snapshot.scalar,
}
: snapshot;
let finiteCount = 0;
for (let y = 0; y < height; y++) {
const lat = 90 - ((y + 0.5) / height) * 180;
for (let x = 0; x < width; x++) {
// Pixel centers cover -180..180; the source's 0-degree origin is not an image origin.
const lon = -180 + ((x + 0.5) / width) * 360;
const value = sampleScalar(flat, lon, lat, kind);
if (value === null) continue;
const t = clamp((value - spec.min) / (spec.max - spec.min), 0, 1);
const rgb = PALETTES[kind][Math.round(t * 127)];
const offset = (y * width + x) * 4;
rgba[offset] = rgb[0];
rgba[offset + 1] = rgb[1];
rgba[offset + 2] = rgb[2];
const alpha =
kind === 'speed'
? 0.22 + 0.43 * Math.sqrt(t)
: kind === 'pressure'
? 0.24 + 0.3 * Math.min(1, Math.abs(value - 1013) / 40)
: 0.95;
rgba[offset + 3] = Math.round(255 * alpha);
finiteCount++;
}
}
return finiteCount ? { width, height, rgba } : null;
}