@aguacerowx/mapsgl 0.0.31 → 0.0.41

package/src/nexrad/MapboxRadarLayer.bundled.js

@@ -0,0 +1,810 @@
+// src/nexrad/MapboxRadarLayer.ts
+import { DEFAULT_COLORMAPS } from "@aguacerowx/javascript-sdk";
+
+// src/nexrad/buildRadarRayGeometry.ts
+function buildRadarRayGeometryBuffer(frame) {
+  const nRays = frame.nRays;
+  const nGates = frame.nGates;
+  if (nRays <= 0 || nGates <= 0) {
+    return { buffer: new Float32Array(0), anchorMercator: { x: 0, y: 0 } };
+  }
+  if (frame.rayBoundariesDeg.length < nRays + 1) {
+    return { buffer: new Float32Array(0), anchorMercator: { x: 0, y: 0 } };
+  }
+  const nearRangeM = frame.firstGateKm * 1e3;
+  const farRangeM = (frame.firstGateKm + frame.gateWidthKm * nGates) * 1e3;
+  const floatsPerVertex = 4;
+  const vertsPerGate = 6;
+  const out = new Float32Array(nRays * nGates * vertsPerGate * floatsPerVertex);
+  let write = 0;
+  const mercatorXFromLonDeg = (lonDeg) => (lonDeg + 180) / 360;
+  const mercatorYFromLatRad = (latRad) => (1 - Math.log(Math.tan(Math.PI * 0.25 + latRad * 0.5)) / Math.PI) * 0.5;
+  const anchorX = mercatorXFromLonDeg(frame.stationLon);
+  const anchorY = mercatorYFromLatRad(frame.stationLat * (Math.PI / 180));
+  const anchorMercator = { x: anchorX, y: anchorY };
+  const getDestination = (lat, lon, distanceM, bearingDeg) => {
+    const R = 6378137;
+    const dRad = distanceM / R;
+    const bRad = bearingDeg * (Math.PI / 180);
+    const lat1 = lat * (Math.PI / 180);
+    const lon1 = lon * (Math.PI / 180);
+    const lat2 = Math.asin(Math.sin(lat1) * Math.cos(dRad) + Math.cos(lat1) * Math.sin(dRad) * Math.cos(bRad));
+    const lon2 = lon1 + Math.atan2(
+      Math.sin(bRad) * Math.sin(dRad) * Math.cos(lat1),
+      Math.cos(dRad) - Math.sin(lat1) * Math.sin(lat2)
+    );
+    return {
+      x: mercatorXFromLonDeg(lon2 * (180 / Math.PI)) - anchorX,
+      y: mercatorYFromLatRad(lat2) - anchorY
+    };
+  };
+  const writeVertex = (x, y, u, v) => {
+    out[write++] = x;
+    out[write++] = y;
+    out[write++] = u;
+    out[write++] = v;
+  };
+  for (let rayIdx = 0; rayIdx < nRays; rayIdx++) {
+    const az1 = frame.rayBoundariesDeg[rayIdx];
+    const az2 = frame.rayBoundariesDeg[rayIdx + 1];
+    const v0 = rayIdx / nRays;
+    const v1 = (rayIdx + 1) / nRays;
+    for (let g = 0; g < nGates; g++) {
+      const r1 = nearRangeM + (farRangeM - nearRangeM) * (g / nGates);
+      const r2 = nearRangeM + (farRangeM - nearRangeM) * ((g + 1) / nGates);
+      const u0 = g / nGates;
+      const u1 = (g + 1) / nGates;
+      const nearLeft = getDestination(frame.stationLat, frame.stationLon, r1, az1);
+      const nearRight = getDestination(frame.stationLat, frame.stationLon, r1, az2);
+      const farLeft = getDestination(frame.stationLat, frame.stationLon, r2, az1);
+      const farRight = getDestination(frame.stationLat, frame.stationLon, r2, az2);
+      writeVertex(nearLeft.x, nearLeft.y, u0, v0);
+      writeVertex(nearRight.x, nearRight.y, u0, v1);
+      writeVertex(farLeft.x, farLeft.y, u1, v0);
+      writeVertex(nearRight.x, nearRight.y, u0, v1);
+      writeVertex(farRight.x, farRight.y, u1, v1);
+      writeVertex(farLeft.x, farLeft.y, u1, v0);
+    }
+  }
+  return { buffer: out, anchorMercator };
+}
+
+// src/nexrad/radarFrameGpuMatch.ts
+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);
+}
+
+// src/nexrad/MapboxRadarLayer.ts
+var GEOMETRY_LRU_MAX = 12;
+var geometryLru = /* @__PURE__ */ new Map();
+function geometryLruTouch(key) {
+  const e = geometryLru.get(key);
+  if (!e) return void 0;
+  geometryLru.delete(key);
+  geometryLru.set(key, e);
+  return e;
+}
+function geometryLruPut(key, entry) {
+  if (geometryLru.has(key)) geometryLru.delete(key);
+  geometryLru.set(key, entry);
+  while (geometryLru.size > GEOMETRY_LRU_MAX) {
+    const oldest = geometryLru.keys().next().value;
+    if (oldest === void 0) break;
+    geometryLru.delete(oldest);
+  }
+}
+function fingerprintRayBoundariesDeg(b) {
+  return fingerprintRayBoundariesDegQuantized(b, 1e3);
+}
+function fingerprintRayBoundariesDegQuantized(b, unitsPerDeg) {
+  const n = b.length;
+  if (n === 0) return "0";
+  let h = 2166136261;
+  for (let i = 0; i < n; i++) {
+    const v = Math.round(b[i] * unitsPerDeg);
+    h ^= v;
+    h = Math.imul(h, 16777619);
+  }
+  h ^= n * 73856093;
+  return (h >>> 0).toString(36);
+}
+function getRefc0DefaultColormap() {
+  const cm = DEFAULT_COLORMAPS?.refc_0?.units?.dBZ?.colormap;
+  return Array.isArray(cm) && cm.length >= 2 ? cm : null;
+}
+function buildRadarShaders(fragmentHighFloatSupported) {
+  const fragPrec = fragmentHighFloatSupported ? "highp" : "mediump";
+  const vertex = `
+precision highp float;
+uniform mat4 u_matrix;
+attribute vec2 a_pos;  // offset from anchor (small numbers)
+attribute vec2 a_uv;
+varying ${fragPrec} vec2 v_uv;
+
+void main() {
+    v_uv = a_uv;
+    // u_matrix already has anchor baked in from CPU-side float64 math
+    gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);
+}`;
+  const fragment = `
+precision ${fragPrec} float;
+varying ${fragPrec} vec2 v_uv;
+
+uniform sampler2D u_gate_texture;
+uniform sampler2D u_lut_texture;
+uniform vec2 u_texture_size;
+uniform vec2 u_value_scale_offset;
+uniform vec2 u_lut_value_range;
+uniform float u_discrete_integer_lut;
+uniform float u_opacity;
+uniform float u_gate_smooth_polar;
+
+float decodeInt16(vec2 encoded) {
+    float hi = floor(encoded.x * 255.0 + 0.5);
+    float lo = floor(encoded.y * 255.0 + 0.5);
+    float raw = lo + hi * 256.0;
+    if (raw >= 32768.0) raw -= 65536.0;
+    return raw;
+}
+
+float sampleGateRawBilinear(vec2 gxy) {
+    vec2 sz = u_texture_size;
+    
+    // Both Range (X) and Azimuth (Y) cover the full domain. 
+    // Scale by size and offset by 0.5 to target the exact texel centers.
+    float x_px = gxy.x * sz.x - 0.5;
+    float y_px = gxy.y * sz.y - 0.5;
+    
+    vec2 i0 = floor(vec2(x_px, y_px));
+    vec2 f = vec2(x_px, y_px) - i0;
+    vec2 i1 = i0 + 1.0;
+    
+    // Clamp Range (X) to valid texel indices
+    i0.x = clamp(i0.x, 0.0, sz.x - 1.0);
+    i1.x = clamp(i1.x, 0.0, sz.x - 1.0);
+    
+    // Wrap Azimuth (Y) seamlessly (add sz.y to avoid negative mod bug on Windows/ANGLE)
+    i0.y = mod(i0.y + sz.y, sz.y);
+    i1.y = mod(i1.y + sz.y, sz.y);
+    
+    // Calculate bilinear weights
+    float w00 = (1.0 - f.x) * (1.0 - f.y);
+    float w10 = f.x * (1.0 - f.y);
+    float w01 = (1.0 - f.x) * f.y;
+    float w11 = f.x * f.y;
+    
+    vec2 invSz = 1.0 / sz;
+    vec4 p00 = texture2D(u_gate_texture, (vec2(i0.x, i0.y) + 0.5) * invSz);
+    vec4 p10 = texture2D(u_gate_texture, (vec2(i1.x, i0.y) + 0.5) * invSz);
+    vec4 p01 = texture2D(u_gate_texture, (vec2(i0.x, i1.y) + 0.5) * invSz);
+    vec4 p11 = texture2D(u_gate_texture, (vec2(i1.x, i1.y) + 0.5) * invSz);
+    
+    float r00 = decodeInt16(vec2(p00.r, p00.a));
+    float r10 = decodeInt16(vec2(p10.r, p10.a));
+    float r01 = decodeInt16(vec2(p01.r, p01.a));
+    float r11 = decodeInt16(vec2(p11.r, p11.a));
+    
+    float acc = 0.0;
+    float wsum = 0.0;
+    if (r00 > -32768.0) { acc += r00 * w00; wsum += w00; }
+    if (r10 > -32768.0) { acc += r10 * w10; wsum += w10; }
+    if (r01 > -32768.0) { acc += r01 * w01; wsum += w01; }
+    if (r11 > -32768.0) { acc += r11 * w11; wsum += w11; }
+    if (wsum < 1e-6) return -32768.0;
+    return acc / wsum;
+}
+
+float sampleGateRawNearest(vec2 gxy) {
+    vec2 sz = u_texture_size;
+    vec2 px = gxy * sz;
+    vec2 i = floor(px);
+    
+    // Clamp Range (X)
+    i.x = clamp(i.x, 0.0, sz.x - 1.0);
+    
+    // Wrap Azimuth (Y) seamlessly (add sz.y to avoid negative mod bug on Windows/ANGLE)
+    i.y = mod(i.y + sz.y, sz.y);
+    
+    vec4 p = texture2D(u_gate_texture, (i + 0.5) / sz);
+    return decodeInt16(vec2(p.r, p.a));
+}
+    
+void main() {
+    float raw;
+    if (u_gate_smooth_polar < 0.5) {
+        raw = sampleGateRawNearest(v_uv);
+    } else {
+        raw = sampleGateRawBilinear(v_uv);
+    }
+    
+    if (raw <= -32768.0) {
+        discard;
+    }
+
+    float physical = raw * u_value_scale_offset.x + u_value_scale_offset.y;
+
+    if (physical < u_lut_value_range.x || physical > u_lut_value_range.y) discard;
+
+    float lutT;
+    if (u_discrete_integer_lut > 0.5) {
+        float n = u_lut_value_range.y - u_lut_value_range.x + 1.0;
+        lutT = (physical - u_lut_value_range.x + 0.5) / max(n, 0.0001);
+    } else {
+        lutT = (physical - u_lut_value_range.x) / max(u_lut_value_range.y - u_lut_value_range.x, 0.0001);
+    }
+    lutT = clamp(lutT, 0.0, 1.0);
+    vec4 color = texture2D(u_lut_texture, vec2(lutT, 0.5));
+    if (color.a <= 0.001) discard;
+    gl_FragColor = vec4(color.rgb, color.a * u_opacity);
+}`;
+  return { vertex, fragment };
+}
+var MapboxRadarLayer = class _MapboxRadarLayer {
+  id;
+  type = "custom";
+  renderingMode = "2d";
+  static DEG_TO_RAD = Math.PI / 180;
+  static RAD_TO_DEG = 180 / Math.PI;
+  static EARTH_RADIUS_M = 6378137;
+  static LUT_SIZE = 256;
+  geometryBuffer = null;
+  gateTexture = null;
+  lutTexture = null;
+  activeVertCount = 0;
+  hasFrame = false;
+  pendingFrame = null;
+  pendingFrameUploadOptions = null;
+  /** Coalesce rapid setFrameData calls (same animation frame → one upload). */
+  pendingSetFrameRaf = null;
+  rafCoalesceFrame = null;
+  rafCoalesceOptions;
+  anchorMercator = { x: 0, y: 0 };
+  program = null;
+  gl = null;
+  uMatrixLocation = null;
+  uGateTextureLocation = null;
+  uLutTextureLocation = null;
+  uTextureSizeLocation = null;
+  uValueScaleOffsetLocation = null;
+  uLutValueRangeLocation = null;
+  uDiscreteIntegerLutLocation = null;
+  uOpacityLocation = null;
+  uGateSmoothPolarLocation = null;
+  aPosLocation = -1;
+  aUvLocation = -1;
+  activeTextureWidth = 0;
+  activeTextureHeight = 0;
+  activeValueScale = 1;
+  activeValueOffset = 0;
+  lutValueMin = 0;
+  lutValueMax = 80;
+  opacity = 1;
+  currentColormap = null;
+  interpolateColormap = true;
+  discreteIntegerLutActive = false;
+  gateSmoothing = false;
+  lastUploadedFrame = null;
+  map = null;
+  geometryCache = null;
+  buildGeometryCacheKey(frame, options) {
+    const base = `${frame.stationLat},${frame.stationLon},${frame.firstGateKm},${frame.gateWidthKm},${frame.nRays},${frame.nGates}`;
+    const layout = options?.geometryLayoutKey;
+    if (layout != null && layout !== "") {
+      return `${base},layout:${layout}`;
+    }
+    if (options?.geometryCacheKeysRayBoundaries === true) {
+      return `${base},rb:${fingerprintRayBoundariesDeg(frame.rayBoundariesDeg)}`;
+    }
+    return base;
+  }
+  constructor(id) {
+    this.id = id;
+  }
+  setValueRange(min, max) {
+    const safeMin = Number.isFinite(min) ? min : 0;
+    const safeMax = Number.isFinite(max) && max > safeMin ? max : 80;
+    if (this.lutValueMin === safeMin && this.lutValueMax === safeMax) return;
+    this.lutValueMin = safeMin;
+    this.lutValueMax = safeMax;
+    const gl = this.gl;
+    if (gl && this.lutTexture) {
+      const lut = this.buildLutTextureData();
+      gl.bindTexture(gl.TEXTURE_2D, this.lutTexture);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        _MapboxRadarLayer.LUT_SIZE,
+        1,
+        0,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        lut
+      );
+      this.applyLutTextureFilter(gl);
+    }
+  }
+  setOpacity(opacity) {
+    const safe = Math.max(0, Math.min(1, Number.isFinite(opacity) ? opacity : 1));
+    if (this.opacity === safe) return;
+    this.opacity = safe;
+  }
+  setColormap(colormap) {
+    const effective = Array.isArray(colormap) && colormap.length >= 2 ? colormap : getRefc0DefaultColormap();
+    const effectiveStr = JSON.stringify(effective);
+    if (JSON.stringify(this.currentColormap) === effectiveStr) return;
+    this.currentColormap = effective;
+    const gl = this.gl;
+    if (gl && this.lutTexture) {
+      const lut = this.buildLutTextureData();
+      gl.bindTexture(gl.TEXTURE_2D, this.lutTexture);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        _MapboxRadarLayer.LUT_SIZE,
+        1,
+        0,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        lut
+      );
+      this.applyLutTextureFilter(gl);
+    }
+  }
+  setGateSmoothing(smooth) {
+    if (this.gateSmoothing === smooth) return;
+    this.gateSmoothing = smooth;
+  }
+  setInterpolateColormap(interpolate) {
+    if (this.interpolateColormap === interpolate) return;
+    this.interpolateColormap = interpolate;
+    const gl = this.gl;
+    if (gl && this.lutTexture) {
+      const lut = this.buildLutTextureData();
+      gl.bindTexture(gl.TEXTURE_2D, this.lutTexture);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        _MapboxRadarLayer.LUT_SIZE,
+        1,
+        0,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        lut
+      );
+      this.applyLutTextureFilter(gl);
+    }
+  }
+  onAdd(map, gl) {
+    this.map = map;
+    this.gl = gl;
+    const hiFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);
+    const fragmentHighFloatSupported = hiFloat != null && hiFloat.precision > 0;
+    const { vertex: vertexSource, fragment: fragmentSource } = buildRadarShaders(fragmentHighFloatSupported);
+    const vs = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vs, vertexSource);
+    gl.compileShader(vs);
+    if (!gl.getShaderParameter(vs, gl.COMPILE_STATUS)) {
+      console.error(`[MapboxRadarLayer] ${this.id} vertex shader error:`, gl.getShaderInfoLog(vs));
+    }
+    const fs = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs, fragmentSource);
+    gl.compileShader(fs);
+    if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) {
+      console.error(`[MapboxRadarLayer] ${this.id} fragment shader error:`, gl.getShaderInfoLog(fs));
+    }
+    this.program = gl.createProgram();
+    gl.attachShader(this.program, vs);
+    gl.attachShader(this.program, fs);
+    gl.linkProgram(this.program);
+    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+      console.error(`[MapboxRadarLayer] ${this.id} shader link error:`, gl.getProgramInfoLog(this.program));
+    }
+    this.uMatrixLocation = gl.getUniformLocation(this.program, "u_matrix");
+    this.uGateTextureLocation = gl.getUniformLocation(this.program, "u_gate_texture");
+    this.uLutTextureLocation = gl.getUniformLocation(this.program, "u_lut_texture");
+    this.uTextureSizeLocation = gl.getUniformLocation(this.program, "u_texture_size");
+    this.uValueScaleOffsetLocation = gl.getUniformLocation(this.program, "u_value_scale_offset");
+    this.uLutValueRangeLocation = gl.getUniformLocation(this.program, "u_lut_value_range");
+    this.uDiscreteIntegerLutLocation = gl.getUniformLocation(this.program, "u_discrete_integer_lut");
+    this.uOpacityLocation = gl.getUniformLocation(this.program, "u_opacity");
+    this.uGateSmoothPolarLocation = gl.getUniformLocation(this.program, "u_gate_smooth_polar");
+    this.aUvLocation = gl.getAttribLocation(this.program, "a_uv");
+    this.aPosLocation = gl.getAttribLocation(this.program, "a_pos");
+    this.geometryBuffer = gl.createBuffer();
+    this.gateTexture = gl.createTexture();
+    this.lutTexture = gl.createTexture();
+    this.initializeLutTexture(gl);
+    if (this.pendingFrame) {
+      this.uploadFrame(gl, this.pendingFrame, this.pendingFrameUploadOptions ?? void 0);
+      this.pendingFrame = null;
+      this.pendingFrameUploadOptions = null;
+    }
+  }
+  onRemove(_map, _gl) {
+    this.map = null;
+  }
+  commitRadarGeometry(gl, cacheKey, buffer, anchorMercator) {
+    this.anchorMercator = anchorMercator;
+    this.geometryCache = {
+      key: cacheKey,
+      buffer,
+      anchor: anchorMercator
+    };
+    geometryLruPut(cacheKey, {
+      buffer,
+      anchor: { ...anchorMercator }
+    });
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.geometryBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, buffer, gl.STATIC_DRAW);
+  }
+  uploadGateTextureAndFinishFrame(gl, sortedFrame) {
+    if (!this.geometryCache) return;
+    this.activeVertCount = this.geometryCache.buffer.length / 4;
+    this.hasFrame = this.activeVertCount > 0;
+    this.activeTextureWidth = sortedFrame.nGates;
+    this.activeTextureHeight = sortedFrame.nRays;
+    this.activeValueScale = sortedFrame.valueScale;
+    this.activeValueOffset = sortedFrame.valueOffset;
+    gl.bindTexture(gl.TEXTURE_2D, this.gateTexture);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    this.applyGateTextureFilter(gl);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.LUMINANCE_ALPHA,
+      sortedFrame.nGates,
+      sortedFrame.nRays,
+      0,
+      gl.LUMINANCE_ALPHA,
+      gl.UNSIGNED_BYTE,
+      sortedFrame.gateData
+    );
+    this.map?.triggerRepaint();
+  }
+  preloadFrame(_frame) {
+    return;
+  }
+  setFrameData(frame, options) {
+    const gl = this.gl;
+    if (!gl) {
+      this.pendingFrame = frame;
+      this.pendingFrameUploadOptions = options ?? null;
+      return;
+    }
+    if (options?.geometryCacheKeysRayBoundaries !== true) {
+      this.uploadFrame(gl, frame, options);
+      return;
+    }
+    this.rafCoalesceFrame = frame;
+    this.rafCoalesceOptions = options;
+    if (this.pendingSetFrameRaf != null) return;
+    this.pendingSetFrameRaf = requestAnimationFrame(() => {
+      this.pendingSetFrameRaf = null;
+      const gl2 = this.gl;
+      const f = this.rafCoalesceFrame;
+      const o = this.rafCoalesceOptions;
+      this.rafCoalesceFrame = null;
+      this.rafCoalesceOptions = void 0;
+      if (!gl2 || !f) return;
+      this.uploadFrame(gl2, f, o);
+    });
+  }
+  evictAllFrames() {
+    if (this.pendingSetFrameRaf != null) {
+      cancelAnimationFrame(this.pendingSetFrameRaf);
+      this.pendingSetFrameRaf = null;
+    }
+    this.rafCoalesceFrame = null;
+    this.rafCoalesceOptions = void 0;
+    const gl = this.gl;
+    if (!gl) return;
+    if (this.geometryBuffer) {
+      gl.deleteBuffer(this.geometryBuffer);
+      this.geometryBuffer = null;
+    }
+    if (this.gateTexture) {
+      gl.deleteTexture(this.gateTexture);
+      this.gateTexture = null;
+    }
+    if (this.lutTexture) {
+      gl.deleteTexture(this.lutTexture);
+      this.lutTexture = null;
+    }
+    this.pendingFrame = null;
+    this.pendingFrameUploadOptions = null;
+    this.lastUploadedFrame = null;
+    this.activeVertCount = 0;
+    this.hasFrame = false;
+    this.activeTextureWidth = 0;
+    this.activeTextureHeight = 0;
+    this.geometryCache = null;
+  }
+  render(gl, matrix) {
+    if (!this.program || !this.geometryBuffer || !this.gateTexture || !this.lutTexture || !this.hasFrame) return;
+    if (this.activeVertCount === 0) return;
+    if (this.aPosLocation < 0 || this.aUvLocation < 0 || !this.uMatrixLocation) return;
+    if (this.uGateTextureLocation === null || this.uLutTextureLocation === null || this.uTextureSizeLocation === null || this.uValueScaleOffsetLocation === null || this.uLutValueRangeLocation === null || this.uDiscreteIntegerLutLocation === null || this.uOpacityLocation === null || this.uGateSmoothPolarLocation === null) return;
+    gl.useProgram(this.program);
+    const ax = this.anchorMercator.x;
+    const ay = this.anchorMercator.y;
+    const shiftedMatrix = new Float32Array(16);
+    for (let i = 0; i < 16; i++) shiftedMatrix[i] = matrix[i];
+    shiftedMatrix[12] = matrix[0] * ax + matrix[4] * ay + matrix[12];
+    shiftedMatrix[13] = matrix[1] * ax + matrix[5] * ay + matrix[13];
+    shiftedMatrix[14] = matrix[2] * ax + matrix[6] * ay + matrix[14];
+    shiftedMatrix[15] = matrix[3] * ax + matrix[7] * ay + matrix[15];
+    gl.uniformMatrix4fv(this.uMatrixLocation, false, shiftedMatrix);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, this.gateTexture);
+    gl.uniform1i(this.uGateTextureLocation, 0);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, this.lutTexture);
+    gl.uniform1i(this.uLutTextureLocation, 1);
+    gl.uniform2f(this.uTextureSizeLocation, this.activeTextureWidth, this.activeTextureHeight);
+    gl.uniform2f(this.uValueScaleOffsetLocation, this.activeValueScale, this.activeValueOffset);
+    gl.uniform2f(this.uLutValueRangeLocation, this.lutValueMin, this.lutValueMax);
+    gl.uniform1f(this.uDiscreteIntegerLutLocation, this.discreteIntegerLutActive ? 1 : 0);
+    gl.uniform1f(this.uOpacityLocation, this.opacity);
+    gl.uniform1f(this.uGateSmoothPolarLocation, this.gateSmoothing ? 1 : 0);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.geometryBuffer);
+    gl.enableVertexAttribArray(this.aPosLocation);
+    gl.vertexAttribPointer(this.aPosLocation, 2, gl.FLOAT, false, 16, 0);
+    gl.enableVertexAttribArray(this.aUvLocation);
+    gl.vertexAttribPointer(this.aUvLocation, 2, gl.FLOAT, false, 16, 8);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    gl.drawArrays(gl.TRIANGLES, 0, this.activeVertCount);
+    gl.disableVertexAttribArray(this.aPosLocation);
+    gl.disableVertexAttribArray(this.aUvLocation);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  uploadFrame(gl, frame, options) {
+    if (!this.geometryBuffer || !this.gateTexture) return;
+    const sortedFrame = prepareRadarFrameForGpuReadout(frame, options);
+    const cacheKey = this.buildGeometryCacheKey(sortedFrame, options);
+    let reused = false;
+    if (this.geometryCache?.key === cacheKey) {
+      this.anchorMercator = this.geometryCache.anchor;
+      reused = true;
+    }
+    if (!reused) {
+      const fromLru = geometryLruTouch(cacheKey);
+      if (fromLru) {
+        this.geometryCache = {
+          key: cacheKey,
+          buffer: fromLru.buffer,
+          anchor: fromLru.anchor
+        };
+        this.anchorMercator = fromLru.anchor;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.geometryBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, fromLru.buffer, gl.STATIC_DRAW);
+        reused = true;
+      }
+    }
+    if (reused) {
+      this.uploadGateTextureAndFinishFrame(gl, sortedFrame);
+      return;
+    }
+    const built = buildRadarRayGeometryBuffer({
+      nRays: sortedFrame.nRays,
+      nGates: sortedFrame.nGates,
+      stationLat: sortedFrame.stationLat,
+      stationLon: sortedFrame.stationLon,
+      firstGateKm: sortedFrame.firstGateKm,
+      gateWidthKm: sortedFrame.gateWidthKm,
+      rayBoundariesDeg: sortedFrame.rayBoundariesDeg
+    });
+    this.commitRadarGeometry(gl, cacheKey, built.buffer, built.anchorMercator);
+    this.uploadGateTextureAndFinishFrame(gl, sortedFrame);
+  }
+  initializeLutTexture(gl) {
+    if (!this.lutTexture) return;
+    const lut = this.buildLutTextureData();
+    gl.bindTexture(gl.TEXTURE_2D, this.lutTexture);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      _MapboxRadarLayer.LUT_SIZE,
+      1,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      lut
+    );
+    this.applyLutTextureFilter(gl);
+  }
+  applyGateTextureFilter(gl) {
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  }
+  applyLutTextureFilter(gl) {
+    const f = this.interpolateColormap ? gl.LINEAR : gl.NEAREST;
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, f);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, f);
+  }
+  buildLutTextureData() {
+    const cm = this.currentColormap ?? getRefc0DefaultColormap();
+    const stops = [];
+    if (cm && cm.length >= 2) {
+      for (let i = 0; i < cm.length; i += 2) {
+        const value = Number(cm[i]);
+        const hex = String(cm[i + 1] ?? "");
+        const m = hex.match(/^#?([a-fA-F0-9]{8}|[a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/);
+        let r = 0, g = 0, b = 0, a = 255;
+        if (m) {
+          const s = m[1];
+          if (s.length === 8) {
+            r = parseInt(s.slice(0, 2), 16);
+            g = parseInt(s.slice(2, 4), 16);
+            b = parseInt(s.slice(4, 6), 16);
+            a = parseInt(s.slice(6, 8), 16);
+          } else if (s.length === 6) {
+            r = parseInt(s.slice(0, 2), 16);
+            g = parseInt(s.slice(2, 4), 16);
+            b = parseInt(s.slice(4, 6), 16);
+          } else {
+            r = parseInt(s[0] + s[0], 16);
+            g = parseInt(s[1] + s[1], 16);
+            b = parseInt(s[2] + s[2], 16);
+          }
+        }
+        stops.push({ value, color: [r, g, b, a] });
+      }
+    }
+    if (stops.length === 0) {
+      this.discreteIntegerLutActive = false;
+      return new Uint8Array(_MapboxRadarLayer.LUT_SIZE * 4);
+    }
+    this.discreteIntegerLutActive = this.shouldUseDiscreteIntegerLut(stops);
+    const { interpolateColormap } = this;
+    const out = new Uint8Array(_MapboxRadarLayer.LUT_SIZE * 4);
+    if (this.discreteIntegerLutActive) {
+      const n = stops.length;
+      for (let i = 0; i < _MapboxRadarLayer.LUT_SIZE; i++) {
+        const u = (i + 0.5) / _MapboxRadarLayer.LUT_SIZE;
+        const bin = Math.min(Math.floor(u * n), n - 1);
+        const c = stops[bin].color;
+        const idx = i * 4;
+        out[idx] = c[0];
+        out[idx + 1] = c[1];
+        out[idx + 2] = c[2];
+        out[idx + 3] = c[3];
+      }
+      return out;
+    }
+    for (let i = 0; i < _MapboxRadarLayer.LUT_SIZE; i++) {
+      const value = this.lutValueMin + i / (_MapboxRadarLayer.LUT_SIZE - 1) * (this.lutValueMax - this.lutValueMin);
+      const color = this.sampleStops(stops, value, interpolateColormap);
+      const idx = i * 4;
+      out[idx] = color[0];
+      out[idx + 1] = color[1];
+      out[idx + 2] = color[2];
+      out[idx + 3] = color[3];
+    }
+    return out;
+  }
+  shouldUseDiscreteIntegerLut(stops) {
+    if (this.interpolateColormap || stops.length < 2) return false;
+    const lo = this.lutValueMin;
+    const hi = this.lutValueMax;
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) return false;
+    const nExp = Math.round(hi - lo + 1);
+    if (stops.length !== nExp) return false;
+    if (Math.abs(Math.round(lo) - lo) > 1e-3 || Math.abs(Math.round(hi) - hi) > 1e-3) return false;
+    for (let i = 0; i < stops.length; i++) {
+      if (Math.abs(stops[i].value - (lo + i)) > 1e-3) return false;
+    }
+    return true;
+  }
+  sampleStops(stops, value, interpolate) {
+    if (value <= stops[0].value) return stops[0].color;
+    if (value >= stops[stops.length - 1].value) return stops[stops.length - 1].color;
+    for (let i = 1; i < stops.length; i++) {
+      if (interpolate) {
+        if (value <= stops[i].value) {
+          const low = stops[i - 1];
+          const high = stops[i];
+          const t = (value - low.value) / Math.max(high.value - low.value, 1e-5);
+          return [
+            Math.round(low.color[0] + (high.color[0] - low.color[0]) * t),
+            Math.round(low.color[1] + (high.color[1] - low.color[1]) * t),
+            Math.round(low.color[2] + (high.color[2] - low.color[2]) * t),
+            Math.round(low.color[3] + (high.color[3] - low.color[3]) * t)
+          ];
+        }
+      } else {
+        if (value < stops[i].value) {
+          return stops[i - 1].color;
+        }
+      }
+    }
+    return stops[stops.length - 1].color;
+  }
+};
+export {
+  MapboxRadarLayer
+};