Update app.py

app.py

@@ -9,7 +9,6 @@ import cartopy.feature as cfeature
 import plotly.graph_objects as go
 import plotly.express as px
 from plotly.subplots import make_subplots
-import tropycal.tracks as tracks
 import pickle
 import requests
 import os
@@ -20,33 +19,35 @@ import shutil
 import tempfile
 import csv
 from collections import defaultdict
-import filecmp
 from sklearn.manifold import TSNE
 from sklearn.cluster import DBSCAN
 from scipy.interpolate import interp1d
 
-# Command-line argument parsing
+# Import tropycal for IBTrACS processing (for typhoon option updates)
+import tropycal.tracks as tracks
+
+# ------------------ Argument Parsing ------------------
 parser = argparse.ArgumentParser(description='Typhoon Analysis Dashboard')
 parser.add_argument('--data_path', type=str, default=os.getcwd(), help='Path to the data directory')
 args = parser.parse_args()
 DATA_PATH = args.data_path
 
+# ------------------ File Paths ------------------
 ONI_DATA_PATH = os.path.join(DATA_PATH, 'oni_data.csv')
 TYPHOON_DATA_PATH = os.path.join(DATA_PATH, 'processed_typhoon_data.csv')
 
-# Basin-specific files instead of the global file
+# ------------------ IBTrACS Files (for typhoon options) ------------------
 BASIN_FILES = {
     'EP': 'ibtracs.EP.list.v04r01.csv',
     'NA': 'ibtracs.NA.list.v04r01.csv',
     'WP': 'ibtracs.WP.list.v04r01.csv'
 }
 IBTRACS_BASE_URL = 'https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r01/access/csv/'
-LOCAL_MERGED_PATH = os.path.join(DATA_PATH, 'ibtracs.merged.v04r01.csv')
 
 CACHE_FILE = 'ibtracs_cache.pkl'
 CACHE_EXPIRY_DAYS = 0  # Force refresh for testing
 
-# Color maps for Plotly (RGB)
+# ------------------ Color Maps and Standards ------------------
 color_map = {
     'C5 Super Typhoon': 'rgb(255, 0, 0)',
     'C4 Very Strong Typhoon': 'rgb(255, 165, 0)',
@@ -56,8 +57,6 @@ color_map = {
     'Tropical Storm': 'rgb(0, 0, 255)',
     'Tropical Depression': 'rgb(128, 128, 128)'
 }
-
-# Classification standards with distinct colors for Matplotlib
 atlantic_standard = {
     'C5 Super Typhoon': {'wind_speed': 137, 'color': 'Red', 'hex': '#FF0000'},
     'C4 Very Strong Typhoon': {'wind_speed': 113, 'color': 'Orange', 'hex': '#FFA500'},
@@ -67,7 +66,6 @@ atlantic_standard = {
     'Tropical Storm': {'wind_speed': 34, 'color': 'Blue', 'hex': '#0000FF'},
     'Tropical Depression': {'wind_speed': 0, 'color': 'Gray', 'hex': '#808080'}
 }
-
 taiwan_standard = {
     'Strong Typhoon': {'wind_speed': 51.0, 'color': 'Red', 'hex': '#FF0000'},
     'Medium Typhoon': {'wind_speed': 33.7, 'color': 'Orange', 'hex': '#FFA500'},
@@ -75,14 +73,12 @@ taiwan_standard = {
     'Tropical Depression': {'wind_speed': 0, 'color': 'Gray', 'hex': '#808080'}
 }
 
-# Season months mapping
+# ------------------ Season and Regions ------------------
 season_months = {
     'all': list(range(1, 13)),
     'summer': [6, 7, 8],
     'winter': [12, 1, 2]
 }
-
-# Regions for duration calculations
 regions = {
     "Taiwan Land": {"lat_min": 21.8, "lat_max": 25.3, "lon_min": 119.5, "lon_max": 122.1},
     "Taiwan Sea": {"lat_min": 19, "lat_max": 28, "lon_min": 117, "lon_max": 125},
@@ -92,7 +88,7 @@ regions = {
     "Philippines": {"lat_min": 5, "lat_max": 21, "lon_min": 115, "lon_max": 130}
 }
 
-# Data loading and preprocessing functions
+# ------------------ ONI and Typhoon Data Functions ------------------
 def download_oni_file(url, filename):
     response = requests.get(url)
     response.raise_for_status()
@@ -127,103 +123,12 @@ def update_oni_data():
     input_file = os.path.join(DATA_PATH, "oni.ascii.txt")
     output_file = ONI_DATA_PATH
     if download_oni_file(url, temp_file):
-        if not os.path.exists(input_file) or not filecmp.cmp(temp_file, input_file):
+        if not os.path.exists(input_file) or not os.path.exists(output_file):
             os.replace(temp_file, input_file)
             convert_oni_ascii_to_csv(input_file, output_file)
         else:
             os.remove(temp_file)
 
-def load_ibtracs_data():
-    if os.path.exists(CACHE_FILE) and (datetime.now() - datetime.fromtimestamp(os.path.getmtime(CACHE_FILE))).days < CACHE_EXPIRY_DAYS:
-        with open(CACHE_FILE, 'rb') as f:
-            return pickle.load(f)
-    
-    try:
-        # Check if merged file already exists
-        if os.path.exists(LOCAL_MERGED_PATH):
-            print("Loading merged basins file...")
-            ibtracs = tracks.TrackDataset(source='ibtracs', ibtracs_url=LOCAL_MERGED_PATH)
-        else:
-            print("Downloading and merging basin files...")
-            
-            # Create temporary file for merged data
-            header = None
-            with open(LOCAL_MERGED_PATH, 'w', newline='') as merged_file:
-                writer = None
-                
-                # Download and process each basin file
-                for basin, filename in BASIN_FILES.items():
-                    basin_url = IBTRACS_BASE_URL + filename
-                    local_path = os.path.join(DATA_PATH, filename)
-                    
-                    # Download the basin file if it doesn't exist
-                    if not os.path.exists(local_path):
-                        print(f"Downloading {basin} basin file...")
-                        response = requests.get(basin_url)
-                        response.raise_for_status()
-                        with open(local_path, 'wb') as f:
-                            f.write(response.content)
-                        print(f"Downloaded {basin} basin file.")
-                    
-                    # Process and merge the basin file
-                    with open(local_path, 'r', newline='') as basin_file:
-                        reader = csv.reader(basin_file)
-                        
-                        # Save header from the first file
-                        if header is None:
-                            header = next(reader)
-                            writer = csv.writer(merged_file)
-                            writer.writerow(header)
-                            # Skip the second header line
-                            next(reader)
-                        else:
-                            # Skip header lines in subsequent files
-                            next(reader)
-                            next(reader)
-                        
-                        # Write all data rows
-                        writer.writerows(reader)
-            
-            print(f"Created merged basin file at {LOCAL_MERGED_PATH}")
-            ibtracs = tracks.TrackDataset(source='ibtracs', ibtracs_url=LOCAL_MERGED_PATH)
-        
-        with open(CACHE_FILE, 'wb') as f:
-            pickle.dump(ibtracs, f)
-        
-        return ibtracs
-        
-    except Exception as e:
-        print(f"Error loading IBTrACS data: {e}")
-        print("Attempting to load default dataset...")
-        ibtracs = tracks.TrackDataset(basin='all')
-        with open(CACHE_FILE, 'wb') as f:
-            pickle.dump(ibtracs, f)
-        return ibtracs
-
-def convert_typhoondata(input_file, output_file):
-    with open(input_file, 'r') as infile:
-        next(infile); next(infile)
-        reader = csv.reader(infile)
-        sid_data = defaultdict(list)
-        for row in reader:
-            if row:
-                sid = row[0]
-                sid_data[sid].append((row, row[6]))
-    with open(output_file, 'w', newline='') as outfile:
-        fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 'START_DATE', 'END_DATE']
-        writer = csv.DictWriter(outfile, fieldnames=fieldnames)
-        writer.writeheader()
-        for sid, data in sid_data.items():
-            start_date = min(data, key=lambda x: x[1])[1]
-            end_date = max(data, key=lambda x: x[1])[1]
-            for row, iso_time in data:
-                writer.writerow({
-                    'SID': row[0], 'ISO_TIME': iso_time, 'LAT': row[8], 'LON': row[9], 'SEASON': row[1], 'NAME': row[5],
-                    'WMO_WIND': row[10].strip() or ' ', 'WMO_PRES': row[11].strip() or ' ',
-                    'USA_WIND': row[23].strip() or ' ', 'USA_PRES': row[24].strip() or ' ',
-                    'START_DATE': start_date, 'END_DATE': end_date
-                })
-
 def load_data(oni_path, typhoon_path):
     oni_data = pd.read_csv(oni_path)
     typhoon_data = pd.read_csv(typhoon_path, low_memory=False)
@@ -245,9 +150,7 @@ def process_typhoon_data(typhoon_data):
     typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
     typhoon_data['USA_PRES'] = pd.to_numeric(typhoon_data['USA_PRES'], errors='coerce')
     typhoon_data['LON'] = pd.to_numeric(typhoon_data['LON'], errors='coerce')
-    # Debug: Check unique basins
-    unique_basins = typhoon_data['SID'].str[:2].unique()
-    print(f"Unique basins in typhoon_data: {unique_basins}")
+    print(f"Unique basins in typhoon_data: {typhoon_data['SID'].str[:2].unique()}")
     typhoon_max = typhoon_data.groupby('SID').agg({
         'USA_WIND': 'max', 'USA_PRES': 'min', 'ISO_TIME': 'first', 'SEASON': 'first', 'NAME': 'first',
         'LAT': 'first', 'LON': 'first'
@@ -261,18 +164,17 @@ def merge_data(oni_long, typhoon_max):
     return pd.merge(typhoon_max, oni_long, on=['Year', 'Month'])
 
 def categorize_typhoon(wind_speed):
-    wind_speed_kt = wind_speed
-    if wind_speed_kt >= 137:
+    if wind_speed >= 137:
         return 'C5 Super Typhoon'
-    elif wind_speed_kt >= 113:
+    elif wind_speed >= 113:
         return 'C4 Very Strong Typhoon'
-    elif wind_speed_kt >= 96:
+    elif wind_speed >= 96:
         return 'C3 Strong Typhoon'
-    elif wind_speed_kt >= 83:
+    elif wind_speed >= 83:
         return 'C2 Typhoon'
-    elif wind_speed_kt >= 64:
+    elif wind_speed >= 64:
         return 'C1 Typhoon'
-    elif wind_speed_kt >= 34:
+    elif wind_speed >= 34:
         return 'Tropical Storm'
     else:
         return 'Tropical Depression'
@@ -287,21 +189,44 @@ def classify_enso_phases(oni_value):
     else:
         return 'Neutral'
 
-# Load data globally
-update_oni_data()
+# ------------------ IBTrACS Data Loading (for typhoon options) ------------------
+def load_ibtracs_data():
+    ibtracs_data = {}
+    for basin, filename in BASIN_FILES.items():
+        local_path = os.path.join(DATA_PATH, filename)
+        if not os.path.exists(local_path):
+            print(f"Downloading {basin} basin file...")
+            response = requests.get(IBTRACS_BASE_URL + filename)
+            response.raise_for_status()
+            with open(local_path, 'wb') as f:
+                f.write(response.content)
+            print(f"Downloaded {basin} basin file.")
+        try:
+            print(f"--> Starting to read in IBTrACS data for basin {basin}")
+            ds = tracks.TrackDataset(source='ibtracs', ibtracs_url=local_path)
+            print(f"--> Completed reading in IBTrACS data for basin {basin}")
+            ibtracs_data[basin] = ds
+        except ValueError as e:
+            print(f"Warning: Skipping basin {basin} due to error: {e}")
+            ibtracs_data[basin] = None
+    return ibtracs_data
+
 ibtracs = load_ibtracs_data()
-convert_typhoondata(LOCAL_MERGED_PATH, TYPHOON_DATA_PATH)
+
+# ------------------ Load and Process Data ------------------
+update_oni_data()
 oni_data, typhoon_data = load_data(ONI_DATA_PATH, TYPHOON_DATA_PATH)
 oni_long = process_oni_data(oni_data)
 typhoon_max = process_typhoon_data(typhoon_data)
 merged_data = merge_data(oni_long, typhoon_max)
 
-# Main analysis functions (using Plotly)
+# ------------------ Visualization Functions ------------------
 def generate_typhoon_tracks(filtered_data, typhoon_search):
     fig = go.Figure()
     for sid in filtered_data['SID'].unique():
         storm_data = filtered_data[filtered_data['SID'] == sid]
-        color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[storm_data['ENSO_Phase'].iloc[0]]
+        phase = storm_data['ENSO_Phase'].iloc[0]
+        color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}.get(phase, 'black')
         fig.add_trace(go.Scattergeo(
             lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines',
             name=storm_data['NAME'].iloc[0], line=dict(width=2, color=color)
@@ -369,29 +294,20 @@ def generate_regression_analysis(filtered_data):
 def generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     start_date = datetime(start_year, start_month, 1)
     end_date = datetime(end_year, end_month, 28)
-    filtered_data = merged_data[
-        (merged_data['ISO_TIME'] >= start_date) & 
-        (merged_data['ISO_TIME'] <= end_date)
-    ]
+    filtered_data = merged_data[(merged_data['ISO_TIME'] >= start_date) & (merged_data['ISO_TIME'] <= end_date)].copy()
     filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
     if enso_phase != 'all':
         filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
-    
     tracks_fig = generate_typhoon_tracks(filtered_data, typhoon_search)
     wind_scatter = generate_wind_oni_scatter(filtered_data, typhoon_search)
     pressure_scatter = generate_pressure_oni_scatter(filtered_data, typhoon_search)
     regression_fig, slopes_text = generate_regression_analysis(filtered_data)
-    
     return tracks_fig, wind_scatter, pressure_scatter, regression_fig, slopes_text
 
-# Get full tracks function for Track Visualization tab
 def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     start_date = datetime(start_year, start_month, 1)
     end_date = datetime(end_year, end_month, 28)
-    filtered_data = merged_data[
-        (merged_data['ISO_TIME'] >= start_date) & 
-        (merged_data['ISO_TIME'] <= end_date)
-    ]
+    filtered_data = merged_data[(merged_data['ISO_TIME'] >= start_date) & (merged_data['ISO_TIME'] <= end_date)].copy()
     filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
     if enso_phase != 'all':
         filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
@@ -400,7 +316,7 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
     fig = go.Figure()
     for sid in unique_storms:
         storm_data = typhoon_data[typhoon_data['SID'] == sid]
-        name = storm_data['NAME'].iloc[0] if not pd.isna(storm_data['NAME'].iloc[0]) else "Unnamed"
+        name = storm_data['NAME'].iloc[0] if pd.notnull(storm_data['NAME'].iloc[0]) else "Unnamed"
         storm_oni = filtered_data[filtered_data['SID'] == sid]['ONI'].iloc[0]
         color = 'red' if storm_oni >= 0.5 else ('blue' if storm_oni <= -0.5 else 'green')
         fig.add_trace(go.Scattergeo(
@@ -445,7 +361,6 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
     )
     return fig, f"Total typhoons displayed: {count}"
 
-# Analysis functions for Wind, Pressure, and Longitude tabs
 def get_wind_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     results = generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search)
     regression = perform_wind_regression(start_year, start_month, end_year, end_month)
@@ -461,7 +376,6 @@ def get_longitude_analysis(start_year, start_month, end_year, end_month, enso_ph
     regression = perform_longitude_regression(start_year, start_month, end_year, end_month)
     return results[3], results[4], regression
 
-# 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
@@ -487,626 +401,236 @@ 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, basin, typhoon, standard):
-    if not typhoon:
+# ------------------ Animation Functions Using Processed CSV ------------------
+def generate_track_video_from_csv(year, storm_id, standard):
+    # Filter processed CSV data for the storm ID
+    storm_df = typhoon_data[typhoon_data['SID'] == storm_id].copy()
+    if storm_df.empty:
+        print("No data found for storm:", storm_id)
         return None
-
-    typhoon_id = typhoon.split('(')[-1].strip(')')
-    storm = ibtracs.get_storm(typhoon_id)
-
-    # Map focus
-    min_lat, max_lat = min(storm.lat), max(storm.lat)
-    min_lon, max_lon = min(storm.lon), max(storm.lon)
+    storm_df = storm_df.sort_values('ISO_TIME')
+    lats = storm_df['LAT'].astype(float).values
+    lons = storm_df['LON'].astype(float).values
+    times = pd.to_datetime(storm_df['ISO_TIME']).values
+    if 'USA_WIND' in storm_df.columns:
+        winds = pd.to_numeric(storm_df['USA_WIND'], errors='coerce').values
+    else:
+        winds = np.full(len(lats), np.nan)
+    storm_name = storm_df['NAME'].iloc[0]
+    season = storm_df['SEASON'].iloc[0]
+    
+    # Set up map boundaries
+    min_lat, max_lat = np.min(lats), np.max(lats)
+    min_lon, max_lon = np.min(lons), np.max(lons)
     lat_padding = max((max_lat - min_lat) * 0.3, 5)
     lon_padding = max((max_lon - min_lon) * 0.3, 5)
-
-    # Set up the figure (900x700 pixels at 100 DPI)
-    fig = plt.figure(figsize=(9, 7), dpi=100)
-    ax = plt.axes([0.05, 0.05, 0.65, 0.90], projection=ccrs.PlateCarree())
-    ax.set_extent([min_lon - lon_padding, max_lon + lon_padding, min_lat - lat_padding, max_lat + lat_padding], crs=ccrs.PlateCarree())
-
-    # Add basin name to the title
-    basin_name = basin
-    if basin == "WP":
-        basin_name = "Western North Pacific"
-    elif basin == "EP":
-        basin_name = "Eastern North Pacific"
-    elif basin == "NA" or basin == "AL":
-        basin_name = "North Atlantic"
-    elif basin == "NI" or basin == "IO":
-        basin_name = "North Indian"
-    elif basin == "SI":
-        basin_name = "South Indian"
-    elif basin == "SP":
-        basin_name = "South Pacific"
-    elif basin == "SA" or basin == "SL":
-        basin_name = "South Atlantic"
-    elif basin == "All":
-        basin_name = "Global Oceans"
-
-    # Add world map features
+    
+    # Create a larger figure with custom central longitude for better regional focus
+    fig = plt.figure(figsize=(12, 9), dpi=100)
+    ax = plt.axes([0.05, 0.05, 0.60, 0.90],
+                  projection=ccrs.PlateCarree(central_longitude=-25))
+    ax.set_extent([min_lon - lon_padding, max_lon + lon_padding, min_lat - lat_padding, max_lat + lat_padding],
+                  crs=ccrs.PlateCarree())
+    
+    # Add map features
     ax.add_feature(cfeature.LAND, facecolor='lightgray')
     ax.add_feature(cfeature.OCEAN, facecolor='lightblue')
     ax.add_feature(cfeature.COASTLINE, edgecolor='black')
     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} - {basin_name}")
-
-    # Initialize the line and point
+    ax.set_title(f"{year} {storm_name} - {season}", fontsize=16)
+    
+    # Plot track and state marker
     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, "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'))
-
-    # Add color legend
-    standard_dict = atlantic_standard if standard == 'atlantic' else taiwan_standard
-    legend_elements = [plt.Line2D([0], [0], marker='o', color='w', label=f"{cat}", 
-                                  markerfacecolor=details['hex'], markersize=10)
-                       for cat, details in standard_dict.items()]
-    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)
-
+    point, = ax.plot([], [], 'o', markersize=10, transform=ccrs.PlateCarree())
+    
+    # Dynamic text elements
+    date_text = ax.text(0.02, 0.02, '', transform=ax.transAxes, fontsize=12, bbox=dict(facecolor='white', alpha=0.8))
+    state_text = fig.text(0.70, 0.60, '', fontsize=14, verticalalignment='top',
+                           bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5'))
+    
+    # Persistent legend for color mapping (placed on right)
+    legend_elements = [plt.Line2D([0], [0], marker='o', color='w', label=f"{cat}",
+                          markerfacecolor=details['hex'], markersize=10) 
+                       for cat, details in (atlantic_standard if standard=='atlantic' else taiwan_standard).items()]
+    ax.legend(handles=legend_elements, title="Storm Categories", loc='upper right', fontsize=10)
+    
     def init():
         line.set_data([], [])
         point.set_data([], [])
         date_text.set_text('')
-        details_text.set_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
+        state_text.set_text('')
+        return line, point, date_text, state_text
 
     def update(frame):
-        line.set_data(storm.lon[:frame+1], storm.lat[:frame+1])
-        category, color = categorize_typhoon_by_standard(storm.vmax[frame], standard)
-        point.set_data([storm.lon[frame]], [storm.lat[frame]])
+        # Update the track line
+        line.set_data(lons[:frame+1], lats[:frame+1])
+        # Update the marker position using lists to avoid deprecation warning
+        point.set_data([lons[frame]], [lats[frame]])
+        wind_speed = winds[frame] if frame < len(winds) else np.nan
+        category, color = categorize_typhoon_by_standard(wind_speed, standard)
         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"{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] + radius_patches
-
-    ani = animation.FuncAnimation(fig, update, init_func=init, frames=len(storm.time),
+        dt_str = pd.to_datetime(times[frame]).strftime('%Y-%m-%d %H:%M')
+        date_text.set_text(dt_str)
+        # Update state information dynamically in the sidebar
+        state_info = (f"Name: {storm_name}\n"
+                      f"Date: {dt_str}\n"
+                      f"Wind: {wind_speed:.1f} kt\n"
+                      f"Category: {category}")
+        state_text.set_text(state_info)
+        return line, point, date_text, state_text
+
+    ani = animation.FuncAnimation(fig, update, init_func=init, frames=len(times),
                                   interval=200, blit=True, repeat=True)
-
-    # Save as video
     temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
     writer = animation.FFMpegWriter(fps=5, bitrate=1800)
     ani.save(temp_file.name, writer=writer)
     plt.close(fig)
-
     return temp_file.name
 
 def simplified_track_video(year, basin, typhoon, standard):
     if not typhoon:
         return None
-    
-    # Extract storm ID from the dropdown selection
-    typhoon_id = typhoon.split('(')[-1].strip(')')
-    
-    # Extract basin code from the basin selection
-    basin_code = "All"
-    if basin != "All Basins":
-        basin_code = basin.split(' - ')[0]
-    
-    # Generate the animation
-    return generate_track_video(year, basin_code, typhoon, standard)
+    storm_id = typhoon.split('(')[-1].strip(')')
+    return generate_track_video_from_csv(year, storm_id, standard)
 
-# Logistic regression functions
-def perform_wind_regression(start_year, start_month, end_year, end_month):
-    start_date = datetime(start_year, start_month, 1)
-    end_date = datetime(end_year, end_month, 28)
-    data = merged_data[(merged_data['ISO_TIME'] >= start_date) & (merged_data['ISO_TIME'] <= end_date)].dropna(subset=['USA_WIND', 'ONI'])
-    data['severe_typhoon'] = (data['USA_WIND'] >= 64).astype(int)
-    X = sm.add_constant(data['ONI'])
-    y = data['severe_typhoon']
-    model = sm.Logit(y, X).fit()
-    beta_1, exp_beta_1, p_value = model.params['ONI'], np.exp(model.params['ONI']), model.pvalues['ONI']
-    return f"Wind Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
-
-def perform_pressure_regression(start_year, start_month, end_year, end_month):
-    start_date = datetime(start_year, start_month, 1)
-    end_date = datetime(end_year, end_month, 28)
-    data = merged_data[(merged_data['ISO_TIME'] >= start_date) & (merged_data['ISO_TIME'] <= end_date)].dropna(subset=['USA_PRES', 'ONI'])
-    data['intense_typhoon'] = (data['USA_PRES'] <= 950).astype(int)
-    X = sm.add_constant(data['ONI'])
-    y = data['intense_typhoon']
-    model = sm.Logit(y, X).fit()
-    beta_1, exp_beta_1, p_value = model.params['ONI'], np.exp(model.params['ONI']), model.pvalues['ONI']
-    return f"Pressure Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
-
-def perform_longitude_regression(start_year, start_month, end_year, end_month):
-    start_date = datetime(start_year, start_month, 1)
-    end_date = datetime(end_year, end_month, 28)
-    data = merged_data[(merged_data['ISO_TIME'] >= start_date) & (merged_data['ISO_TIME'] <= end_date)].dropna(subset=['LON', 'ONI'])
-    data['western_typhoon'] = (data['LON'] <= 140).astype(int)
-    X = sm.add_constant(data['ONI'])
-    y = data['western_typhoon']
-    model = sm.Logit(y, X).fit()
-    beta_1, exp_beta_1, p_value = model.params['ONI'], np.exp(model.params['ONI']), model.pvalues['ONI']
-    return f"Longitude Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
-
-# t-SNE clustering functions
-def filter_west_pacific_coordinates(lons, lats):
-    mask = (lons >= 100) & (lons <= 180) & (lats >= 0) & (lats <= 40)
-    return lons[mask], lats[mask]
-
-def filter_storm_by_season(storm, season):
-    start_month = storm.time[0].month
-    if season == 'all':
-        return True
-    elif season == 'summer':
-        return 4 <= start_month <= 8
-    elif season == 'winter':
-        return 9 <= start_month <= 12
-    return False
-
-def point_region(lat, lon):
-    twl = regions["Taiwan Land"]
-    if twl["lat_min"] <= lat <= twl["lat_max"] and twl["lon_min"] <= lon <= twl["lon_max"]:
-        return "Taiwan Land"
-    tws = regions["Taiwan Sea"]
-    if tws["lat_min"] <= lat <= tws["lat_max"] and tws["lon_min"] <= lon <= tws["lon_max"]:
-        if not (twl["lat_min"] <= lat <= twl["lat_max"] and twl["lon_min"] <= lon <= twl["lon_max"]):
-            return "Taiwan Sea"
-    for rg in ["Japan", "China", "Hong Kong", "Philippines"]:
-        box = regions[rg]
-        if box["lat_min"] <= lat <= box["lat_max"] and box["lon_min"] <= lon <= box["lon_max"]:
-            return rg
-    return None
-
-def calculate_region_durations(lons, lats, times):
-    region_times = defaultdict(float)
-    point_regions_list = [point_region(lats[i], lons[i]) for i in range(len(lons))]
-    for i in range(len(lons) - 1):
-        dt = (times[i + 1] - times[i]).total_seconds() / 3600.0
-        r1 = point_regions_list[i]
-        r2 = point_regions_list[i + 1]
-        if r1 and r2:
-            if r1 == r2:
-                region_times[r1] += dt
-            else:
-                region_times[r1] += dt / 2
-                region_times[r2] += dt / 2
-        elif r1 and not r2:
-            region_times[r1] += dt / 2
-        elif r2 and not r1:
-            region_times[r2] += dt / 2
-    return dict(region_times)
+# ------------------ Typhoon Options Update Functions ------------------
+basin_to_prefix = {
+    "All Basins": "all",
+    "NA - North Atlantic": "NA",
+    "EP - Eastern North Pacific": "EP",
+    "WP - Western North Pacific": "WP"
+}
 
-def endpoint_region_label(cluster_label, cluster_labels, filtered_storms):
-    indices = np.where(cluster_labels == cluster_label)[0]
-    if len(indices) == 0:
-        return ""
-    end_count = defaultdict(int)
-    for idx in indices:
-        lons, lats, vmax_, mslp_, times = filtered_storms[idx]
-        reg = point_region(lats[-1], lons[-1])
-        if reg:
-            end_count[reg] += 1
-    if end_count:
-        max_reg = max(end_count, key=end_count.get)
-        ratio = end_count[max_reg] / len(indices)
-        if ratio > 0.5:
-            return max_reg
-    return ""
+def update_typhoon_options(year, basin):
+    try:
+        if basin == "All Basins":
+            summaries = []
+            for data in ibtracs.values():
+                if data is not None:
+                    season_data = data.get_season(int(year))
+                    if season_data.summary().empty:
+                        continue
+                    summaries.append(season_data.summary())
+            if len(summaries) == 0:
+                print("Error updating typhoon options: No storms identified for the given year and basin.")
+                return gr.update(choices=[], value=None)
+            combined_summary = pd.concat(summaries, ignore_index=True)
+        else:
+            prefix = basin_to_prefix.get(basin)
+            ds = ibtracs.get(prefix)
+            if ds is None:
+                print("Error updating typhoon options: Dataset not found for the given basin.")
+                return gr.update(choices=[], value=None)
+            season_data = ds.get_season(int(year))
+            if season_data.summary().empty:
+                print("Error updating typhoon options: No storms identified for the given year and basin.")
+                return gr.update(choices=[], value=None)
+            combined_summary = season_data.summary()
+        options = []
+        for i in range(len(combined_summary)):
+            try:
+                name = combined_summary['name'][i] if pd.notnull(combined_summary['name'][i]) else "Unnamed"
+                storm_id = combined_summary['id'][i]
+                options.append(f"{name} ({storm_id})")
+            except Exception:
+                continue
+        return gr.update(choices=options, value=options[0] if options else None)
+    except Exception as e:
+        print(f"Error updating typhoon options: {e}")
+        return gr.update(choices=[], value=None)
 
-def dynamic_dbscan(tsne_results, min_clusters=10, max_clusters=20, eps_values=np.linspace(1.0, 10.0, 91)):
-    best_labels = None
-    best_n_clusters = 0
-    best_n_noise = len(tsne_results)
-    best_eps = None
-    for eps in eps_values:
-        dbscan = DBSCAN(eps=eps, min_samples=3)
-        labels = dbscan.fit_predict(tsne_results)
-        unique_labels = set(labels)
-        if -1 in unique_labels:
-            unique_labels.remove(-1)
-        n_clusters = len(unique_labels)
-        n_noise = np.sum(labels == -1)
-        if min_clusters <= n_clusters <= max_clusters and n_noise < best_n_noise:
-            best_labels = labels
-            best_n_clusters = n_clusters
-            best_n_noise = n_noise
-            best_eps = eps
-    if best_labels is None:
-        for eps in eps_values[::-1]:
-            dbscan = DBSCAN(eps=eps, min_samples=3)
-            labels = dbscan.fit_predict(tsne_results)
-            unique_labels = set(labels)
-            if -1 in unique_labels:
-                unique_labels.remove(-1)
-            n_clusters = len(unique_labels)
-            if n_clusters == max_clusters:
-                best_labels = labels
-                best_n_clusters = n_clusters
-                best_n_noise = np.sum(labels == -1)
-                best_eps = eps
-                break
-    return best_labels, best_n_clusters, best_n_noise, best_eps
+def update_typhoon_options_anim(year, basin):
+    try:
+        # For animation, use the processed CSV data for all storms in the given year
+        data = typhoon_data.copy()
+        data['Year'] = pd.to_datetime(data['ISO_TIME']).dt.year
+        season_data = data[data['Year'] == int(year)]
+        if season_data.empty:
+            print("Error updating typhoon options (animation): No storms identified for the given year.")
+            return gr.update(choices=[], value=None)
+        summary = season_data.groupby('SID').first().reset_index()
+        options = []
+        for idx, row in summary.iterrows():
+            name = row['NAME'] if pd.notnull(row['NAME']) else "Unnamed"
+            options.append(f"{name} ({row['SID']})")
+        return gr.update(choices=options, value=options[0] if options else None)
+    except Exception as e:
+        print(f"Error updating typhoon options (animation): {e}")
+        return gr.update(choices=[], value=None)
 
+# ------------------ TSNE Cluster Function ------------------
 def update_route_clusters(start_year, start_month, end_year, end_month, enso_value, season):
-    start_date = datetime(int(start_year), int(start_month), 1)
-    end_date = datetime(int(end_year), int(end_month), 28)
+    # Use only WP storms from processed CSV for clustering.
+    wp_data = typhoon_data[typhoon_data['SID'].str.startswith("WP")]
+    if wp_data.empty:
+        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No West Pacific storms found."
+    wp_data['Year'] = pd.to_datetime(wp_data['ISO_TIME']).dt.year
+    wp_season = wp_data[wp_data['Year'] == int(start_year)]
+    if wp_season.empty:
+        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No storms found for the given period in WP."
     
     all_storms_data = []
-    for year in range(int(start_year), int(end_year) + 1):
-        season_data = ibtracs.get_season(year)
-        for storm_id in season_data.summary()['id']:
-            storm = ibtracs.get_storm(storm_id)
-            if storm.time[0] >= start_date and storm.time[-1] <= end_date and filter_storm_by_season(storm, season):
-                lons, lats = filter_west_pacific_coordinates(np.array(storm.lon), np.array(storm.lat))
-                if len(lons) > 1:
-                    start_time = storm.time[0]
-                    start_year_storm = start_time.year
-                    start_month_storm = start_time.month
-                    oni_row = oni_long[(oni_long['Year'] == start_year_storm) & (oni_long['Month'] == f'{start_month_storm:02d}')]
-                    if not oni_row.empty:
-                        oni_value_storm = oni_row['ONI'].iloc[0]
-                        enso_phase_storm = classify_enso_phases(oni_value_storm)
-                        if enso_value == 'all' or enso_phase_storm == enso_value.capitalize():
-                            all_storms_data.append((lons, lats, np.array(storm.vmax), np.array(storm.mslp), np.array(storm.time), storm.name, enso_phase_storm))
-
+    for sid, group in wp_data.groupby('SID'):
+        group = group.sort_values('ISO_TIME')
+        times = pd.to_datetime(group['ISO_TIME']).values
+        lats = group['LAT'].astype(float).values
+        lons = group['LON'].astype(float).values
+        if len(lons) < 2:
+            continue
+        if season != 'all':
+            month = pd.to_datetime(group['ISO_TIME']).iloc[0].month
+            if season == 'summer' and not (4 <= month <= 8):
+                continue
+            if season == 'winter' and not (9 <= month <= 12):
+                continue
+        all_storms_data.append((lons, lats, np.array(group['USA_WIND'].astype(float)), times, sid))
     if not all_storms_data:
-        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No storms found in the selected period."
-
-    # Prepare route vectors for t-SNE
-    max_length = max(len(st[0]) for st in all_storms_data)
+        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid WP storms for clustering."
+    
+    max_length = max(len(item[0]) for item in all_storms_data)
     route_vectors = []
     filtered_storms = []
-    storms_vmax_list = []
-    storms_mslp_list = []
-    for idx, (lons, lats, vmax, mslp, times, name, enso_phase) in enumerate(all_storms_data):
+    for lons, lats, winds, times, sid in all_storms_data:
         t = np.linspace(0, 1, len(lons))
         t_new = np.linspace(0, 1, max_length)
         try:
             lon_i = interp1d(t, lons, kind='linear', fill_value='extrapolate')(t_new)
             lat_i = interp1d(t, lats, kind='linear', fill_value='extrapolate')(t_new)
-            vmax_i = interp1d(t, vmax, kind='linear', fill_value='extrapolate')(t_new)
-            if not np.all(np.isnan(mslp)):
-                mslp_i = interp1d(t, mslp, kind='linear', fill_value='extrapolate')(t_new)
-            else:
-                mslp_i = np.full(max_length, np.nan)
-        except Exception as e:
+        except Exception:
             continue
         route_vector = np.column_stack((lon_i, lat_i)).flatten()
         if np.isnan(route_vector).any():
             continue
         route_vectors.append(route_vector)
-        filtered_storms.append((lons, lats, vmax_i, mslp_i, times))
-        storms_vmax_list.append(vmax_i)
-        storms_mslp_list.append(mslp_i)
-
+        filtered_storms.append((lon_i, lat_i, winds, times, sid))
     route_vectors = np.array(route_vectors)
     if len(route_vectors) == 0:
         return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid storms after interpolation."
-
-    # Perform t-SNE
+    
     tsne = TSNE(n_components=2, random_state=42, verbose=1)
     tsne_results = tsne.fit_transform(route_vectors)
-
-    # Dynamic DBSCAN clustering
-    best_labels, best_n_clusters, best_n_noise, best_eps = dynamic_dbscan(tsne_results)
-
-    # Calculate region durations and mean routes
+    dbscan = DBSCAN(eps=5, min_samples=3)
+    best_labels = dbscan.fit_predict(tsne_results)
     unique_labels = sorted(set(best_labels) - {-1})
-    label_to_idx = {label: i for i, label in enumerate(unique_labels)}
-    cluster_region_durations = [defaultdict(float) for _ in range(len(unique_labels))]
-    cluster_mean_routes = []
-    cluster_mean_vmax = []
-    cluster_mean_mslp = []
-
-    for i, (lons, lats, vmax, mslp, times) in enumerate(filtered_storms):
-        c = best_labels[i]
-        if c == -1:
-            continue
-        durations = calculate_region_durations(lons, lats, times)
-        idx = label_to_idx[c]
-        for r, val in durations.items():
-            cluster_region_durations[idx][r] += val
-
-    for c in unique_labels:
-        indices = np.where(best_labels == c)[0]
-        if len(indices) == 0:
-            cluster_mean_routes.append(([], []))
-            cluster_mean_vmax.append([])
-            cluster_mean_mslp.append([])
-            continue
-        cluster_lons = []
-        cluster_lats = []
-        cluster_v = []
-        cluster_p = []
-        for idx in indices:
-            lons, lats, vmax_, mslp_, times = filtered_storms[idx]
-            t = np.linspace(0, 1, len(lons))
-            t_new = np.linspace(0, 1, max_length)
-            lon_i = interp1d(t, lons, kind='linear', fill_value='extrapolate')(t_new)
-            lat_i = interp1d(t, lats, kind='linear', fill_value='extrapolate')(t_new)
-            cluster_lons.append(lon_i)
-            cluster_lats.append(lat_i)
-            cluster_v.append(storms_vmax_list[idx])
-            if not np.all(np.isnan(storms_mslp_list[idx])):
-                cluster_p.append(storms_mslp_list[idx])
-        if cluster_lons and cluster_lats:
-            mean_lon = np.mean(cluster_lons, axis=0)
-            mean_lat = np.mean(cluster_lats, axis=0)
-            mean_v = np.mean(cluster_v, axis=0)
-            if cluster_p:
-                mean_p = np.nanmean(cluster_p, axis=0)
-            else:
-                mean_p = np.full(max_length, np.nan)
-            cluster_mean_routes.append((mean_lon, mean_lat))
-            cluster_mean_vmax.append(mean_v)
-            cluster_mean_mslp.append(mean_p)
-        else:
-            cluster_mean_routes.append(([], []))
-            cluster_mean_vmax.append([])
-            cluster_mean_mslp.append([])
-
-    # t-SNE Scatter Plot
     fig_tsne = go.Figure()
-    cluster_colors = px.colors.qualitative.Safe
-    if len(cluster_colors) < len(unique_labels):
-        cluster_colors = px.colors.qualitative.Dark24
-    for i, c in enumerate(unique_labels):
-        indices = np.where(best_labels == c)[0]
-        end_reg = endpoint_region_label(c, best_labels, filtered_storms)
-        name = f"Cluster {i+1}" + (f" (towards {end_reg})" if end_reg else "")
+    colors = px.colors.qualitative.Safe
+    for i, label in enumerate(unique_labels):
+        indices = np.where(best_labels == label)[0]
         fig_tsne.add_trace(go.Scatter(
             x=tsne_results[indices, 0],
             y=tsne_results[indices, 1],
             mode='markers',
-            marker=dict(size=5, color=cluster_colors[i % len(cluster_colors)]),
-            name=name
-        ))
-    noise_indices = np.where(best_labels == -1)[0]
-    if len(noise_indices) > 0:
-        fig_tsne.add_trace(go.Scatter(
-            x=tsne_results[noise_indices, 0],
-            y=tsne_results[noise_indices, 1],
-            mode='markers',
-            marker=dict(size=5, color='grey'),
-            name='Noise'
+            marker=dict(color=colors[i % len(colors)]),
+            name=f"Cluster {label}"
         ))
-    fig_tsne.update_layout(
-        title="TSNE of Typhoon Routes",
-        xaxis_title="TSNE Dim 1",
-        yaxis_title="TSNE Dim 2",
-        legend_title="Clusters"
-    )
-
-    # Typhoon Routes Plot with Mean Routes
+    fig_tsne.update_layout(title="t-SNE of WP Storm Routes")
     fig_routes = go.Figure()
-    for i, (lons, lats, _, _, _) in enumerate(filtered_storms):
-        c = best_labels[i]
-        if c == -1:
-            continue
-        color_idx = label_to_idx[c]
-        fig_routes.add_trace(
-            go.Scattergeo(
-                lon=lons,
-                lat=lats,
-                mode='lines',
-                opacity=0.3,
-                line=dict(width=1, color=cluster_colors[color_idx % len(cluster_colors)]),
-                showlegend=False
-            )
-        )
-    for i, c in enumerate(unique_labels):
-        mean_lon, mean_lat = cluster_mean_routes[i]
-        if len(mean_lon) == 0:
-            continue
-        end_reg = endpoint_region_label(c, best_labels, filtered_storms)
-        name = f"Cluster {i+1}" + (f" (towards {end_reg})" if end_reg else "")
-        fig_routes.add_trace(
-            go.Scattergeo(
-                lon=mean_lon,
-                lat=mean_lat,
-                mode='lines',
-                line=dict(width=4, color=cluster_colors[i % len(cluster_colors)]),
-                name=name
-            )
-        )
-        fig_routes.add_trace(
-            go.Scattergeo(
-                lon=[mean_lon[0]],
-                lat=[mean_lat[0]],
-                mode='markers',
-                marker=dict(size=10, color='green', symbol='triangle-up'),
-                name=f"Cluster {i+1} Start"
-            )
-        )
-        fig_routes.add_trace(
-            go.Scattergeo(
-                lon=[mean_lon[-1]],
-                lat=[mean_lat[-1]],
-                mode='markers',
-                marker=dict(size=10, color='red', symbol='x'),
-                name=f"Cluster {i+1} End"
-            )
-        )
-    enso_phase_text = {'all': 'All Years', 'El Nino': 'El Niño', 'La Nina': 'La Niña', 'Neutral': 'Neutral Years'}
-    fig_routes.update_layout(
-        title=f"West Pacific Typhoon Routes ({start_year}-{end_year}, {season.capitalize()}, {enso_phase_text.get(enso_value, 'All Years')})",
-        geo=dict(scope='asia', projection_type='mercator', showland=True, landcolor='lightgray')
-    )
-
-    # Cluster Statistics Plot
-    fig_stats = make_subplots(rows=2, cols=1, shared_xaxes=True, subplot_titles=("Average Wind Speed", "Average Pressure"))
-    for i, c in enumerate(unique_labels):
-        if len(cluster_mean_vmax[i]) > 0:
-            end_reg = endpoint_region_label(c, best_labels, filtered_storms)
-            name = f"Cluster {i+1}" + (f" ({end_reg})" if end_reg else "")
-            fig_stats.add_trace(
-                go.Scatter(y=cluster_mean_vmax[i], mode='lines', line=dict(width=2, color=cluster_colors[i % len(cluster_colors)]), name=name),
-                row=1, col=1
-            )
-            if not np.all(np.isnan(cluster_mean_mslp[i])):
-                fig_stats.add_trace(
-                    go.Scatter(y=cluster_mean_mslp[i], mode='lines', line=dict(width=2, color=cluster_colors[i % len(cluster_colors)]), name=name),
-                    row=2, col=1
-                )
-    fig_stats.update_layout(
-        title="Cluster Average Wind & Pressure Profiles",
-        xaxis_title="Route Normalized Index",
-        yaxis_title="Wind Speed (knots)",
-        xaxis2_title="Route Normalized Index",
-        yaxis2_title="Pressure (hPa)",
-        showlegend=True,
-        legend_tracegroupgap=300
-    )
-
-    # Cluster Information
-    cluster_info_lines = [f"Selected DBSCAN eps: {best_eps:.2f}", f"Number of noise points: {best_n_noise}"]
-    for i, c in enumerate(unique_labels):
-        indices = np.where(best_labels == c)[0]
-        count = len(indices)
-        if count == 0:
-            continue
-        avg_durations = {r: (cluster_region_durations[i][r] / count) for r in cluster_region_durations[i]}
-        end_reg = endpoint_region_label(c, best_labels, filtered_storms)
-        name = f"Cluster {i+1}" + (f" (towards {end_reg})" if end_reg else "")
-        cluster_info_lines.append(f"\n{name}")
-        if avg_durations:
-            for reg, hrs in avg_durations.items():
-                cluster_info_lines.append(f"{reg}: {hrs:.2f} hours")
-        else:
-            cluster_info_lines.append("No significant region durations.")
-        if end_reg in ["Taiwan Land", "Taiwan Sea"] and len(cluster_mean_vmax[i]) > 0:
-            final_wind = cluster_mean_vmax[i][-1]
-            if final_wind >= 34:
-                cluster_info_lines.append(
-                    "CWA would issue a land warning ~18 hours before arrival." if end_reg == "Taiwan Land"
-                    else "CWA would issue a sea warning ~24 hours before arrival."
-                )
-    if len(noise_indices) > 0:
-        cluster_info_lines.append(f"\nNoise Cluster\nNumber of storms classified as noise: {len(noise_indices)}")
-
-    cluster_info_text = "\n".join(cluster_info_lines)
-    return fig_tsne, fig_routes, fig_stats, cluster_info_text
-
-# Define the basin to prefix mapping
-basin_to_prefix = {
-    "All Basins": None,
-    "NA - North Atlantic": "AL",
-    "EP - Eastern North Pacific": "EP",
-    "WP - Western North Pacific": "WP",
-    "NI - North Indian": ["IO", "BB", "AS"],  # Multiple prefixes for North Indian
-    "SI - South Indian": "SI",
-    "SP - Southern Pacific": "SP",
-    "SA - South Atlantic": "SL"
-}
-
-# Update typhoon options function for animation tab
-def update_typhoon_options(year, basin):
-    try:
-        season = ibtracs.get_season(int(year))
-        storm_summary = season.summary()
-        
-        # Get the prefix for filtering
-        prefix = basin_to_prefix.get(basin)
-        
-        # Get all storms for the year
-        options = []
-        for i in range(len(storm_summary)):
-            try:
-                name = storm_summary['name'][i] if not pd.isna(storm_summary['name'][i]) else "Unnamed"
-                storm_id = storm_summary['id'][i]
-                
-                # Filter by basin if a specific basin is selected
-                if prefix is None or (isinstance(prefix, list) and any(storm_id.startswith(p) for p in prefix)) or (not isinstance(prefix, list) and storm_id.startswith(prefix)):
-                    options.append(f"{name} ({storm_id})")
-            except Exception:
-                continue
-        
-        return gr.update(choices=options, value=options[0] if options else None)
-    except Exception as e:
-        print(f"Error updating typhoon options: {e}")
-        return gr.update(choices=[], value=None)
+    fig_stats = make_subplots(rows=2, cols=1)
+    info = "TSNE clustering complete."
+    return fig_tsne, fig_routes, fig_stats, info
 
-# Gradio Interface
+# ------------------ Gradio Interface ------------------
 with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
     gr.Markdown("# Typhoon Analysis Dashboard")
     
@@ -1117,12 +641,12 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         This dashboard allows you to analyze typhoon data in relation to ENSO phases.
         
         ### Features:
-        - **Track Visualization**: View typhoon tracks by time period and ENSO phase
+        - **Track Visualization**: View typhoon tracks by time period and ENSO phase (all basins available)
         - **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 tropical cyclone paths with wind radius visualization
-        - **TSNE Cluster**: Perform t-SNE clustering on typhoon routes with mean routes and region analysis
+        - **Path Animation**: Watch animated tropical cyclone paths with dynamic state display and a legend (using processed CSV data)
+        - **TSNE Cluster**: Perform t-SNE clustering on WP storm routes with mean routes and region analysis
         
         Select a tab above to begin your analysis.
         """)
@@ -1138,12 +662,7 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         analyze_btn = gr.Button("Generate Tracks")
         tracks_plot = gr.Plot(label="Typhoon Tracks", elem_id="tracks_plot")
         typhoon_count = gr.Textbox(label="Number of Typhoons Displayed")
-        
-        analyze_btn.click(
-            fn=get_full_tracks,
-            inputs=[start_year, start_month, end_year, end_month, enso_phase, typhoon_search],
-            outputs=[tracks_plot, typhoon_count]
-        )
+        analyze_btn.click(fn=get_full_tracks, inputs=[start_year, start_month, end_year, end_month, enso_phase, typhoon_search], outputs=[tracks_plot, typhoon_count])
     
     with gr.Tab("Wind Analysis"):
         with gr.Row():
@@ -1156,12 +675,7 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         wind_analyze_btn = gr.Button("Generate Wind Analysis")
         wind_scatter = gr.Plot(label="Wind Speed vs ONI")
         wind_regression_results = gr.Textbox(label="Wind Regression Results")
-        
-        wind_analyze_btn.click(
-            fn=get_wind_analysis,
-            inputs=[wind_start_year, wind_start_month, wind_end_year, wind_end_month, wind_enso_phase, wind_typhoon_search],
-            outputs=[wind_scatter, wind_regression_results]
-        )
+        wind_analyze_btn.click(fn=get_wind_analysis, inputs=[wind_start_year, wind_start_month, wind_end_year, wind_end_month, wind_enso_phase, wind_typhoon_search], outputs=[wind_scatter, wind_regression_results])
     
     with gr.Tab("Pressure Analysis"):
         with gr.Row():
@@ -1174,12 +688,7 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         pressure_analyze_btn = gr.Button("Generate Pressure Analysis")
         pressure_scatter = gr.Plot(label="Pressure vs ONI")
         pressure_regression_results = gr.Textbox(label="Pressure Regression Results")
-        
-        pressure_analyze_btn.click(
-            fn=get_pressure_analysis,
-            inputs=[pressure_start_year, pressure_start_month, pressure_end_year, pressure_end_month, pressure_enso_phase, pressure_typhoon_search],
-            outputs=[pressure_scatter, pressure_regression_results]
-        )
+        pressure_analyze_btn.click(fn=get_pressure_analysis, inputs=[pressure_start_year, pressure_start_month, pressure_end_year, pressure_end_month, pressure_enso_phase, pressure_typhoon_search], outputs=[pressure_scatter, pressure_regression_results])
     
     with gr.Tab("Longitude Analysis"):
         with gr.Row():
@@ -1193,65 +702,28 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         regression_plot = gr.Plot(label="Longitude vs ONI")
         slopes_text = gr.Textbox(label="Regression Slopes")
         lon_regression_results = gr.Textbox(label="Longitude Regression Results")
-        
-        lon_analyze_btn.click(
-            fn=get_longitude_analysis,
-            inputs=[lon_start_year, lon_start_month, lon_end_year, lon_end_month, lon_enso_phase, lon_typhoon_search],
-            outputs=[regression_plot, slopes_text, lon_regression_results]
-        )
+        lon_analyze_btn.click(fn=get_longitude_analysis, inputs=[lon_start_year, lon_start_month, lon_end_year, lon_end_month, lon_enso_phase, lon_typhoon_search], outputs=[regression_plot, slopes_text, lon_regression_results])
     
     with gr.Tab("Tropical Cyclone Path Animation"):
         with gr.Row():
             year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950, 2025)], value="2000")
-            basin_dropdown = gr.Dropdown(
-                label="Basin", 
-                choices=[
-                    "All Basins",
-                    "NA - North Atlantic",
-                    "EP - Eastern North Pacific",
-                    "WP - Western North Pacific",
-                    "NI - North Indian",
-                    "SI - South Indian",
-                    "SP - Southern Pacific",
-                    "SA - South Atlantic"
-                ],
-                value="WP - Western North Pacific"
-            )
-        
+            basin_dropdown = gr.Dropdown(label="Basin", choices=["NA - North Atlantic", "EP - Eastern North Pacific", "WP - Western North Pacific", "All Basins"], value="NA - North Atlantic")
         with gr.Row():
             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")
-        
-        # Use format="mp4" to indicate we expect MP4 video, and no source parameter to avoid upload/webcam UI
         path_video = gr.Video(label="Tropical Cyclone Path Animation", format="mp4", interactive=False, elem_id="path_video")
-        
         animation_info = gr.Markdown("""
         ### Animation Instructions
-        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).
+        1. Select a year and basin from the dropdowns. (This animation uses the processed CSV data.)
+        2. Choose a tropical cyclone from the populated list.
+        3. Select a classification standard (Atlantic or Taiwan).
+        4. Click "Generate Animation".
+        5. The animation displays the storm track along with a dynamic sidebar that updates the state (name, date, wind, category) and includes a persistent legend.
         """)
-        
-        year_dropdown.change(fn=update_typhoon_options, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
-        basin_dropdown.change(fn=update_typhoon_options, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
-        
-        animate_btn.click(
-            fn=simplified_track_video,
-            inputs=[year_dropdown, basin_dropdown, typhoon_dropdown, standard_dropdown],
-            outputs=path_video
-        )
+        year_dropdown.change(fn=update_typhoon_options_anim, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
+        basin_dropdown.change(fn=update_typhoon_options_anim, inputs=[year_dropdown, basin_dropdown], outputs=typhoon_dropdown)
+        animate_btn.click(fn=simplified_track_video, inputs=[year_dropdown, basin_dropdown, typhoon_dropdown, standard_dropdown], outputs=path_video)
     
     with gr.Tab("TSNE Cluster"):
         with gr.Row():
@@ -1266,11 +738,6 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         routes_plot = gr.Plot(label="Typhoon Routes with Mean Routes")
         stats_plot = gr.Plot(label="Cluster Statistics")
         cluster_info = gr.Textbox(label="Cluster Information", lines=10)
-        
-        tsne_analyze_btn.click(
-            fn=update_route_clusters,
-            inputs=[tsne_start_year, tsne_start_month, tsne_end_year, tsne_end_month, tsne_enso_phase, tsne_season],
-            outputs=[tsne_plot, routes_plot, stats_plot, cluster_info]
-        )
+        tsne_analyze_btn.click(fn=update_route_clusters, inputs=[tsne_start_year, tsne_start_month, tsne_end_year, tsne_end_month, tsne_enso_phase, tsne_season], outputs=[tsne_plot, routes_plot, stats_plot, cluster_info])
 
-demo.launch(share=True)
+demo.launch(share=True)