@aguacerowx/react-native 0.0.46 → 0.0.49

package/ios/SatelliteMeshBuilder.swift

@@ -0,0 +1,204 @@
+import Foundation
+import JavaScriptCore
+
+private final class SatelliteMeshBundleMarker: NSObject {}
+
+/// GEOS satellite mesh — parity with Android {@link SatelliteMeshBuilder}.
+enum SatelliteMeshBuilder {
+
+    struct MeshResult {
+        let vertices: [Float]
+        let indices: [UInt32]
+        let indexCount: Int
+    }
+
+    struct CustomProj {
+        let h: Double
+        let lon0: Double
+        let xOff: Double
+        let yOff: Double
+        let xScale: Double
+        let yScale: Double
+    }
+
+    private static let meshQueue = DispatchQueue(label: "com.aguacero.satellite-mesh", qos: .userInitiated)
+    private static let goesConusExtentM: [Double] = [-3627020.7, 1583424.2, 1382521.8, 4588949.1]
+
+    private static var jsContext: JSContext?
+    private static let jsLock = NSLock()
+
+    private static func projStringCompatibleWithProj4j(_ proj: String) -> String {
+        proj.replacingOccurrences(of: "\\s*\\+sweep=[^\\s]+", with: "", options: .regularExpression)
+    }
+
+    private static func mercatorXFromLng(_ lng: Double) -> Double {
+        (180.0 + lng) / 360.0
+    }
+
+    private static func mercatorYFromLat(_ lat: Double) -> Double {
+        let clamped = max(-85.05112878, min(85.05112878, lat))
+        let sin = sin(clamped * .pi / 180.0)
+        return 0.5 - log((1.0 + sin) / (1.0 - sin)) / (4.0 * .pi)
+    }
+
+    private static func parseProjectionFromFileName(_ fileName: String?) -> CustomProj? {
+        guard let fileName, !fileName.isEmpty else { return nil }
+        let pattern = "_proj_([-\\d\\.eE]+)_([-\\d\\.eE]+)_([-\\d\\.eE]+)"
+        guard let re = try? NSRegularExpression(pattern: pattern) else { return nil }
+        let range = NSRange(fileName.startIndex..., in: fileName)
+        guard let m = re.firstMatch(in: fileName, range: range),
+              m.numberOfRanges >= 4,
+              let r1 = Range(m.range(at: 1), in: fileName),
+              let r2 = Range(m.range(at: 2), in: fileName),
+              let r3 = Range(m.range(at: 3), in: fileName),
+              let scale = Double(fileName[r3])
+        else { return nil }
+        return CustomProj(
+            h: 35786023.0,
+            lon0: -75.0,
+            xOff: Double(fileName[r1]) ?? 0,
+            yOff: Double(fileName[r2]) ?? 0,
+            xScale: scale,
+            yScale: -scale
+        )
+    }
+
+    private static func ensureContext() -> JSContext? {
+        jsLock.lock()
+        defer { jsLock.unlock() }
+        if let jsContext { return jsContext }
+        let ctx = JSContext()!
+        guard let bundleUrl = Bundle(for: SatelliteMeshBundleMarker.self).url(forResource: "proj4", withExtension: "js")
+            ?? Bundle.main.url(forResource: "proj4", withExtension: "js") else {
+            return nil
+        }
+        guard let src = try? String(contentsOf: bundleUrl, encoding: .utf8) else { return nil }
+        ctx.exceptionHandler = { _, err in
+            _ = err
+        }
+        ctx.evaluateScript(src)
+        ctx.evaluateScript(
+            """
+            function __agu_sat_forward(projString, x, y) {
+              var ps = projString.replace(/\\s*\\+sweep=[^\\s]+/g, '');
+              var tr = proj4(ps, 'WGS84');
+              var o = tr.forward([x, y]);
+              return [o[0], o[1]];
+            }
+            """
+        )
+        jsContext = ctx
+        return ctx
+    }
+
+    private static func forwardProj(_ projString: String, x: Double, y: Double) -> (lon: Double, lat: Double)? {
+        guard let ctx = ensureContext(),
+              let fn = ctx.objectForKeyedSubscript("__agu_sat_forward"),
+              let res = fn.call(withArguments: [projString, x, y]),
+              let arr = res.toArray() as? [Double],
+              arr.count >= 2
+        else { return nil }
+        return (arr[0], arr[1])
+    }
+
+    /// Must run on {@code meshQueue}.
+    private static func buildMeshUnsafe(shaderFileName: String?, fullWidth: Int, fullHeight: Int) -> MeshResult? {
+        let fn = shaderFileName ?? ""
+        var meshSubdivisions = 50
+        var projString = "+proj=geos +h=35786023.0 +lon_0=-75.0 +sweep=x +no_defs"
+        var extent = goesConusExtentM
+        var isMesoscale = false
+
+        if fn.hasPrefix("F_") || fn.contains("MCMIPF") || fn.contains("CMIPF") {
+            projString = "+proj=geos +h=35786023.0 +lon_0=-75.0 +sweep=x +no_defs"
+            extent = [-5434894.885056, -5434894.885056, 5434894.885056, 5434894.885056]
+            meshSubdivisions = 100
+        } else if fn.hasPrefix("M1_") || fn.hasPrefix("M2_") || fn.contains("MCMIPM") || fn.contains("CMIPM") {
+            isMesoscale = true
+            meshSubdivisions = 30
+        }
+
+        if let cp = parseProjectionFromFileName(shaderFileName) {
+            let xMinRad = cp.xOff
+            let xMaxRad = cp.xOff + (Double(fullWidth) * cp.xScale)
+            let yMinRad = cp.yOff + (Double(fullHeight) * cp.yScale)
+            let yMaxRad = cp.yOff
+            extent = [
+                min(xMinRad, xMaxRad) * cp.h,
+                min(yMinRad, yMaxRad) * cp.h,
+                max(xMinRad, xMaxRad) * cp.h,
+                max(yMinRad, yMaxRad) * cp.h,
+            ]
+            projString =
+                "+proj=geos +h=\(cp.h) +lon_0=\(cp.lon0) +sweep=x +no_defs"
+        } else if isMesoscale {
+            // Mesoscale without proj metadata — match Android warning + GOES defaults.
+        }
+
+        let projForJvm = projStringCompatibleWithProj4j(projString)
+        let tileSize = 512.0
+
+        let xMin = extent[0]
+        let yMin = extent[1]
+        let xMax = extent[2]
+        let yMax = extent[3]
+
+        var vertices: [Float] = []
+        vertices.reserveCapacity((meshSubdivisions + 1) * (meshSubdivisions + 1) * 4)
+
+        for row in 0 ... meshSubdivisions {
+            for col in 0 ... meshSubdivisions {
+                let u = Double(col) / Double(meshSubdivisions)
+                let v = Double(row) / Double(meshSubdivisions)
+                let projX = xMin + u * (xMax - xMin)
+                let projY = yMax - v * (yMax - yMin)
+
+                if let ll = forwardProj(projForJvm, x: projX, y: projY) {
+                    let lon = ll.lon
+                    let lat = ll.lat
+                    if abs(lon) > 180 || abs(lat) > 90 {
+                        vertices.append(contentsOf: [Float.nan, Float.nan, Float.nan, Float.nan])
+                    } else {
+                        let mx = Float(mercatorXFromLng(lon) * tileSize)
+                        let my = Float(mercatorYFromLat(lat) * tileSize)
+                        vertices.append(contentsOf: [mx, my, Float(u), Float(v)])
+                    }
+                } else {
+                    vertices.append(contentsOf: [Float.nan, Float.nan, Float.nan, Float.nan])
+                }
+            }
+        }
+
+        let vertsPerRow = meshSubdivisions + 1
+        var indices: [UInt32] = []
+
+        for row in 0 ..< meshSubdivisions {
+            for col in 0 ..< meshSubdivisions {
+                let i00 = row * vertsPerRow + col
+                let i10 = i00 + 1
+                let i01 = (row + 1) * vertsPerRow + col
+                let i11 = i01 + 1
+
+                let base = i00 * 4
+                let ok =
+                    !vertices[base].isNaN
+                    && !vertices[i10 * 4].isNaN
+                    && !vertices[i01 * 4].isNaN
+                    && !vertices[i11 * 4].isNaN
+                if ok {
+                    indices.append(contentsOf: [UInt32(i00), UInt32(i01), UInt32(i10), UInt32(i10), UInt32(i01), UInt32(i11)])
+                }
+            }
+        }
+
+        return MeshResult(vertices: vertices, indices: indices, indexCount: indices.count)
+    }
+
+    static func buildMesh(shaderFileName: String?, width: Int, height: Int) -> MeshResult? {
+        var out: MeshResult?
+        meshQueue.sync {
+            out = buildMeshUnsafe(shaderFileName: shaderFileName, fullWidth: width, fullHeight: height)
+        }
+        return out
+    }
+}

package/ios/Shaders.metal

@@ -317,4 +317,174 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
 
     float final_alpha = color.a * uniforms.opacity * alpha_multiplier;
     return float4(color.rgb * final_alpha, final_alpha);
+}
+
+// MARK: - NEXRAD (Android GLES parity — see nexrad_fragment.glsl)
+
+struct NexradRasterizerData {
+    float4 position [[position]];
+    float2 uv;
+};
+
+struct NexradFragmentUniforms {
+    float2 texture_size;
+    float2 value_scale_offset;
+    float2 lut_value_range;
+    float discrete_integer_lut;
+    float opacity;
+    float gate_smooth_polar;
+    /// Constant-buffer packing rounds struct size to 40 bytes; Swift must upload 40 bytes (see NexradRadarLayer).
+    float _pad;
+};
+
+vertex NexradRasterizerData nexrad_vertex_main(const Vertex in [[stage_in]],
+                                               constant float4x4 &mvp [[buffer(1)]]) {
+    NexradRasterizerData out;
+    out.position = mvp * float4(in.position, 0.0, 1.0);
+    out.uv = in.texCoord;
+    return out;
+}
+
+static float nexrad_decode_int16(float2 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;
+}
+
+static float nexrad_sample_gate_raw_bilinear(texture2d<float, access::sample> gateTex,
+                                             sampler gateSampler,
+                                             float2 gxy,
+                                             float2 sz) {
+    float x_px = gxy.x * sz.x - 0.5;
+    float y_px = gxy.y * sz.y - 0.5;
+    float2 i0 = floor(float2(x_px, y_px));
+    float2 f = float2(x_px, y_px) - i0;
+    float2 i1 = i0 + 1.0;
+    i0.x = clamp(i0.x, 0.0, sz.x - 1.0);
+    i1.x = clamp(i1.x, 0.0, sz.x - 1.0);
+    i0.y = fmod(i0.y + sz.y, sz.y);
+    i1.y = fmod(i1.y + sz.y, sz.y);
+    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;
+    float2 invSz = 1.0 / sz;
+
+    float2 c00 = (i0 + 0.5) * invSz;
+    float2 c10 = (float2(i1.x, i0.y) + 0.5) * invSz;
+    float2 c01 = (float2(i0.x, i1.y) + 0.5) * invSz;
+    float2 c11 = (i1 + 0.5) * invSz;
+
+    float4 p00 = gateTex.sample(gateSampler, c00);
+    float4 p10 = gateTex.sample(gateSampler, c10);
+    float4 p01 = gateTex.sample(gateSampler, c01);
+    float4 p11 = gateTex.sample(gateSampler, c11);
+
+    float r00 = nexrad_decode_int16(float2(p00.r, p00.g));
+    float r10 = nexrad_decode_int16(float2(p10.r, p10.g));
+    float r01 = nexrad_decode_int16(float2(p01.r, p01.g));
+    float r11 = nexrad_decode_int16(float2(p11.r, p11.g));
+
+    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;
+}
+
+static float nexrad_sample_gate_raw_nearest(texture2d<float, access::sample> gateTex,
+                                            sampler gateSampler,
+                                            float2 gxy,
+                                            float2 sz) {
+    float2 px = gxy * sz;
+    float2 i = floor(px);
+    i.x = clamp(i.x, 0.0, sz.x - 1.0);
+    i.y = fmod(i.y + sz.y, sz.y);
+    float2 coord = (i + 0.5) / sz;
+    float4 p = gateTex.sample(gateSampler, coord);
+    return nexrad_decode_int16(float2(p.r, p.g));
+}
+
+fragment float4 nexrad_fragment_main(NexradRasterizerData in [[stage_in]],
+                                     constant NexradFragmentUniforms &u [[buffer(0)]],
+                                     texture2d<float, access::sample> gateTex [[texture(0)]],
+                                     texture2d<float, access::sample> lutTex [[texture(1)]],
+                                     sampler gateSampler [[sampler(0)]],
+                                     sampler lutSampler [[sampler(1)]]) {
+    float raw;
+    if (u.gate_smooth_polar < 0.5) {
+        raw = nexrad_sample_gate_raw_nearest(gateTex, gateSampler, in.uv, u.texture_size);
+    } else {
+        raw = nexrad_sample_gate_raw_bilinear(gateTex, gateSampler, in.uv, u.texture_size);
+    }
+    if (raw <= -32768.0) {
+        discard_fragment();
+    }
+
+    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_fragment();
+    }
+
+    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);
+    float4 color = lutTex.sample(lutSampler, float2(lutT, 0.5));
+    if (color.a <= 0.001) {
+        discard_fragment();
+    }
+    return float4(color.rgb, color.a * u.opacity);
+}
+
+// MARK: - Satellite (Android OpenGL SatelliteLayer parity)
+
+struct SatelliteRasterizerData {
+    float4 position [[position]];
+    float2 texCoord;
+};
+
+struct SatelliteFragmentUniforms {
+    float opacity;
+    int is_true_color;
+    int use_colormap;
+    float _pad;
+};
+
+vertex SatelliteRasterizerData satellite_vertex_main(const Vertex in [[stage_in]],
+                                                   constant float4x4 &mvp [[buffer(1)]]) {
+    SatelliteRasterizerData out;
+    out.position = mvp * float4(in.position, 0.0, 1.0);
+    out.texCoord = in.texCoord;
+    return out;
+}
+
+fragment float4 satellite_fragment_main(SatelliteRasterizerData in [[stage_in]],
+                                        constant SatelliteFragmentUniforms &u [[buffer(0)]],
+                                        texture2d<float, access::sample> satTex [[texture(0)]],
+                                        texture2d<float, access::sample> cmapTex [[texture(1)]],
+                                        sampler satSampler [[sampler(0)]],
+                                        sampler cmapSampler [[sampler(1)]]) {
+    float4 texColor = satTex.sample(satSampler, in.texCoord);
+    float3 rawColor = texColor.rgb;
+    if (u.is_true_color != 0) {
+        return float4(rawColor, texColor.a * u.opacity);
+    }
+    float luminance = rawColor.r;
+    if (u.use_colormap != 0) {
+        float intensity = clamp(luminance, 0.0, 1.0);
+        float3 colorMapped = cmapTex.sample(cmapSampler, float2(intensity, 0.5)).rgb;
+        return float4(colorMapped, u.opacity);
+    }
+    float val = clamp(luminance * 1.7, 0.0, 1.0);
+    return float4(val, val, val, u.opacity);
 }

package/ios/WeatherFrameProcessorModule.swift

@@ -25,10 +25,8 @@ class WeatherFrameProcessorModule: NSObject {
 
     @objc(cancelAllFrames)
     func cancelAllFrames() {
-        print("⚡️ [PERF] [WeatherFrameProcessor] CancelAllFrames called. RAM: \(getMemoryUsage())")
-        // Incrementing the token effectively cancels any in-flight tasks
-        // as they will check their token against the new value upon completion.
         currentRunToken += 1
+        print("🔍 [WeatherFrameProcessor] cancelAllFrames → new runToken=\(currentRunToken) (in-flight fetches will reject with E_CANCELLED). RAM: \(getMemoryUsage())")
     }
 
     @objc(processFrame:resolver:rejecter:)
@@ -37,43 +35,67 @@ class WeatherFrameProcessorModule: NSObject {
         let startTime = CFAbsoluteTimeGetCurrent()
 
         guard let urlString = options["url"] as? String, let url = URL(string: urlString) else {
+            print("🔍 [WeatherFrameProcessor] processFrame REJECT invalid url options=\(options.keys.sorted())")
             reject("INVALID_URL", "The provided URL is not valid.", nil)
             return
         }
         
         // Extract filename for log identification
         let fileId = url.lastPathComponent
-        print("⚡️ [PERF] [WeatherFrameProcessor] START Fetch: \(fileId) | RAM: \(getMemoryUsage())")
+        print("🔍 [WeatherFrameProcessor] processFrame START fileId=\(fileId) host=\(url.host ?? "?") runToken=\(taskToken) RAM=\(getMemoryUsage())")
 
         let apiKey = options["apiKey"] as? String ?? ""
         let bundleId = options["bundleId"] as? String
 
         var request = URLRequest(url: url)
         request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
-        if let bundleId = bundleId {
+        if let bundleId = bundleId, !bundleId.isEmpty {
             request.setValue(bundleId, forHTTPHeaderField: "x-app-identifier")
         }
+        if let site = options["gridRequestSiteOrigin"] as? String {
+            var origin = site.trimmingCharacters(in: .whitespacesAndNewlines)
+            while origin.hasSuffix("/") {
+                origin.removeLast()
+            }
+            if !origin.isEmpty {
+                request.setValue(origin, forHTTPHeaderField: "Origin")
+                request.setValue("\(origin)/", forHTTPHeaderField: "Referer")
+            }
+        }
 
         let task = session.dataTask(with: request) { data, response, error in
             let fetchDuration = (CFAbsoluteTimeGetCurrent() - startTime) * 1000
-            
-            if self.currentRunToken != taskToken {
+
+            // Must reject so JS `await processFrame` does not hang forever (otherwise WeatherLayerManager
+            // leaves hasPreloadedRef stuck and grid data never loads after cancelAllFrames).
+            let finishCancelled = {
                 print("⚡️ [PERF] [WeatherFrameProcessor] CANCELLED: \(fileId) after \(String(format: "%.2f", fetchDuration))ms")
+                DispatchQueue.main.async {
+                    reject("E_CANCELLED", "Weather frame fetch superseded", nil)
+                }
+            }
+
+            if self.currentRunToken != taskToken {
+                print("🔍 [WeatherFrameProcessor] \(fileId) aborted: runToken mismatch (task=\(taskToken) current=\(self.currentRunToken)) → E_CANCELLED")
+                finishCancelled()
                 return
             }
 
             if let error = error {
+                print("🔍 [WeatherFrameProcessor] \(fileId) NETWORK_ERROR: \(error.localizedDescription)")
                 reject("NETWORK_ERROR", "Failed to fetch frame data: \(error.localizedDescription)", error)
                 return
             }
 
             guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
                 let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+                print("🔍 [WeatherFrameProcessor] \(fileId) HTTP_ERROR status=\(statusCode)")
                 reject("HTTP_ERROR", "HTTP request failed with status code: \(statusCode)", nil)
                 return
             }
 
             guard let data = data else {
+                print("🔍 [WeatherFrameProcessor] \(fileId) NO_DATA")
                 reject("NO_DATA", "The server returned no data.", nil)
                 return
             }
@@ -84,6 +106,7 @@ class WeatherFrameProcessorModule: NSObject {
                 // 1. JSON Parsing
                 let jsonStart = CFAbsoluteTimeGetCurrent()
                 guard let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
+                    print("🔍 [WeatherFrameProcessor] \(fileId) INVALID_RESPONSE: top-level JSON not object")
                     reject("INVALID_RESPONSE", "The API response format was invalid JSON.", nil)
                     return
                 }
@@ -94,6 +117,8 @@ class WeatherFrameProcessorModule: NSObject {
                       let scale = encoding["scale"] as? NSNumber,
                       let offset = encoding["offset"] as? NSNumber,
                       let missing = encoding["missing_quantized"] as? NSNumber else {
+                    let encKeys = (jsonResponse["encoding"] as? [String: Any])?.keys.sorted() ?? []
+                    print("🔍 [WeatherFrameProcessor] \(fileId) INVALID_RESPONSE: keys=\(Array(jsonResponse.keys).sorted()) encodingKeys=\(encKeys)")
                     reject("INVALID_RESPONSE", "The API response format was invalid structure.", nil)
                     return
                 }
@@ -101,6 +126,7 @@ class WeatherFrameProcessorModule: NSObject {
                 // 2. Base64 Decoding
                 let decodeStart = CFAbsoluteTimeGetCurrent()
                 guard let compressedData = Data(base64Encoded: b64CompressedData) else {
+                    print("🔍 [WeatherFrameProcessor] \(fileId) DECODING_ERROR: base64 decode failed (b64 len=\(b64CompressedData.count))")
                     reject("DECODING_ERROR", "Failed to decode base64 data string.", nil)
                     return
                 }
@@ -137,12 +163,22 @@ class WeatherFrameProcessorModule: NSObject {
                    - RAM End: \(self.getMemoryUsage())
                 """)
 
-                resolve(responseMap)
+                if self.currentRunToken != taskToken {
+                    print("🔍 [WeatherFrameProcessor] \(fileId) discarded after disk write: runToken mismatch before resolve")
+                    finishCancelled()
+                    return
+                }
+                DispatchQueue.main.async {
+                    print("🔍 [WeatherFrameProcessor] \(fileId) RESOLVE ok path=\(dataFile.path)")
+                    resolve(responseMap)
+                }
 
             } catch {
+                print("🔍 [WeatherFrameProcessor] \(fileId) PROCESSING_ERROR: \(error.localizedDescription)")
                 reject("PROCESSING_ERROR", "Failed to process the frame data: \(error.localizedDescription)", error)
             }
         }
+        print("🔍 [WeatherFrameProcessor] \(fileId) URLSession.dataTask.resume() (runToken=\(taskToken))")
         task.resume()
     }
     

package/ios/aguacero-sdks.code-workspace

@@ -0,0 +1,11 @@
+{
+	"folders": [
+		{
+			"path": "../../.."
+		},
+		{
+			"path": "../../../../aguacero-testing-local"
+		}
+	],
+	"settings": {}
+}

package/ios/cpp/aguacero_satellite_ktx.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Transcodes KTX2 bytes to packed `AGS1` format (same layout as Android JNI).
+/// Returns malloc-allocated buffer; caller must free with `aguacero_satellite_ktx_free`.
+/// Returns NULL on failure.
+uint8_t *aguacero_satellite_transcode_ktx2(const uint8_t *ktx_data, size_t ktx_len, size_t *out_size);
+
+void aguacero_satellite_ktx_free(uint8_t *ptr);
+
+#ifdef __cplusplus
+}
+#endif