@aguacerowx/mapsgl 0.0.41 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -8,7 +8,8 @@
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "bundle-nexrad": "esbuild src/nexrad/radarDecode.worker.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarDecode.worker.bundled.js && esbuild src/nexrad/radarArchiveCore.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarArchiveCore.bundled.js --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/MapboxRadarLayer.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/MapboxRadarLayer.bundled.js --external:mapbox-gl --external:@aguacerowx/javascript-sdk",
+    "prepublishOnly": "npm run bundle-nexrad",
+    "bundle-nexrad": "esbuild src/nexrad/radarDecode.worker.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarDecode.worker.bundled.js && esbuild src/nexrad/radarArchiveCore.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarArchiveCore.bundled.js --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/MapboxRadarLayer.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/MapboxRadarLayer.bundled.js --external:mapbox-gl --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/nexradCrossSectionSampleAtLatLon.ts --format=esm --platform=browser --outfile=src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js && esbuild src/nexrad/radarFrameGpuMatch.ts --format=esm --platform=browser --outfile=src/nexrad/radarFrameGpuMatch.bundled.js",
     "gen:nws-key": "esbuild ../../../aguacero-frontend/src/components/WarningsMenu/nwsWarningCustomizationKey.ts --bundle --format=esm --platform=neutral --outfile=src/nwsWarningCustomizationKey.gen.js"
   },
   "files": [

package/src/NexradWeatherController.js

@@ -6,8 +6,8 @@ import { getUnitConversionFunction, getDefaultRadarTilt } from '@aguacerowx/java
 import { fetchAndParseArchive, objectKeyToUrl, setNexradArchiveApiKey } from './nexrad/radarArchiveCore.bundled.js';
 import { MapboxRadarLayer } from './nexrad/MapboxRadarLayer.bundled.js';
 import { nexradBinGroupIdForKey, variableToNexradGroup } from '@aguacerowx/javascript-sdk';
-import { sampleNexradFrameAtLatLon } from './nexrad/nexradCrossSectionSampleAtLatLon.ts';
-import { prepareRadarFrameForGpuReadout } from './nexrad/radarFrameGpuMatch.ts';
+import { sampleNexradFrameAtLatLon } from './nexrad/nexradCrossSectionSampleAtLatLon.bundled.js';
+import { prepareRadarFrameForGpuReadout } from './nexrad/radarFrameGpuMatch.bundled.js';
 import { mapboxFrameUploadOptionsForNexradState } from './nexrad/nexradMapboxFrameOpts.js';
 
 function pickNearestLevel3ObjectKey(unixTime, timeToKeyMap, maxDeltaSec = 600) {

package/src/WeatherLayerManager.js

@@ -722,7 +722,132 @@ export class WeatherLayerManager extends EventEmitter {
         // the active time.
     }
 
-    async _rebuildLayerAndPreload(state) {
+    /**
+     * MRMS timestamps or model forecast hours for the active timeline (ordering preserved from source lists).
+     * @returns {number[]}
+     */
+    _collectNormalizedTimelineSteps(state) {
+        let fromCore = [];
+        try {
+            if (!state.isMRMS && typeof this.core.getAvailableForecastHours === 'function') {
+                fromCore = this.core.getAvailableForecastHours();
+            }
+        } catch (err) {
+            // ignore
+        }
+
+        const fromState = state.isMRMS
+            ? (state.availableTimestamps || [])
+            : (state.availableHours || []);
+
+        let timeSteps;
+        if (state.isMRMS) {
+            timeSteps = fromState.length ? fromState : fromCore;
+        } else {
+            timeSteps = fromCore.length > 0 ? fromCore : fromState;
+        }
+
+        return (timeSteps || [])
+            .map(t => Number(t))
+            .filter(t => !Number.isNaN(t));
+    }
+
+    /**
+     * @param {object} state
+     * @param {number[]} times
+     * @param {{ rebuildId: number, mode: 'rebuild' | 'append' }} options
+     */
+    _runParallelGridFrameLoads(state, times, options) {
+        const { rebuildId, mode } = options;
+        if (!times.length || !this.shaderLayer) {
+            if (mode === 'rebuild') {
+                this._initialGridLoadPending = false;
+            }
+            return;
+        }
+
+        const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
+        /** When the active timestep is unset/NaN, paint the first timeline step (legacy single-fetch behavior). */
+        let primaryTimeForRebuild = Number.NaN;
+        if (mode === 'rebuild') {
+            primaryTimeForRebuild = Number.isFinite(currentFrameTime)
+                ? currentFrameTime
+                : times[0];
+        }
+        const tsKey = state.isMRMS ? 'mrmsTimestamp' : 'forecastHour';
+        const gridModel = state.isMRMS ? 'mrms' : state.model;
+        const { gridDef } = this.core._getGridCornersAndDef(gridModel);
+
+        times.forEach((time) => {
+            const stateForTime = { ...state, [tsKey]: time };
+            this.core._loadGridData(stateForTime)
+                .then((grid) => {
+                    if (rebuildId !== this.currentRebuildId || !this.shaderLayer) {
+                        return;
+                    }
+
+                    const isPrimaryFrame =
+                        mode === 'rebuild' &&
+                        Number.isFinite(primaryTimeForRebuild) &&
+                        time === primaryTimeForRebuild;
+
+                    if (isPrimaryFrame) {
+                        const coreTimeKey = state.isMRMS
+                            ? (this.core.state.mrmsTimestamp == null
+                                ? null
+                                : Number(this.core.state.mrmsTimestamp))
+                            : Number(this.core.state.forecastHour);
+                        if (coreTimeKey !== this._rebuildTargetTimeKey) {
+                            return;
+                        }
+                        if (!grid?.data) {
+                            this._initialGridLoadPending = false;
+                            return;
+                        }
+                        this.shaderLayer.updateDataTexture(
+                            grid.data,
+                            grid.encoding,
+                            gridDef.grid_params.nx,
+                            gridDef.grid_params.ny,
+                        );
+                        this.currentLoadedTimeKey = time;
+                        this.shaderLayer.registerCurrentDataTextureAsPreloaded(time);
+                        this._initialGridLoadPending = false;
+                        this.map.triggerRepaint();
+                        return;
+                    }
+
+                    if (grid?.data) {
+                        this.shaderLayer.storePreloadedTexture(
+                            time,
+                            grid.data,
+                            grid.encoding,
+                            gridDef.grid_params.nx,
+                            gridDef.grid_params.ny,
+                        );
+                        const s = this.core.state;
+                        const activeTime = s.isMRMS
+                            ? (s.mrmsTimestamp == null ? null : Number(s.mrmsTimestamp))
+                            : Number(s.forecastHour);
+                        if (time === activeTime && this.shaderLayer.switchToPreloadedTexture(time)) {
+                            this.currentLoadedTimeKey = time;
+                            this.map.triggerRepaint();
+                        }
+                    }
+                })
+                .catch(() => {
+                    if (
+                        mode === 'rebuild' &&
+                        Number.isFinite(primaryTimeForRebuild) &&
+                        time === primaryTimeForRebuild
+                    ) {
+                        this._initialGridLoadPending = false;
+                    }
+                });
+        });
+    }
+
+    _rebuildLayerAndPreload(state) {
         if (state.isSatellite) {
             return;
         }
@@ -775,75 +900,28 @@ export class WeatherLayerManager extends EventEmitter {
             : Number(state.forecastHour);
         this._initialGridLoadPending = true;
 
-        let grid;
-        try {
-            grid = await this.core._loadGridData(state);
-        } catch (e) {
-            this._initialGridLoadPending = false;
-            throw e;
+        const normalized = this._collectNormalizedTimelineSteps(state);
+        const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
+        const timesSet = new Set(normalized);
+        if (!Number.isNaN(currentFrameTime)) {
+            timesSet.add(currentFrameTime);
         }
-
-        if (rebuildId !== this.currentRebuildId) {
-            this._initialGridLoadPending = false;
-            return;
+        let timesToLoad = [...timesSet];
+        if (timesToLoad.length === 0 && !Number.isNaN(currentFrameTime)) {
+            timesToLoad = [currentFrameTime];
         }
-
-        const coreTimeKey = state.isMRMS
-            ? (this.core.state.mrmsTimestamp == null ? null : Number(this.core.state.mrmsTimestamp))
-            : Number(this.core.state.forecastHour);
-        if (coreTimeKey !== this._rebuildTargetTimeKey) {
+        if (timesToLoad.length === 0) {
             this._initialGridLoadPending = false;
             return;
         }
 
-        if (grid && grid.data) {
-            const gridModel = state.isMRMS ? 'mrms' : state.model;
-            const { gridDef } = this.core._getGridCornersAndDef(gridModel);
-
-            this.shaderLayer.updateDataTexture(
-                grid.data, grid.encoding,
-                gridDef.grid_params.nx, gridDef.grid_params.ny
-            );
-
-            this.currentLoadedTimeKey = state.isMRMS
-                ? (state.mrmsTimestamp == null ? null : Number(state.mrmsTimestamp))
-                : Number(state.forecastHour);
-            this.shaderLayer.registerCurrentDataTextureAsPreloaded(this.currentLoadedTimeKey);
-            this.map.triggerRepaint();
-        }
-
-        this._initialGridLoadPending = false;
-
         if (rebuildId === this.currentRebuildId) {
-            this._preloadAllTimeSteps(state);
+            this._runParallelGridFrameLoads(state, timesToLoad, { rebuildId, mode: 'rebuild' });
         }
     }
-    
-    _preloadAllTimeSteps(state) {
-        let fromCore = [];
-        try {
-            if (!state.isMRMS && typeof this.core.getAvailableForecastHours === 'function') {
-                fromCore = this.core.getAvailableForecastHours();
-            }
-        } catch (err) {
-            // ignore
-        }
-
-        const fromState = state.isMRMS
-            ? (state.availableTimestamps || [])
-            : (state.availableHours || []);
-
-        let timeSteps;
-        if (state.isMRMS) {
-            timeSteps = fromState.length ? fromState : fromCore;
-        } else {
-            timeSteps = fromCore.length > 0 ? fromCore : fromState;
-        }
-
-        const normalized = (timeSteps || [])
-            .map(t => Number(t))
-            .filter(t => !Number.isNaN(t));
 
+    _preloadAllTimeSteps(state) {
+        const normalized = this._collectNormalizedTimelineSteps(state);
         const currentFrameTime = Number(state.isMRMS ? state.mrmsTimestamp : state.forecastHour);
         const stepsToPreload = normalized.filter(t => t !== currentFrameTime);
 
@@ -856,38 +934,7 @@ export class WeatherLayerManager extends EventEmitter {
         }
 
         const capturedRebuildId = this.currentRebuildId;
-
-        const gridModel = state.isMRMS ? 'mrms' : state.model;
-        const { gridDef } = this.core._getGridCornersAndDef(gridModel);
-
-        stepsToPreload.forEach(time => {
-            const stateForTime = {
-                ...state,
-                [state.isMRMS ? 'mrmsTimestamp' : 'forecastHour']: time
-            };
-
-            this.core._loadGridData(stateForTime)
-                .then(grid => {
-                    if (capturedRebuildId !== this.currentRebuildId) {
-                        return;
-                    }
-                    if (grid?.data && this.shaderLayer) {
-                        this.shaderLayer.storePreloadedTexture(
-                            time, grid.data, grid.encoding,
-                            gridDef.grid_params.nx, gridDef.grid_params.ny
-                        );
-                        const s = this.core.state;
-                        const activeTime = s.isMRMS
-                            ? (s.mrmsTimestamp == null ? null : Number(s.mrmsTimestamp))
-                            : Number(s.forecastHour);
-                        if (time === activeTime && this.shaderLayer.switchToPreloadedTexture(time)) {
-                            this.currentLoadedTimeKey = time;
-                            this.map.triggerRepaint();
-                        }
-                    }
-                })
-                .catch(() => {});
-        });
+        this._runParallelGridFrameLoads(state, stepsToPreload, { rebuildId: capturedRebuildId, mode: 'append' });
     }
 
     _updateLayerData(state) {

package/src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js

@@ -0,0 +1,91 @@
+function wrapAzimuthDeltaDeg(azDeg, azimuthBaseDeg) {
+  let da = azDeg - azimuthBaseDeg;
+  da -= Math.floor(da / 360) * 360;
+  if (da < 0) da += 360;
+  return da;
+}
+function snapGateCoord(t, nCells) {
+  if (nCells <= 1) return 0;
+  const idx = Math.floor(t * (nCells - 1) + 0.5);
+  return idx / (nCells - 1);
+}
+function readGateRawSigned(frame, rayIdx, gateIdx) {
+  if (rayIdx < 0 || gateIdx < 0 || rayIdx >= frame.nRays || gateIdx >= frame.nGates) return null;
+  const byteOffset = (rayIdx * frame.nGates + gateIdx) * 2;
+  const hi = frame.gateData[byteOffset];
+  const lo = frame.gateData[byteOffset + 1];
+  const raw = lo + hi * 256;
+  const rawSigned = raw >= 32768 ? raw - 65536 : raw;
+  if (rawSigned <= -32768) return null;
+  return rawSigned;
+}
+function sampleGateRawBilinearDecoded(frame, gateX, gateY) {
+  const w = frame.nGates;
+  const h = frame.nRays;
+  if (w < 1 || h < 1) return null;
+  const gx = Math.min(1, Math.max(0, gateX));
+  const gy = Math.min(1, Math.max(0, gateY));
+  const sx = gx * Math.max(w - 1, 1);
+  const sy = gy * Math.max(h - 1, 1);
+  const i0 = Math.floor(sx);
+  const j0 = Math.floor(sy);
+  const i1 = Math.min(i0 + 1, w - 1);
+  const j1 = Math.min(j0 + 1, h - 1);
+  const fx = sx - i0;
+  const fy = sy - j0;
+  const w00 = (1 - fx) * (1 - fy);
+  const w10 = fx * (1 - fy);
+  const w01 = (1 - fx) * fy;
+  const w11 = fx * fy;
+  let acc = 0;
+  let wsum = 0;
+  const add = (r, wt) => {
+    if (r !== null) {
+      acc += r * wt;
+      wsum += wt;
+    }
+  };
+  add(readGateRawSigned(frame, j0, i0), w00);
+  add(readGateRawSigned(frame, j0, i1), w10);
+  add(readGateRawSigned(frame, j1, i0), w01);
+  add(readGateRawSigned(frame, j1, i1), w11);
+  if (wsum < 1e-6) return null;
+  return acc / wsum;
+}
+function sampleNexradFrameAtLatLon(frame, lat, lon, options) {
+  const DEG_TO_RAD = Math.PI / 180;
+  const EARTH_RADIUS_M = 6378137;
+  const dLatDeg = lat - frame.stationLat;
+  const dLonDeg = lon - frame.stationLon;
+  const cosLat = Math.max(Math.cos(lat * DEG_TO_RAD), 1e-6);
+  const xM = dLonDeg * DEG_TO_RAD * EARTH_RADIUS_M * cosLat;
+  const yM = dLatDeg * DEG_TO_RAD * EARTH_RADIUS_M;
+  const rangeM = Math.hypot(xM, yM);
+  const rangeKm = rangeM / 1e3;
+  if (rangeKm < frame.firstGateKm) return null;
+  const spanKm = frame.nGates * frame.gateWidthKm;
+  if (!(spanKm > 0)) return null;
+  const maxRangeKm = frame.firstGateKm + spanKm;
+  if (rangeKm >= maxRangeKm) return null;
+  let azDeg = Math.atan2(xM, yM) * (180 / Math.PI);
+  if (azDeg < 0) azDeg += 360;
+  const boundaries = frame.rayBoundariesDeg;
+  const azimuthBaseDeg = boundaries.length > 0 ? Number(boundaries[0]) : 0;
+  const da = wrapAzimuthDeltaDeg(azDeg, azimuthBaseDeg);
+  let gateY = da / 360;
+  gateY = Math.min(1, Math.max(0, gateY));
+  let gateX = (rangeKm - frame.firstGateKm) / spanKm;
+  gateX = Math.min(1, Math.max(0, gateX));
+  const smoothPolar = options?.smoothPolar === true;
+  if (!smoothPolar) {
+    gateX = snapGateCoord(gateX, frame.nGates);
+    gateY = snapGateCoord(gateY, frame.nRays);
+  }
+  const rawSigned = sampleGateRawBilinearDecoded(frame, gateX, gateY);
+  if (rawSigned === null) return null;
+  const physical = rawSigned * frame.valueScale + frame.valueOffset;
+  return { value: physical, groundRangeKm: rangeKm };
+}
+export {
+  sampleNexradFrameAtLatLon
+};

package/src/nexrad/radarFrameGpuMatch.bundled.js

@@ -0,0 +1,79 @@
+function angularDistanceDeg(a, b) {
+  let d = Math.abs(a - b) % 360;
+  if (d > 180) d = 360 - d;
+  return d;
+}
+function canonicalBinsRadarFrame(frame) {
+  const nRays = frame.nRays;
+  const nGates = frame.nGates;
+  if (nRays <= 0 || nGates <= 0) return frame;
+  if (frame.rayBoundariesDeg.length < nRays + 1) return frame;
+  const degPerBin = 360 / nRays;
+  const bytesPerRay = nGates * 2;
+  const centers = new Float32Array(nRays);
+  for (let r = 0; r < nRays; r++) {
+    const lower = frame.rayBoundariesDeg[r];
+    const upper = frame.rayBoundariesDeg[r + 1];
+    const center = (lower + upper) * 0.5;
+    centers[r] = (center % 360 + 360) % 360;
+  }
+  const canonicalGateData = new Uint8Array(nRays * bytesPerRay);
+  for (let i = 0; i < canonicalGateData.length; i += 2) {
+    canonicalGateData[i] = 128;
+  }
+  const used = new Array(nRays).fill(false);
+  for (let bin = 0; bin < nRays; bin++) {
+    const targetDeg = ((bin + 0.5) * degPerBin % 360 + 360) % 360;
+    let bestR = -1;
+    let bestDist = Infinity;
+    for (let r = 0; r < nRays; r++) {
+      if (used[r]) continue;
+      const dist = angularDistanceDeg(centers[r], targetDeg);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestR = r;
+      }
+    }
+    if (bestR >= 0) {
+      used[bestR] = true;
+      canonicalGateData.set(
+        frame.gateData.subarray(bestR * bytesPerRay, (bestR + 1) * bytesPerRay),
+        bin * bytesPerRay
+      );
+    }
+  }
+  const canonicalBoundaries = new Float32Array(nRays + 1);
+  for (let i = 0; i <= nRays; i++) {
+    canonicalBoundaries[i] = i * degPerBin;
+  }
+  return { ...frame, gateData: canonicalGateData, rayBoundariesDeg: canonicalBoundaries };
+}
+function sortRadarFrameByAzimuth(frame) {
+  const nRays = frame.nRays;
+  const nGates = frame.nGates;
+  const bytesPerRay = nGates * 2;
+  const rayOrder = Array.from({ length: nRays }, (_, i) => i).sort(
+    (a, b) => frame.rayBoundariesDeg[a] - frame.rayBoundariesDeg[b]
+  );
+  const sortedGateData = new Uint8Array(nRays * bytesPerRay);
+  const sortedBoundaries = new Float32Array(nRays + 1);
+  for (let newIdx = 0; newIdx < nRays; newIdx++) {
+    const oldIdx = rayOrder[newIdx];
+    sortedGateData.set(
+      frame.gateData.subarray(oldIdx * bytesPerRay, (oldIdx + 1) * bytesPerRay),
+      newIdx * bytesPerRay
+    );
+    sortedBoundaries[newIdx] = frame.rayBoundariesDeg[oldIdx];
+  }
+  sortedBoundaries[nRays] = frame.rayBoundariesDeg[rayOrder[nRays - 1]] + (frame.rayBoundariesDeg[rayOrder[1]] - frame.rayBoundariesDeg[rayOrder[0]]);
+  return { ...frame, gateData: sortedGateData, rayBoundariesDeg: sortedBoundaries };
+}
+function prepareRadarFrameForGpuReadout(frame, options) {
+  const hasLayoutKey = options?.geometryLayoutKey != null && options.geometryLayoutKey !== "";
+  return hasLayoutKey ? canonicalBinsRadarFrame(frame) : sortRadarFrameByAzimuth(frame);
+}
+export {
+  canonicalBinsRadarFrame,
+  prepareRadarFrameForGpuReadout,
+  sortRadarFrameByAzimuth
+};