@aguacerowx/react-native 0.0.42 → 0.0.44

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/RadarFrameGpuMatch.java

@@ -0,0 +1,117 @@
+package com.aguacerowx.reactnative;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class RadarFrameGpuMatch {
+
+    public static class Result {
+        public final byte[] gateData;
+        public final float[] rayBoundariesDeg;
+
+        public Result(byte[] gateData, float[] rayBoundariesDeg) {
+            this.gateData = gateData;
+            this.rayBoundariesDeg = rayBoundariesDeg;
+        }
+    }
+
+    private static double angularDistanceDeg(double a, double b) {
+        double d = Math.abs(a - b) % 360.0;
+        if (d > 180.0) {
+            d = 360.0 - d;
+        }
+        return d;
+    }
+
+    public static Result canonicalBinsRadarFrame(int nRays, int nGates, byte[] gateData, float[] rayBoundariesDeg) {
+        if (nRays <= 0 || nGates <= 0 || rayBoundariesDeg == null || rayBoundariesDeg.length < nRays + 1) {
+            return new Result(gateData, rayBoundariesDeg);
+        }
+
+        double degPerBin = 360.0 / nRays;
+        int bytesPerRay = nGates * 2;
+        double[] centers = new double[nRays];
+
+        for (int r = 0; r < nRays; r++) {
+            double lower = rayBoundariesDeg[r];
+            double upper = rayBoundariesDeg[r + 1];
+            double center = (lower + upper) * 0.5;
+            centers[r] = ((center % 360.0) + 360.0) % 360.0;
+        }
+
+        byte[] canonicalGateData = new byte[nRays * bytesPerRay];
+        for (int i = 0; i < canonicalGateData.length; i += 2) {
+            canonicalGateData[i] = (byte) 128;
+            canonicalGateData[i + 1] = 0; // Default alpha to 0 or whatever is appropriate, though JS sets [i] = 128. Wait, JS sets canonicalGateData[i] = 128, which means [i] = 128, [i+1] = 0.
+        }
+
+        boolean[] used = new boolean[nRays];
+        for (int bin = 0; bin < nRays; bin++) {
+            double targetDeg = (((bin + 0.5) * degPerBin) % 360.0 + 360.0) % 360.0;
+            int bestR = -1;
+            double bestDist = Double.POSITIVE_INFINITY;
+
+            for (int r = 0; r < nRays; r++) {
+                if (used[r]) continue;
+                double dist = angularDistanceDeg(centers[r], targetDeg);
+                if (dist < bestDist) {
+                    bestDist = dist;
+                    bestR = r;
+                }
+            }
+
+            if (bestR >= 0) {
+                used[bestR] = true;
+                System.arraycopy(gateData, bestR * bytesPerRay, canonicalGateData, bin * bytesPerRay, bytesPerRay);
+            }
+        }
+
+        float[] canonicalBoundaries = new float[nRays + 1];
+        for (int i = 0; i <= nRays; i++) {
+            canonicalBoundaries[i] = (float) (i * degPerBin);
+        }
+
+        return new Result(canonicalGateData, canonicalBoundaries);
+    }
+
+    public static Result sortRadarFrameByAzimuth(int nRays, int nGates, byte[] gateData, float[] rayBoundariesDeg) {
+        if (nRays <= 0 || nGates <= 0 || rayBoundariesDeg == null || rayBoundariesDeg.length < nRays + 1) {
+            return new Result(gateData, rayBoundariesDeg);
+        }
+
+        int bytesPerRay = nGates * 2;
+        Integer[] rayOrder = new Integer[nRays];
+        for (int i = 0; i < nRays; i++) {
+            rayOrder[i] = i;
+        }
+
+        Arrays.sort(rayOrder, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                return Float.compare(rayBoundariesDeg[a], rayBoundariesDeg[b]);
+            }
+        });
+
+        byte[] sortedGateData = new byte[nRays * bytesPerRay];
+        float[] sortedBoundaries = new float[nRays + 1];
+
+        for (int newIdx = 0; newIdx < nRays; newIdx++) {
+            int oldIdx = rayOrder[newIdx];
+            System.arraycopy(gateData, oldIdx * bytesPerRay, sortedGateData, newIdx * bytesPerRay, bytesPerRay);
+            sortedBoundaries[newIdx] = rayBoundariesDeg[oldIdx];
+        }
+
+        sortedBoundaries[nRays] = rayBoundariesDeg[rayOrder[nRays - 1]] + (rayBoundariesDeg[rayOrder[1]] - rayBoundariesDeg[rayOrder[0]]);
+
+        return new Result(sortedGateData, sortedBoundaries);
+    }
+
+    public static Result prepareRadarFrameForGpuReadout(int nRays, int nGates, byte[] gateData, float[] rayBoundariesDeg, String geometryLayoutKey) {
+        boolean hasLayoutKey = geometryLayoutKey != null && !geometryLayoutKey.isEmpty();
+        if (hasLayoutKey) {
+            return canonicalBinsRadarFrame(nRays, nGates, gateData, rayBoundariesDeg);
+        } else {
+            return sortRadarFrameByAzimuth(nRays, nGates, gateData, rayBoundariesDeg);
+        }
+    }
+}

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/RadarRayGeometryBuilder.java

@@ -0,0 +1,202 @@
+package com.aguacerowx.reactnative;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+/**
+ * Port of mapsgl {@code buildRadarRayGeometryBuffer} for NEXRAD polar mesh on Mapbox Android custom layer.
+ *
+ * <p>Vertex {@code x,y} must match {@link GridRenderLayer}: normalized Web Mercator is multiplied by
+ * {@link #TILE_MERCA_UNITS} (512) so positions live in the same tile-mercator space as the weather grid.
+ * The projection path in {@link NexradRadarLayer} then applies {@code 2^zoom} on matrix indices 0-11
+ * like {@link GridRenderLayer}. Web mapsgl uses raw normalized coords because Mapbox GL JS uses a
+ * different matrix convention.
+ */
+public final class RadarRayGeometryBuilder {
+
+    private RadarRayGeometryBuilder() {}
+
+    /** Same as {@link GridRenderLayer} regional / GFS paths ({@code TILE_SIZE = 512}). */
+    private static final double TILE_MERCA_UNITS = 512.0;
+
+    public static final class Result {
+        public final FloatBuffer vertexBuffer;
+        public final int vertexCount;
+        public final float anchorMercatorX;
+        public final float anchorMercatorY;
+
+        Result(FloatBuffer vertexBuffer, int vertexCount, float anchorMercatorX, float anchorMercatorY) {
+            this.vertexBuffer = vertexBuffer;
+            this.vertexCount = vertexCount;
+            this.anchorMercatorX = anchorMercatorX;
+            this.anchorMercatorY = anchorMercatorY;
+        }
+    }
+
+    private static double mercatorXFromLonDeg(double lonDeg) {
+        return (lonDeg + 180.0) / 360.0;
+    }
+
+    private static double mercatorYFromLatRad(double latRad) {
+        return (1.0 - Math.log(Math.tan(Math.PI * 0.25 + latRad * 0.5)) / Math.PI) * 0.5;
+    }
+
+    private static class Merc {
+        final double x;
+        final double y;
+        Merc(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    private static Merc getDestination(
+            double stationLatDeg,
+            double stationLonDeg,
+            double distanceM,
+            double bearingDeg,
+            double anchorX,
+            double anchorY
+    ) {
+        final double R = 6378137.0;
+        double dRad = distanceM / R;
+        double bRad = Math.toRadians(bearingDeg);
+        double lat1 = Math.toRadians(stationLatDeg);
+        double lon1 = Math.toRadians(stationLonDeg);
+        double lat2 = Math.asin(Math.sin(lat1) * Math.cos(dRad) + Math.cos(lat1) * Math.sin(dRad) * Math.cos(bRad));
+        double lon2 =
+                lon1
+                        + Math.atan2(
+                        Math.sin(bRad) * Math.sin(dRad) * Math.cos(lat1),
+                        Math.cos(dRad) - Math.sin(lat1) * Math.sin(lat2));
+        double lonDeg = lon2 * (180.0 / Math.PI);
+        double dx = mercatorXFromLonDeg(lonDeg) - anchorX;
+        double dy = mercatorYFromLatRad(lat2) - anchorY;
+        return new Merc(dx * TILE_MERCA_UNITS, dy * TILE_MERCA_UNITS);
+    }
+
+    public static Result build(
+            int nRays,
+            int nGates,
+            double stationLat,
+            double stationLon,
+            float firstGateKm,
+            float gateWidthKm,
+            float[] rayBoundariesDeg
+    ) {
+        if (nRays <= 0 || nGates <= 0 || rayBoundariesDeg == null || rayBoundariesDeg.length < nRays + 1) {
+            ByteBuffer bb = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder());
+            return new Result(bb.asFloatBuffer(), 0, 0f, 0f);
+        }
+
+        double nearRangeM = firstGateKm * 1000.0;
+        double farRangeM = (firstGateKm + gateWidthKm * nGates) * 1000.0;
+
+        final int floatsPerVertex = 4;
+        final int vertsPerGate = 6;
+        int totalFloats = nRays * nGates * vertsPerGate * floatsPerVertex;
+        ByteBuffer bb = ByteBuffer.allocateDirect(totalFloats * 4).order(ByteOrder.nativeOrder());
+        FloatBuffer out = bb.asFloatBuffer();
+
+        double anchorX = mercatorXFromLonDeg(stationLon);
+        double anchorY = mercatorYFromLatRad(Math.toRadians(stationLat));
+
+        double lat1 = Math.toRadians(stationLat);
+        double lon1 = Math.toRadians(stationLon);
+        double sinLat1 = Math.sin(lat1);
+        double cosLat1 = Math.cos(lat1);
+        final double R = 6378137.0;
+
+        // Precompute distance terms
+        double[] sinD = new double[nGates + 1];
+        double[] cosD = new double[nGates + 1];
+        for (int g = 0; g <= nGates; g++) {
+            double rM = nearRangeM + (farRangeM - nearRangeM) * (g / (double) nGates);
+            double dRad = rM / R;
+            sinD[g] = Math.sin(dRad);
+            cosD[g] = Math.cos(dRad);
+        }
+
+        // Precompute bearing terms
+        double[] sinB = new double[nRays + 1];
+        double[] cosB = new double[nRays + 1];
+        for (int rayIdx = 0; rayIdx <= nRays; rayIdx++) {
+            double bRad = Math.toRadians(rayBoundariesDeg[rayIdx]);
+            sinB[rayIdx] = Math.sin(bRad);
+            cosB[rayIdx] = Math.cos(bRad);
+        }
+
+        // Precompute all mercator coordinates
+        float[] mercX = new float[(nGates + 1) * (nRays + 1)];
+        float[] mercY = new float[(nGates + 1) * (nRays + 1)];
+        
+        for (int rayIdx = 0; rayIdx <= nRays; rayIdx++) {
+            double sb = sinB[rayIdx];
+            double cb = cosB[rayIdx];
+            int rowOffset = rayIdx * (nGates + 1);
+            for (int g = 0; g <= nGates; g++) {
+                double sd = sinD[g];
+                double cd = cosD[g];
+                
+                double lat2 = Math.asin(sinLat1 * cd + cosLat1 * sd * cb);
+                double lon2 = lon1 + Math.atan2(sb * sd * cosLat1, cd - sinLat1 * Math.sin(lat2));
+                
+                double lonDeg = lon2 * (180.0 / Math.PI);
+                double dx = mercatorXFromLonDeg(lonDeg) - anchorX;
+                double dy = mercatorYFromLatRad(lat2) - anchorY;
+                
+                int idx = rowOffset + g;
+                mercX[idx] = (float)(dx * TILE_MERCA_UNITS);
+                mercY[idx] = (float)(dy * TILE_MERCA_UNITS);
+            }
+        }
+
+        for (int rayIdx = 0; rayIdx < nRays; rayIdx++) {
+            float v0 = (float) rayIdx / nRays;
+            float v1 = (float) (rayIdx + 1) / nRays;
+            int row0 = rayIdx * (nGates + 1);
+            int row1 = (rayIdx + 1) * (nGates + 1);
+
+            for (int g = 0; g < nGates; g++) {
+                float u0 = (float) g / nGates;
+                float u1 = (float) (g + 1) / nGates;
+
+                float nlX = mercX[row0 + g];
+                float nlY = mercY[row0 + g];
+                
+                float nrX = mercX[row1 + g];
+                float nrY = mercY[row1 + g];
+                
+                float flX = mercX[row0 + g + 1];
+                float flY = mercY[row0 + g + 1];
+                
+                float frX = mercX[row1 + g + 1];
+                float frY = mercY[row1 + g + 1];
+
+                putVertex(out, nlX, nlY, u0, v0);
+                putVertex(out, nrX, nrY, u0, v1);
+                putVertex(out, flX, flY, u1, v0);
+
+                putVertex(out, nrX, nrY, u0, v1);
+                putVertex(out, frX, frY, u1, v1);
+                putVertex(out, flX, flY, u1, v0);
+            }
+        }
+
+        out.position(0);
+        int vertCount = nRays * nGates * vertsPerGate;
+        return new Result(
+                out,
+                vertCount,
+                (float) (anchorX * TILE_MERCA_UNITS),
+                (float) (anchorY * TILE_MERCA_UNITS));
+    }
+
+    private static void putVertex(FloatBuffer out, float x, float y, float u, float v) {
+        out.put(x);
+        out.put(y);
+        out.put(u);
+        out.put(v);
+    }
+}

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/SatelliteColormap.java

@@ -0,0 +1,134 @@
+package com.aguacerowx.reactnative;
+
+import java.util.Arrays;
+
+/**
+ * Default satellite colormap RGBA bytes (256×1) — parity with mapsgl {@code satelliteDefaultColormaps.js}.
+ */
+final class SatelliteColormap {
+
+    private SatelliteColormap() {}
+
+    static byte[] defaultIrColormapRgba() {
+        double[] stops =
+                new double[] {
+                    5, 51, 52, 58, 64, 73, 78, 82, 88, 90, 96, 100,
+                };
+        String[] colors =
+                new String[] {
+                    "#000000",
+                    "#ffffff",
+                    "#00ffff",
+                    "#0033cc",
+                    "#33ff00",
+                    "#ffee00",
+                    "#ff0000",
+                    "#660000",
+                    "#808080",
+                    "#cc66ff",
+                    "#9933cc",
+                    "#9933cc",
+                };
+        return buildColormapFromStops(stops, colors, "IR", true);
+    }
+
+    static byte[] defaultWvColormapRgba() {
+        double[] stops = new double[] {10, 20, 30, 45, 55, 70, 80, 90, 100};
+        String[] colors =
+                new String[] {
+                    "#cece55",
+                    "#ce5555",
+                    "#262626",
+                    "#ffffff",
+                    "#55cece",
+                    "#5555ce",
+                    "#4d3366",
+                    "#e673e6",
+                    "#efe6eb",
+                };
+        return buildColormapFromStops(stops, colors, "WV", true);
+    }
+
+    /** Channel type {@code IR}, {@code WV}, or {@code VIS}. */
+    static byte[] buildColormapFromStops(double[] norms, String[] hexColors, String channelType, boolean interpolate) {
+        final int width = 256;
+        byte[] data = new byte[width * 4];
+
+        if (norms == null || hexColors == null || norms.length != hexColors.length || norms.length == 0) {
+            Arrays.fill(data, (byte) 0);
+            return data;
+        }
+
+        double minK = channelType.equals("WV") ? 183 : 180;
+        double maxK = channelType.equals("WV") ? 288 : 330;
+
+        double[][] parsed = new double[norms.length][4];
+        for (int i = 0; i < norms.length; i++) {
+            double normVal = norms[i];
+            String hex = hexColors[i];
+            int r = Integer.parseInt(hex.substring(1, 3), 16);
+            int g = Integer.parseInt(hex.substring(3, 5), 16);
+            int b = Integer.parseInt(hex.substring(5, 7), 16);
+            double texCoord;
+            if ("VIS".equals(channelType)) {
+                texCoord = normVal / 100.0;
+            } else {
+                double fraction = normVal / 100.0;
+                double kelvin = maxK - (fraction * (maxK - minK));
+                texCoord = (maxK - kelvin) / (maxK - minK);
+            }
+            parsed[i][0] = texCoord;
+            parsed[i][1] = r;
+            parsed[i][2] = g;
+            parsed[i][3] = b;
+        }
+
+        Arrays.sort(parsed, (a, b) -> Double.compare(a[0], b[0]));
+
+        for (int i = 0; i < width; i++) {
+            double t = i / (double) (width - 1);
+            int r, g, b;
+            if (interpolate) {
+                double[] c1 = parsed[0];
+                double[] c2 = parsed[parsed.length - 1];
+                for (int j = 0; j < parsed.length - 1; j++) {
+                    if (t >= parsed[j][0] && t <= parsed[j + 1][0]) {
+                        c1 = parsed[j];
+                        c2 = parsed[j + 1];
+                        break;
+                    }
+                }
+                double seg = c2[0] - c1[0];
+                if (seg < 1e-5) {
+                    r = (int) c1[1];
+                    g = (int) c1[2];
+                    b = (int) c1[3];
+                } else {
+                    double f = (t - c1[0]) / seg;
+                    r = (int) Math.round(c1[1] + f * (c2[1] - c1[1]));
+                    g = (int) Math.round(c1[2] + f * (c2[2] - c1[2]));
+                    b = (int) Math.round(c1[3] + f * (c2[3] - c1[3]));
+                }
+            } else {
+                double[] chosen = parsed[0];
+                for (double[] stop : parsed) {
+                    if (t >= stop[0]) {
+                        chosen = stop;
+                    } else {
+                        break;
+                    }
+                }
+                r = (int) chosen[1];
+                g = (int) chosen[2];
+                b = (int) chosen[3];
+            }
+            int idx = i * 4;
+            data[idx] = (byte) Math.max(0, Math.min(255, r));
+            data[idx + 1] = (byte) Math.max(0, Math.min(255, g));
+            data[idx + 2] = (byte) Math.max(0, Math.min(255, b));
+            data[idx + 3] = (byte) 255;
+        }
+
+        return data;
+    }
+}

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/SatelliteKtxDecoder.java

@@ -0,0 +1,75 @@
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.Nullable;
+
+/**
+ * JNI wrapper around Basis Universal KTX2 transcoder — parity with mapsgl {@code satelliteKtxWorker.js}.
+ */
+public final class SatelliteKtxDecoder {
+
+    static {
+        System.loadLibrary("aguacero_satellite_ktx");
+    }
+
+    public static final int DECODE_FLAGS_DEFAULT = 0;
+
+    /** Ordered ordinals from {@code basist::transcoder_texture_format}. */
+    public static final int TF_ETC2_RGBA = 1;
+
+    public static final int TF_ASTC_LDR_4x4_RGBA = 10;
+    public static final int TF_RGBA32 = 13;
+
+    private SatelliteKtxDecoder() {}
+
+    private static native byte[] nativeTranscodeKtx2(byte[] ktx2FileBytes, int decodeFlags);
+
+    @Nullable
+    public static byte[] transcodeKtx2(byte[] ktx2FileBytes) {
+        if (ktx2FileBytes == null || ktx2FileBytes.length == 0) return null;
+        return nativeTranscodeKtx2(ktx2FileBytes, DECODE_FLAGS_DEFAULT);
+    }
+
+    public static final class Parsed {
+        public final int width;
+        public final int height;
+        public final int basisFormatOrdinal;
+        public final byte[] payload;
+
+        Parsed(int width, int height, int basisFormatOrdinal, byte[] payload) {
+            this.width = width;
+            this.height = height;
+            this.basisFormatOrdinal = basisFormatOrdinal;
+            this.payload = payload;
+        }
+    }
+
+    @Nullable
+    public static Parsed parsePacked(@Nullable byte[] packed) {
+        if (packed == null || packed.length < 20) return null;
+        if (packed[0] != 'A' || packed[1] != 'G' || packed[2] != 'S' || packed[3] != '1') return null;
+        int width =
+                (packed[4] & 0xFF)
+                        | ((packed[5] & 0xFF) << 8)
+                        | ((packed[6] & 0xFF) << 16)
+                        | ((packed[7] & 0xFF) << 24);
+        int height =
+                (packed[8] & 0xFF)
+                        | ((packed[9] & 0xFF) << 8)
+                        | ((packed[10] & 0xFF) << 16)
+                        | ((packed[11] & 0xFF) << 24);
+        int fmt =
+                (packed[12] & 0xFF)
+                        | ((packed[13] & 0xFF) << 8)
+                        | ((packed[14] & 0xFF) << 16)
+                        | ((packed[15] & 0xFF) << 24);
+        int psz =
+                (packed[16] & 0xFF)
+                        | ((packed[17] & 0xFF) << 8)
+                        | ((packed[18] & 0xFF) << 16)
+                        | ((packed[19] & 0xFF) << 24);
+        if (psz <= 0 || 20 + psz > packed.length) return null;
+        byte[] payload = new byte[psz];
+        System.arraycopy(packed, 20, payload, 0, psz);
+        return new Parsed(width, height, fmt, payload);
+    }
+}