Update app.py

app.py

@@ -1,3 +1,12 @@
+import os
+import argparse
+import logging
+import pickle
+import threading
+import time
+from datetime import datetime, timedelta
+from collections import defaultdict
+
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -9,45 +18,57 @@ import cartopy.feature as cfeature
 import plotly.graph_objects as go
 import plotly.express as px
 from plotly.subplots import make_subplots
-import pickle
-import requests
-import os
-import argparse
-from datetime import datetime
-import statsmodels.api as sm
-import shutil
-import tempfile
-import csv
-from collections import defaultdict
+
 from sklearn.manifold import TSNE
 from sklearn.cluster import DBSCAN
+from sklearn.preprocessing import StandardScaler
 from scipy.interpolate import interp1d
 
-# Import tropycal for IBTrACS processing (for typhoon options)
+import requests
+import tempfile
+import shutil
+import xarray as xr
+
+try:
+    import cdsapi
+    CDSAPI_AVAILABLE = True
+except ImportError:
+    CDSAPI_AVAILABLE = False
+
 import tropycal.tracks as tracks
 
-# ------------------ Argument Parsing ------------------
+# -----------------------------
+# Configuration and Setup
+# -----------------------------
+logging.basicConfig(
+    level=logging.INFO,  # Use DEBUG for more details
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
 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 ------------------
+# Data paths
 ONI_DATA_PATH = os.path.join(DATA_PATH, 'oni_data.csv')
 TYPHOON_DATA_PATH = os.path.join(DATA_PATH, 'processed_typhoon_data.csv')
+MERGED_DATA_CSV = os.path.join(DATA_PATH, 'merged_typhoon_era5_data.csv')  # used by other analyses
 
-# ------------------ IBTrACS Files (for typhoon options) ------------------
+# IBTrACS (used only for typhoon option updates)
+LOCAL_IBTRACS_PATH = os.path.join(DATA_PATH, 'ibtracs.WP.list.v04r01.csv')
+IBTRACS_URI = 'https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r01/access/csv/ibtracs.WP.list.v04r01.csv'
+CACHE_FILE = os.path.join(DATA_PATH, 'ibtracs_cache.pkl')
+CACHE_EXPIRY_DAYS = 1
 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/'
-
-CACHE_FILE = 'ibtracs_cache.pkl'
-CACHE_EXPIRY_DAYS = 0  # Force refresh for testing
 
-# ------------------ Color Maps and Standards ------------------
+# -----------------------------
+# Color Maps and Standards
+# -----------------------------
 color_map = {
     'C5 Super Typhoon': 'rgb(255, 0, 0)',
     'C4 Very Strong Typhoon': 'rgb(255, 165, 0)',
@@ -73,7 +94,9 @@ taiwan_standard = {
     'Tropical Depression': {'wind_speed': 0, 'color': 'Gray', 'hex': '#808080'}
 }
 
-# ------------------ Season and Regions ------------------
+# -----------------------------
+# Season and Regions
+# -----------------------------
 season_months = {
     'all': list(range(1, 13)),
     'summer': [6, 7, 8],
@@ -88,7 +111,9 @@ regions = {
     "Philippines": {"lat_min": 5, "lat_max": 21, "lon_min": 115, "lon_max": 130}
 }
 
-# ------------------ ONI and Typhoon Data Functions ------------------
+# -----------------------------
+# ONI and Typhoon Data Functions
+# -----------------------------
 def download_oni_file(url, filename):
     response = requests.get(url)
     response.raise_for_status()
@@ -98,8 +123,8 @@ def download_oni_file(url, filename):
 
 def convert_oni_ascii_to_csv(input_file, output_file):
     data = defaultdict(lambda: [''] * 12)
-    season_to_month = {'DJF': 12, 'JFM': 1, 'FMA': 2, 'MAM': 3, 'AMJ': 4, 'MJJ': 5,
-                       'JJA': 6, 'JAS': 7, 'ASO': 8, 'SON': 9, 'OND': 10, 'NDJ': 11}
+    season_to_month = {'DJF':12, 'JFM':1, 'FMA':2, 'MAM':3, 'AMJ':4, 'MJJ':5,
+                       'JJA':6, 'JAS':7, 'ASO':8, 'SON':9, 'OND':10, 'NDJ':11}
     with open(input_file, 'r') as f:
         lines = f.readlines()[1:]
         for line in lines:
@@ -109,11 +134,11 @@ def convert_oni_ascii_to_csv(input_file, output_file):
                 if season in season_to_month:
                     month = season_to_month[season]
                     if season == 'DJF':
-                        year = str(int(year) - 1)
+                        year = str(int(year)-1)
                     data[year][month-1] = anom
     with open(output_file, 'w', newline='') as f:
         writer = csv.writer(f)
-        writer.writerow(['Year', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
+        writer.writerow(['Year','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
         for year in sorted(data.keys()):
             writer.writerow([year] + data[year])
 
@@ -138,10 +163,10 @@ def load_data(oni_path, typhoon_path):
 
 def process_oni_data(oni_data):
     oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
-    month_map = {'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',
-                 'Jul': '07', 'Aug': '08', 'Sep': '09', 'Oct': '10', 'Nov': '11', 'Dec': '12'}
+    month_map = {'Jan':'01','Feb':'02','Mar':'03','Apr':'04','May':'05','Jun':'06',
+                 'Jul':'07','Aug':'08','Sep':'09','Oct':'10','Nov':'11','Dec':'12'}
     oni_long['Month'] = oni_long['Month'].map(month_map)
-    oni_long['Date'] = pd.to_datetime(oni_long['Year'].astype(str) + '-' + oni_long['Month'] + '-01')
+    oni_long['Date'] = pd.to_datetime(oni_long['Year'].astype(str)+'-'+oni_long['Month']+'-01')
     oni_long['ONI'] = pd.to_numeric(oni_long['ONI'], errors='coerce')
     return oni_long
 
@@ -150,10 +175,10 @@ 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')
-    print(f"Unique basins in typhoon_data: {typhoon_data['SID'].str[:2].unique()}")
+    logging.info(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'
+        'USA_WIND':'max','USA_PRES':'min','ISO_TIME':'first','SEASON':'first','NAME':'first',
+        'LAT':'first','LON':'first'
     }).reset_index()
     typhoon_max['Month'] = typhoon_max['ISO_TIME'].dt.strftime('%m')
     typhoon_max['Year'] = typhoon_max['ISO_TIME'].dt.year
@@ -161,7 +186,7 @@ def process_typhoon_data(typhoon_data):
     return typhoon_max
 
 def merge_data(oni_long, typhoon_max):
-    return pd.merge(typhoon_max, oni_long, on=['Year', 'Month'])
+    return pd.merge(typhoon_max, oni_long, on=['Year','Month'])
 
 def categorize_typhoon(wind_speed):
     if wind_speed >= 137:
@@ -189,12 +214,12 @@ def classify_enso_phases(oni_value):
     else:
         return 'Neutral'
 
-# ------------------ Regression Functions ------------------
+# ------------- 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)
+    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(disp=0)
@@ -206,8 +231,8 @@ def perform_wind_regression(start_year, start_month, end_year, end_month):
 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)
+    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(disp=0)
@@ -219,54 +244,54 @@ def perform_pressure_regression(start_year, start_month, end_year, end_month):
 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)
+    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(disp=0)
+    model = sm.OLS(y, sm.add_constant(X)).fit()
     beta_1 = model.params['ONI']
     exp_beta_1 = np.exp(beta_1)
     p_value = model.pvalues['ONI']
     return f"Longitude Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
 
-# ------------------ IBTrACS Data Loading (for typhoon options) ------------------
+# ------------- IBTrACS Data Loading -------------
 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)
+            logging.info(f"Downloading {basin} basin file...")
+            response = requests.get(IBTRACS_BASE_URI+filename)
             response.raise_for_status()
             with open(local_path, 'wb') as f:
                 f.write(response.content)
-            print(f"Downloaded {basin} basin file.")
+            logging.info(f"Downloaded {basin} basin file.")
         try:
-            print(f"--> Starting to read in IBTrACS data for basin {basin}")
+            logging.info(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}")
+            logging.info(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}")
+            logging.warning(f"Skipping basin {basin} due to error: {e}")
             ibtracs_data[basin] = None
     return ibtracs_data
 
 ibtracs = load_ibtracs_data()
 
-# ------------------ Load and Process Data ------------------
+# ------------- Load & 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)
 
-# ------------------ Visualization Functions ------------------
+# ------------- 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]
         phase = storm_data['ENSO_Phase'].iloc[0]
-        color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}.get(phase, 'black')
+        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)
@@ -287,32 +312,36 @@ def generate_typhoon_tracks(filtered_data, typhoon_search):
     return fig
 
 def generate_wind_oni_scatter(filtered_data, typhoon_search):
-    fig = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category', hover_data=['NAME', 'Year', 'Category'],
-                     title='Wind Speed vs ONI', labels={'ONI': 'ONI Value', 'USA_WIND': 'Max Wind Speed (knots)'},
+    fig = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category',
+                     hover_data=['NAME','Year','Category'],
+                     title='Wind Speed vs ONI',
+                     labels={'ONI':'ONI Value','USA_WIND':'Max Wind Speed (knots)'},
                      color_discrete_map=color_map)
     if typhoon_search:
         mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
         if mask.any():
             fig.add_trace(go.Scatter(
-                x=filtered_data.loc[mask, 'ONI'], y=filtered_data.loc[mask, 'USA_WIND'],
+                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_WIND'],
                 mode='markers', marker=dict(size=10, color='red', symbol='star'),
                 name=f'Matched: {typhoon_search}',
-                text=filtered_data.loc[mask, 'NAME'] + ' (' + filtered_data.loc[mask, 'Year'].astype(str) + ')'
+                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
             ))
     return fig
 
 def generate_pressure_oni_scatter(filtered_data, typhoon_search):
-    fig = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category', hover_data=['NAME', 'Year', 'Category'],
-                     title='Pressure vs ONI', labels={'ONI': 'ONI Value', 'USA_PRES': 'Min Pressure (hPa)'},
+    fig = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category',
+                     hover_data=['NAME','Year','Category'],
+                     title='Pressure vs ONI',
+                     labels={'ONI':'ONI Value','USA_PRES':'Min Pressure (hPa)'},
                      color_discrete_map=color_map)
     if typhoon_search:
         mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
         if mask.any():
             fig.add_trace(go.Scatter(
-                x=filtered_data.loc[mask, 'ONI'], y=filtered_data.loc[mask, 'USA_PRES'],
+                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_PRES'],
                 mode='markers', marker=dict(size=10, color='red', symbol='star'),
                 name=f'Matched: {typhoon_search}',
-                text=filtered_data.loc[mask, 'NAME'] + ' (' + filtered_data.loc[mask, 'Year'].astype(str) + ')'
+                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
             ))
     return fig
 
@@ -320,7 +349,7 @@ def generate_regression_analysis(filtered_data):
     fig = px.scatter(filtered_data, x='LON', y='ONI', hover_data=['NAME'],
                      title='Typhoon Generation Longitude vs ONI (All Years)')
     if len(filtered_data) > 1:
-        X = np.array(filtered_data['LON']).reshape(-1, 1)
+        X = np.array(filtered_data['LON']).reshape(-1,1)
         y = filtered_data['ONI']
         model = sm.OLS(y, sm.add_constant(X)).fit()
         y_pred = model.predict(sm.add_constant(X))
@@ -334,7 +363,7 @@ 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)].copy()
+    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()]
@@ -347,7 +376,7 @@ def generate_main_analysis(start_year, start_month, end_year, end_month, enso_ph
 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)].copy()
+    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()]
@@ -355,27 +384,25 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
     count = len(unique_storms)
     fig = go.Figure()
     for sid in unique_storms:
-        storm_data = typhoon_data[typhoon_data['SID'] == sid]
+        storm_data = typhoon_data[typhoon_data['SID']==sid]
         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')
+        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(
             lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines',
             name=f"{name} ({storm_data['SEASON'].iloc[0]})",
-            line=dict(width=1.5, color=color),
-            hoverinfo="name"
+            line=dict(width=1.5, color=color), hoverinfo="name"
         ))
     if typhoon_search:
         search_mask = typhoon_data['NAME'].str.contains(typhoon_search, case=False, na=False)
         if search_mask.any():
             for sid in typhoon_data[search_mask]['SID'].unique():
-                storm_data = typhoon_data[typhoon_data['SID'] == sid]
+                storm_data = typhoon_data[typhoon_data['SID']==sid]
                 fig.add_trace(go.Scattergeo(
                     lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines+markers',
                     name=f"MATCHED: {storm_data['NAME'].iloc[0]} ({storm_data['SEASON'].iloc[0]})",
                     line=dict(width=3, color='yellow'),
-                    marker=dict(size=5),
-                    hoverinfo="name"
+                    marker=dict(size=5), hoverinfo="name"
                 ))
     fig.update_layout(
         title=f"Typhoon Tracks ({start_year}-{start_month} to {end_year}-{end_month})",
@@ -383,9 +410,9 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
             projection_type='natural earth',
             showland=True,
             showcoastlines=True,
-            landcolor='rgb(243, 243, 243)',
-            countrycolor='rgb(204, 204, 204)',
-            coastlinecolor='rgb(204, 204, 204)',
+            landcolor='rgb(243,243,243)',
+            countrycolor='rgb(204,204,204)',
+            coastlinecolor='rgb(204,204,204)',
             center=dict(lon=140, lat=20),
             projection_scale=3
         ),
@@ -416,8 +443,8 @@ 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
 
-def categorize_typhoon_by_standard(wind_speed, standard):
-    if standard == 'taiwan':
+def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
+    if standard=='taiwan':
         wind_speed_ms = wind_speed * 0.514444
         if wind_speed_ms >= 51.0:
             return 'Strong Typhoon', taiwan_standard['Strong Typhoon']['hex']
@@ -441,11 +468,120 @@ def categorize_typhoon_by_standard(wind_speed, standard):
             return 'Tropical Storm', atlantic_standard['Tropical Storm']['hex']
         return 'Tropical Depression', atlantic_standard['Tropical Depression']['hex']
 
-# ------------------ Animation Functions Using Processed CSV ------------------
+# ------------- Updated TSNE Cluster Function -------------
+def update_route_clusters(start_year, start_month, end_year, end_month, enso_value, season):
+    try:
+        # Use raw typhoon data (with multiple observations per storm) merged with ONI info.
+        raw_data = typhoon_data.copy()
+        raw_data['Year'] = raw_data['ISO_TIME'].dt.year
+        raw_data['Month'] = raw_data['ISO_TIME'].dt.strftime('%m')
+        merged_raw = pd.merge(raw_data, process_oni_data(oni_data), on=['Year','Month'], how='left')
+        
+        # Filter by date
+        start_date = datetime(start_year, start_month, 1)
+        end_date = datetime(end_year, end_month, 28)
+        merged_raw = merged_raw[(merged_raw['ISO_TIME'] >= start_date) & (merged_raw['ISO_TIME'] <= end_date)]
+        logging.info(f"Total points after date filtering: {merged_raw.shape[0]}")
+        
+        # Filter by ENSO phase if not 'all'
+        merged_raw['ENSO_Phase'] = merged_raw['ONI'].apply(classify_enso_phases)
+        if enso_value != 'all':
+            merged_raw = merged_raw[merged_raw['ENSO_Phase'] == enso_value.capitalize()]
+        logging.info(f"Total points after ENSO filtering: {merged_raw.shape[0]}")
+        
+        # Use regional filtering for Western Pacific (adjust boundaries as needed)
+        wp_data = merged_raw[(merged_raw['LON'] >= 100) & (merged_raw['LON'] <= 180) &
+                             (merged_raw['LAT'] >= 0) & (merged_raw['LAT'] <= 40)]
+        logging.info(f"Total points after WP regional filtering: {wp_data.shape[0]}")
+        if wp_data.empty:
+            logging.info("WP regional filter returned no data; using all filtered data.")
+            wp_data = merged_raw
+        
+        # Group by SID so each storm route has multiple observations
+        all_storms_data = []
+        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
+            all_storms_data.append((sid, lons, lats, times))
+        logging.info(f"Storms available for TSNE after grouping: {len(all_storms_data)}")
+        if not all_storms_data:
+            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid storms for clustering."
+        
+        # Interpolate each storm's route to a common length
+        max_length = max(len(item[1]) for item in all_storms_data)
+        route_vectors = []
+        storm_ids = []
+        for sid, lons, lats, times in all_storms_data:
+            t = np.linspace(0, 1, len(lons))
+            t_new = np.linspace(0, 1, max_length)
+            try:
+                lon_interp = interp1d(t, lons, kind='linear', fill_value='extrapolate')(t_new)
+                lat_interp = interp1d(t, lats, kind='linear', fill_value='extrapolate')(t_new)
+            except Exception as ex:
+                logging.error(f"Interpolation error for storm {sid}: {ex}")
+                continue
+            route_vector = np.column_stack((lon_interp, lat_interp)).flatten()
+            if np.isnan(route_vector).any():
+                continue
+            route_vectors.append(route_vector)
+            storm_ids.append(sid)
+        logging.info(f"Storms with valid route vectors: {len(route_vectors)}")
+        if len(route_vectors) == 0:
+            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid storms after interpolation."
+        
+        route_vectors = np.array(route_vectors)
+        tsne = TSNE(n_components=2, random_state=42, verbose=1)
+        tsne_results = tsne.fit_transform(route_vectors)
+        
+        dbscan = DBSCAN(eps=5, min_samples=3)
+        labels = dbscan.fit_predict(tsne_results)
+        unique_labels = sorted(set(labels) - {-1})
+        
+        fig_tsne = go.Figure()
+        colors = px.colors.qualitative.Safe
+        for i, label in enumerate(unique_labels):
+            indices = np.where(labels == label)[0]
+            fig_tsne.add_trace(go.Scatter(
+                x=tsne_results[indices, 0],
+                y=tsne_results[indices, 1],
+                mode='markers',
+                marker=dict(color=colors[i % len(colors)]),
+                name=f"Cluster {label}"
+            ))
+        noise_indices = np.where(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(color='grey'),
+                name='Noise'
+            ))
+        fig_tsne.update_layout(
+            title="t-SNE of Storm Routes",
+            xaxis_title="t-SNE Dim 1",
+            yaxis_title="t-SNE Dim 2"
+        )
+        
+        # Placeholder figures for routes and stats
+        fig_routes = go.Figure()
+        fig_stats = make_subplots(rows=2, cols=1, shared_xaxes=True,
+                                  subplot_titles=("Average Wind Speed", "Average Pressure"))
+        info = "TSNE clustering complete."
+        return fig_tsne, fig_routes, fig_stats, info
+    except Exception as e:
+        logging.error(f"Error in TSNE clustering: {e}")
+        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), f"Error in TSNE clustering: {e}"
+
+# ------------- Animation Functions Using Processed CSV & Stock Map -------------
 def generate_track_video_from_csv(year, storm_id, standard):
     storm_df = typhoon_data[typhoon_data['SID'] == storm_id].copy()
     if storm_df.empty:
-        print("No data found for storm:", storm_id)
+        logging.error(f"No data found for storm: {storm_id}")
         return None
     storm_df = storm_df.sort_values('ISO_TIME')
     lats = storm_df['LAT'].astype(float).values
@@ -460,42 +596,41 @@ def generate_track_video_from_csv(year, storm_id, standard):
     
     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)
+    lat_padding = max((max_lat - min_lat)*0.3, 5)
+    lon_padding = max((max_lon - min_lon)*0.3, 5)
     
-    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))
+    fig = plt.figure(figsize=(12,6), dpi=100)
+    ax = plt.axes([0.05, 0.05, 0.60, 0.85],
+                  projection=ccrs.PlateCarree(central_longitude=180))
+    ax.stock_img()
     ax.set_extent([min_lon - lon_padding, max_lon + lon_padding, min_lat - lat_padding, max_lat + lat_padding],
                   crs=ccrs.PlateCarree())
+    ax.coastlines(resolution='50m', color='black', linewidth=1)
+    gl = ax.gridlines(draw_labels=True, color='gray', alpha=0.4, linestyle='--')
+    gl.top_labels = gl.right_labels = False
+    ax.set_title(f"{year} {storm_name} - {season}", fontsize=14)
     
-    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} - {season}", fontsize=16)
-    
-    line, = ax.plot([], [], 'b-', linewidth=2, transform=ccrs.PlateCarree())
-    point, = ax.plot([], [], 'o', markersize=10, transform=ccrs.PlateCarree())
-    date_text = ax.text(0.02, 0.02, '', transform=ax.transAxes, fontsize=12,
-                         bbox=dict(facecolor='white', alpha=0.8))
-    # Dynamic state display at right side
-    state_text = fig.text(0.70, 0.60, '', fontsize=14, verticalalignment='top',
-                          bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5'))
+    line, = ax.plot([], [], transform=ccrs.PlateCarree(), color='blue', linewidth=2)
+    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))
+    storm_info_text = fig.text(0.70, 0.60, '', fontsize=10,
+                               bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5'))
     
-    # Persistent legend for category colors
-    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)
+    from matplotlib.lines import Line2D
+    standard_dict = atlantic_standard if standard=='atlantic' else taiwan_standard
+    legend_elements = [Line2D([0],[0], marker='o', color='w', label=cat,
+                              markerfacecolor=details['hex'], markersize=8)
+                       for cat, details in standard_dict.items()]
+    ax.legend(handles=legend_elements, title="Storm Categories",
+              loc='upper right', fontsize=9)
     
     def init():
         line.set_data([], [])
         point.set_data([], [])
         date_text.set_text('')
-        state_text.set_text('')
-        return line, point, date_text, state_text
+        storm_info_text.set_text('')
+        return line, point, date_text, storm_info_text
 
     def update(frame):
         line.set_data(lons[:frame+1], lats[:frame+1])
@@ -505,12 +640,12 @@ def generate_track_video_from_csv(year, storm_id, standard):
         point.set_color(color)
         dt_str = pd.to_datetime(times[frame]).strftime('%Y-%m-%d %H:%M')
         date_text.set_text(dt_str)
-        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
+        info_str = (f"Name: {storm_name}\n"
+                    f"Date: {dt_str}\n"
+                    f"Wind: {wind_speed:.1f} kt\n"
+                    f"Category: {category}")
+        storm_info_text.set_text(info_str)
+        return line, point, date_text, storm_info_text
 
     ani = animation.FuncAnimation(fig, update, init_func=init, frames=len(times),
                                   interval=200, blit=True, repeat=True)
@@ -526,7 +661,7 @@ def simplified_track_video(year, basin, typhoon, standard):
     storm_id = typhoon.split('(')[-1].strip(')')
     return generate_track_video_from_csv(year, storm_id, standard)
 
-# ------------------ Typhoon Options Update Functions ------------------
+# ------------- Typhoon Options Update Functions -------------
 basin_to_prefix = {
     "All Basins": "all",
     "NA - North Atlantic": "NA",
@@ -545,18 +680,18 @@ def update_typhoon_options(year, basin):
                         continue
                     summaries.append(season_data.summary())
             if len(summaries) == 0:
-                print("Error updating typhoon options: No storms identified for the given year and basin.")
+                logging.error("No storms found for 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.")
+                logging.error(f"Dataset not found for basin {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.")
+                logging.error("No storms found for given year and basin.")
                 return gr.update(choices=[], value=None)
             combined_summary = season_data.summary()
         options = []
@@ -569,17 +704,16 @@ def update_typhoon_options(year, basin):
                 continue
         return gr.update(choices=options, value=options[0] if options else None)
     except Exception as e:
-        print(f"Error updating typhoon options: {e}")
+        logging.error(f"Error in update_typhoon_options: {e}")
         return gr.update(choices=[], value=None)
 
 def update_typhoon_options_anim(year, basin):
     try:
-        # For animation, use the processed CSV data (without filtering by a specific prefix)
         data = typhoon_data.copy()
-        data['Year'] = pd.to_datetime(data['ISO_TIME']).dt.year
+        data['Year'] = 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.")
+            logging.error(f"No storms found for year {year} in animation update.")
             return gr.update(choices=[], value=None)
         summary = season_data.groupby('SID').first().reset_index()
         options = []
@@ -588,188 +722,127 @@ def update_typhoon_options_anim(year, basin):
             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}")
+        logging.error(f"Error in update_typhoon_options_anim: {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):
-    # 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 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 valid WP storms for clustering."
-    
-    max_length = max(len(item[0]) for item in all_storms_data)
-    route_vectors = []
-    filtered_storms = []
-    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)
-        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((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."
-    
-    tsne = TSNE(n_components=2, random_state=42, verbose=1)
-    tsne_results = tsne.fit_transform(route_vectors)
-    dbscan = DBSCAN(eps=5, min_samples=3)
-    best_labels = dbscan.fit_predict(tsne_results)
-    unique_labels = sorted(set(best_labels) - {-1})
-    fig_tsne = go.Figure()
-    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(color=colors[i % len(colors)]),
-            name=f"Cluster {label}"
-        ))
-    fig_tsne.update_layout(title="t-SNE of WP Storm Routes")
-    fig_routes = go.Figure()  # Placeholder
-    fig_stats = make_subplots(rows=2, cols=1)  # Placeholder
-    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")
     
     with gr.Tab("Overview"):
         gr.Markdown("""
         ## Welcome to the Typhoon Analysis Dashboard
-        
+
         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 (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 a dynamic state display and persistent 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.
+        - **Track Visualization**: View typhoon tracks by time period and ENSO phase.
+        - **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**: View animated storm tracks on a free stock world map (centered at 180°) with a dynamic sidebar and persistent legend.
+        - **TSNE Cluster**: Perform t-SNE clustering on WP storm routes using raw merged typhoon+ONI data with detailed error management.
         """)
     
     with gr.Tab("Track Visualization"):
         with gr.Row():
             start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+            start_month = gr.Dropdown(label="Start Month", choices=list(range(1,13)), value=1)
             end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+            end_month = gr.Dropdown(label="End Month", choices=list(range(1,13)), value=6)
+            enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all','El Nino','La Nina','Neutral'], value='all')
             typhoon_search = gr.Textbox(label="Typhoon Search")
         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():
             wind_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            wind_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+            wind_start_month = gr.Dropdown(label="Start Month", choices=list(range(1,13)), value=1)
             wind_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            wind_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            wind_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+            wind_end_month = gr.Dropdown(label="End Month", choices=list(range(1,13)), value=6)
+            wind_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all','El Nino','La Nina','Neutral'], value='all')
             wind_typhoon_search = gr.Textbox(label="Typhoon Search")
         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():
             pressure_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            pressure_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+            pressure_start_month = gr.Dropdown(label="Start Month", choices=list(range(1,13)), value=1)
             pressure_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            pressure_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            pressure_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+            pressure_end_month = gr.Dropdown(label="End Month", choices=list(range(1,13)), value=6)
+            pressure_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all','El Nino','La Nina','Neutral'], value='all')
             pressure_typhoon_search = gr.Textbox(label="Typhoon Search")
         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():
             lon_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            lon_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            lon_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            lon_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            lon_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+            lon_start_month = gr.Dropdown(label="Start Month", choices=list(range(1,13)), value=1)
+            lon_end_year = gr.Number(label="End Year", value=2000, minimum=1900, maximum=2024, step=1)
+            lon_end_month = gr.Dropdown(label="End Month", choices=list(range(1,13)), value=6)
+            lon_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all','El Nino','La Nina','Neutral'], value='all')
             lon_typhoon_search = gr.Textbox(label="Typhoon Search (Optional)")
         lon_analyze_btn = gr.Button("Generate Longitude Analysis")
         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=["NA - North Atlantic", "EP - Eastern North Pacific", "WP - Western North Pacific", "All Basins"], value="NA - North Atlantic")
+            year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950,2025)], value="2000")
+            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')
+            standard_dropdown = gr.Dropdown(label="Classification Standard", choices=['atlantic','taiwan'], value='atlantic')
         animate_btn = gr.Button("Generate Animation")
         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. (This animation uses processed CSV data.)
+        1. Select a year and basin (data is from your processed CSV).
         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 shows the current state (name, date, wind, category) and a persistent legend for colors.
+        5. The animation displays the storm track on a free stock world map (centered at 180°) with a dynamic sidebar and a persistent legend.
         """)
         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)
+        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():
             tsne_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            tsne_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+            tsne_start_month = gr.Dropdown(label="Start Month", choices=list(range(1,13)), value=1)
             tsne_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            tsne_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=12)
-            tsne_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            tsne_season = gr.Dropdown(label="Season", choices=['all', 'summer', 'winter'], value='all')
+            tsne_end_month = gr.Dropdown(label="End Month", choices=list(range(1,13)), value=12)
+            tsne_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all','El Nino','La Nina','Neutral'], value='all')
+            tsne_season = gr.Dropdown(label="Season", choices=['all','summer','winter'], value='all')
         tsne_analyze_btn = gr.Button("Analyze")
         tsne_plot = gr.Plot(label="t-SNE Clusters")
         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)