Implement dual radar system: Canadian + American support

- Added RadarAnalyzer class supporting both Canadian and US radar
- Created radar toggle switch in Gradio interface
- Integrated NOAA/NEXRAD WMS endpoints for US radar data
- Downloaded multiple US radar legend options for user cropping
- Added create_us_legend_data.py helper script for US legend processing
- Updated map configuration to switch between radar systems
- Maintained backward compatibility with CanadianRadarAnalyzer

Features:
- 🇨🇦 Canadian Radar (ECCC) - Full North America coverage
- 🇺🇸 American Radar (NOAA/NEXRAD) - Continental US coverage
- Toggle switch between radar systems
- Automatic map bounds adjustment per radar type
- Ready for US legend mapping once cropped legend is provided

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -6,36 +6,74 @@ import numpy as np
 from PIL import Image
 import base64
 import io
-from radar_analyzer import CanadianRadarAnalyzer
+from radar_analyzer import RadarAnalyzer, CanadianRadarAnalyzer
 
 class RadarAnalysisApp:
     def __init__(self):
-        self.wms_url = "https://geo.weather.gc.ca/geomet"
-        self.analyzer = CanadianRadarAnalyzer()
+        self.current_radar_type = "canadian"
+        self.analyzer = RadarAnalyzer(radar_type=self.current_radar_type)
         
-        # Extended North America bounds for map centering - covers Alaska to southeastern US
-        self.canada_bounds = {
-            "center": [52.5, -105.0],
-            "southwest": [20, -170],
-            "northeast": [85, -40]
+        # Radar configurations
+        self.radar_configs = {
+            "canadian": {
+                "wms_url": "https://geo.weather.gc.ca/geomet",
+                "layer": "RADAR_1KM_RRAI",
+                "bounds": (20.0, 85.0, -170.0, -40.0),  # lat_min, lat_max, lon_min, lon_max
+                "center": [52.5, -105.0],
+                "zoom": 3,
+                "name": "🇨🇦 Canadian Radar (ECCC)"
+            },
+            "american": {
+                "wms_url": "https://nowcoast.noaa.gov/arcgis/services/nowcoast/radar_meteo_imagery_nexrad_time/MapServer/WMSServer",
+                "layer": "1", 
+                "bounds": (20.0, 50.0, -130.0, -65.0),  # Continental US
+                "center": [39.0, -98.0],
+                "zoom": 4,
+                "name": "🇺🇸 American Radar (NOAA/NEXRAD)"
+            }
         }
+        
+        # Current configuration
+        self.current_config = self.radar_configs[self.current_radar_type]
+
+    def switch_radar_type(self, radar_type: str):
+        """Switch between Canadian and American radar systems."""
+        if radar_type.lower() in self.radar_configs:
+            self.current_radar_type = radar_type.lower()
+            self.current_config = self.radar_configs[self.current_radar_type]
+            self.analyzer = RadarAnalyzer(radar_type=self.current_radar_type)
+            print(f"✅ Switched to {self.current_config['name']}")
+            return True
+        else:
+            print(f"❌ Unknown radar type: {radar_type}")
+            return False
 
     def fetch_current_radar(self):
-        """Fetch the most recent Canadian radar image."""
+        """Fetch the most recent radar image based on current radar type."""
         try:
-            url = f"{self.wms_url}?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&LAYERS=RADAR_1KM_RRAI&STYLES=&CRS=EPSG:4326&BBOX=20,-170,85,-40&WIDTH=1200&HEIGHT=800&FORMAT=image/png"
+            config = self.current_config
+            lat_min, lat_max, lon_min, lon_max = config["bounds"]
+            
+            if self.current_radar_type == "canadian":
+                url = f"{config['wms_url']}?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&LAYERS={config['layer']}&STYLES=&CRS=EPSG:4326&BBOX={lat_min},{lon_min},{lat_max},{lon_max}&WIDTH=1200&HEIGHT=800&FORMAT=image/png"
             
+            elif self.current_radar_type == "american":
+                # NOAA NEXRAD WMS request
+                url = f"{config['wms_url']}?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&LAYERS={config['layer']}&STYLES=&CRS=EPSG:4326&BBOX={lat_min},{lon_min},{lat_max},{lon_max}&WIDTH=1200&HEIGHT=800&FORMAT=image/png&TIME=current"
+            
+            print(f"📡 Fetching {config['name']} data...")
             response = requests.get(url, timeout=30)
             response.raise_for_status()
             
-            # Save the radar image
-            with open('current_radar_fetch.png', 'wb') as f:
+            # Save the radar image with radar type prefix
+            filename = f'{self.current_radar_type}_radar_fetch.png'
+            with open(filename, 'wb') as f:
                 f.write(response.content)
                 
-            return 'current_radar_fetch.png'
+            return filename
             
         except Exception as e:
-            print(f"Error fetching radar: {e}")
+            print(f"Error fetching {self.current_radar_type} radar: {e}")
             return None
 
     def analyze_current_radar(self):
@@ -91,10 +129,11 @@ class RadarAnalysisApp:
     def create_radar_map_with_analysis(self, show_analysis=True):
         """Create a Folium map with radar overlay and optional analysis."""
         try:
-            # Create base map
+            # Create base map using current radar configuration
+            config = self.current_config
             m = folium.Map(
-                location=self.canada_bounds["center"],
-                zoom_start=4,
+                location=config["center"],
+                zoom_start=config["zoom"],
                 tiles="OpenStreetMap"
             )
             
@@ -109,17 +148,18 @@ class RadarAnalysisApp:
                     pass
             
             # Add live radar overlay with hover functionality
+            config = self.current_config
             wms_layer = folium.raster_layers.WmsTileLayer(
-                url=self.wms_url,
-                layers="RADAR_1KM_RRAI",
+                url=config["wms_url"],
+                layers=config["layer"],
                 version="1.3.0",
                 transparent=True,
                 format="image/png",
-                name="Canadian Radar - Rain",
+                name=config["name"],
                 overlay=True,
                 control=True,
                 opacity=0.7,
-                attr='<a href="https://eccc-msc.github.io/open-data/licence/readme_en/">ECCC</a>'
+                attr=f'<a href="#">{config["name"]}</a>'
             )
             
             wms_layer.add_to(m)
@@ -198,7 +238,8 @@ class RadarAnalysisApp:
             
         except Exception as e:
             # Return error map
-            error_map = folium.Map(location=self.canada_bounds["center"], zoom_start=4)
+            config = self.current_config
+            error_map = folium.Map(location=config["center"], zoom_start=config["zoom"])
             
             error_html = f"""
             <div style="position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
@@ -237,18 +278,47 @@ def show_live_radar():
     radar_map = app.create_radar_map_with_analysis(show_analysis=False)
     return radar_map._repr_html_()
 
+def switch_radar_system(radar_type):
+    """Switch between Canadian and American radar systems."""
+    success = app.switch_radar_type(radar_type)
+    if success:
+        config = app.current_config
+        status_msg = f"✅ Switched to {config['name']}"
+        # Update the map view
+        radar_map = app.create_radar_map_with_analysis(show_analysis=False)
+        return status_msg, radar_map._repr_html_()
+    else:
+        return f"❌ Failed to switch to {radar_type} radar", ""
+
 # Create Gradio interface
-with gr.Blocks(title="Canadian Weather Radar Analyzer", theme=gr.themes.Soft()) as interface:
-    gr.Markdown("# 🇨🇦 Canadian Weather Radar Analyzer")
-    gr.Markdown("Precise pixel-level analysis of Canadian radar data with dBZ reflectivity mapping")
+with gr.Blocks(title="North American Weather Radar Analyzer", theme=gr.themes.Soft()) as interface:
+    gr.Markdown("# 🌎 North American Weather Radar Analyzer")
+    gr.Markdown("Dual radar system supporting Canadian (ECCC) and American (NOAA/NEXRAD) weather data")
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("## Controls")
             
+            # Radar system selector
+            radar_selector = gr.Radio(
+                choices=["canadian", "american"],
+                value="canadian",
+                label="🌍 Radar System",
+                info="Switch between Canadian and American radar data"
+            )
+            
+            gr.Markdown("---")
+            
             analyze_btn = gr.Button("🔍 Analyze Current Radar", variant="primary", size="lg")
             live_btn = gr.Button("📡 Show Live Radar", variant="secondary")
             
+            # Status display
+            status_display = gr.Textbox(
+                value="🇨🇦 Canadian Radar Active",
+                label="System Status",
+                interactive=False
+            )
+            
             gr.Markdown("---")
             
             gr.Markdown("### Features:")
@@ -282,6 +352,12 @@ with gr.Blocks(title="Canadian Weather Radar Analyzer", theme=gr.themes.Soft())
                 )
     
     # Event handlers
+    radar_selector.change(
+        fn=switch_radar_system,
+        inputs=[radar_selector],
+        outputs=[status_display, radar_map]
+    )
+    
     analyze_btn.click(
         fn=update_radar_analysis,
         outputs=[radar_map, analysis_output, annotated_image]

create_us_legend_data.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Helper script to create US radar legend data from a cropped legend image.
+Run this after the user provides a cropped US radar legend.
+"""
+
+from radar_analyzer import RadarAnalyzer
+import json
+import os
+
+def create_us_legend_data(legend_image_path: str):
+    """Create legend data JSON file from US radar legend image."""
+    
+    if not os.path.exists(legend_image_path):
+        print(f"❌ Legend file not found: {legend_image_path}")
+        return False
+    
+    print(f"🎨 Processing US radar legend: {legend_image_path}")
+    
+    try:
+        # Create US radar analyzer
+        analyzer = RadarAnalyzer(radar_type="american", legend_path=legend_image_path)
+        
+        # Extract colors using the precise extraction method
+        color_ranges = analyzer._extract_precise_legend_colors()
+        
+        if color_ranges:
+            print(f"✅ Extracted {len(color_ranges)} color ranges from US legend")
+            
+            # Show sample colors and dBZ ranges
+            print('\n📊 Sample US radar color ranges:')
+            for i, cr in enumerate(color_ranges[::len(color_ranges)//10]):  # Show every 10th
+                print(f'  {cr.name}: {cr.min_value:.1f}-{cr.max_value:.1f} dBZ -> RGB{cr.rgb}')
+            
+            # Save the US legend data
+            cache_data = {
+                'source_file': legend_image_path,
+                'radar_type': 'american',
+                'total_colors': len(color_ranges),
+                'dbz_range': [color_ranges[0].min_value, color_ranges[-1].max_value] if color_ranges else [0, 0],
+                'colors': []
+            }
+            
+            for cr in color_ranges:
+                cache_data['colors'].append({
+                    'min_value': cr.min_value,
+                    'max_value': cr.max_value,
+                    'rgb': list(cr.rgb),
+                    'name': cr.name,
+                    'dbz_center': (cr.min_value + cr.max_value) / 2
+                })
+            
+            # Save with descriptive filename
+            output_file = 'us_radar_legend_data.json'
+            with open(output_file, 'w') as f:
+                json.dump(cache_data, f, indent=2)
+            
+            print(f'💾 Saved US legend data: {output_file}')
+            
+            # Show dBZ range
+            if color_ranges:
+                min_dbz = min(cr.min_value for cr in color_ranges)
+                max_dbz = max(cr.max_value for cr in color_ranges)
+                print(f'📊 US dBZ Range: {min_dbz:.1f} to {max_dbz:.1f}')
+                
+            print('\n✅ US radar legend data created successfully!')
+            print('🔄 The dual radar system is now ready to use!')
+            
+            return True
+                
+        else:
+            print(f'❌ No colors extracted from {legend_image_path}')
+            return False
+            
+    except Exception as e:
+        print(f'❌ Error processing US legend: {e}')
+        return False
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) != 2:
+        print("Usage: python create_us_legend_data.py <path_to_cropped_us_legend.png>")
+        print("Example: python create_us_legend_data.py us_radar_legend_cropped.png")
+        sys.exit(1)
+    
+    legend_path = sys.argv[1]
+    success = create_us_legend_data(legend_path)
+    
+    if success:
+        sys.exit(0)
+    else:
+        sys.exit(1)

radar_analyzer.py

@@ -15,22 +15,37 @@ class ColorRange:
     rgb: Tuple[int, int, int]
     name: str
 
-class CanadianRadarAnalyzer:
+class RadarAnalyzer:
     """
-    Precise pixel analyzer for Canadian weather radar data.
-    Analyzes dBZ reflectivity values using color mapping from ECCC radar legend.
+    Dual radar analyzer for Canadian and US weather radar data.
+    Analyzes dBZ reflectivity values using color mapping from radar legends.
     """
     
-    def __init__(self, legend_path: str = "radar_legendwellcropped.png"):
-        # ECCC Radar WMS endpoints
-        self.wms_base_url = "https://geo.weather.gc.ca/geomet"
-        self.radar_layer = "RADAR_1KM_RRAI"  # 1km Rain Radar
+    def __init__(self, radar_type: str = "canadian", legend_path: str = None):
+        self.radar_type = radar_type.lower()
+        
+        if self.radar_type == "canadian":
+            # ECCC Radar WMS endpoints
+            self.wms_base_url = "https://geo.weather.gc.ca/geomet"
+            self.radar_layer = "RADAR_1KM_RRAI"  # 1km Rain Radar
+            self.default_legend = "radar_legendwellcropped.png"
+            self.bounds = (20.0, 85.0, -170.0, -40.0)  # lat_min, lat_max, lon_min, lon_max
+            
+        elif self.radar_type == "american" or self.radar_type == "us":
+            # NOAA/NWS Radar endpoints (will be added)
+            self.wms_base_url = "https://nowcoast.noaa.gov/arcgis/services/nowcoast/radar_meteo_imagery_nexrad_time/MapServer/WMSServer"
+            self.radar_layer = "1"  # NEXRAD reflectivity
+            self.default_legend = "us_radar_legend_cropped.png"  # Will be provided by user
+            self.bounds = (20.0, 50.0, -130.0, -65.0)  # Continental US bounds
+            
+        else:
+            raise ValueError(f"Unsupported radar type: {radar_type}. Use 'canadian' or 'american'")
         
-        # Load pre-computed legend data (much faster!)
-        self.legend_path = legend_path
+        # Load legend data
+        self.legend_path = legend_path or self.default_legend
         self.precipitation_scale = self._load_precomputed_legend_data()
         
-        # Color tolerance for matching (RGB distance) - increased for better detection
+        # Color tolerance for matching (RGB distance)
         self.color_tolerance = 40
         
         # Initialize reference colors from legend
@@ -38,6 +53,13 @@ class CanadianRadarAnalyzer:
         if not self.precipitation_scale:
             # Fallback to manual colors if legend extraction fails
             self._extract_legend_colors()
+
+
+# Keep backward compatibility
+class CanadianRadarAnalyzer(RadarAnalyzer):
+    """Backward compatibility class for Canadian radar."""
+    def __init__(self, legend_path: str = "radar_legendwellcropped.png"):
+        super().__init__(radar_type="canadian", legend_path=legend_path)
     
     def _load_precomputed_legend_data(self) -> List[ColorRange]:
         """