@aguacerowx/mapsgl 0.0.57 → 0.0.58

package/src/nexrad/PreprocessedSweepParser.ts

@@ -1,226 +1,226 @@
-/**
- * Parser for the pre-processed sweep binary format produced by the NEXRAD Lambda.
- *
- * Binary layout (all little-endian — numpy default on x86):
- *   [0-3]   int32   version = 1
- *   [4-7]   float32 scale
- *   [8-11]  float32 offset
- *   [12-15] float32 sweep_idx
- *   [16-19] float32 elev_angle (degrees)
- *   [20-23] float32 n_rays 
- *   [24-27] float32 n_gates
- *   [28-31] float32 first_gate (km — range to center of first gate)
- *   [32-35] float32 gate_width (km — range sample interval)
- *   [36 ...]              float32[n_rays] azimuths (degrees)
- *   [36+n_rays*4 ...]     float32[n_rays] elevations (degrees, unused for 2-D rendering)
- *   [36+n_rays*8 ...]     int16[n_rays * n_gates] gate values (-32768 = masked/NaN)
- *
- * Gate decoding: physical_value = raw_int16 * scale + offset  (when raw != -32768)
- * Masked gates are stored as -99 in the output dataMoments array to match the
- * existing VertexDataGenerator convention.
- */
-
-const PREPROCESSED_VERSION = 1;
-const HEADER_SIZE = 36; // 4 + 8 + 24 bytes
-
-export interface NexradSite {
-    id: string;
-    lat: number;
-    lon: number;
-}
-
-/** Minimal moment interface consumed by VertexDataGenerator */
-export interface SweepMoment {
-    dataMomentName: string;
-    azimuth: number;
-    /** Distance to center of first gate (km) */
-    dataMomentRange: number;
-    /** Gate width / range sample interval (km) */
-    dataMomentRangeSampleInterval: number;
-    /** Physical gate values; masked gates = -99 */
-    dataMoments: Float32Array;
-}
-
-export interface SweepRay {
-    dataMoments: SweepMoment[];
-}
-
-/** Minimal archive interface consumed by VertexDataGenerator and MapboxRadarLayer */
-export interface RadarArchive {
-    latitude: number;
-    longitude: number;
-    fieldName: string;
-    elevAngle: number;
-    nRays: number;
-    nGates: number;
-    volume: {
-        sweeps: Array<{ rays: SweepRay[] }>;
-    };
-}
-
-/**
- * Returns true if the buffer starts with the preprocessed sweep version header.
- * Used in RadarLayer to dispatch to the correct parser.
- */
-export function isPreprocessedFormat(buffer: ArrayBuffer): boolean {
-    if (buffer.byteLength < HEADER_SIZE) return false;
-    return new DataView(buffer).getInt32(0, true) === PREPROCESSED_VERSION;
-}
-
-export function parsePreprocessedSweep(
-    buffer: ArrayBuffer,
-    stationId: string,
-    fieldName: string,
-    nexradSites: NexradSite[],
-): RadarArchive | null {
-    const LE = true;
-    const view = new DataView(buffer);
-
-    const version = view.getInt32(0, LE);
-    if (version !== PREPROCESSED_VERSION) {
-        console.error(`[PreprocessedSweepParser] Unknown version ${version}, expected ${PREPROCESSED_VERSION}`);
-        return null;
-    }
-
-    const scale     = view.getFloat32(4,  LE);
-    const offsetVal = view.getFloat32(8,  LE);
-    // sweep_idx at bytes 12-15 (not needed for rendering)
-    const elevAngle = view.getFloat32(16, LE);
-    const nRays     = Math.round(view.getFloat32(20, LE));
-    const nGates    = Math.round(view.getFloat32(24, LE));
-    const firstGate = view.getFloat32(28, LE); // km
-    const gateWidth = view.getFloat32(32, LE); // km
-
-    const azOffset   = HEADER_SIZE;                    // 36
-    const elOffset   = azOffset  + nRays * 4;          // 36 + nRays*4
-    const gateOffset = elOffset  + nRays * 4;          // 36 + nRays*8
-
-    const expectedBytes = gateOffset + nRays * nGates * 2;
-    if (buffer.byteLength < expectedBytes) {
-        console.error(
-            `[PreprocessedSweepParser] Buffer too small: got ${buffer.byteLength} bytes, ` +
-            `need ${expectedBytes} (nRays=${nRays}, nGates=${nGates})`,
-        );
-        return null;
-    }
-
-    const site = nexradSites.find(s => s.id === stationId);
-    if (!site) {
-        console.error(`[PreprocessedSweepParser] Station "${stationId}" not found in nexrad.json`);
-        return null;
-    }
-
-    // Slice into aligned copies for typed-array access
-    const azimuths = new Float32Array(buffer.slice(azOffset, azOffset + nRays * 4));
-    const gatesRaw = new Int16Array(buffer.slice(gateOffset, gateOffset + nRays * nGates * 2));
-
-    const rays: SweepRay[] = [];
-    for (let i = 0; i < nRays; i++) {
-        const physicalGates = new Float32Array(nGates);
-        const base = i * nGates;
-        for (let g = 0; g < nGates; g++) {
-            const raw = gatesRaw[base + g];
-            physicalGates[g] = raw === -32768 ? -99 : raw * scale + offsetVal;
-        }
-        rays.push({
-            dataMoments: [{
-                dataMomentName: fieldName,
-                azimuth: azimuths[i],
-                dataMomentRange: firstGate,
-                dataMomentRangeSampleInterval: gateWidth,
-                dataMoments: physicalGates,
-            }],
-        });
-    }
-
-    return {
-        latitude: site.lat,
-        longitude: site.lon,
-        fieldName,
-        elevAngle,
-        nRays,
-        nGates,
-        volume: { sweeps: [{ rays }] },
-    };
-}
-
-const SLOT_HDR_BYTES = 28;
-
-export function parseSlotBuffer(
-    buffer: ArrayBuffer,
-    stationId: string,
-    fieldName: string,
-    nexradSites: NexradSite[],
-    // These come from the file header fetched separately
-    nRaysFile: number,
-    nGatesFile: number,
-    firstGateKm: number,
-    gateWidthKm: number,
-    azimuths: Float32Array,
-): RadarArchive | null {
-    const BE = false; // DataView default is big-endian when false
-    const view = new DataView(buffer);
-
-    const scale    = view.getFloat32(0,  false); // big-endian
-    const offsetV  = view.getFloat32(4,  false);
-    const present  = view.getUint32(8,   false);
-    const nRays    = view.getUint16(12,  false);
-    const nGates   = view.getUint16(14,  false);
-
-    if (present === 0) {
-        console.warn(`[parseSlotBuffer] Slot for ${fieldName} marked not present`);
-        return null;
-    }
-
-    const gateOffset = SLOT_HDR_BYTES;
-    const expectedBytes = gateOffset + nRays * nGates * 2;
-    if (buffer.byteLength < expectedBytes) {
-        console.error(
-            `[parseSlotBuffer] Buffer too small: got ${buffer.byteLength}, need ${expectedBytes}`
-        );
-        return null;
-    }
-
-    const site = nexradSites.find(s => s.id === stationId);
-    if (!site) {
-        console.error(`[parseSlotBuffer] Station "${stationId}" not found`);
-        return null;
-    }
-
-    // Gate data is big-endian int16
-    const gateBytes = buffer.slice(gateOffset, gateOffset + nRays * nGates * 2);
-    const gatesRaw = new Int16Array(nRays * nGates);
-    const gateView = new DataView(gateBytes);
-    for (let i = 0; i < nRays * nGates; i++) {
-        gatesRaw[i] = gateView.getInt16(i * 2, false); // big-endian
-    }
-
-    const rays: SweepRay[] = [];
-    for (let i = 0; i < nRays; i++) {
-        const physicalGates = new Float32Array(nGates);
-        const base = i * nGates;
-        for (let g = 0; g < nGates; g++) {
-            const raw = gatesRaw[base + g];
-            physicalGates[g] = raw === -32768 ? -99 : raw * scale + offsetV;
-        }
-        rays.push({
-            dataMoments: [{
-                dataMomentName:               fieldName,
-                azimuth:                      azimuths[i],
-                dataMomentRange:              firstGateKm,
-                dataMomentRangeSampleInterval: gateWidthKm,
-                dataMoments:                  physicalGates,
-            }],
-        });
-    }
-
-    return {
-        latitude:  site.lat,
-        longitude: site.lon,
-        fieldName,
-        elevAngle: 0, // not stored in slot, pass from file header if needed
-        nRays,
-        nGates,
-        volume: { sweeps: [{ rays }] },
-    };
+/**
+ * Parser for the pre-processed sweep binary format produced by the NEXRAD Lambda.
+ *
+ * Binary layout (all little-endian — numpy default on x86):
+ *   [0-3]   int32   version = 1
+ *   [4-7]   float32 scale
+ *   [8-11]  float32 offset
+ *   [12-15] float32 sweep_idx
+ *   [16-19] float32 elev_angle (degrees)
+ *   [20-23] float32 n_rays 
+ *   [24-27] float32 n_gates
+ *   [28-31] float32 first_gate (km — range to center of first gate)
+ *   [32-35] float32 gate_width (km — range sample interval)
+ *   [36 ...]              float32[n_rays] azimuths (degrees)
+ *   [36+n_rays*4 ...]     float32[n_rays] elevations (degrees, unused for 2-D rendering)
+ *   [36+n_rays*8 ...]     int16[n_rays * n_gates] gate values (-32768 = masked/NaN)
+ *
+ * Gate decoding: physical_value = raw_int16 * scale + offset  (when raw != -32768)
+ * Masked gates are stored as -99 in the output dataMoments array to match the
+ * existing VertexDataGenerator convention.
+ */
+
+const PREPROCESSED_VERSION = 1;
+const HEADER_SIZE = 36; // 4 + 8 + 24 bytes
+
+export interface NexradSite {
+    id: string;
+    lat: number;
+    lon: number;
+}
+
+/** Minimal moment interface consumed by VertexDataGenerator */
+export interface SweepMoment {
+    dataMomentName: string;
+    azimuth: number;
+    /** Distance to center of first gate (km) */
+    dataMomentRange: number;
+    /** Gate width / range sample interval (km) */
+    dataMomentRangeSampleInterval: number;
+    /** Physical gate values; masked gates = -99 */
+    dataMoments: Float32Array;
+}
+
+export interface SweepRay {
+    dataMoments: SweepMoment[];
+}
+
+/** Minimal archive interface consumed by VertexDataGenerator and MapboxRadarLayer */
+export interface RadarArchive {
+    latitude: number;
+    longitude: number;
+    fieldName: string;
+    elevAngle: number;
+    nRays: number;
+    nGates: number;
+    volume: {
+        sweeps: Array<{ rays: SweepRay[] }>;
+    };
+}
+
+/**
+ * Returns true if the buffer starts with the preprocessed sweep version header.
+ * Used in RadarLayer to dispatch to the correct parser.
+ */
+export function isPreprocessedFormat(buffer: ArrayBuffer): boolean {
+    if (buffer.byteLength < HEADER_SIZE) return false;
+    return new DataView(buffer).getInt32(0, true) === PREPROCESSED_VERSION;
+}
+
+export function parsePreprocessedSweep(
+    buffer: ArrayBuffer,
+    stationId: string,
+    fieldName: string,
+    nexradSites: NexradSite[],
+): RadarArchive | null {
+    const LE = true;
+    const view = new DataView(buffer);
+
+    const version = view.getInt32(0, LE);
+    if (version !== PREPROCESSED_VERSION) {
+        console.error(`[PreprocessedSweepParser] Unknown version ${version}, expected ${PREPROCESSED_VERSION}`);
+        return null;
+    }
+
+    const scale     = view.getFloat32(4,  LE);
+    const offsetVal = view.getFloat32(8,  LE);
+    // sweep_idx at bytes 12-15 (not needed for rendering)
+    const elevAngle = view.getFloat32(16, LE);
+    const nRays     = Math.round(view.getFloat32(20, LE));
+    const nGates    = Math.round(view.getFloat32(24, LE));
+    const firstGate = view.getFloat32(28, LE); // km
+    const gateWidth = view.getFloat32(32, LE); // km
+
+    const azOffset   = HEADER_SIZE;                    // 36
+    const elOffset   = azOffset  + nRays * 4;          // 36 + nRays*4
+    const gateOffset = elOffset  + nRays * 4;          // 36 + nRays*8
+
+    const expectedBytes = gateOffset + nRays * nGates * 2;
+    if (buffer.byteLength < expectedBytes) {
+        console.error(
+            `[PreprocessedSweepParser] Buffer too small: got ${buffer.byteLength} bytes, ` +
+            `need ${expectedBytes} (nRays=${nRays}, nGates=${nGates})`,
+        );
+        return null;
+    }
+
+    const site = nexradSites.find(s => s.id === stationId);
+    if (!site) {
+        console.error(`[PreprocessedSweepParser] Station "${stationId}" not found in nexrad.json`);
+        return null;
+    }
+
+    // Slice into aligned copies for typed-array access
+    const azimuths = new Float32Array(buffer.slice(azOffset, azOffset + nRays * 4));
+    const gatesRaw = new Int16Array(buffer.slice(gateOffset, gateOffset + nRays * nGates * 2));
+
+    const rays: SweepRay[] = [];
+    for (let i = 0; i < nRays; i++) {
+        const physicalGates = new Float32Array(nGates);
+        const base = i * nGates;
+        for (let g = 0; g < nGates; g++) {
+            const raw = gatesRaw[base + g];
+            physicalGates[g] = raw === -32768 ? -99 : raw * scale + offsetVal;
+        }
+        rays.push({
+            dataMoments: [{
+                dataMomentName: fieldName,
+                azimuth: azimuths[i],
+                dataMomentRange: firstGate,
+                dataMomentRangeSampleInterval: gateWidth,
+                dataMoments: physicalGates,
+            }],
+        });
+    }
+
+    return {
+        latitude: site.lat,
+        longitude: site.lon,
+        fieldName,
+        elevAngle,
+        nRays,
+        nGates,
+        volume: { sweeps: [{ rays }] },
+    };
+}
+
+const SLOT_HDR_BYTES = 28;
+
+export function parseSlotBuffer(
+    buffer: ArrayBuffer,
+    stationId: string,
+    fieldName: string,
+    nexradSites: NexradSite[],
+    // These come from the file header fetched separately
+    nRaysFile: number,
+    nGatesFile: number,
+    firstGateKm: number,
+    gateWidthKm: number,
+    azimuths: Float32Array,
+): RadarArchive | null {
+    const BE = false; // DataView default is big-endian when false
+    const view = new DataView(buffer);
+
+    const scale    = view.getFloat32(0,  false); // big-endian
+    const offsetV  = view.getFloat32(4,  false);
+    const present  = view.getUint32(8,   false);
+    const nRays    = view.getUint16(12,  false);
+    const nGates   = view.getUint16(14,  false);
+
+    if (present === 0) {
+        console.warn(`[parseSlotBuffer] Slot for ${fieldName} marked not present`);
+        return null;
+    }
+
+    const gateOffset = SLOT_HDR_BYTES;
+    const expectedBytes = gateOffset + nRays * nGates * 2;
+    if (buffer.byteLength < expectedBytes) {
+        console.error(
+            `[parseSlotBuffer] Buffer too small: got ${buffer.byteLength}, need ${expectedBytes}`
+        );
+        return null;
+    }
+
+    const site = nexradSites.find(s => s.id === stationId);
+    if (!site) {
+        console.error(`[parseSlotBuffer] Station "${stationId}" not found`);
+        return null;
+    }
+
+    // Gate data is big-endian int16
+    const gateBytes = buffer.slice(gateOffset, gateOffset + nRays * nGates * 2);
+    const gatesRaw = new Int16Array(nRays * nGates);
+    const gateView = new DataView(gateBytes);
+    for (let i = 0; i < nRays * nGates; i++) {
+        gatesRaw[i] = gateView.getInt16(i * 2, false); // big-endian
+    }
+
+    const rays: SweepRay[] = [];
+    for (let i = 0; i < nRays; i++) {
+        const physicalGates = new Float32Array(nGates);
+        const base = i * nGates;
+        for (let g = 0; g < nGates; g++) {
+            const raw = gatesRaw[base + g];
+            physicalGates[g] = raw === -32768 ? -99 : raw * scale + offsetV;
+        }
+        rays.push({
+            dataMoments: [{
+                dataMomentName:               fieldName,
+                azimuth:                      azimuths[i],
+                dataMomentRange:              firstGateKm,
+                dataMomentRangeSampleInterval: gateWidthKm,
+                dataMoments:                  physicalGates,
+            }],
+        });
+    }
+
+    return {
+        latitude:  site.lat,
+        longitude: site.lon,
+        fieldName,
+        elevAngle: 0, // not stored in slot, pass from file header if needed
+        nRays,
+        nGates,
+        volume: { sweeps: [{ rays }] },
+    };
 }

package/src/nexrad/buildRadarRayGeometry.ts

@@ -1,97 +1,97 @@
-/**
- * CPU-heavy polar wedge mesh for {@link MapboxRadarLayer}. Extracted for Web Worker offload.
- */
-export type RadarRayGeometryFrame = {
-    nRays: number;
-    nGates: number;
-    stationLat: number;
-    stationLon: number;
-    firstGateKm: number;
-    gateWidthKm: number;
-    rayBoundariesDeg: Float32Array;
-};
-
-export function buildRadarRayGeometryBuffer(frame: RadarRayGeometryFrame): {
-    buffer: Float32Array;
-    anchorMercator: { x: number; y: number };
-} {
-    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 * 1000;
-    const farRangeM = (frame.firstGateKm + frame.gateWidthKm * nGates) * 1000;
-
-    const floatsPerVertex = 4;
-    const vertsPerGate = 6;
-    const out = new Float32Array(nRays * nGates * vertsPerGate * floatsPerVertex);
-    let write = 0;
-
-    const mercatorXFromLonDeg = (lonDeg: number) => (lonDeg + 180) / 360;
-    const mercatorYFromLatRad = (latRad: number) =>
-        (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: number, lon: number, distanceM: number, bearingDeg: number) => {
-        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: number, y: number, u: number, v: number) => {
-        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 };
-}
+/**
+ * CPU-heavy polar wedge mesh for {@link MapboxRadarLayer}. Extracted for Web Worker offload.
+ */
+export type RadarRayGeometryFrame = {
+    nRays: number;
+    nGates: number;
+    stationLat: number;
+    stationLon: number;
+    firstGateKm: number;
+    gateWidthKm: number;
+    rayBoundariesDeg: Float32Array;
+};
+
+export function buildRadarRayGeometryBuffer(frame: RadarRayGeometryFrame): {
+    buffer: Float32Array;
+    anchorMercator: { x: number; y: number };
+} {
+    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 * 1000;
+    const farRangeM = (frame.firstGateKm + frame.gateWidthKm * nGates) * 1000;
+
+    const floatsPerVertex = 4;
+    const vertsPerGate = 6;
+    const out = new Float32Array(nRays * nGates * vertsPerGate * floatsPerVertex);
+    let write = 0;
+
+    const mercatorXFromLonDeg = (lonDeg: number) => (lonDeg + 180) / 360;
+    const mercatorYFromLatRad = (latRad: number) =>
+        (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: number, lon: number, distanceM: number, bearingDeg: number) => {
+        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: number, y: number, u: number, v: number) => {
+        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 };
+}