ok3

app.py

@@ -4,11 +4,14 @@ import requests
 import json
 from datetime import datetime
 import time
+import urllib.parse
 
 class RainViewerMap:
     def __init__(self):
         self.api_url = "https://api.rainviewer.com/public/weather-maps.json"
         self.tile_host = "https://tilecache.rainviewer.com"
+        self.nhc_api_base = "https://mapservices.weather.noaa.gov/tropical/rest/services/tropical/NHC_tropical_weather/MapServer"
+        self.storm_cache = {}
         
     def get_radar_data(self):
         """Fetch available radar timestamps from RainViewer API"""
@@ -20,8 +23,71 @@ class RainViewerMap:
             print(f"Error fetching radar data: {e}")
             return None
     
-    def create_map(self, lat=40.7128, lon=-74.0060, zoom=8, show_radar=True, time_index=0):
-        """Create a Folium map with optional radar overlay"""
+    def get_hurricane_data(self):
+        """Fetch active hurricane/tropical storm data from NOAA NHC"""
+        try:
+            # Get list of available layers
+            layers_url = f"{self.nhc_api_base}/layers?f=json"
+            layers_response = requests.get(layers_url)
+            layers_data = layers_response.json()
+            
+            active_storms = []
+            
+            # Look for active storm layers (forecast points, tracks, etc.)
+            for layer in layers_data.get('layers', []):
+                layer_name = layer.get('name', '')
+                layer_id = layer.get('id')
+                
+                # Focus on forecast points which contain current storm positions
+                if 'forecast points' in layer_name.lower() and layer_id is not None:
+                    # Query the layer for features
+                    query_url = f"{self.nhc_api_base}/{layer_id}/query"
+                    params = {
+                        'where': '1=1',
+                        'outFields': '*',
+                        'f': 'geojson'
+                    }
+                    
+                    query_response = requests.get(query_url, params=params)
+                    if query_response.status_code == 200:
+                        geojson_data = query_response.json()
+                        if geojson_data.get('features'):
+                            active_storms.append({
+                                'layer_name': layer_name,
+                                'layer_id': layer_id,
+                                'geojson': geojson_data
+                            })
+            
+            return active_storms
+            
+        except Exception as e:
+            print(f"Error fetching hurricane data: {e}")
+            return []
+    
+    def get_storm_track_data(self, layer_id):
+        """Fetch track data for a specific storm layer"""
+        try:
+            # Look for corresponding track layer (usually layer_id - 1 or nearby)
+            track_layer_id = layer_id - 1 if layer_id > 0 else layer_id + 1
+            
+            query_url = f"{self.nhc_api_base}/{track_layer_id}/query"
+            params = {
+                'where': '1=1',
+                'outFields': '*',
+                'f': 'geojson'
+            }
+            
+            response = requests.get(query_url, params=params)
+            if response.status_code == 200:
+                return response.json()
+            return None
+            
+        except Exception as e:
+            print(f"Error fetching track data: {e}")
+            return None
+    
+    def create_map(self, lat=40.7128, lon=-74.0060, zoom=8, show_radar=True, time_index=0, show_hurricanes=True):
+        """Create a Folium map with optional radar overlay and hurricane tracking"""
         # Create base map
         m = folium.Map(
             location=[lat, lon],
@@ -64,11 +130,107 @@ class RainViewerMap:
                         icon=folium.Icon(color='blue', icon='info-sign')
                     ).add_to(m)
         
+        # Add hurricane tracking
+        if show_hurricanes:
+            self.add_hurricane_layers(m)
+        
         # Add layer control
         folium.LayerControl().add_to(m)
         
         return m._repr_html_()
     
+    def add_hurricane_layers(self, folium_map):
+        """Add hurricane tracking layers to the map"""
+        hurricane_data = self.get_hurricane_data()
+        
+        for storm_info in hurricane_data:
+            layer_name = storm_info['layer_name']
+            layer_id = storm_info['layer_id']
+            geojson_data = storm_info['geojson']
+            
+            # Add forecast points
+            for feature in geojson_data.get('features', []):
+                if feature['geometry']['type'] == 'Point':
+                    coords = feature['geometry']['coordinates']
+                    props = feature.get('properties', {})
+                    
+                    # Extract storm information
+                    storm_name = props.get('STORMNAME', 'Unknown Storm')
+                    storm_type = props.get('STORMTYPE', 'Unknown')
+                    max_wind = props.get('MAXWIND', 'N/A')
+                    pressure = props.get('MSLP', 'N/A')
+                    forecast_hour = props.get('FHOUR', 'Current')
+                    
+                    # Determine marker color based on storm intensity
+                    color = self.get_storm_color(max_wind)
+                    
+                    # Create popup with storm details
+                    popup_text = f"""
+                    <b>{storm_name}</b><br>
+                    Type: {storm_type}<br>
+                    Max Wind: {max_wind} kt<br>
+                    Pressure: {pressure} mb<br>
+                    Forecast Hour: {forecast_hour}
+                    """
+                    
+                    # Add marker
+                    folium.CircleMarker(
+                        location=[coords[1], coords[0]],
+                        radius=8,
+                        popup=popup_text,
+                        color=color,
+                        fill=True,
+                        fillColor=color,
+                        fillOpacity=0.7,
+                        weight=2
+                    ).add_to(folium_map)
+            
+            # Try to get and add track data
+            track_data = self.get_storm_track_data(layer_id)
+            if track_data:
+                self.add_storm_tracks(folium_map, track_data)
+    
+    def add_storm_tracks(self, folium_map, track_data):
+        """Add storm track lines to the map"""
+        for feature in track_data.get('features', []):
+            if feature['geometry']['type'] == 'LineString':
+                coords = feature['geometry']['coordinates']
+                # Convert coordinates from [lon, lat] to [lat, lon] for Folium
+                track_coords = [[coord[1], coord[0]] for coord in coords]
+                
+                props = feature.get('properties', {})
+                storm_name = props.get('STORMNAME', 'Storm Track')
+                
+                folium.PolyLine(
+                    locations=track_coords,
+                    color='red',
+                    weight=3,
+                    opacity=0.8,
+                    popup=f"Track: {storm_name}"
+                ).add_to(folium_map)
+    
+    def get_storm_color(self, max_wind):
+        """Get color based on storm intensity (Saffir-Simpson scale)"""
+        try:
+            wind_speed = float(max_wind) if max_wind != 'N/A' else 0
+            
+            if wind_speed >= 137:  # Category 5
+                return 'purple'
+            elif wind_speed >= 113:  # Category 4
+                return 'red'
+            elif wind_speed >= 96:  # Category 3
+                return 'orange'
+            elif wind_speed >= 83:  # Category 2
+                return 'yellow'
+            elif wind_speed >= 64:  # Category 1
+                return 'green'
+            elif wind_speed >= 34:  # Tropical Storm
+                return 'blue'
+            else:  # Tropical Depression
+                return 'lightblue'
+        except:
+            return 'gray'
+    
     def get_available_times(self):
         """Get list of available radar times for dropdown"""
         radar_data = self.get_radar_data()
@@ -93,8 +255,8 @@ def create_gradio_app():
     time_options = rain_viewer.get_available_times()
     
     with gr.Blocks(title="RainViewer Radar Map") as demo:
-        gr.Markdown("# RainViewer Radar Map")
-        gr.Markdown("Interactive weather radar map powered by RainViewer API")
+        gr.Markdown("# Weather Radar & Hurricane Tracker")
+        gr.Markdown("Interactive weather map with radar data from RainViewer and hurricane tracking from NOAA NHC")
         
         with gr.Row():
             with gr.Column(scale=1):
@@ -119,6 +281,10 @@ def create_gradio_app():
                     label="Show Radar", 
                     value=True
                 )
+                show_hurricanes = gr.Checkbox(
+                    label="Show Hurricanes", 
+                    value=True
+                )
                 time_dropdown = gr.Dropdown(
                     choices=time_options,
                     label="Radar Time",
@@ -135,12 +301,12 @@ def create_gradio_app():
                     label="Radar Map"
                 )
         
-        def update_map(lat, lon, zoom, show_radar_flag, selected_time):
+        def update_map(lat, lon, zoom, show_radar_flag, show_hurricanes_flag, selected_time):
             time_index = 0
             if selected_time and ":" in selected_time:
                 time_index = int(selected_time.split(":")[0])
             
-            return rain_viewer.create_map(lat, lon, zoom, show_radar_flag, time_index)
+            return rain_viewer.create_map(lat, lon, zoom, show_radar_flag, time_index, show_hurricanes_flag)
         
         def refresh_times():
             new_times = rain_viewer.get_available_times()
@@ -148,7 +314,7 @@ def create_gradio_app():
         
         update_btn.click(
             fn=update_map,
-            inputs=[lat_input, lon_input, zoom_input, show_radar, time_dropdown],
+            inputs=[lat_input, lon_input, zoom_input, show_radar, show_hurricanes, time_dropdown],
             outputs=map_html
         )
         
@@ -158,10 +324,10 @@ def create_gradio_app():
         )
         
         # Auto-update on input changes
-        for input_component in [lat_input, lon_input, zoom_input, show_radar, time_dropdown]:
+        for input_component in [lat_input, lon_input, zoom_input, show_radar, show_hurricanes, time_dropdown]:
             input_component.change(
                 fn=update_map,
-                inputs=[lat_input, lon_input, zoom_input, show_radar, time_dropdown],
+                inputs=[lat_input, lon_input, zoom_input, show_radar, show_hurricanes, time_dropdown],
                 outputs=map_html
             )