@aguacerowx/react-native 0.0.46 → 0.0.49

package/ios/RCTSatelliteLayerComponentView.mm

@@ -0,0 +1,97 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTViewComponentView.h>
+
+#import <react/renderer/components/AguaceroWxReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/AguaceroWxReactNativeSpec/Props.h>
+
+#if __has_include("aguacerowx_react_native-Swift.h")
+#import "aguacerowx_react_native-Swift.h"
+#else
+#import <aguacerowx_react_native/aguacerowx_react_native-Swift.h>
+#endif
+
+using namespace facebook::react;
+
+/**
+ * Fabric-only component view. Declared only in this .mm so it is not pulled into the
+ * Swift module umbrella (importing RCTViewComponentView.h there breaks C++ std scanning).
+ */
+@interface RCTSatelliteLayerComponentView : RCTViewComponentView
+@end
+
+@implementation RCTSatelliteLayerComponentView {
+    SatelliteLayerView *_satelliteView;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const SatelliteLayerProps>();
+        _props = defaultProps;
+
+        _satelliteView = [[SatelliteLayerView alloc] init];
+        [self setContentView:_satelliteView];
+    }
+    return self;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<SatelliteLayerComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+    const auto &oldSat = *std::static_pointer_cast<const SatelliteLayerProps>(_props);
+    const auto &newSat = *std::static_pointer_cast<const SatelliteLayerProps>(props);
+
+    if (oldSat.belowID != newSat.belowID) {
+        if (newSat.belowID.empty()) {
+            _satelliteView.belowID = nil;
+        } else {
+            _satelliteView.belowID = [NSString stringWithUTF8String:newSat.belowID.c_str()];
+        }
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+- (void)prepareForRecycle
+{
+    [_satelliteView clearSatellite];
+    [super prepareForRecycle];
+}
+
+#pragma mark - Commands (RendererProxy.dispatchCommand → Fabric)
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+    if ([commandName isEqualToString:@"syncSatellite"]) {
+        NSString *json = args.count > 0 ? [RCTConvert NSString:args[0]] : nil;
+        [_satelliteView syncFromJson:json];
+        return;
+    }
+    if ([commandName isEqualToString:@"clearSatellite"]) {
+        [_satelliteView clearSatellite];
+        return;
+    }
+    if ([commandName isEqualToString:@"activateSatelliteCachedUnix"]) {
+        double u = args.count > 0 ? [RCTConvert double:args[0]] : 0;
+        [_satelliteView activateSatelliteCachedUnix:(long long)u];
+        return;
+    }
+    if ([commandName isEqualToString:@"updateSatelliteStyle"]) {
+        NSString *json = args.count > 0 ? [RCTConvert NSString:args[0]] : nil;
+        [_satelliteView updateStyleFromJson:json];
+        return;
+    }
+}
+
+@end
+
+extern "C" Class<RCTComponentViewProtocol> SatelliteLayerCls(void)
+{
+    return RCTSatelliteLayerComponentView.class;
+}

package/ios/RadarFrameGpuMatch.swift

@@ -0,0 +1,162 @@
+import Foundation
+
+/// Port of Android `RadarFrameGpuMatch`.
+enum RadarFrameGpuMatch {
+
+    struct Result {
+        let gateData: Data
+        let rayBoundariesDeg: [Float]
+    }
+
+    private static func angularDistanceDeg(_ a: Double, _ b: Double) -> Double {
+        var d = abs(a - b).truncatingRemainder(dividingBy: 360.0)
+        if d > 180.0 { d = 360.0 - d }
+        return d
+    }
+
+    static func canonicalBinsRadarFrame(
+        nRays: Int,
+        nGates: Int,
+        gateData: Data,
+        rayBoundariesDeg: [Float]
+    ) -> Result {
+        if nRays <= 0 || nGates <= 0 || rayBoundariesDeg.count < nRays + 1 {
+            return Result(gateData: gateData, rayBoundariesDeg: rayBoundariesDeg)
+        }
+
+        let bytesPerRay = nGates * 2
+        let requiredBytes = nRays * bytesPerRay
+        guard gateData.count >= requiredBytes else {
+            print("⚠️ [RadarFrameGpuMatch] canonicalBins: gateData short \(gateData.count) need \(requiredBytes)")
+            return Result(gateData: gateData, rayBoundariesDeg: rayBoundariesDeg)
+        }
+
+        let degPerBin = 360.0 / Double(nRays)
+
+        var centers = [Double](repeating: 0, count: nRays)
+        for r in 0 ..< nRays {
+            let lower = Double(rayBoundariesDeg[r])
+            let upper = Double(rayBoundariesDeg[r + 1])
+            let center = (lower + upper) * 0.5
+            centers[r] = ((center.truncatingRemainder(dividingBy: 360.0)) + 360.0).truncatingRemainder(dividingBy: 360.0)
+        }
+
+        var buf = [UInt8](repeating: 0, count: nRays * bytesPerRay)
+        for i in stride(from: 0, to: buf.count, by: 2) {
+            buf[i] = 128
+            buf[i + 1] = 0
+        }
+
+        var used = [Bool](repeating: false, count: nRays)
+
+        let src = [UInt8](gateData)
+
+        for bin in 0 ..< nRays {
+            let targetDeg = (((Double(bin) + 0.5) * degPerBin).truncatingRemainder(dividingBy: 360.0) + 360.0)
+                .truncatingRemainder(dividingBy: 360.0)
+            var bestR = -1
+            var bestDist = Double.infinity
+
+            for r in 0 ..< nRays {
+                if used[r] { continue }
+                let dist = angularDistanceDeg(centers[r], targetDeg)
+                if dist < bestDist {
+                    bestDist = dist
+                    bestR = r
+                }
+            }
+
+            if bestR >= 0 {
+                used[bestR] = true
+                let srcOff = bestR * bytesPerRay
+                let dstOff = bin * bytesPerRay
+                for k in 0 ..< bytesPerRay {
+                    buf[dstOff + k] = src[srcOff + k]
+                }
+            }
+        }
+
+        let canonicalGateData = Data(buf)
+
+        var canonicalBoundaries = [Float](repeating: 0, count: nRays + 1)
+        for i in 0 ... nRays {
+            canonicalBoundaries[i] = Float(Double(i) * degPerBin)
+        }
+
+        return Result(gateData: canonicalGateData, rayBoundariesDeg: canonicalBoundaries)
+    }
+
+    static func sortRadarFrameByAzimuth(
+        nRays: Int,
+        nGates: Int,
+        gateData: Data,
+        rayBoundariesDeg: [Float]
+    ) -> Result {
+        if nRays <= 0 || nGates <= 0 || rayBoundariesDeg.count < nRays + 1 {
+            return Result(gateData: gateData, rayBoundariesDeg: rayBoundariesDeg)
+        }
+
+        let bytesPerRay = nGates * 2
+        let requiredBytes = nRays * bytesPerRay
+        guard gateData.count >= requiredBytes else {
+            print("⚠️ [RadarFrameGpuMatch] sortByAzimuth: gateData short \(gateData.count) need \(requiredBytes)")
+            return Result(gateData: gateData, rayBoundariesDeg: rayBoundariesDeg)
+        }
+
+        var rayOrder = Array(0 ..< nRays)
+        rayOrder.sort { rayBoundariesDeg[$0] < rayBoundariesDeg[$1] }
+
+        var sortedBoundaries = [Float](repeating: 0, count: nRays + 1)
+        let src = [UInt8](gateData)
+        var buf = [UInt8](repeating: 0, count: nRays * bytesPerRay)
+
+        for newIdx in 0 ..< nRays {
+            let oldIdx = rayOrder[newIdx]
+            let srcOff = oldIdx * bytesPerRay
+            let dstOff = newIdx * bytesPerRay
+            for k in 0 ..< bytesPerRay {
+                buf[dstOff + k] = src[srcOff + k]
+            }
+            sortedBoundaries[newIdx] = rayBoundariesDeg[oldIdx]
+        }
+
+        // Closing boundary: uses angular step between two rays — invalid indices when nRays < 2 (was crashing).
+        if nRays >= 2 {
+            sortedBoundaries[nRays] = rayBoundariesDeg[rayOrder[nRays - 1]]
+                + (rayBoundariesDeg[rayOrder[1]] - rayBoundariesDeg[rayOrder[0]])
+        } else {
+            sortedBoundaries[nRays] = rayBoundariesDeg.count > 1 ? rayBoundariesDeg[1] : rayBoundariesDeg[0] + 360.0
+        }
+
+        let sortedGateData = Data(buf)
+
+        return Result(gateData: sortedGateData, rayBoundariesDeg: sortedBoundaries)
+    }
+
+    static func prepareRadarFrameForGpuReadout(
+        nRays: Int,
+        nGates: Int,
+        gateData: Data,
+        rayBoundariesDeg: [Float],
+        geometryLayoutKey: String
+    ) -> Result {
+        let hasLayoutKey = !geometryLayoutKey.isEmpty
+        print(
+            "📡 [NEXRAD][iOS] RadarFrameGpuMatch.prepare path=\(hasLayoutKey ? "canonicalBins" : "sortByAzimuth") nRays=\(nRays) nGates=\(nGates) gateIn=\(gateData.count) raysIn=\(rayBoundariesDeg.count)"
+        )
+        if hasLayoutKey {
+            return canonicalBinsRadarFrame(
+                nRays: nRays,
+                nGates: nGates,
+                gateData: gateData,
+                rayBoundariesDeg: rayBoundariesDeg
+            )
+        }
+        return sortRadarFrameByAzimuth(
+            nRays: nRays,
+            nGates: nGates,
+            gateData: gateData,
+            rayBoundariesDeg: rayBoundariesDeg
+        )
+    }
+}

package/ios/RadarRayGeometryBuilder.swift

@@ -0,0 +1,132 @@
+import Foundation
+
+/// Port of Android `RadarRayGeometryBuilder` — polar radar mesh in tile-mercator (512) space.
+enum RadarRayGeometryBuilder {
+
+    struct Result {
+        let vertexFloats: [Float]
+        let vertexCount: Int
+        let anchorMercatorX: Float
+        let anchorMercatorY: Float
+    }
+
+    private static let tileMercUnits: Double = 512.0
+
+    private static func mercatorXFromLonDeg(_ lonDeg: Double) -> Double {
+        (lonDeg + 180.0) / 360.0
+    }
+
+    private static func mercatorYFromLatRad(_ latRad: Double) -> Double {
+        (1.0 - log(tan(Double.pi * 0.25 + latRad * 0.5)) / Double.pi) * 0.5
+    }
+
+    static func build(
+        nRays: Int,
+        nGates: Int,
+        stationLat: Double,
+        stationLon: Double,
+        firstGateKm: Float,
+        gateWidthKm: Float,
+        rayBoundariesDeg: [Float]
+    ) -> Result {
+        if nRays <= 0 || nGates <= 0 || rayBoundariesDeg.count < nRays + 1 {
+            return Result(vertexFloats: [], vertexCount: 0, anchorMercatorX: 0, anchorMercatorY: 0)
+        }
+
+        let vertsPerGate = 6
+        let floatsPerVertex = 4
+
+        let nearRangeM = Double(firstGateKm) * 1000.0
+        let farRangeM = (Double(firstGateKm) + Double(gateWidthKm) * Double(nGates)) * 1000.0
+
+        let totalFloats = nRays * nGates * vertsPerGate * floatsPerVertex
+        var out = [Float]()
+        out.reserveCapacity(totalFloats)
+
+        let anchorX = mercatorXFromLonDeg(stationLon)
+        let anchorY = mercatorYFromLatRad(stationLat * Double.pi / 180.0)
+
+        let lat1 = stationLat * Double.pi / 180.0
+        let lon1 = stationLon * Double.pi / 180.0
+        let sinLat1 = sin(lat1)
+        let cosLat1 = cos(lat1)
+        let R = 6378137.0
+
+        var sinD = [Double](repeating: 0, count: nGates + 1)
+        var cosD = [Double](repeating: 0, count: nGates + 1)
+        for g in 0 ... nGates {
+            let rM = nearRangeM + (farRangeM - nearRangeM) * (Double(g) / Double(nGates))
+            let dRad = rM / R
+            sinD[g] = sin(dRad)
+            cosD[g] = cos(dRad)
+        }
+
+        var sinB = [Double](repeating: 0, count: nRays + 1)
+        var cosB = [Double](repeating: 0, count: nRays + 1)
+        for rayIdx in 0 ... nRays {
+            let bRad = Double(rayBoundariesDeg[rayIdx]) * Double.pi / 180.0
+            sinB[rayIdx] = sin(bRad)
+            cosB[rayIdx] = cos(bRad)
+        }
+
+        var mercX = [Float](repeating: 0, count: (nGates + 1) * (nRays + 1))
+        var mercY = [Float](repeating: 0, count: (nGates + 1) * (nRays + 1))
+
+        for rayIdx in 0 ... nRays {
+            let sb = sinB[rayIdx]
+            let cb = cosB[rayIdx]
+            let rowOffset = rayIdx * (nGates + 1)
+            for g in 0 ... nGates {
+                let sd = sinD[g]
+                let cd = cosD[g]
+
+                let lat2 = asin(sinLat1 * cd + cosLat1 * sd * cb)
+                let lon2 = lon1 + atan2(sb * sd * cosLat1, cd - sinLat1 * sin(lat2))
+
+                let lonDeg = lon2 * (180.0 / Double.pi)
+                let dx = mercatorXFromLonDeg(lonDeg) - anchorX
+                let dy = mercatorYFromLatRad(lat2) - anchorY
+
+                let idx = rowOffset + g
+                mercX[idx] = Float(dx * tileMercUnits)
+                mercY[idx] = Float(dy * tileMercUnits)
+            }
+        }
+
+        for rayIdx in 0 ..< nRays {
+            let v0 = Float(rayIdx) / Float(nRays)
+            let v1 = Float(rayIdx + 1) / Float(nRays)
+            let row0 = rayIdx * (nGates + 1)
+            let row1 = (rayIdx + 1) * (nGates + 1)
+
+            for g in 0 ..< nGates {
+                let u0 = Float(g) / Float(nGates)
+                let u1 = Float(g + 1) / Float(nGates)
+
+                let nlX = mercX[row0 + g]
+                let nlY = mercY[row0 + g]
+                let nrX = mercX[row1 + g]
+                let nrY = mercY[row1 + g]
+                let flX = mercX[row0 + g + 1]
+                let flY = mercY[row0 + g + 1]
+                let frX = mercX[row1 + g + 1]
+                let frY = mercY[row1 + g + 1]
+
+                out.append(contentsOf: [nlX, nlY, u0, v0, nrX, nrY, u0, v1, flX, flY, u1, v0])
+                out.append(contentsOf: [nrX, nrY, u0, v1, frX, frY, u1, v1, flX, flY, u1, v0])
+            }
+        }
+
+        let vertCount = nRays * nGates * vertsPerGate
+        let outMb = Double(out.count * MemoryLayout<Float>.size) / 1024 / 1024
+        print(
+            "📡 [NEXRAD][iOS] RadarRayGeometryBuilder.build DONE verts=\(vertCount) floatCount=\(out.count) ~\(String(format: "%.1f", outMb)) MB anchor=(\(anchorX * tileMercUnits),\(anchorY * tileMercUnits))"
+        )
+        return Result(
+            vertexFloats: out,
+            vertexCount: vertCount,
+            anchorMercatorX: Float(anchorX * tileMercUnits),
+            anchorMercatorY: Float(anchorY * tileMercUnits)
+        )
+    }
+}

package/ios/SatelliteColormap.swift

@@ -0,0 +1,103 @@
+import Foundation
+
+/// Default satellite colormap RGBA bytes (256×1) — parity with Android {@code SatelliteColormap} / mapsgl defaults.
+enum SatelliteColormap {
+    static func defaultIrColormapRgba() -> Data {
+        let norms: [Double] = [5, 51, 52, 58, 64, 73, 78, 82, 88, 90, 96, 100]
+        let colors = [
+            "#000000", "#ffffff", "#00ffff", "#0033cc", "#33ff00", "#ffee00", "#ff0000",
+            "#660000", "#808080", "#cc66ff", "#9933cc", "#9933cc",
+        ]
+        return buildColormapFromStops(norms: norms, hexColors: colors, channelType: "IR", interpolate: true)
+    }
+
+    static func defaultWvColormapRgba() -> Data {
+        let norms: [Double] = [10, 20, 30, 45, 55, 70, 80, 90, 100]
+        let colors = [
+            "#cece55", "#ce5555", "#262626", "#ffffff", "#55cece", "#5555ce", "#4d3366", "#e673e6", "#efe6eb",
+        ]
+        return buildColormapFromStops(norms: norms, hexColors: colors, channelType: "WV", interpolate: true)
+    }
+
+    private static func buildColormapFromStops(
+        norms: [Double],
+        hexColors: [String],
+        channelType: String,
+        interpolate: Bool
+    ) -> Data {
+        let width = 256
+        var data = Data(count: width * 4)
+        guard norms.count == hexColors.count, !norms.isEmpty else {
+            return data
+        }
+
+        let minK = channelType == "WV" ? 183.0 : 180.0
+        let maxK = channelType == "WV" ? 288.0 : 330.0
+
+        var parsed: [(texCoord: Double, r: Double, g: Double, b: Double)] = []
+        for i in 0 ..< norms.count {
+            let normVal = norms[i]
+            let hex = hexColors[i]
+            guard hex.count >= 7 else { continue }
+            let r = Double(Int(hex.dropFirst(1).prefix(2), radix: 16) ?? 0)
+            let g = Double(Int(hex.dropFirst(3).prefix(2), radix: 16) ?? 0)
+            let b = Double(Int(hex.dropFirst(5).prefix(2), radix: 16) ?? 0)
+            let texCoord: Double
+            if channelType == "VIS" {
+                texCoord = normVal / 100.0
+            } else {
+                let fraction = normVal / 100.0
+                let kelvin = maxK - (fraction * (maxK - minK))
+                texCoord = (maxK - kelvin) / (maxK - minK)
+            }
+            parsed.append((texCoord, r, g, b))
+        }
+        parsed.sort { $0.texCoord < $1.texCoord }
+
+        data.withUnsafeMutableBytes { raw in
+            guard let ptr = raw.bindMemory(to: UInt8.self).baseAddress else { return }
+            for i in 0 ..< width {
+                let t = Double(i) / Double(width - 1)
+                var r: Double = 0
+                var g: Double = 0
+                var b: Double = 0
+                if interpolate {
+                    var c1 = parsed[0]
+                    var c2 = parsed[parsed.count - 1]
+                    for j in 0 ..< parsed.count - 1 {
+                        if t >= parsed[j].texCoord && t <= parsed[j + 1].texCoord {
+                            c1 = parsed[j]
+                            c2 = parsed[j + 1]
+                            break
+                        }
+                    }
+                    let seg = c2.texCoord - c1.texCoord
+                    if seg < 1e-5 {
+                        r = c1.r
+                        g = c1.g
+                        b = c1.b
+                    } else {
+                        let f = (t - c1.texCoord) / seg
+                        r = c1.r + f * (c2.r - c1.r)
+                        g = c1.g + f * (c2.g - c1.g)
+                        b = c1.b + f * (c2.b - c1.b)
+                    }
+                } else {
+                    var chosen = parsed[0]
+                    for stop in parsed where t >= stop.texCoord {
+                        chosen = stop
+                    }
+                    r = chosen.r
+                    g = chosen.g
+                    b = chosen.b
+                }
+                let idx = i * 4
+                ptr[idx] = UInt8(max(0, min(255, Int(round(r)))))
+                ptr[idx + 1] = UInt8(max(0, min(255, Int(round(g)))))
+                ptr[idx + 2] = UInt8(max(0, min(255, Int(round(b)))))
+                ptr[idx + 3] = 255
+            }
+        }
+        return data
+    }
+}

package/ios/SatelliteKtxBridge.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface AguaceroSatelliteKtxBridge : NSObject
++ (NSData *_Nullable)transcodeKtx2:(NSData *_Nonnull)ktxData;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SatelliteKtxBridge.mm

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+#import "SatelliteKtxBridge.h"
+#import "aguacero_satellite_ktx.h"
+
+@implementation AguaceroSatelliteKtxBridge
+
++ (NSData *_Nullable)transcodeKtx2:(NSData *_Nonnull)ktxData {
+    if (ktxData.length == 0) {
+        NSLog(@"🛰️ [AguaceroSatelliteKtxBridge] transcodeKtx2: empty input");
+        return nil;
+    }
+    size_t outLen = 0;
+    const uint8_t *bytes = (const uint8_t *)ktxData.bytes;
+    uint8_t *packed = aguacero_satellite_transcode_ktx2(bytes, ktxData.length, &outLen);
+    if (packed == NULL || outLen == 0) {
+        NSLog(@"🛰️ [AguaceroSatelliteKtxBridge] transcodeKtx2: basis_transcode failed (inLen=%lu packed=%p outLen=%zu)", (unsigned long)ktxData.length, packed, outLen);
+        aguacero_satellite_ktx_free(packed);
+        return nil;
+    }
+    NSData *result = [NSData dataWithBytesNoCopy:packed length:outLen freeWhenDone:YES];
+    return result;
+}
+
+@end