@aguacerowx/react-native 0.0.33 → 0.0.35

package/lib/module/ios/GridRenderLayer.swift

@@ -695,8 +695,21 @@ public class GridRenderLayer: NSObject {
         let lat_span = lat_last - lat_first
         let isSouthToNorth = lat_span > 0
 
-        let data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
-        let data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
+        // Check if this is ECMWF and normalize longitudes
+        let isECMWF = isECMWFType(gridParams: gridParams)
+        var data_lon_first_180 = lon_first
+        var data_lon_last_180 = lon_last
+
+        if isECMWF {
+            // Convert ECMWF's 180 to -180 range to -180 to 180
+            data_lon_first_180 = lon_first >= 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last >= 180 ? lon_last - 360 : lon_last
+        } else {
+            // For GFS and other models
+            data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
+        }
+
         let data_lon_range = data_lon_last_180 - data_lon_first_180
 
         let subdivisions_x = 120
@@ -705,7 +718,7 @@ public class GridRenderLayer: NSObject {
         let TILE_SIZE: Double = 512.0
 
         let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]
-        
+
         for world_copy in worldCopies {
             let vertexStartIndex = UInt16(vertices.count / 4)
             let lon_offset = Double(world_copy) * 360.0
@@ -755,6 +768,11 @@ public class GridRenderLayer: NSObject {
         return (gridParams["lon_first"] as? Double) == 0.0 &&
                abs((gridParams["lat_first"] as? Double) ?? -1) == 90.0
     }
+
+    private func isECMWFType(gridParams: [String: Any]) -> Bool {
+        return (gridParams["lon_first"] as? Double) == 180.0 &&
+            (gridParams["lat_first"] as? Double) == 90.0
+    }
     
     private func lonLatToMercator(lon: Double, lat: Double, tileSize: Double) -> (x: Float, y: Float) {
         let mercX_normalized = (lon + 180.0) / 360.0

package/lib/module/ios/Shaders.metal

@@ -116,7 +116,7 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
         float2 v11_coord = (bl_texel_index + float2(1.5, 1.5)) * texel_size;
 
         if (uniforms.isPtype == 1) {
-            // --- PTYPE-SPECIFIC INTERPOLATION (CATEGORICAL) ---
+            // --- ENHANCED PTYPE-SPECIFIC INTERPOLATION ---
             float v00 = dequantize_val(get_value(dataTexture, dataSampler, v00_coord, uniforms), uniforms);
             float v10 = dequantize_val(get_value(dataTexture, dataSampler, v10_coord, uniforms), uniforms);
             float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
@@ -127,25 +127,162 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
             float p01 = get_ptype_from_physical(v01, uniforms);
             float p11 = get_ptype_from_physical(v11, uniforms);
 
-            // Determine the dominant precipitation type for this pixel
-            float dominant_ptype = -1.0;
-            if (p00 != -1.0) dominant_ptype = p00;
-            else if (p10 != -1.0) dominant_ptype = p10;
-            else if (p01 != -1.0) dominant_ptype = p01;
-            else if (p11 != -1.0) dominant_ptype = p11;
+            // Count unique valid precipitation types
+            bool has_type_0 = false;
+            bool has_type_1 = false;
+            bool has_type_2 = false;
+            bool has_type_3 = false;
+            int valid_count = 0;
             
-            if (dominant_ptype == -1.0) discard_fragment();
-
-            // Interpolate ONLY the values that match the dominant ptype
-            float total_value = 0.0;
-            float total_weight = 0.0;
-            if (p00 == dominant_ptype) { float w = (1.0-f.x)*(1.0-f.y); total_value+=v00*w; total_weight+=w; }
-            if (p10 == dominant_ptype) { float w = f.x*(1.0-f.y);       total_value+=v10*w; total_weight+=w; }
-            if (p01 == dominant_ptype) { float w = (1.0-f.x)*f.y;       total_value+=v01*w; total_weight+=w; }
-            if (p11 == dominant_ptype) { float w = f.x*f.y;             total_value+=v11*w; total_weight+=w; }
-
-            if (total_weight <= 0.0) discard_fragment();
-            raw_value = total_value / total_weight;
+            if (p00 >= 0.0) { 
+                int ptype = int(p00);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p10 >= 0.0) { 
+                int ptype = int(p10);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p01 >= 0.0) { 
+                int ptype = int(p01);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p11 >= 0.0) { 
+                int ptype = int(p11);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            
+            if (valid_count == 0) discard_fragment();
+            
+            // Count how many unique types we have
+            int unique_types = 0;
+            if (has_type_0) unique_types++;
+            if (has_type_1) unique_types++;
+            if (has_type_2) unique_types++;
+            if (has_type_3) unique_types++;
+            
+            if (unique_types == 1) {
+                // ALL SAME TYPE - smooth interpolation across all valid pixels
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 >= 0.0) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 >= 0.0) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 >= 0.0) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+                
+            } else {
+                // MULTIPLE TYPES - weighted voting to determine dominant type
+                float type_weight_0 = 0.0;
+                float type_weight_1 = 0.0;
+                float type_weight_2 = 0.0;
+                float type_weight_3 = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float w = (1.0 - f.x) * (1.0 - f.y);
+                    int ptype = int(p00);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p10 >= 0.0) {
+                    float w = f.x * (1.0 - f.y);
+                    int ptype = int(p10);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p01 >= 0.0) {
+                    float w = (1.0 - f.x) * f.y;
+                    int ptype = int(p01);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p11 >= 0.0) {
+                    float w = f.x * f.y;
+                    int ptype = int(p11);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                
+                // Find the type with the highest weight at this pixel location
+                float max_type_weight = 0.0;
+                float winning_type = -1.0;
+                if (type_weight_0 > max_type_weight) { max_type_weight = type_weight_0; winning_type = 0.0; }
+                if (type_weight_1 > max_type_weight) { max_type_weight = type_weight_1; winning_type = 1.0; }
+                if (type_weight_2 > max_type_weight) { max_type_weight = type_weight_2; winning_type = 2.0; }
+                if (type_weight_3 > max_type_weight) { max_type_weight = type_weight_3; winning_type = 3.0; }
+                
+                if (winning_type == -1.0) discard_fragment();
+                
+                // Now smoothly interpolate only among pixels of the winning type
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 == winning_type) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 == winning_type) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 == winning_type) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 == winning_type) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+            }
             
             // Force full alpha to prevent dark borders between ptype regions
             alpha_multiplier = 1.0;

package/lib/module/lib/commonjs/ios/GridRenderLayer.swift

@@ -695,8 +695,21 @@ public class GridRenderLayer: NSObject {
         let lat_span = lat_last - lat_first
         let isSouthToNorth = lat_span > 0
 
-        let data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
-        let data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
+        // Check if this is ECMWF and normalize longitudes
+        let isECMWF = isECMWFType(gridParams: gridParams)
+        var data_lon_first_180 = lon_first
+        var data_lon_last_180 = lon_last
+
+        if isECMWF {
+            // Convert ECMWF's 180 to -180 range to -180 to 180
+            data_lon_first_180 = lon_first >= 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last >= 180 ? lon_last - 360 : lon_last
+        } else {
+            // For GFS and other models
+            data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
+        }
+
         let data_lon_range = data_lon_last_180 - data_lon_first_180
 
         let subdivisions_x = 120
@@ -705,7 +718,7 @@ public class GridRenderLayer: NSObject {
         let TILE_SIZE: Double = 512.0
 
         let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]
-        
+
         for world_copy in worldCopies {
             let vertexStartIndex = UInt16(vertices.count / 4)
             let lon_offset = Double(world_copy) * 360.0
@@ -755,6 +768,11 @@ public class GridRenderLayer: NSObject {
         return (gridParams["lon_first"] as? Double) == 0.0 &&
                abs((gridParams["lat_first"] as? Double) ?? -1) == 90.0
     }
+
+    private func isECMWFType(gridParams: [String: Any]) -> Bool {
+        return (gridParams["lon_first"] as? Double) == 180.0 &&
+            (gridParams["lat_first"] as? Double) == 90.0
+    }
     
     private func lonLatToMercator(lon: Double, lat: Double, tileSize: Double) -> (x: Float, y: Float) {
         let mercX_normalized = (lon + 180.0) / 360.0

package/lib/module/lib/commonjs/ios/Shaders.metal

@@ -116,7 +116,7 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
         float2 v11_coord = (bl_texel_index + float2(1.5, 1.5)) * texel_size;
 
         if (uniforms.isPtype == 1) {
-            // --- PTYPE-SPECIFIC INTERPOLATION (CATEGORICAL) ---
+            // --- ENHANCED PTYPE-SPECIFIC INTERPOLATION ---
             float v00 = dequantize_val(get_value(dataTexture, dataSampler, v00_coord, uniforms), uniforms);
             float v10 = dequantize_val(get_value(dataTexture, dataSampler, v10_coord, uniforms), uniforms);
             float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
@@ -127,25 +127,162 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
             float p01 = get_ptype_from_physical(v01, uniforms);
             float p11 = get_ptype_from_physical(v11, uniforms);
 
-            // Determine the dominant precipitation type for this pixel
-            float dominant_ptype = -1.0;
-            if (p00 != -1.0) dominant_ptype = p00;
-            else if (p10 != -1.0) dominant_ptype = p10;
-            else if (p01 != -1.0) dominant_ptype = p01;
-            else if (p11 != -1.0) dominant_ptype = p11;
+            // Count unique valid precipitation types
+            bool has_type_0 = false;
+            bool has_type_1 = false;
+            bool has_type_2 = false;
+            bool has_type_3 = false;
+            int valid_count = 0;
             
-            if (dominant_ptype == -1.0) discard_fragment();
-
-            // Interpolate ONLY the values that match the dominant ptype
-            float total_value = 0.0;
-            float total_weight = 0.0;
-            if (p00 == dominant_ptype) { float w = (1.0-f.x)*(1.0-f.y); total_value+=v00*w; total_weight+=w; }
-            if (p10 == dominant_ptype) { float w = f.x*(1.0-f.y);       total_value+=v10*w; total_weight+=w; }
-            if (p01 == dominant_ptype) { float w = (1.0-f.x)*f.y;       total_value+=v01*w; total_weight+=w; }
-            if (p11 == dominant_ptype) { float w = f.x*f.y;             total_value+=v11*w; total_weight+=w; }
-
-            if (total_weight <= 0.0) discard_fragment();
-            raw_value = total_value / total_weight;
+            if (p00 >= 0.0) { 
+                int ptype = int(p00);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p10 >= 0.0) { 
+                int ptype = int(p10);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p01 >= 0.0) { 
+                int ptype = int(p01);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p11 >= 0.0) { 
+                int ptype = int(p11);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            
+            if (valid_count == 0) discard_fragment();
+            
+            // Count how many unique types we have
+            int unique_types = 0;
+            if (has_type_0) unique_types++;
+            if (has_type_1) unique_types++;
+            if (has_type_2) unique_types++;
+            if (has_type_3) unique_types++;
+            
+            if (unique_types == 1) {
+                // ALL SAME TYPE - smooth interpolation across all valid pixels
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 >= 0.0) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 >= 0.0) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 >= 0.0) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+                
+            } else {
+                // MULTIPLE TYPES - weighted voting to determine dominant type
+                float type_weight_0 = 0.0;
+                float type_weight_1 = 0.0;
+                float type_weight_2 = 0.0;
+                float type_weight_3 = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float w = (1.0 - f.x) * (1.0 - f.y);
+                    int ptype = int(p00);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p10 >= 0.0) {
+                    float w = f.x * (1.0 - f.y);
+                    int ptype = int(p10);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p01 >= 0.0) {
+                    float w = (1.0 - f.x) * f.y;
+                    int ptype = int(p01);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p11 >= 0.0) {
+                    float w = f.x * f.y;
+                    int ptype = int(p11);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                
+                // Find the type with the highest weight at this pixel location
+                float max_type_weight = 0.0;
+                float winning_type = -1.0;
+                if (type_weight_0 > max_type_weight) { max_type_weight = type_weight_0; winning_type = 0.0; }
+                if (type_weight_1 > max_type_weight) { max_type_weight = type_weight_1; winning_type = 1.0; }
+                if (type_weight_2 > max_type_weight) { max_type_weight = type_weight_2; winning_type = 2.0; }
+                if (type_weight_3 > max_type_weight) { max_type_weight = type_weight_3; winning_type = 3.0; }
+                
+                if (winning_type == -1.0) discard_fragment();
+                
+                // Now smoothly interpolate only among pixels of the winning type
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 == winning_type) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 == winning_type) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 == winning_type) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 == winning_type) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+            }
             
             // Force full alpha to prevent dark borders between ptype regions
             alpha_multiplier = 1.0;

package/lib/module/lib/commonjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/lib/module/lib/commonjs/src/WeatherLayerManager.js

@@ -745,7 +745,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       run
     } = core.state;
     if (isMRMS) {
-      // --- MRMS LOGIC WITH PRE-LOADING ---
+      // --- MRMS LOGIC (Keep existing logic) ---
       const oldTimestamps = new Set(core.mrmsStatus?.[currentVariable] || []);
       const mrmsStatus = await core.fetchMRMSStatus(true);
       const newTimestamps = mrmsStatus?.[currentVariable] || [];
@@ -755,6 +755,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
         core.mrmsStatus = mrmsStatus;
         core._emitStateChange(); // Update UI slider without changing selection
 
+        // ... (Keep your existing preloading logic here) ...
         const {
           corners,
           gridDef
@@ -770,12 +771,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
           const y = frameDate.getUTCFullYear(),
             m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0'),
             d = frameDate.getUTCDate().toString().padStart(2, '0');
-
-          // --- THIS IS THE FIX ---
-          // Changed 'variable' to 'currentVariable'
           const resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${currentVariable}/0`;
-          // --- END FIX ---
-
           const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
           WeatherFrameProcessorModule.processFrame({
             url,
@@ -813,19 +809,10 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
         });
       }
     } else {
-      // --- MODEL LOGIC ---
       const modelStatus = await core.fetchModelStatus(true);
+      core._emitStateChange();
       const latestRun = findLatestModelRun(modelStatus, currentModel);
       if (!latestRun) return;
-      const currentRunKey = `${date}:${run}`;
-      const latestRunKey = `${latestRun.date}:${latestRun.run}`;
-      if (latestRunKey > currentRunKey) {
-        // This preserves the current forecastHour while changing the run
-        await core.setState({
-          date: latestRun.date,
-          run: latestRun.run
-        });
-      }
     }
   }, [core]);
   (0, _react.useEffect)(() => {