Update app.py

app.py

@@ -130,14 +130,16 @@ def load_ibtracs_data():
         with open(CACHE_FILE, 'rb') as f:
             return pickle.load(f)
     if os.path.exists(LOCAL_iBtrace_PATH):
-        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
+        # Remove the basin='west_pacific' parameter to load all basins
+        ibtracs = tracks.TrackDataset(source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
     else:
         response = requests.get(iBtrace_uri)
         response.raise_for_status()
         with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
             temp_file.write(response.text)
             shutil.move(temp_file.name, LOCAL_iBtrace_PATH)
-        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
+        # Remove the basin='west_pacific' parameter here as well
+        ibtracs = tracks.TrackDataset(source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
     with open(CACHE_FILE, 'wb') as f:
         pickle.dump(ibtracs, f)
     return ibtracs
@@ -323,7 +325,7 @@ def generate_main_analysis(start_year, start_month, end_year, end_month, enso_ph
     
     return tracks_fig, wind_scatter, pressure_scatter, regression_fig, slopes_text
 
-# Video animation function with fixed sidebar
+# Video animation function with fixed sidebar and wind radius visualization
 def categorize_typhoon_by_standard(wind_speed, standard):
     if standard == 'taiwan':
         wind_speed_ms = wind_speed * 0.514444
@@ -349,7 +351,7 @@ def categorize_typhoon_by_standard(wind_speed, standard):
             return 'Tropical Storm', atlantic_standard['Tropical Storm']['hex']
         return 'Tropical Depression', atlantic_standard['Tropical Depression']['hex']
 
-def generate_track_video(year, typhoon, standard):
+def generate_track_video(year, basin, typhoon, standard):
     if not typhoon:
         return None
 
@@ -374,15 +376,21 @@ def generate_track_video(year, typhoon, standard):
     ax.add_feature(cfeature.BORDERS, linestyle=':', edgecolor='gray')
     ax.gridlines(draw_labels=True, linestyle='--', color='gray', alpha=0.5)
 
-    ax.set_title(f"{year} {storm.name} Typhoon Path")
+    ax.set_title(f"{year} {storm.name} Tropical Cyclone Path")
 
     # Initialize the line and point
     line, = ax.plot([], [], 'b-', linewidth=2, transform=ccrs.PlateCarree())
     point, = ax.plot([], [], 'o', markersize=8, transform=ccrs.PlateCarree())
     date_text = ax.text(0.02, 0.02, '', transform=ax.transAxes, fontsize=10, bbox=dict(facecolor='white', alpha=0.8))
 
+    # Initialize wind radius circles for 34kt, 50kt, and 64kt
+    radius_patches = []
+    for _ in range(3):
+        patch = plt.Circle((0, 0), 0, fill=False, linewidth=2, visible=False, transform=ccrs.PlateCarree())
+        radius_patches.append(ax.add_patch(patch))
+
     # Add sidebar on the right with adjusted positions
-    details_title = fig.text(0.7, 0.95, "Typhoon Details", fontsize=12, fontweight='bold', verticalalignment='top')
+    details_title = fig.text(0.7, 0.95, "Cyclone Details", fontsize=12, fontweight='bold', verticalalignment='top')
     details_text = fig.text(0.7, 0.85, '', fontsize=12, verticalalignment='top',
                             bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5'))
 
@@ -394,12 +402,25 @@ def generate_track_video(year, typhoon, standard):
     fig.legend(handles=legend_elements, title="Color Legend", loc='center right', 
                bbox_to_anchor=(0.95, 0.5), fontsize=10)
 
+    # Add wind radius legend
+    radius_legend = [
+        plt.Line2D([0], [0], color='blue', label='34kt Gale Force'),
+        plt.Line2D([0], [0], color='orange', label='50kt Storm Force'),
+        plt.Line2D([0], [0], color='red', label='64kt Hurricane Force')
+    ]
+    fig.legend(handles=radius_legend, title="Wind Radii", loc='lower right', 
+               bbox_to_anchor=(0.95, 0.15), fontsize=9)
+
     def init():
         line.set_data([], [])
         point.set_data([], [])
         date_text.set_text('')
         details_text.set_text('')
-        return line, point, date_text, details_text
+        for patch in radius_patches:
+            patch.set_center((0, 0))
+            patch.set_radius(0)
+            patch.set_visible(False)
+        return [line, point, date_text, details_text] + radius_patches
 
     def update(frame):
         line.set_data(storm.lon[:frame+1], storm.lat[:frame+1])
@@ -407,12 +428,70 @@ def generate_track_video(year, typhoon, standard):
         point.set_data([storm.lon[frame]], [storm.lat[frame]])
         point.set_color(color)
         date_text.set_text(storm.time[frame].strftime('%Y-%m-%d %H:%M'))
+        
+        # Update wind radius circles
+        radius_info = []
+        
+        # Check for radius data from different agencies
+        wind_thresholds = [(34, 'blue'), (50, 'orange'), (64, 'red')]
+        
+        for i, (wind_kt, circle_color) in enumerate(wind_thresholds):
+            # Check USA agency radius data (average of all quadrants)
+            radius_values = []
+            
+            # Check USA agency data
+            for quadrant in ['ne', 'se', 'sw', 'nw']:
+                attr = f'usa_r{wind_kt}_{quadrant}'
+                if hasattr(storm, attr) and frame < len(getattr(storm, attr)) and not np.isnan(getattr(storm, attr)[frame]):
+                    radius_values.append(getattr(storm, attr)[frame])
+            
+            # If no USA data, check BOM data
+            if not radius_values:
+                for quadrant in ['ne', 'se', 'sw', 'nw']:
+                    attr = f'bom_r{wind_kt}_{quadrant}'
+                    if hasattr(storm, attr) and frame < len(getattr(storm, attr)) and not np.isnan(getattr(storm, attr)[frame]):
+                        radius_values.append(getattr(storm, attr)[frame])
+            
+            # If still no data, try Reunion data
+            if not radius_values:
+                for quadrant in ['ne', 'se', 'sw', 'nw']:
+                    attr = f'reunion_r{wind_kt}_{quadrant}'
+                    if hasattr(storm, attr) and frame < len(getattr(storm, attr)) and not np.isnan(getattr(storm, attr)[frame]):
+                        radius_values.append(getattr(storm, attr)[frame])
+            
+            if radius_values:
+                # Calculate average radius (nautical miles)
+                avg_radius = np.mean(radius_values)
+                
+                # Convert from nautical miles to approximate degrees (1 nm ≈ 1/60 degree)
+                radius_deg = avg_radius / 60.0
+                
+                radius_patches[i].set_center((storm.lon[frame], storm.lat[frame]))
+                radius_patches[i].set_radius(radius_deg)
+                radius_patches[i].set_edgecolor(circle_color)
+                radius_patches[i].set_visible(True)
+                
+                radius_info.append(f"{wind_kt}kt radius: {avg_radius:.1f} nm")
+            else:
+                radius_patches[i].set_visible(False)
+                radius_info.append(f"{wind_kt}kt radius: 0 nm")
+        
+        # Add radius information to details
+        radius_text = "\n".join(radius_info)
+        
+        # Get pressure value if available, otherwise show 'N/A'
+        pressure_value = storm.mslp[frame] if hasattr(storm, 'mslp') and frame < len(storm.mslp) and not np.isnan(storm.mslp[frame]) else 'N/A'
+        pressure_text = f"Pressure: {pressure_value if pressure_value != 'N/A' else 'N/A'} mb"
+        
         details = f"Name: {storm.name}\n" \
                   f"Date: {storm.time[frame].strftime('%Y-%m-%d %H:%M')}\n" \
                   f"Wind Speed: {storm.vmax[frame]:.1f} kt\n" \
-                  f"Category: {category}"
+                  f"{pressure_text}\n" \
+                  f"Category: {category}\n" \
+                  f"\nWind Radii:\n{radius_text}"
+                  
         details_text.set_text(details)
-        return line, point, date_text, details_text
+        return [line, point, date_text, details_text] + radius_patches
 
     ani = animation.FuncAnimation(fig, update, init_func=init, frames=len(storm.time),
                                   interval=200, blit=True, repeat=True)
@@ -833,7 +912,7 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         - **Wind Analysis**: Examine wind speed vs ONI relationships
         - **Pressure Analysis**: Analyze pressure vs ONI relationships
         - **Longitude Analysis**: Study typhoon generation longitude vs ONI
-        - **Path Animation**: Watch animated typhoon paths with a sidebar
+        - **Path Animation**: Watch animated typhoon paths with wind radius visualization
         - **TSNE Cluster**: Perform t-SNE clustering on typhoon routes with mean routes and region analysis
         
         Select a tab above to begin your analysis.
@@ -990,33 +1069,47 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
     with gr.Tab("Typhoon Path Animation"):
         with gr.Row():
             year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950, 2025)], value="2024")
-            typhoon_dropdown = gr.Dropdown(label="Typhoon")
+            basin_dropdown = gr.Dropdown(label="Basin", choices=["NA", "EP", "WP", "NI", "SI", "SP", "SA", "All"], value="WP")
+            typhoon_dropdown = gr.Dropdown(label="Tropical Cyclone")
             standard_dropdown = gr.Dropdown(label="Classification Standard", choices=['atlantic', 'taiwan'], value='atlantic')
         
         animate_btn = gr.Button("Generate Animation")
-        path_video = gr.Video(label="Typhoon Path Animation", elem_id="path_video")
+        path_video = gr.Video(label="Tropical Cyclone Path Animation", elem_id="path_video")
         animation_info = gr.Markdown("""
         ### Animation Instructions
-        1. Select a year and typhoon from the dropdowns
-        2. Choose a classification standard (Atlantic or Taiwan)
-        3. Click "Generate Animation"
-        4. Use the video player's built-in controls to play, pause, or scrub through the animation
-        5. The animation shows the typhoon track growing over a world map, with:
-           - Date on the bottom left
-           - Sidebar on the right showing typhoon details (name, date, wind speed, category) as it moves
-           - Color legend with colored markers centered on the right
+        1. Select a year and basin from the dropdowns
+        2. Choose a tropical cyclone from the populated list
+        3. Select a classification standard (Atlantic or Taiwan)
+        4. Click "Generate Animation"
+        5. The animation shows:
+           - Tropical cyclone track growing over time with colored markers based on intensity
+           - Wind radius circles (if data available) for 34kt (blue), 50kt (orange), and 64kt (red)
+           - Date/time on the bottom left 
+           - Details sidebar showing name, date, wind speed, pressure, category, and wind radii
+           - Color legend for storm categories and wind radii
+        
+        Note: Wind radius data may not be available for all storms or all observation times.
+        Different agencies use different wind speed averaging periods: USA (1-min), JTWC (1-min), JMA (10-min), IMD (3-min).
         """)
         
-        def update_typhoon_options(year):
+        def update_typhoon_options(year, basin):
             season = ibtracs.get_season(int(year))
             storm_summary = season.summary()
-            options = [f"{storm_summary['name'][i]} ({storm_summary['id'][i]})" for i in range(storm_summary['season_storms'])]
+            if basin != "All":
+                storm_summary = storm_summary[storm_summary['basin'] == basin]
+            options = [f"{name} ({id})" for name, id in zip(storm_summary['name'], storm_summary['id'])]
             return gr.update(choices=options, value=options[0] if options else None)
         
-        year_dropdown.change(fn=update_typhoon_options, inputs=year_dropdown, outputs=typhoon_dropdown)
+        def update_basin_options(year):
+            return gr.update(value="WP")
+        
+        year_dropdown.change(fn=update_basin_options, inputs=year_dropdown, outputs=basin_dropdown)
+        basin_dropdown.change(fn=update_typhoon_options, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
+        year_dropdown.change(fn=update_typhoon_options, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
+        
         animate_btn.click(
             fn=generate_track_video,
-            inputs=[year_dropdown, typhoon_dropdown, standard_dropdown],
+            inputs=[year_dropdown, basin_dropdown, typhoon_dropdown, standard_dropdown],
             outputs=path_video
         )