Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import folium | |
| import requests | |
| import json | |
| import numpy as np | |
| from PIL import Image | |
| import base64 | |
| import io | |
| from radar_analyzer import CanadianRadarAnalyzer | |
| import cv2 | |
| class RadarAnalysisApp: | |
| def __init__(self): | |
| # Always use Canadian radar data source | |
| self.wms_url = "https://geo.weather.gc.ca/geomet" | |
| self.analyzer = CanadianRadarAnalyzer() | |
| # Color display mode | |
| self.american_colors = False # False = Canadian colors, True = American colors | |
| # 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] | |
| } | |
| def toggle_color_scheme(self, use_american_colors: bool): | |
| """Toggle between Canadian and American color schemes for the same radar data.""" | |
| self.american_colors = use_american_colors | |
| color_scheme = "American" if use_american_colors else "Canadian" | |
| print(f"🎨 Switched to {color_scheme} color scheme") | |
| return f"🎨 Using {color_scheme} Colors" | |
| def fetch_current_radar(self): | |
| """Fetch the most recent Canadian radar image.""" | |
| 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" | |
| response = requests.get(url, timeout=30) | |
| response.raise_for_status() | |
| # Save the radar image | |
| with open('current_radar_fetch.png', 'wb') as f: | |
| f.write(response.content) | |
| return 'current_radar_fetch.png' | |
| except Exception as e: | |
| print(f"Error fetching radar: {e}") | |
| return None | |
| def analyze_current_radar(self): | |
| """Fetch and analyze the current radar image with optional color conversion.""" | |
| radar_file = self.fetch_current_radar() | |
| if not radar_file: | |
| return None, "Failed to fetch radar data" | |
| try: | |
| # Analyze the radar image using Canadian legend | |
| result = self.analyzer.analyze_radar(radar_file, "radar_legendwellcropped.png") | |
| # Apply American color conversion if requested | |
| if self.american_colors: | |
| print("🔄 Converting to American color scheme...") | |
| original_image = cv2.imread(radar_file) | |
| if original_image is not None: | |
| original_rgb = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB) | |
| converted_image = self.analyzer.convert_colors_to_american_scale(original_rgb) | |
| # Save converted image | |
| converted_file = radar_file.replace('.png', '_american_colors.png') | |
| converted_bgr = cv2.cvtColor(converted_image, cv2.COLOR_RGB2BGR) | |
| cv2.imwrite(converted_file, converted_bgr) | |
| # Update the result to point to converted image | |
| result['output_file'] = converted_file | |
| print(f"✅ Saved American color version: {converted_file}") | |
| # Debug: Print what we actually got | |
| print("Analysis result keys:", result.keys()) | |
| print("Analysis keys:", result['analysis'].keys()) | |
| # Create analysis summary with safe access | |
| analysis = result['analysis'] | |
| analysis_text = f""" | |
| **Radar Analysis Results:** | |
| - **Precipitation Pixels:** {analysis.get('precipitation_pixels', 0):,} | |
| - **Total Image Pixels:** {analysis.get('total_pixels', 0):,} | |
| - **Coverage:** {analysis.get('precipitation_percentage', 0):.2f}% | |
| - **Regions Found:** {len(result.get('regions', []))} | |
| **Detected Precipitation Levels:** | |
| """ | |
| # Add intensity breakdown | |
| intensity_levels = analysis.get('intensity_levels', analysis.get('pixel_statistics', {})) | |
| for intensity, count in intensity_levels.items(): | |
| if count > 0: | |
| analysis_text += f"\n- {intensity}: {count:,} pixels" | |
| # Add dBZ scale reference | |
| analysis_text += f""" | |
| **dBZ Scale Reference:** | |
| - 0.1-1.0 dBZ: Very light precipitation (blue) | |
| - 1.0-8.0 dBZ: Light to moderate (green-yellow) | |
| - 8.0-32.0 dBZ: Heavy precipitation (orange-red) | |
| - 32.0+ dBZ: Intense precipitation (red-purple) | |
| *Hover over radar pixels to see precise dBZ values* | |
| """ | |
| return result['output_file'], analysis_text | |
| except Exception as e: | |
| return None, f"Analysis failed: {str(e)}" | |
| def create_radar_map_with_analysis(self, show_analysis=True): | |
| """Create a Folium map with radar overlay and optional analysis.""" | |
| try: | |
| # Create base map | |
| m = folium.Map( | |
| location=self.canada_bounds["center"], | |
| zoom_start=4, | |
| tiles="OpenStreetMap" | |
| ) | |
| if show_analysis: | |
| # Analyze current radar | |
| annotated_file, analysis_text = self.analyze_current_radar() | |
| if annotated_file: | |
| # Add the analyzed radar as an overlay | |
| # Note: For this demo, we'll add the WMS layer | |
| # In a full implementation, you'd convert the analyzed image to map overlay | |
| pass | |
| # Add live radar overlay with hover functionality | |
| color_scheme = "American" if self.american_colors else "Canadian" | |
| wms_layer = folium.raster_layers.WmsTileLayer( | |
| url=self.wms_url, | |
| layers="RADAR_1KM_RRAI", | |
| version="1.3.0", | |
| transparent=True, | |
| format="image/png", | |
| name=f"🇨🇦 Canadian Radar ({color_scheme} Colors)", | |
| overlay=True, | |
| control=True, | |
| opacity=0.7, | |
| attr='<a href="https://eccc-msc.github.io/open-data/licence/readme_en/">ECCC</a>' | |
| ) | |
| wms_layer.add_to(m) | |
| folium.LayerControl().add_to(m) | |
| # Add dBZ hover points if analysis data is available | |
| if show_analysis: | |
| try: | |
| # Try to get the latest analysis | |
| radar_file = self.fetch_current_radar() | |
| if radar_file: | |
| result = self.analyzer.analyze_radar(radar_file, "radar_legendwellcropped.png") | |
| hover_data = result.get('hover_data', {}) | |
| hover_points = hover_data.get('points', []) | |
| print(f"🚀 Adding {len(hover_points)} MAXIMUM RESOLUTION hover points to map") | |
| print(f"🎯 Coverage: ENTIRE radar image, EVERY precipitation pixel") | |
| # Add ALL precipitation pixels as hover points for MAXIMUM resolution | |
| # NO limits, NO caps, COMPLETE coverage | |
| for i, point in enumerate(hover_points): | |
| if i % 1000 == 0 and i > 0: | |
| progress = (i / len(hover_points)) * 100 | |
| print(f" 📍 Added {i:,}/{len(hover_points):,} hover points ({progress:.1f}%)") | |
| # Create ultra-precise markers for maximum zoom resolution | |
| folium.CircleMarker( | |
| location=[point['lat'], point['lon']], | |
| radius=0.8, # Ultra-small for high-resolution detail | |
| popup=folium.Popup( | |
| f""" | |
| <div style='font-family: monospace;'> | |
| <b>🌧️ dBZ: {point['dbz']}</b><br> | |
| <b>Intensity:</b> {point['intensity']}<br> | |
| <b>Pixel:</b> ({point['pixel_x']}, {point['pixel_y']})<br> | |
| <b>Lat:</b> {point['lat']:.6f}°N<br> | |
| <b>Lon:</b> {point['lon']:.6f}°W<br> | |
| <small><i>Ultra-high resolution point</i></small> | |
| </div> | |
| """, | |
| max_width=250 | |
| ), | |
| tooltip=f"⚡ {point['dbz']} dBZ ({point['intensity']})", | |
| color='red', | |
| fillColor='red', | |
| fillOpacity=0.4, | |
| opacity=0.6, | |
| weight=1 | |
| ).add_to(m) | |
| print(f"✅ Added ALL {len(hover_points):,} hover points for MAXIMUM zoom resolution") | |
| print(f"✅ NO caps applied - full dBZ range coverage") | |
| print(f"✅ Complete radar image coverage achieved") | |
| except Exception as e: | |
| print(f"Error adding hover data: {e}") | |
| pass | |
| # Add info panel | |
| info_html = """ | |
| <div style="position: fixed; | |
| top: 10px; right: 10px; width: 250px; height: auto; | |
| background-color: rgba(255,255,255,0.95); border:2px solid #333; z-index:9999; | |
| font-size:12px; padding: 10px; border-radius: 8px;"> | |
| <div style="font-weight: bold; margin-bottom: 8px; color: #333;">🇨🇦 Canadian Radar Analysis</div> | |
| <div style="margin-bottom: 4px;">• Real-time precipitation data</div> | |
| <div style="margin-bottom: 4px;">• Pixel-level dBZ analysis</div> | |
| <div style="margin-bottom: 4px;">• Color-mapped intensity regions</div> | |
| <div style="font-size:10px; margin-top:8px; color: #666;">Data: ECCC MSC GeoMet</div> | |
| </div> | |
| """ | |
| m.get_root().html.add_child(folium.Element(info_html)) | |
| return m | |
| except Exception as e: | |
| # Return error map | |
| error_map = folium.Map(location=self.canada_bounds["center"], zoom_start=4) | |
| error_html = f""" | |
| <div style="position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); | |
| background-color: #ffebee; border: 2px solid #f44336; | |
| padding: 20px; border-radius: 5px; z-index: 9999;"> | |
| <h3 style="color: #f44336;">Radar Analysis Error</h3> | |
| <p>Error: {str(e)}</p> | |
| </div> | |
| """ | |
| error_map.get_root().html.add_child(folium.Element(error_html)) | |
| return error_map | |
| # Initialize the app | |
| app = RadarAnalysisApp() | |
| def update_radar_analysis(): | |
| """Update radar analysis and return results.""" | |
| try: | |
| # Analyze current radar | |
| annotated_file, analysis_text = app.analyze_current_radar() | |
| if annotated_file: | |
| # Create map | |
| radar_map = app.create_radar_map_with_analysis(show_analysis=True) | |
| return radar_map._repr_html_(), analysis_text, annotated_file | |
| else: | |
| return "Analysis failed", analysis_text, None | |
| except Exception as e: | |
| return f"Error: {str(e)}", "Analysis failed", None | |
| def show_live_radar(): | |
| """Show live radar without analysis.""" | |
| radar_map = app.create_radar_map_with_analysis(show_analysis=False) | |
| return radar_map._repr_html_() | |
| def toggle_color_scheme(use_american_colors): | |
| """Toggle between Canadian and American color schemes.""" | |
| status_msg = app.toggle_color_scheme(use_american_colors) | |
| return status_msg | |
| # Create Gradio interface | |
| with gr.Blocks(title="Canadian Weather Radar with Dual Color Schemes", theme=gr.themes.Soft()) as interface: | |
| gr.Markdown("# 🇨🇦 Canadian Weather Radar Analyzer") | |
| gr.Markdown("Canadian radar data with switchable color schemes: Canadian (ECCC) ↔ American (NWS) colors") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("## Controls") | |
| # Color scheme toggle | |
| color_toggle = gr.Checkbox( | |
| value=False, | |
| label="🎨 Use American Colors", | |
| info="Toggle to convert Canadian radar to American color scale" | |
| ) | |
| 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="🎨 Using Canadian Colors", | |
| label="Color Scheme Status", | |
| interactive=False | |
| ) | |
| gr.Markdown("---") | |
| gr.Markdown("### Features:") | |
| gr.Markdown(""" | |
| - **Pixel-Perfect Analysis**: Every pixel analyzed for precise dBZ values | |
| - **Color Mapping**: Uses official Canadian radar color scale | |
| - **Region Detection**: Groups same-intensity pixels into regions | |
| - **Real-time Data**: Fresh data from ECCC every 10 minutes | |
| - **Quantitative Results**: Pixel counts and coverage statistics | |
| """) | |
| gr.Markdown("### Analysis Output:") | |
| analysis_output = gr.Textbox( | |
| label="Analysis Results", | |
| lines=15, | |
| placeholder="Click 'Analyze Current Radar' to see detailed analysis...", | |
| interactive=False | |
| ) | |
| with gr.Column(scale=6): | |
| with gr.Row(): | |
| radar_map = gr.HTML( | |
| value=app.create_radar_map_with_analysis(show_analysis=False)._repr_html_(), | |
| label="Radar Map" | |
| ) | |
| with gr.Row(): | |
| annotated_image = gr.Image( | |
| label="Analyzed Radar Image (with dBZ annotations)", | |
| type="filepath" | |
| ) | |
| # Event handlers | |
| color_toggle.change( | |
| fn=toggle_color_scheme, | |
| inputs=[color_toggle], | |
| outputs=[status_display] | |
| ) | |
| analyze_btn.click( | |
| fn=update_radar_analysis, | |
| outputs=[radar_map, analysis_output, annotated_image] | |
| ) | |
| live_btn.click( | |
| fn=show_live_radar, | |
| outputs=[radar_map] | |
| ) | |
| # Launch the app | |
| if __name__ == "__main__": | |
| interface.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True, | |
| debug=True | |
| ) |