Update app.py

app.py

@@ -1,25 +1,20 @@
 import gradio as gr
-import plotly.graph_objects as go
-import plotly.express as px
 import pandas as pd
 import numpy as np
-from datetime import datetime
-from scipy import stats
-from sklearn.linear_model import LinearRegression
-from sklearn.cluster import KMeans
-from scipy.interpolate import interp1d
-from fractions import Fraction
-import statsmodels.api as sm
+import plotly.graph_objects as go
+import plotly.express as px
 import tropycal.tracks as tracks
-import os
 import pickle
 import requests
-import tempfile
+import os
+import argparse
+from datetime import datetime
+import statsmodels.api as sm
 import shutil
-import filecmp
+import tempfile
 import csv
 from collections import defaultdict
-import argparse
+import filecmp
 
 # Command-line argument parsing
 parser = argparse.ArgumentParser(description='Typhoon Analysis Dashboard')
@@ -27,7 +22,6 @@ parser.add_argument('--data_path', type=str, default=os.getcwd(), help='Path to
 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')
 LOCAL_iBtrace_PATH = os.path.join(DATA_PATH, 'ibtracs.WP.list.v04r01.csv')
@@ -35,7 +29,7 @@ iBtrace_uri = 'https://www.ncei.noaa.gov/data/international-best-track-archive-f
 CACHE_FILE = 'ibtracs_cache.pkl'
 CACHE_EXPIRY_DAYS = 1
 
-# Color map for categories
+# Color map for typhoon categories
 color_map = {
     'C5 Super Typhoon': 'rgb(255, 0, 0)',
     'C4 Very Strong Typhoon': 'rgb(255, 63, 0)',
@@ -64,47 +58,18 @@ taiwan_standard = {
     'Tropical Depression': {'wind_speed': 0, 'color': 'rgb(173, 216, 230)'}
 }
 
-# Data loading and processing functions (unchanged from Dash)
-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 not row:
-                continue
-            sid = row[0]
-            iso_time = row[6]
-            sid_data[sid].append((row, iso_time))
-    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
-                })
-
+# Data loading and preprocessing functions
 def download_oni_file(url, filename):
-    try:
-        response = requests.get(url)
-        response.raise_for_status()
-        with open(filename, 'wb') as f:
-            f.write(response.content)
-        return True
-    except requests.RequestException:
-        return False
+    response = requests.get(url)
+    response.raise_for_status()
+    with open(filename, 'wb') as f:
+        f.write(response.content)
+    return True
 
 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:
@@ -128,7 +93,7 @@ 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, shallow=False):
+        if not os.path.exists(input_file) or not filecmp.cmp(temp_file, input_file):
             os.replace(temp_file, input_file)
             convert_oni_ascii_to_csv(input_file, output_file)
         else:
@@ -145,16 +110,47 @@ def load_ibtracs_data():
         response.raise_for_status()
         with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
             temp_file.write(response.text)
-            temp_file_path = temp_file.name
-        shutil.move(temp_file_path, LOCAL_iBtrace_PATH)
+            shutil.move(temp_file.name, LOCAL_iBtrace_PATH)
         ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
     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)  # Skip header lines
+        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)
+    typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
+    typhoon_data = typhoon_data.dropna(subset=['ISO_TIME'])
+    return oni_data, typhoon_data
+
 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['ONI'] = pd.to_numeric(oni_long['ONI'], errors='coerce')
@@ -166,7 +162,8 @@ def process_typhoon_data(typhoon_data):
     typhoon_data['USA_PRES'] = pd.to_numeric(typhoon_data['USA_PRES'], errors='coerce')
     typhoon_data['LON'] = pd.to_numeric(typhoon_data['LON'], errors='coerce')
     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
@@ -177,18 +174,18 @@ 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 / 2
-    if wind_speed_kt >= 137/2.35:
+    wind_speed_kt = wind_speed  # Assuming input is already in knots
+    if wind_speed_kt >= 137:
         return 'C5 Super Typhoon'
-    elif wind_speed_kt >= 113/2.35:
+    elif wind_speed_kt >= 113:
         return 'C4 Very Strong Typhoon'
-    elif wind_speed_kt >= 96/2.35:
+    elif wind_speed_kt >= 96:
         return 'C3 Strong Typhoon'
-    elif wind_speed_kt >= 83/2.35:
+    elif wind_speed_kt >= 83:
         return 'C2 Typhoon'
-    elif wind_speed_kt >= 64/2.35:
+    elif wind_speed_kt >= 64:
         return 'C1 Typhoon'
-    elif wind_speed_kt >= 34/2.35:
+    elif wind_speed_kt >= 34:
         return 'Tropical Storm'
     else:
         return 'Tropical Depression'
@@ -203,238 +200,121 @@ def classify_enso_phases(oni_value):
     else:
         return 'Neutral'
 
-def filter_west_pacific_coordinates(lons, lats):
-    mask = (100 <= lons) & (lons <= 180) & (0 <= lats) & (lats <= 40)
-    return lons[mask], lats[mask]
-
-def get_storm_data(storm_id):
-    return ibtracs.get_storm(storm_id)
-
 # Load data globally
 update_oni_data()
 ibtracs = load_ibtracs_data()
 convert_typhoondata(LOCAL_iBtrace_PATH, TYPHOON_DATA_PATH)
-oni_data = pd.read_csv(ONI_DATA_PATH)
-typhoon_data = pd.read_csv(TYPHOON_DATA_PATH, low_memory=False)
+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)
-oni_df = pd.read_csv(ONI_DATA_PATH, index_col='Date', parse_dates=True)
-
-# Main Analysis Function
-def 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_oni_df = oni_df[(oni_df.index >= start_date) & (oni_df.index <= end_date)]
-    filtered_data = merged_data[(merged_data['Year'] >= start_year) & (merged_data['Year'] <= end_year) & 
-                               (merged_data['Month'].astype(int) >= start_month) & (merged_data['Month'].astype(int) <= end_month)]
-
-    # Typhoon Tracks
-    fig_tracks = go.Figure()
-    regression_data = {'El Nino': {'longitudes': [], 'oni_values': [], 'names': []}, 'La Nina': {'longitudes': [], 'oni_values': [], 'names': []},
-                       'Neutral': {'longitudes': [], 'oni_values': [], 'names': []}, 'All': {'longitudes': [], 'oni_values': [], 'names': []}}
-    for year in range(start_year, end_year + 1):
-        season = ibtracs.get_season(year)
-        for storm_id in season.summary()['id']:
-            storm = get_storm_data(storm_id)
-            storm_dates = storm.time
-            if any(start_date <= date <= end_date for date in storm_dates):
-                storm_oni = filtered_oni_df.loc[storm_dates[0].strftime('%Y-%b')]['ONI']
-                if isinstance(storm_oni, pd.Series):
-                    storm_oni = storm_oni.iloc[0]
-                phase = classify_enso_phases(storm_oni)
-                regression_data[phase]['longitudes'].append(storm.lon[0])
-                regression_data[phase]['oni_values'].append(storm_oni)
-                regression_data[phase]['names'].append(f'{storm.name} ({year})')
-                regression_data['All']['longitudes'].append(storm.lon[0])
-                regression_data['All']['oni_values'].append(storm_oni)
-                regression_data['All']['names'].append(f'{storm.name} ({year})')
-                if (enso_phase == 'All Years' or (enso_phase == 'El Niño Years' and phase == 'El Nino') or
-                    (enso_phase == 'La Niña Years' and phase == 'La Nina') or (enso_phase == 'Neutral Years' and phase == 'Neutral')):
-                    color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[phase]
-                    fig_tracks.add_trace(go.Scattergeo(lon=storm.lon, lat=storm.lat, mode='lines', name=storm.name,
-                                                       text=f'{storm.name} ({year})', hoverinfo='text', line=dict(width=2, color=color)))
-    fig_tracks.update_layout(title=f'Typhoon Tracks from {start_year}-{start_month} to {end_year}-{end_month}', geo=dict(projection_type='natural earth', showland=True))
-
-    # All Years Regression
-    all_years_fig = go.Figure()
-    df_all = pd.DataFrame({'Longitude': regression_data['All']['longitudes'], 'ONI': regression_data['All']['oni_values'], 'Name': regression_data['All']['names']})
-    if not df_all.empty and len(df_all) > 1:
-        all_years_fig = px.scatter(df_all, x='Longitude', y='ONI', hover_data=['Name'], title='All Years Typhoon Generation vs. ONI')
-        X = np.array(df_all['Longitude']).reshape(-1, 1)
-        y = df_all['ONI']
-        model = LinearRegression().fit(X, y)
-        y_pred = model.predict(X)
-        all_years_fig.add_trace(go.Scatter(x=df_all['Longitude'], y=y_pred, mode='lines', name='Regression Line'))
 
-    # Regression Graphs by Phase
-    regression_html = ""
-    slopes_html = ""
-    for phase in ['El Nino', 'La Nina', 'Neutral']:
-        df = pd.DataFrame({'Longitude': regression_data[phase]['longitudes'], 'ONI': regression_data[phase]['oni_values'], 'Name': regression_data[phase]['names']})
-        if not df.empty and len(df) > 1:
-            fig = px.scatter(df, x='Longitude', y='ONI', hover_data=['Name'], title=f'{phase} Typhoon Generation vs. ONI')
-            X = np.array(df['Longitude']).reshape(-1, 1)
-            y = df['ONI']
-            model = LinearRegression().fit(X, y)
-            y_pred = model.predict(X)
-            slope = model.coef_[0]
-            correlation_coef = np.corrcoef(df['Longitude'], df['ONI'])[0, 1]
-            fig.add_trace(go.Scatter(x=df['Longitude'], y=y_pred, mode='lines', name='Regression Line'))
-            regression_html += fig.to_html(include_plotlyjs=False)
-            slopes_html += f"<p>{phase} Regression Slope: {slope:.4f}, Correlation Coefficient: {correlation_coef:.4f}</p>"
-
-    # Wind and Pressure Scatter Plots
-    wind_oni_scatter = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category', hover_data=['NAME', 'Year', 'Category'],
-                                  title='Wind Speed vs ONI', labels={'USA_WIND': 'Maximum Wind Speed (knots)'}, color_discrete_map=color_map)
-    pressure_oni_scatter = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category', hover_data=['NAME', 'Year', 'Category'],
-                                      title='Pressure vs ONI', labels={'USA_PRES': 'Minimum Pressure (hPa)'}, color_discrete_map=color_map)
+# Main analysis 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]]
+        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)
+        ))
     if typhoon_search:
-        for fig in [wind_oni_scatter, pressure_oni_scatter]:
-            mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
-            fig.add_trace(go.Scatter(x=filtered_data.loc[mask, 'ONI'], y=filtered_data.loc[mask, 'USA_WIND' if 'Wind' in fig.layout.title.text else 'USA_PRES'],
-                                     mode='markers', marker=dict(size=10, color='red', symbol='star'), name=f'Matched: {typhoon_search}'))
-
-    # Additional Metrics
-    max_wind_speed = filtered_data['USA_WIND'].max()
-    min_pressure = filtered_data['USA_PRES'].min()
-    typhoon_counts = filtered_data['ONI'].apply(classify_enso_phases).value_counts().to_dict()
-    month_counts = filtered_data.groupby([filtered_data['ONI'].apply(classify_enso_phases), filtered_data['ISO_TIME'].dt.month]).size().unstack(fill_value=0)
-    concentrated_months = month_counts.idxmax(axis=1).to_dict()
-    month_names = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-    count_analysis_html = "".join([f"<p>{phase}: {count} typhoons</p>" for phase, count in typhoon_counts.items()])
-    month_analysis_html = "".join([f"<p>{phase}: Most concentrated in {month_names[month-1]}</p>" for phase, month in concentrated_months.items()])
-
-    return (fig_tracks, all_years_fig, regression_html, slopes_html, wind_oni_scatter, pressure_oni_scatter,
-            "Logistic Regression Results: See Logistic Regression Tab", f"Maximum Wind Speed: {max_wind_speed:.2f} knots",
-            f"Minimum Pressure: {min_pressure:.2f} hPa", "Wind-ONI correlation: See Logistic Regression Tab",
-            "Pressure-ONI correlation: See Logistic Regression Tab", count_analysis_html, month_analysis_html)
-
-# Cluster Analysis Function
-def cluster_analysis(n_clusters, show_clusters, show_routes, fourier_series, start_year, start_month, end_year, end_month, enso_phase):
-    start_date = datetime(start_year, start_month, 1)
-    end_date = datetime(end_year, end_month, 28)
-    filtered_oni_df = oni_df[(oni_df.index >= start_date) & (oni_df.index <= end_date)]
-    fig_routes = go.Figure()
-    west_pacific_storms = []
-    for year in range(start_year, end_year + 1):
-        season = ibtracs.get_season(year)
-        for storm_id in season.summary()['id']:
-            storm = get_storm_data(storm_id)
-            storm_date = storm.time[0]
-            storm_oni = filtered_oni_df.loc[storm_date.strftime('%Y-%b')]['ONI']
-            if isinstance(storm_oni, pd.Series):
-                storm_oni = storm_oni.iloc[0]
-            storm_phase = classify_enso_phases(storm_oni)
-            if (enso_phase == 'All Years' or (enso_phase == 'El Niño Years' and storm_phase == 'El Nino') or
-                (enso_phase == 'La Niña Years' and storm_phase == 'La Nina') or (enso_phase == 'Neutral Years' and storm_phase == 'Neutral')):
-                lons, lats = filter_west_pacific_coordinates(np.array(storm.lon), np.array(storm.lat))
-                if len(lons) > 1:
-                    west_pacific_storms.append((lons, lats))
+        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
+        if mask.any():
+            storm_data = filtered_data[mask]
+            fig.add_trace(go.Scattergeo(
+                lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines',
+                name=f'Matched: {typhoon_search}', line=dict(width=5, color='yellow')
+            ))
+    fig.update_layout(title='Typhoon Tracks', geo=dict(projection_type='natural earth', showland=True))
+    return fig
 
-    max_length = max(len(storm[0]) for storm in west_pacific_storms)
-    standardized_routes = []
-    for lons, lats in west_pacific_storms:
-        if len(lons) < 2:
-            continue
-        t = np.linspace(0, 1, len(lons))
-        t_new = np.linspace(0, 1, max_length)
-        lon_interp = interp1d(t, lons, kind='linear')(t_new)
-        lat_interp = interp1d(t, lats, kind='linear')(t_new)
-        route_vector = np.column_stack((lon_interp, lat_interp)).flatten()
-        standardized_routes.append(route_vector)
+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)'},
+                     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'],
+                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) + ')'
+            ))
+    return fig
 
-    kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
-    clusters = kmeans.fit_predict(standardized_routes)
-    cluster_counts = np.bincount(clusters)
-    equations_html = ""
-    if show_routes:
-        for lons, lats in west_pacific_storms:
-            fig_routes.add_trace(go.Scattergeo(lon=lons, lat=lats, mode='lines', line=dict(width=1, color='lightgray'), showlegend=False, hoverinfo='none'))
-    if show_clusters:
-        for i in range(n_clusters):
-            cluster_center = kmeans.cluster_centers_[i].reshape(-1, 2)
-            fig_routes.add_trace(go.Scattergeo(lon=cluster_center[:, 0], lat=cluster_center[:, 1], mode='lines', name=f'Cluster {i+1} (n={cluster_counts[i]})', line=dict(width=3)))
-            if fourier_series:
-                X = cluster_center[:, 0]
-                y = cluster_center[:, 1]
-                x_min, x_max = X.min(), X.max()
-                X_normalized = 2 * np.pi * (X - x_min) / (x_max - x_min)
-                params, _ = curve_fit(lambda x, a0, a1, b1, a2, b2, a3, b3, a4, b4: a0 + a1*np.cos(x) + b1*np.sin(x) +
-                                      a2*np.cos(2*x) + b2*np.sin(2*x) + a3*np.cos(3*x) + b3*np.sin(3*x) + a4*np.cos(4*x) + b4*np.sin(4*x),
-                                      X_normalized, y)
-                a0, a1, b1, a2, b2, a3, b3, a4, b4 = params
-                equations_html += f"<h4>Cluster {i+1} (Typhoons: {cluster_counts[i]})</h4><p>Fourier Series: y = {a0:.4f} + {a1:.4f}*cos(x) + {b1:.4f}*sin(x) + " \
-                                  f"{a2:.4f}*cos(2x) + {b2:.4f}*sin(2x) + {a3:.4f}*cos(3x) + {b3:.4f}*sin(3x) + {a4:.4f}*cos(4x) + {b4:.4f}*sin(4x)</p>" \
-                                  f"<p>X Range: 0 to {2*np.pi:.4f}</p><p>Longitude Range: {x_min:.4f}°E to {x_max:.4f}°E</p><hr>"
+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)'},
+                     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'],
+                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) + ')'
+            ))
+    return fig
 
-    fig_routes.update_layout(title=f'Typhoon Routes Clustering ({start_year}-{end_year}) - {enso_phase}', geo=dict(projection_type='mercator', showland=True,
-                                                                                                                lataxis={'range': [0, 40]}, lonaxis={'range': [100, 180]}))
-    return fig_routes, equations_html
+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)
+        y = filtered_data['ONI']
+        model = sm.OLS(y, sm.add_constant(X)).fit()
+        y_pred = model.predict(sm.add_constant(X))
+        fig.add_trace(go.Scatter(x=filtered_data['LON'], y=y_pred, mode='lines', name='Regression Line'))
+        slope = model.params[1]
+        slopes_text = f"All Years Slope: {slope:.4f}"
+    else:
+        slopes_text = "Insufficient data for regression"
+    return fig, slopes_text
 
-# Logistic Regression Functions
-def logistic_regression(regression_type, start_year, start_month, end_year, end_month):
+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)]
-    if regression_type == 'Wind':
-        filtered_data['severe_typhoon'] = (filtered_data['USA_WIND'] >= 64).astype(int)
-        X = sm.add_constant(filtered_data['ONI'])
-        y = filtered_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']
-        el_nino_severe = filtered_data[filtered_data['ONI'] >= 0.5]['severe_typhoon'].mean()
-        la_nina_severe = filtered_data[filtered_data['ONI'] <= -0.5]['severe_typhoon'].mean()
-        neutral_severe = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]['severe_typhoon'].mean()
-        return f"<h3>Wind Speed Logistic Regression</h3><p>β1: {beta_1:.4f}</p><p>Odds Ratio: {exp_beta_1:.4f}</p><p>P-value: {p_value:.4f}</p>" \
-               f"<p>El Niño: {el_nino_severe:.2%}</p><p>La Niña: {la_nina_severe:.2%}</p><p>Neutral: {neutral_severe:.2%}</p>"
-    elif regression_type == 'Pressure':
-        filtered_data['intense_typhoon'] = (filtered_data['USA_PRES'] <= 950).astype(int)
-        X = sm.add_constant(filtered_data['ONI'])
-        y = filtered_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']
-        el_nino_intense = filtered_data[filtered_data['ONI'] >= 0.5]['intense_typhoon'].mean()
-        la_nina_intense = filtered_data[filtered_data['ONI'] <= -0.5]['intense_typhoon'].mean()
-        neutral_intense = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]['intense_typhoon'].mean()
-        return f"<h3>Pressure Logistic Regression</h3><p>β1: {beta_1:.4f}</p><p>Odds Ratio: {exp_beta_1:.4f}</p><p>P-value: {p_value:.4f}</p>" \
-               f"<p>El Niño: {el_nino_intense:.2%}</p><p>La Niña: {la_nina_intense:.2%}</p><p>Neutral: {neutral_intense:.2%}</p>"
-    elif regression_type == 'Longitude':
-        filtered_data = filtered_data.dropna(subset=['LON'])
-        filtered_data['western_typhoon'] = (filtered_data['LON'] <= 140).astype(int)
-        X = sm.add_constant(filtered_data['ONI'])
-        y = filtered_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']
-        el_nino_western = filtered_data[filtered_data['ONI'] >= 0.5]['western_typhoon'].mean()
-        la_nina_western = filtered_data[filtered_data['ONI'] <= -0.5]['western_typhoon'].mean()
-        neutral_western = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]['western_typhoon'].mean()
-        return f"<h3>Longitude Logistic Regression</h3><p>β1: {beta_1:.4f}</p><p>Odds Ratio: {exp_beta_1:.4f}</p><p>P-value: {p_value:.4f}</p>" \
-               f"<p>El Niño: {el_nino_western:.2%}</p><p>La Niña: {la_nina_western:.2%}</p><p>Neutral: {neutral_western:.2%}</p>"
-
-# Typhoon Path Animation Function
-def typhoon_path_animation(year, typhoon, standard):
-    storm = ibtracs.get_storm(typhoon)
+    filtered_data = merged_data[
+        (merged_data['ISO_TIME'] >= start_date) & 
+        (merged_data['ISO_TIME'] <= end_date)
+    ]
+    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
+
+# Path animation function
+def generate_path_animation(year, typhoon, standard):
+    typhoon_id = typhoon.split('(')[-1].strip(')')
+    storm = ibtracs.get_storm(typhoon_id)
     fig = go.Figure()
-    fig.add_trace(go.Scattergeo(lon=storm.lon, lat=storm.lat, mode='lines', line=dict(width=2, color='gray'), name='Path', showlegend=False))
-    fig.add_trace(go.Scattergeo(lon=[storm.lon[0]], lat=[storm.lat[0]], mode='markers', marker=dict(size=10, color='green', symbol='star'),
-                                name='Starting Point', text=storm.time[0].strftime('%Y-%m-%d %H:%M'), hoverinfo='text+name'))
-    frames = []
-    for i in range(len(storm.time)):
-        category, color = categorize_typhoon_by_standard(storm.vmax[i], standard)
-        frame_data = [
-            go.Scattergeo(lon=storm.lon[:i+1], lat=storm.lat[:i+1], mode='lines', line=dict(width=2, color='blue'), name='Path Traveled', showlegend=False),
-            go.Scattergeo(lon=[storm.lon[i]], lat=[storm.lat[i]], mode='markers+text', marker=dict(size=10, color=color, symbol='star'),
-                          text=category, textposition="top center", name='Current Location', hovertext=f"{storm.time[i].strftime('%Y-%m-%d %H:%M')}<br>Category: {category}<br>Wind Speed: {storm.vmax[i]:.1f} m/s")
-        ]
-        frames.append(go.Frame(data=frame_data, name=f"frame{i}"))
+    fig.add_trace(go.Scattergeo(lon=storm.lon, lat=storm.lat, mode='lines', line=dict(width=2, color='gray')))
+    fig.add_trace(go.Scattergeo(lon=[storm.lon[0]], lat=[storm.lat[0]], mode='markers',
+                                marker=dict(size=10, color='green', symbol='star'), name='Start'))
+    frames = [
+        go.Frame(data=[
+            go.Scattergeo(lon=storm.lon[:i+1], lat=storm.lat[:i+1], mode='lines', line=dict(width=2, color='blue')),
+            go.Scattergeo(lon=[storm.lon[i]], lat=[storm.lat[i]], mode='markers',
+                          marker=dict(size=10, color=categorize_typhoon_by_standard(storm.vmax[i], standard)[1]))
+        ], name=f"frame{i}") for i in range(len(storm.time))
+    ]
     fig.frames = frames
-    fig.update_layout(title=f"{year} {storm.name} Typhoon Path", geo=dict(projection_type='natural earth', showland=True),
-                      updatemenus=[{"buttons": [{"args": [None, {"frame": {"duration": 100, "redraw": True}, "fromcurrent": True, "transition": {"duration": 0}}], "label": "Play", "method": "animate"},
-                                                {"args": [[None], {"frame": {"duration": 0, "redraw": True}, "mode": "immediate", "transition": {"duration": 0}}], "label": "Pause", "method": "animate"}],
-                                    "direction": "left", "pad": {"r": 10, "t": 87}, "showactive": False, "type": "buttons", "x": 0.1, "xanchor": "right", "y": 0, "yanchor": "top"}],
-                      sliders=[{"steps": [{"args": [[f"frame{k}"], {"frame": {"duration": 100, "redraw": True}, "mode": "immediate", "transition": {"duration": 0}}],
-                                          "label": storm.time[k].strftime('%Y-%m-%d %H:%M'), "method": "animate"} for k in range(len(storm.time))]}])
+    fig.update_layout(
+        title=f"{year} {storm.name} Typhoon Path",
+        geo=dict(projection_type='natural earth', showland=True),
+        updatemenus=[{"buttons": [{"label": "Play", "method": "animate", "args": [None, {"frame": {"duration": 100}}]},
+                                  {"label": "Pause", "method": "animate", "args": [[None], {"mode": "immediate"}]}]}]
+    )
     return fig
 
 def categorize_typhoon_by_standard(wind_speed, standard):
@@ -446,8 +326,7 @@ def categorize_typhoon_by_standard(wind_speed, standard):
             return 'Medium Typhoon', taiwan_standard['Medium Typhoon']['color']
         elif wind_speed_ms >= 17.2:
             return 'Mild Typhoon', taiwan_standard['Mild Typhoon']['color']
-        else:
-            return 'Tropical Depression', taiwan_standard['Tropical Depression']['color']
+        return 'Tropical Depression', taiwan_standard['Tropical Depression']['color']
     else:
         if wind_speed >= 137:
             return 'C5 Super Typhoon', atlantic_standard['C5 Super Typhoon']['color']
@@ -461,83 +340,94 @@ def categorize_typhoon_by_standard(wind_speed, standard):
             return 'C1 Typhoon', atlantic_standard['C1 Typhoon']['color']
         elif wind_speed >= 34:
             return 'Tropical Storm', atlantic_standard['Tropical Storm']['color']
-        else:
-            return 'Tropical Depression', atlantic_standard['Tropical Depression']['color']
-
-# Update Typhoon Dropdown
-def update_typhoon_dropdown(selected_year):
-    season = ibtracs.get_season(selected_year)
-    storm_summary = season.summary()
-    options = [f"{storm_summary['name'][i]} ({storm_summary['id'][i]})" for i in range(storm_summary['season_storms'])]
-    values = [storm_summary['id'][i] for i in range(storm_summary['season_storms'])]
-    return gr.Dropdown.update(choices=options, value=values[0] if values else None)
+        return 'Tropical Depression', atlantic_standard['Tropical Depression']['color']
 
-# Gradio Interface
+# 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}"
+
+# Gradio interface
 with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
     gr.Markdown("# Typhoon Analysis Dashboard")
-
+    
     with gr.Tab("Main Analysis"):
         with gr.Row():
             start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            start_month = gr.Number(label="Start Month", value=1, minimum=1, maximum=12, step=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.Number(label="End Month", value=6, minimum=1, maximum=12, step=1)
-        enso_dropdown = gr.Dropdown(label="ENSO Phase", choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"], value="All Years")
-        typhoon_search = gr.Textbox(label="Search Typhoon Name")
-        analyze_button = gr.Button("Analyze")
-        typhoon_tracks = gr.Plot(label="Typhoon Tracks")
-        all_years_regression = gr.Plot(label="All Years Regression")
-        regression_graphs = gr.HTML(label="Regression Graphs by ENSO Phase")
-        slopes = gr.HTML(label="Slopes")
-        wind_oni_scatter = gr.Plot(label="Wind Speed vs ONI")
-        pressure_oni_scatter = gr.Plot(label="Pressure vs ONI")
-        correlation_text = gr.HTML(label="Correlation Coefficient")
-        max_wind_speed_text = gr.HTML(label="Max Wind Speed")
-        min_pressure_text = gr.HTML(label="Min Pressure")
-        wind_oni_correlation = gr.HTML(label="Wind-ONI Correlation")
-        pressure_oni_correlation = gr.HTML(label="Pressure-ONI Correlation")
-        count_analysis = gr.HTML(label="Typhoon Count Analysis")
-        month_analysis = gr.HTML(label="Concentrated Months Analysis")
-        analyze_button.click(main_analysis, inputs=[start_year, start_month, end_year, end_month, enso_dropdown, typhoon_search],
-                             outputs=[typhoon_tracks, all_years_regression, regression_graphs, slopes, wind_oni_scatter, pressure_oni_scatter,
-                                      correlation_text, max_wind_speed_text, min_pressure_text, wind_oni_correlation, pressure_oni_correlation,
-                                      count_analysis, month_analysis])
-
-    with gr.Tab("Cluster Analysis"):
-        n_clusters = gr.Number(label="Number of Clusters", value=5, minimum=1, maximum=20, step=1)
-        show_clusters = gr.Checkbox(label="Show Clusters")
-        show_routes = gr.Checkbox(label="Show Typhoon Routes")
-        fourier_series = gr.Checkbox(label="Fourier Series")
-        with gr.Row():
-            cluster_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            cluster_start_month = gr.Number(label="Start Month", value=1, minimum=1, maximum=12, step=1)
-            cluster_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            cluster_end_month = gr.Number(label="End Month", value=6, minimum=1, maximum=12, step=1)
-        cluster_enso = gr.Dropdown(label="ENSO Phase", choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"], value="All Years")
-        cluster_button = gr.Button("Generate Cluster Analysis")
-        cluster_figure = gr.Plot(label="Cluster Routes")
-        equations_output = gr.HTML(label="Cluster Equations")
-        cluster_button.click(cluster_analysis, inputs=[n_clusters, show_clusters, show_routes, fourier_series, cluster_start_year, cluster_start_month, cluster_end_year, cluster_end_month, cluster_enso],
-                             outputs=[cluster_figure, equations_output])
-
-    with gr.Tab("Logistic Regression"):
-        regression_type = gr.Dropdown(label="Regression Type", choices=["Wind", "Pressure", "Longitude"], value="Wind")
+            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("Analyze")
         with gr.Row():
-            reg_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            reg_start_month = gr.Number(label="Start Month", value=1, minimum=1, maximum=12, step=1)
-            reg_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            reg_end_month = gr.Number(label="End Month", value=6, minimum=1, maximum=12, step=1)
-        regression_button = gr.Button("Run Regression")
-        regression_results = gr.HTML(label="Regression Results")
-        regression_button.click(logistic_regression, inputs=[regression_type, reg_start_year, reg_start_month, reg_end_year, reg_end_month], outputs=[regression_results])
-
+            tracks_plot = gr.Plot(label="Typhoon Tracks")
+            wind_scatter = gr.Plot(label="Wind Speed vs ONI")
+            pressure_scatter = gr.Plot(label="Pressure vs ONI")
+            regression_plot = gr.Plot(label="Regression Analysis")
+        slopes_text = gr.Textbox(label="Regression Slopes")
+        analyze_btn.click(
+            fn=generate_main_analysis,
+            inputs=[start_year, start_month, end_year, end_month, enso_phase, typhoon_search],
+            outputs=[tracks_plot, wind_scatter, pressure_scatter, regression_plot, slopes_text]
+        )
+    
     with gr.Tab("Typhoon Path Animation"):
-        year_dropdown = gr.Dropdown(label="Year", choices=[str(year) for year in range(1950, 2025)], value="2024")
-        typhoon_dropdown = gr.Dropdown(label="Typhoon", choices=[])
-        standard_dropdown = gr.Dropdown(label="Classification Standard", choices=["Atlantic", "Taiwan"], value="Atlantic")
-        animation_button = gr.Button("Generate Animation")
-        animation_figure = gr.Plot(label="Typhoon Path Animation")
-        year_dropdown.change(update_typhoon_dropdown, inputs=[year_dropdown], outputs=[typhoon_dropdown])
-        animation_button.click(typhoon_path_animation, inputs=[year_dropdown, typhoon_dropdown, standard_dropdown], outputs=[animation_figure])
+        year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950, 2025)], value="2024")
+        typhoon_dropdown = gr.Dropdown(label="Typhoon")
+        standard_dropdown = gr.Dropdown(label="Classification Standard", choices=['atlantic', 'taiwan'], value='atlantic')
+        path_plot = gr.Plot(label="Typhoon Path Animation")
+        
+        def update_typhoon_options(year):
+            season = ibtracs.get_season(int(year))
+            storm_summary = season.summary()
+            options = [f"{storm_summary['name'][i]} ({storm_summary['id'][i]})" for i in range(storm_summary['season_storms'])]
+            return gr.update(choices=options, value=options[0] if options else None)
+        
+        year_dropdown.change(fn=update_typhoon_options, inputs=year_dropdown, outputs=typhoon_dropdown)
+        gr.Button("Generate Animation").click(
+            fn=generate_path_animation,
+            inputs=[year_dropdown, typhoon_dropdown, standard_dropdown],
+            outputs=path_plot
+        )
+    
+    with gr.Tab("Logistic Regressions"):
+        with gr.Row():
+            wind_btn = gr.Button("Wind Speed Regression")
+            pressure_btn = gr.Button("Pressure Regression")
+            longitude_btn = gr.Button("Longitude Regression")
+        regression_results = gr.Textbox(label="Regression Results", lines=10)
+        wind_btn.click(fn=perform_wind_regression, inputs=[start_year, start_month, end_year, end_month], outputs=regression_results)
+        pressure_btn.click(fn=perform_pressure_regression, inputs=[start_year, start_month, end_year, end_month], outputs=regression_results)
+        longitude_btn.click(fn=perform_longitude_regression, inputs=[start_year, start_month, end_year, end_month], outputs=regression_results)
 
 demo.launch()