ok4

app.py

@@ -25,43 +25,103 @@ class RainViewerMap:
     
     def get_hurricane_data(self):
         """Fetch active hurricane/tropical storm data from NOAA NHC"""
+        active_storms = []
+        error_messages = []
+        
+        # Try multiple approaches to get hurricane data
         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()
+            # Approach 1: Try the simplified hurricane data endpoint
+            simple_url = "https://www.nhc.noaa.gov/CurrentStorms.json"
+            try:
+                response = requests.get(simple_url, timeout=10)
+                if response.status_code == 200:
+                    storms_data = response.json()
+                    for storm in storms_data.get('activeStorms', []):
+                        active_storms.append({
+                            'source': 'NHC CurrentStorms',
+                            'data': storm,
+                            'type': 'current_storms'
+                        })
+            except Exception as e:
+                error_messages.append(f"CurrentStorms.json failed: {e}")
             
-            active_storms = []
+            # Approach 2: Try NOAA GIS layers for specific storm data
+            if not active_storms:
+                layers_url = f"{self.nhc_api_base}/layers?f=json"
+                try:
+                    layers_response = requests.get(layers_url, timeout=15)
+                    if layers_response.status_code == 200:
+                        layers_data = layers_response.json()
+                        
+                        # Look for Atlantic storms (AT1-AT5) forecast points
+                        for layer in layers_data.get('layers', []):
+                            layer_name = layer.get('name', '').lower()
+                            layer_id = layer.get('id')
+                            
+                            if ('at1' in layer_name or 'at2' in layer_name or 'at3' in layer_name) and 'forecast points' in layer_name:
+                                query_url = f"{self.nhc_api_base}/{layer_id}/query"
+                                params = {
+                                    'where': '1=1',
+                                    'outFields': '*',
+                                    'f': 'geojson',
+                                    'returnGeometry': 'true'
+                                }
+                                
+                                try:
+                                    query_response = requests.get(query_url, params=params, timeout=15)
+                                    if query_response.status_code == 200:
+                                        geojson_data = query_response.json()
+                                        if geojson_data.get('features'):
+                                            active_storms.append({
+                                                'source': 'NOAA GIS',
+                                                'layer_name': layer.get('name', ''),
+                                                'layer_id': layer_id,
+                                                'geojson': geojson_data,
+                                                'type': 'gis_layer'
+                                            })
+                                except Exception as e:
+                                    error_messages.append(f"Layer {layer_id} query failed: {e}")
+                except Exception as e:
+                    error_messages.append(f"Layers API failed: {e}")
             
-            # 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'
+            # Approach 3: Add sample data if no real data available (for testing)
+            if not active_storms:
+                sample_storm = {
+                    'source': 'Sample Data',
+                    'type': 'sample',
+                    'geojson': {
+                        'type': 'FeatureCollection',
+                        'features': [
+                            {
+                                'type': 'Feature',
+                                'geometry': {
+                                    'type': 'Point',
+                                    'coordinates': [-80.0, 26.0]
+                                },
+                                'properties': {
+                                    'STORMNAME': 'Sample Hurricane',
+                                    'STORMTYPE': 'Hurricane',
+                                    'MAXWIND': '75',
+                                    'MSLP': '980',
+                                    'FHOUR': 'Current'
+                                }
+                            }
+                        ]
                     }
-                    
-                    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
-                            })
+                }
+                active_storms.append(sample_storm)
+                error_messages.append("No real storm data available, showing sample data")
+            
+            # Store error messages for debugging
+            self.storm_cache['errors'] = error_messages
+            self.storm_cache['last_update'] = datetime.now().isoformat()
             
             return active_storms
             
         except Exception as e:
-            print(f"Error fetching hurricane data: {e}")
+            error_messages.append(f"General error fetching hurricane data: {e}")
+            self.storm_cache['errors'] = error_messages
+            print(f"Hurricane data fetch error: {e}")
             return []
     
     def get_storm_track_data(self, layer_id):
@@ -144,51 +204,94 @@ class RainViewerMap:
         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']
+            storm_type = storm_info.get('type', 'unknown')
             
-            # 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)
+            if storm_type == 'current_storms':
+                # Handle CurrentStorms.json format
+                storm_data = storm_info['data']
+                self.add_current_storms_markers(folium_map, storm_data)
+                
+            elif storm_type == 'gis_layer':
+                # Handle GIS layer format
+                geojson_data = storm_info['geojson']
+                layer_name = storm_info.get('layer_name', 'Unknown Layer')
+                
+                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', props.get('STORMNUM', 'Unknown Storm'))
+                        storm_type_detail = props.get('STORMTYPE', 'Unknown')
+                        max_wind = props.get('MAXWIND', props.get('INTENSITY', 'N/A'))
+                        pressure = props.get('MSLP', 'N/A')
+                        forecast_hour = props.get('FHOUR', props.get('TAU', '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_detail}<br>
+                        Max Wind: {max_wind} kt<br>
+                        Pressure: {pressure} mb<br>
+                        Forecast Hour: {forecast_hour}<br>
+                        Source: {layer_name}
+                        """
+                        
+                        # 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)
+                        
+            elif storm_type == 'sample':
+                # Handle sample data
+                geojson_data = storm_info['geojson']
+                for feature in geojson_data.get('features', []):
+                    if feature['geometry']['type'] == 'Point':
+                        coords = feature['geometry']['coordinates']
+                        props = feature.get('properties', {})
+                        
+                        storm_name = props.get('STORMNAME', 'Sample Storm')
+                        storm_type_detail = props.get('STORMTYPE', 'Sample')
+                        max_wind = props.get('MAXWIND', '75')
+                        pressure = props.get('MSLP', '980')
+                        
+                        color = self.get_storm_color(max_wind)
+                        
+                        popup_text = f"""
+                        <b>{storm_name} (Sample)</b><br>
+                        Type: {storm_type_detail}<br>
+                        Max Wind: {max_wind} kt<br>
+                        Pressure: {pressure} mb<br>
+                        Note: This is sample data for demonstration
+                        """
+                        
+                        folium.CircleMarker(
+                            location=[coords[1], coords[0]],
+                            radius=10,
+                            popup=popup_text,
+                            color=color,
+                            fill=True,
+                            fillColor=color,
+                            fillOpacity=0.7,
+                            weight=3
+                        ).add_to(folium_map)
+    
+    def add_current_storms_markers(self, folium_map, storm_data):
+        """Add markers for storms from CurrentStorms.json format"""
+        # This method handles the specific format from NHC CurrentStorms.json
+        # Implementation depends on the actual JSON structure
+        pass
     
     def add_storm_tracks(self, folium_map, track_data):
         """Add storm track lines to the map"""
@@ -292,8 +395,15 @@ def create_gradio_app():
                     info="Select radar timestamp"
                 )
                 
+                gr.Markdown("### Hurricane Information")
+                storm_list = gr.HTML(
+                    value="Loading storm data...",
+                    label="Active Storms"
+                )
+                
                 update_btn = gr.Button("Update Map", variant="primary")
                 refresh_times_btn = gr.Button("Refresh Times")
+                refresh_storms_btn = gr.Button("Refresh Storms")
             
             with gr.Column(scale=2):
                 map_html = gr.HTML(
@@ -312,6 +422,63 @@ def create_gradio_app():
             new_times = rain_viewer.get_available_times()
             return gr.Dropdown(choices=new_times, value=new_times[-1] if new_times else None)
         
+        def get_storm_list_html():
+            """Generate HTML for storm list display"""
+            hurricane_data = rain_viewer.get_hurricane_data()
+            
+            if not hurricane_data:
+                return "<p>No active storms currently detected.</p>"
+            
+            html_content = "<div style='font-family: Arial, sans-serif;'>"
+            html_content += "<h4>Active Storms:</h4>"
+            
+            for i, storm_info in enumerate(hurricane_data):
+                storm_type = storm_info.get('type', 'unknown')
+                source = storm_info.get('source', 'Unknown')
+                
+                html_content += f"<div style='margin: 10px 0; padding: 10px; border: 1px solid #ddd; border-radius: 5px;'>"
+                html_content += f"<strong>Storm #{i+1}</strong> - Source: {source}<br>"
+                
+                if storm_type == 'gis_layer':
+                    layer_name = storm_info.get('layer_name', 'Unknown')
+                    geojson = storm_info.get('geojson', {})
+                    feature_count = len(geojson.get('features', []))
+                    html_content += f"Layer: {layer_name}<br>"
+                    html_content += f"Data points: {feature_count}<br>"
+                    
+                    # Show first feature details if available
+                    features = geojson.get('features', [])
+                    if features:
+                        first_feature = features[0]
+                        props = first_feature.get('properties', {})
+                        storm_name = props.get('STORMNAME', props.get('STORMNUM', 'N/A'))
+                        max_wind = props.get('MAXWIND', props.get('INTENSITY', 'N/A'))
+                        pressure = props.get('MSLP', 'N/A')
+                        
+                        html_content += f"Name: {storm_name}<br>"
+                        html_content += f"Max Wind: {max_wind} kt<br>"
+                        html_content += f"Pressure: {pressure} mb<br>"
+                
+                elif storm_type == 'sample':
+                    html_content += "<em>Sample data for demonstration</em><br>"
+                    html_content += "Name: Sample Hurricane<br>"
+                    html_content += "Max Wind: 75 kt<br>"
+                    html_content += "Pressure: 980 mb<br>"
+                
+                html_content += "</div>"
+            
+            # Add error information if available
+            errors = rain_viewer.storm_cache.get('errors', [])
+            if errors:
+                html_content += "<div style='margin-top: 15px; padding: 10px; background-color: #fff3cd; border: 1px solid #ffeaa7; border-radius: 5px;'>"
+                html_content += "<strong>Debug Info:</strong><br>"
+                for error in errors[-3:]:  # Show last 3 errors
+                    html_content += f"• {error}<br>"
+                html_content += "</div>"
+            
+            html_content += "</div>"
+            return html_content
+        
         update_btn.click(
             fn=update_map,
             inputs=[lat_input, lon_input, zoom_input, show_radar, show_hurricanes, time_dropdown],
@@ -323,6 +490,17 @@ def create_gradio_app():
             outputs=time_dropdown
         )
         
+        refresh_storms_btn.click(
+            fn=get_storm_list_html,
+            outputs=storm_list
+        )
+        
+        # Initialize storm list on load
+        demo.load(
+            fn=get_storm_list_html,
+            outputs=storm_list
+        )
+        
         # Auto-update on input changes
         for input_component in [lat_input, lon_input, zoom_input, show_radar, show_hurricanes, time_dropdown]:
             input_component.change(