Update app.py

app.py

@@ -140,6 +140,14 @@ matplotlib_color_map = {
     'C5 Super Typhoon': '#FF0000'     # Red
 }
 
+# Taiwan color mapping
+taiwan_color_map = {
+    'Tropical Depression': '#808080',  # Gray
+    'Mild Typhoon': '#FFFF00',         # Yellow
+    'Medium Typhoon': '#FFA500',       # Orange
+    'Strong Typhoon': '#FF0000'        # Red
+}
+
 def rgb_string_to_hex(rgb_string):
     """Convert 'rgb(r,g,b)' string to hex color for matplotlib"""
     try:
@@ -158,6 +166,10 @@ def get_matplotlib_color(category):
     """Get matplotlib-compatible color for a storm category"""
     return matplotlib_color_map.get(category, '#808080')
 
+def get_taiwan_color(category):
+    """Get Taiwan standard color for a storm category"""
+    return taiwan_color_map.get(category, '#808080')
+
 # Cluster colors for route visualization
 CLUSTER_COLORS = [
     '#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7',
@@ -724,6 +736,24 @@ def categorize_typhoon_enhanced(wind_speed):
     else:  # 137+ knots = Category 5 Super Typhoon
         return 'C5 Super Typhoon'
 
+def categorize_typhoon_taiwan(wind_speed):
+    """Taiwan categorization system"""
+    if pd.isna(wind_speed):
+        return 'Tropical Depression'
+    
+    # Convert to m/s if in knots
+    if wind_speed > 50:  # Likely in knots, convert to m/s
+        wind_speed = wind_speed * 0.514444
+    
+    if wind_speed >= 51.0:
+        return 'Strong Typhoon'
+    elif wind_speed >= 33.7:
+        return 'Medium Typhoon'
+    elif wind_speed >= 17.2:
+        return 'Mild Typhoon'
+    else:
+        return 'Tropical Depression'
+
 # Original function for backward compatibility
 def categorize_typhoon(wind_speed):
     """Original categorize typhoon function for backward compatibility"""
@@ -1007,8 +1037,8 @@ def cluster_storms(embedding, method='dbscan', eps=0.5, min_samples=3):
         # Return single cluster as fallback
         return np.array([0] * len(embedding))
 
-def create_advanced_clustering_visualization(storm_features, typhoon_data, method='umap', show_routes=True):
-    """Create comprehensive clustering visualization with route display - FIXED VERSION"""
+def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'):
+    """Create separate plots for clustering analysis - FIXED VERSION"""
     try:
         # Validate inputs
         if storm_features is None or storm_features.empty:
@@ -1043,115 +1073,71 @@ def create_advanced_clustering_visualization(storm_features, typhoon_data, metho
             storm_features_viz['NAME'] = 'UNNAMED'
             storm_features_viz['SEASON'] = 2000
         
-        if show_routes:
-            # Create subplot with both scatter plot and route map
-            fig = make_subplots(
-                rows=1, cols=2,
-                subplot_titles=(
-                    f'Storm Clustering using {method.upper()}',
-                    'Clustered Storm Routes'
-                ),
-                specs=[[{"type": "scatter"}, {"type": "geo"}]],
-                column_widths=[0.5, 0.5]
-            )
+        # 1. Clustering scatter plot
+        fig_cluster = px.scatter(
+            storm_features_viz,
+            x='dim1',
+            y='dim2',
+            color='cluster',
+            hover_data=['NAME', 'SEASON'],
+            title=f'Storm Clustering using {method.upper()}',
+            labels={
+                'dim1': f'{method.upper()} Dimension 1',
+                'dim2': f'{method.upper()} Dimension 2',
+                'cluster': 'Cluster'
+            }
+        )
+        
+        # 2. Route map
+        fig_routes = go.Figure()
+        
+        unique_clusters = sorted(storm_features_viz['cluster'].unique())
+        for i, cluster in enumerate(unique_clusters):
+            if cluster == -1:  # Skip noise for route visualization
+                continue
+                
+            cluster_storm_ids = storm_features_viz[storm_features_viz['cluster'] == cluster]['SID'].tolist()
+            color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)]
             
-            # Add clustering scatter plot
-            unique_clusters = sorted(storm_features_viz['cluster'].unique())
-            for i, cluster in enumerate(unique_clusters):
-                cluster_data = storm_features_viz[storm_features_viz['cluster'] == cluster]
-                color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)] if cluster != -1 else '#CCCCCC'
-                cluster_name = f'Cluster {cluster}' if cluster != -1 else 'Noise'
-                
-                # FIXED: Add safe access to clustering features
+            tracks_added = 0
+            for j, sid in enumerate(cluster_storm_ids[:5]):  # Limit to 5 storms per cluster for performance
                 try:
-                    max_wind = cluster_data['USA_WIND_max'].fillna(0)
-                    min_pres = cluster_data['USA_PRES_min'].fillna(1000)
-                    track_len = cluster_data['track_length'].fillna(0)
-                except KeyError as e:
-                    logging.warning(f"Missing clustering feature: {e}")
-                    max_wind = pd.Series([0] * len(cluster_data))
-                    min_pres = pd.Series([1000] * len(cluster_data))
-                    track_len = pd.Series([0] * len(cluster_data))
-                
-                fig.add_trace(
-                    go.Scatter(
-                        x=cluster_data['dim1'],
-                        y=cluster_data['dim2'],
-                        mode='markers',
-                        marker=dict(color=color, size=8),
-                        name=cluster_name,
-                        hovertemplate=(
-                            '<b>%{customdata[0]}</b><br>'
-                            'Season: %{customdata[1]}<br>'
-                            'Max Wind: %{customdata[2]:.0f} kt<br>'
-                            'Min Pressure: %{customdata[3]:.0f} hPa<br>'
-                            'Track Length: %{customdata[4]:.0f} points<br>'
-                            '<extra></extra>'
-                        ),
-                        customdata=np.column_stack((
-                            cluster_data['NAME'].fillna('UNNAMED'),
-                            cluster_data['SEASON'].fillna(2000),
-                            max_wind,
-                            min_pres,
-                            track_len
-                        ))
-                    ),
-                    row=1, col=1
-                )
-            
-            # Add route map - FIXED with better error handling
-            for i, cluster in enumerate(unique_clusters):
-                if cluster == -1:  # Skip noise for route visualization
-                    continue
-                    
-                cluster_storm_ids = storm_features_viz[storm_features_viz['cluster'] == cluster]['SID'].tolist()
-                color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)]
-                
-                tracks_added = 0
-                for j, sid in enumerate(cluster_storm_ids[:5]):  # Limit to 5 storms per cluster for performance
-                    try:
-                        storm_track = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
+                    storm_track = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
+                    if len(storm_track) > 1:
+                        # Ensure valid coordinates
+                        valid_coords = storm_track['LAT'].notna() & storm_track['LON'].notna()
+                        storm_track = storm_track[valid_coords]
+                        
                         if len(storm_track) > 1:
-                            # Ensure valid coordinates
-                            valid_coords = storm_track['LAT'].notna() & storm_track['LON'].notna()
-                            storm_track = storm_track[valid_coords]
+                            storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
                             
-                            if len(storm_track) > 1:
-                                storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
-                                
-                                fig.add_trace(
-                                    go.Scattergeo(
-                                        lon=storm_track['LON'],
-                                        lat=storm_track['LAT'],
-                                        mode='lines+markers',
-                                        line=dict(color=color, width=2),
-                                        marker=dict(color=color, size=4),
-                                        name=f'C{cluster}: {storm_name}' if tracks_added == 0 else None,
-                                        showlegend=(tracks_added == 0),
-                                        hovertemplate=(
-                                            f'<b>{storm_name}</b><br>'
-                                            'Lat: %{lat:.1f}°<br>'
-                                            'Lon: %{lon:.1f}°<br>'
-                                            f'Cluster: {cluster}<br>'
-                                            '<extra></extra>'
-                                        )
-                                    ),
-                                    row=1, col=2
+                            fig_routes.add_trace(
+                                go.Scattergeo(
+                                    lon=storm_track['LON'],
+                                    lat=storm_track['LAT'],
+                                    mode='lines+markers',
+                                    line=dict(color=color, width=2),
+                                    marker=dict(color=color, size=4),
+                                    name=f'C{cluster}: {storm_name}' if tracks_added == 0 else None,
+                                    showlegend=(tracks_added == 0),
+                                    hovertemplate=(
+                                        f'<b>{storm_name}</b><br>'
+                                        'Lat: %{lat:.1f}°<br>'
+                                        'Lon: %{lon:.1f}°<br>'
+                                        f'Cluster: {cluster}<br>'
+                                        '<extra></extra>'
+                                    )
                                 )
-                                tracks_added += 1
-                    except Exception as track_error:
-                        logging.warning(f"Error adding track for storm {sid}: {track_error}")
-                        continue
-            
-            # Update layout
-            fig.update_layout(
-                title_text="Advanced Storm Clustering Analysis with Route Visualization",
-                showlegend=True,
-                height=600
-            )
-            
-            # Update geo layout
-            fig.update_geos(
+                            )
+                            tracks_added += 1
+                except Exception as track_error:
+                    logging.warning(f"Error adding track for storm {sid}: {track_error}")
+                    continue
+        
+        # Update route map layout
+        fig_routes.update_layout(
+            title="Clustered Storm Routes",
+            geo=dict(
                 projection_type="natural earth",
                 showland=True,
                 landcolor="LightGray",
@@ -1159,29 +1145,97 @@ def create_advanced_clustering_visualization(storm_features, typhoon_data, metho
                 oceancolor="LightBlue",
                 showcoastlines=True,
                 coastlinecolor="Gray",
-                center=dict(lat=20, lon=140),
-                row=1, col=2
+                center=dict(lat=20, lon=140)
             )
+        )
+        
+        # 3. Pressure evolution plot
+        fig_pressure = go.Figure()
+        
+        for i, cluster in enumerate(unique_clusters):
+            if cluster == -1:
+                continue
+                
+            cluster_storm_ids = storm_features_viz[storm_features_viz['cluster'] == cluster]['SID'].tolist()
+            color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)]
             
-            # Update scatter plot axes
-            fig.update_xaxes(title_text=f"{method.upper()} Dimension 1", row=1, col=1)
-            fig.update_yaxes(title_text=f"{method.upper()} Dimension 2", row=1, col=1)
+            for j, sid in enumerate(cluster_storm_ids[:3]):  # Limit to 3 storms per cluster
+                try:
+                    storm_track = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
+                    if len(storm_track) > 1 and 'USA_PRES' in storm_track.columns:
+                        pressure_values = pd.to_numeric(storm_track['USA_PRES'], errors='coerce').dropna()
+                        if len(pressure_values) > 0:
+                            storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
+                            time_hours = range(len(pressure_values))
+                            
+                            fig_pressure.add_trace(
+                                go.Scatter(
+                                    x=time_hours,
+                                    y=pressure_values,
+                                    mode='lines',
+                                    line=dict(color=color, width=2),
+                                    name=f'C{cluster}: {storm_name}' if j == 0 else None,
+                                    showlegend=(j == 0),
+                                    hovertemplate=(
+                                        f'<b>{storm_name}</b><br>'
+                                        'Hour: %{x}<br>'
+                                        'Pressure: %{y:.0f} hPa<br>'
+                                        '<extra></extra>'
+                                    )
+                                )
+                            )
+                except Exception as e:
+                    continue
+        
+        fig_pressure.update_layout(
+            title="Pressure Evolution by Cluster",
+            xaxis_title="Time (hours)",
+            yaxis_title="Pressure (hPa)"
+        )
+        
+        # 4. Wind evolution plot
+        fig_wind = go.Figure()
+        
+        for i, cluster in enumerate(unique_clusters):
+            if cluster == -1:
+                continue
+                
+            cluster_storm_ids = storm_features_viz[storm_features_viz['cluster'] == cluster]['SID'].tolist()
+            color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)]
             
-        else:
-            # Simple scatter plot only
-            fig = px.scatter(
-                storm_features_viz,
-                x='dim1',
-                y='dim2',
-                color='cluster',
-                hover_data=['NAME', 'SEASON'],
-                title=f'Storm Clustering using {method.upper()}',
-                labels={
-                    'dim1': f'{method.upper()} Dimension 1',
-                    'dim2': f'{method.upper()} Dimension 2',
-                    'cluster': 'Cluster'
-                }
-            )
+            for j, sid in enumerate(cluster_storm_ids[:3]):  # Limit to 3 storms per cluster
+                try:
+                    storm_track = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
+                    if len(storm_track) > 1 and 'USA_WIND' in storm_track.columns:
+                        wind_values = pd.to_numeric(storm_track['USA_WIND'], errors='coerce').dropna()
+                        if len(wind_values) > 0:
+                            storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
+                            time_hours = range(len(wind_values))
+                            
+                            fig_wind.add_trace(
+                                go.Scatter(
+                                    x=time_hours,
+                                    y=wind_values,
+                                    mode='lines',
+                                    line=dict(color=color, width=2),
+                                    name=f'C{cluster}: {storm_name}' if j == 0 else None,
+                                    showlegend=(j == 0),
+                                    hovertemplate=(
+                                        f'<b>{storm_name}</b><br>'
+                                        'Hour: %{x}<br>'
+                                        'Wind: %{y:.0f} kt<br>'
+                                        '<extra></extra>'
+                                    )
+                                )
+                            )
+                except Exception as e:
+                    continue
+        
+        fig_wind.update_layout(
+            title="Wind Speed Evolution by Cluster",
+            xaxis_title="Time (hours)",
+            yaxis_title="Wind Speed (kt)"
+        )
         
         # Generate detailed cluster statistics - FIXED
         try:
@@ -1201,11 +1255,6 @@ def create_advanced_clustering_visualization(storm_features, typhoon_data, metho
             existing_cols = {k: v for k, v in available_cols.items() if v in storm_features_viz.columns}
             
             if len(existing_cols) > 1:  # Need at least SID + one other column
-                cluster_stats = storm_features_viz.groupby('cluster').agg(
-                    {col: ['mean', 'std', 'count'] if col != 'SID' else 'count' 
-                     for col in existing_cols.values()}
-                ).round(2)
-                
                 stats_text = "ADVANCED CLUSTER ANALYSIS RESULTS\n" + "="*50 + "\n\n"
                 
                 for cluster in sorted(storm_features_viz['cluster'].unique()):
@@ -1256,7 +1305,7 @@ def create_advanced_clustering_visualization(storm_features, typhoon_data, metho
             logging.error(f"Error generating cluster statistics: {stats_error}")
             stats_text = f"Error generating cluster statistics: {str(stats_error)}"
         
-        return fig, stats_text, storm_features_viz
+        return fig_cluster, fig_routes, fig_pressure, fig_wind, stats_text
         
     except Exception as e:
         logging.error(f"Error in clustering analysis: {e}")
@@ -1270,7 +1319,7 @@ def create_advanced_clustering_visualization(storm_features, typhoon_data, metho
             x=0.5, y=0.5, xanchor='center', yanchor='middle',
             showarrow=False, font_size=16
         )
-        return error_fig, f"Error in clustering: {str(e)}", None
+        return error_fig, error_fig, error_fig, error_fig, f"Error in clustering: {str(e)}"
 
 # -----------------------------
 # ENHANCED: Advanced Prediction System with Route Forecasting
@@ -1513,18 +1562,18 @@ def predict_storm_route_and_intensity(lat, lon, month, oni_value, models=None, f
         }
 
 def create_route_visualization(prediction_results, show_uncertainty=True):
-    """Create comprehensive route and intensity visualization"""
+    """Create comprehensive route and intensity visualization - FIXED"""
     try:
         if 'route_forecast' not in prediction_results or not prediction_results['route_forecast']:
             return None, "No route forecast data available"
         
         route_data = prediction_results['route_forecast']
         
-        # Create subplot with route map and intensity evolution
+        # Create subplot with route map and intensity evolution - FIXED
         fig = make_subplots(
             rows=1, cols=2,
             subplot_titles=('Forecast Track', 'Intensity Evolution'),
-            specs=[[{"type": "geo"}, {"type": "scatter"}]],
+            specs=[[{"type": "geo"}, {"type": "xy"}]],  # Changed to xy for regular plot
             column_widths=[0.6, 0.4]
         )
         
@@ -1619,7 +1668,7 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
                 row=1, col=1
             )
         
-        # Intensity evolution plot
+        # Intensity evolution plot - FIXED to use regular scatter plot
         fig.add_trace(
             go.Scatter(
                 x=hours,
@@ -1658,7 +1707,7 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
             height=600
         )
         
-        # Update geo layout
+        # Update geo layout - FIXED: Only update geo subplot
         fig.update_geos(
             projection_type="natural earth",
             showland=True,
@@ -1672,7 +1721,7 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
             row=1, col=1
         )
         
-        # Update intensity plot
+        # Update intensity plot - FIXED: Use correct method for regular subplot
         fig.update_xaxes(title_text="Forecast Hour", row=1, col=2)
         fig.update_yaxes(title_text="Intensity (kt)", row=1, col=2)
         
@@ -1922,7 +1971,12 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
         return 'Tropical Depression', '#808080'
     
     if standard=='taiwan':
-        wind_speed_ms = wind_speed * 0.514444
+        # Taiwan standard uses m/s, convert if needed
+        if wind_speed > 50:  # Likely in knots, convert to m/s
+            wind_speed_ms = wind_speed * 0.514444
+        else:
+            wind_speed_ms = wind_speed
+            
         if wind_speed_ms >= 51.0:
             return 'Strong Typhoon', '#FF0000'  # Red
         elif wind_speed_ms >= 33.7:
@@ -1931,6 +1985,7 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
             return 'Mild Typhoon', '#FFFF00'   # Yellow
         return 'Tropical Depression', '#808080'  # Gray
     else:
+        # Atlantic standard in knots
         if wind_speed >= 137:
             return 'C5 Super Typhoon', '#FF0000'      # Red
         elif wind_speed >= 113:
@@ -1946,7 +2001,7 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
         return 'Tropical Depression', '#808080'       # Gray
 
 # -----------------------------
-# ENHANCED: Animation Functions
+# ENHANCED: Animation Functions with Taiwan Standard Support
 # -----------------------------
 
 def get_available_years(typhoon_data):
@@ -2032,7 +2087,7 @@ def update_typhoon_options_enhanced(year, basin):
         return gr.update(choices=["Error loading storms"], value=None)
 
 def generate_enhanced_track_video(year, typhoon_selection, standard):
-    """Enhanced track video generation with TD support and 2025 compatibility - FIXED color handling"""
+    """Enhanced track video generation with TD support, Taiwan standard, and 2025 compatibility"""
     if not typhoon_selection or typhoon_selection == "No storms found":
         return None
     
@@ -2063,10 +2118,10 @@ def generate_enhanced_track_video(year, typhoon_selection, standard):
         storm_name = storm_df['NAME'].iloc[0] if pd.notna(storm_df['NAME'].iloc[0]) else "UNNAMED"
         season = storm_df['SEASON'].iloc[0] if 'SEASON' in storm_df.columns else year
         
-        print(f"Generating video for {storm_name} ({sid}) with {len(lats)} track points")
+        print(f"Generating video for {storm_name} ({sid}) with {len(lats)} track points using {standard} standard")
         
         # Create figure with enhanced map
-        fig, ax = plt.subplots(figsize=(14, 8), subplot_kw={'projection': ccrs.PlateCarree()})
+        fig, ax = plt.subplots(figsize=(16, 10), subplot_kw={'projection': ccrs.PlateCarree()})
         
         # Enhanced map features
         ax.stock_img()
@@ -2086,28 +2141,37 @@ def generate_enhanced_track_video(year, typhoon_selection, standard):
         gl = ax.gridlines(draw_labels=True, alpha=0.3)
         gl.top_labels = gl.right_labels = False
         
-        # Title with enhanced info
-        ax.set_title(f"{season} {storm_name} ({sid}) Track Animation", fontsize=16, fontweight='bold')
+        # Title with enhanced info and standard
+        ax.set_title(f"{season} {storm_name} ({sid}) Track Animation - {standard.upper()} Standard", 
+                    fontsize=18, fontweight='bold')
         
         # Animation elements
         line, = ax.plot([], [], 'b-', linewidth=3, alpha=0.7, label='Track')
-        point, = ax.plot([], [], 'o', markersize=12)
+        point, = ax.plot([], [], 'o', markersize=15)
         
         # Enhanced info display
         info_box = ax.text(0.02, 0.98, '', transform=ax.transAxes, 
-                          fontsize=11, verticalalignment='top',
+                          fontsize=12, verticalalignment='top',
                           bbox=dict(boxstyle="round,pad=0.5", facecolor='white', alpha=0.9))
         
-        # Color legend with TD support - FIXED
+        # Color legend with both standards - ENHANCED
         legend_elements = []
-        for category in ['Tropical Depression', 'Tropical Storm', 'C1 Typhoon', 'C2 Typhoon', 
-                        'C3 Strong Typhoon', 'C4 Very Strong Typhoon', 'C5 Super Typhoon']:
-            if category in matplotlib_color_map:
+        
+        if standard == 'taiwan':
+            categories = ['Tropical Depression', 'Mild Typhoon', 'Medium Typhoon', 'Strong Typhoon']
+            for category in categories:
+                color = get_taiwan_color(category)
+                legend_elements.append(plt.Line2D([0], [0], marker='o', color='w',
+                                                markerfacecolor=color, markersize=10, label=category))
+        else:
+            categories = ['Tropical Depression', 'Tropical Storm', 'C1 Typhoon', 'C2 Typhoon', 
+                         'C3 Strong Typhoon', 'C4 Very Strong Typhoon', 'C5 Super Typhoon']
+            for category in categories:
                 color = get_matplotlib_color(category)
                 legend_elements.append(plt.Line2D([0], [0], marker='o', color='w',
-                                                markerfacecolor=color, markersize=8, label=category))
+                                                markerfacecolor=color, markersize=10, label=category))
         
-        ax.legend(handles=legend_elements, loc='upper right', fontsize=9)
+        ax.legend(handles=legend_elements, loc='upper right', fontsize=10)
         
         def animate(frame):
             try:
@@ -2117,32 +2181,43 @@ def generate_enhanced_track_video(year, typhoon_selection, standard):
                 # Update track line
                 line.set_data(lons[:frame+1], lats[:frame+1])
                 
-                # Update current position
+                # Update current position with appropriate categorization
                 current_wind = winds[frame]
-                category = categorize_typhoon_enhanced(current_wind)
-                color = get_matplotlib_color(category)  # FIXED: Use matplotlib-compatible color
+                
+                if standard == 'taiwan':
+                    category, color = categorize_typhoon_by_standard(current_wind, 'taiwan')
+                else:
+                    category, color = categorize_typhoon_by_standard(current_wind, 'atlantic')
                 
                 # Debug print for first few frames
                 if frame < 3:
-                    print(f"Frame {frame}: Wind={current_wind:.1f}kt, Category={category}, Color={color}")
+                    print(f"Frame {frame}: Wind={current_wind:.1f}kt, Category={category}, Color={color}, Standard={standard}")
                 
                 point.set_data([lons[frame]], [lats[frame]])
                 point.set_color(color)
-                point.set_markersize(8 + current_wind/10)  # Size based on intensity
+                point.set_markersize(10 + current_wind/8)  # Size based on intensity
                 
-                # Enhanced info display
+                # Enhanced info display with standard information
                 if 'ISO_TIME' in storm_df.columns and frame < len(storm_df):
                     current_time = storm_df.iloc[frame]['ISO_TIME']
                     time_str = current_time.strftime('%Y-%m-%d %H:%M UTC') if pd.notna(current_time) else 'Unknown'
                 else:
                     time_str = f"Step {frame+1}"
                 
+                # Convert wind speed for Taiwan standard display
+                if standard == 'taiwan':
+                    wind_ms = current_wind * 0.514444  # Convert to m/s for display
+                    wind_display = f"{current_wind:.0f} kt ({wind_ms:.1f} m/s)"
+                else:
+                    wind_display = f"{current_wind:.0f} kt"
+                
                 info_text = (
                     f"Storm: {storm_name}\n"
                     f"Time: {time_str}\n"
                     f"Position: {lats[frame]:.1f}°N, {lons[frame]:.1f}°E\n"
-                    f"Max Wind: {current_wind:.0f} kt\n"
+                    f"Max Wind: {wind_display}\n"
                     f"Category: {category}\n"
+                    f"Standard: {standard.upper()}\n"
                     f"Frame: {frame+1}/{len(lats)}"
                 )
                 info_box.set_text(info_text)
@@ -2156,7 +2231,7 @@ def generate_enhanced_track_video(year, typhoon_selection, standard):
         # Create animation
         anim = animation.FuncAnimation(
             fig, animate, frames=len(lats),
-            interval=300, blit=False, repeat=True
+            interval=400, blit=False, repeat=True  # Slightly slower for better viewing
         )
         
         # Save animation
@@ -2165,12 +2240,12 @@ def generate_enhanced_track_video(year, typhoon_selection, standard):
         
         # Enhanced writer settings
         writer = animation.FFMpegWriter(
-            fps=4, bitrate=2000, codec='libx264',
+            fps=3, bitrate=2000, codec='libx264',  # Slower FPS for better visibility
             extra_args=['-pix_fmt', 'yuv420p']  # Better compatibility
         )
         
         print(f"Saving animation to {temp_file.name}")
-        anim.save(temp_file.name, writer=writer, dpi=100)
+        anim.save(temp_file.name, writer=writer, dpi=120)  # Higher DPI for better quality
         plt.close(fig)
         
         print(f"Video generated successfully: {temp_file.name}")
@@ -2236,7 +2311,7 @@ def initialize_data():
 initialize_data()
 
 # -----------------------------
-# ENHANCED: Gradio Interface with Advanced Features
+# ENHANCED: Gradio Interface with Fixed Route Visualization and Enhanced Features
 # -----------------------------
 
 def create_interface():
@@ -2271,11 +2346,12 @@ def create_interface():
                 This dashboard provides comprehensive analysis of typhoon data in relation to ENSO phases with advanced machine learning capabilities.
 
                 ### 🚀 Enhanced Features:
-                - **Advanced ML Clustering**: UMAP/t-SNE storm pattern analysis with route visualization
+                - **Advanced ML Clustering**: UMAP/t-SNE storm pattern analysis with separate visualizations
                 - **Predictive Routing**: Advanced storm track and intensity forecasting with uncertainty quantification
                 - **Complete TD Support**: Now includes Tropical Depressions (< 34 kt)
+                - **Taiwan Standard**: Full support for Taiwan meteorological classification system
                 - **2025 Data Ready**: Real-time compatibility with current year data
-                - **Enhanced Animations**: High-quality storm track visualizations
+                - **Enhanced Animations**: High-quality storm track visualizations with both standards
                 
                 ### 📊 Data Status:
                 - **ONI Data**: {len(oni_data)} years loaded
@@ -2299,8 +2375,8 @@ def create_interface():
                 gr.Markdown(overview_text)
 
             with gr.Tab("🔬 Advanced ML Clustering"):
-                gr.Markdown("## 🎯 Storm Pattern Analysis using UMAP/t-SNE with Route Visualization")
-                gr.Markdown("**This tab shows both the dimensional clustering analysis AND the actual storm tracks colored by cluster**")
+                gr.Markdown("## 🎯 Storm Pattern Analysis with Separate Visualizations")
+                gr.Markdown("**Four separate plots: Clustering, Routes, Pressure Evolution, and Wind Evolution**")
                 
                 with gr.Row():
                     with gr.Column(scale=2):
@@ -2311,52 +2387,61 @@ def create_interface():
                             info="UMAP provides better global structure preservation"
                         )
                     with gr.Column(scale=1):
-                        show_routes = gr.Checkbox(
-                            label="🗺️ Show Storm Routes on Map",
-                            value=True,
-                            info="Display actual storm tracks colored by cluster"
-                        )
+                        analyze_clusters_btn = gr.Button("🚀 Generate All Cluster Analyses", variant="primary", size="lg")
                 
-                analyze_clusters_btn = gr.Button("🚀 Analyze Storm Clusters & Routes", variant="primary", size="lg")
+                with gr.Row():
+                    with gr.Column():
+                        cluster_plot = gr.Plot(label="📊 Storm Clustering Analysis")
+                    with gr.Column():
+                        routes_plot = gr.Plot(label="🗺️ Clustered Storm Routes")
                 
                 with gr.Row():
-                    cluster_plot = gr.Plot(label="Storm Clustering with Route Visualization")
+                    with gr.Column():
+                        pressure_plot = gr.Plot(label="🌡️ Pressure Evolution by Cluster")
+                    with gr.Column():
+                        wind_plot = gr.Plot(label="💨 Wind Speed Evolution by Cluster")
                 
                 with gr.Row():
                     cluster_stats = gr.Textbox(label="📈 Detailed Cluster Statistics", lines=15, max_lines=20)
                 
-                def run_advanced_clustering_analysis(method, show_routes):
+                def run_separate_clustering_analysis(method):
                     try:
                         # Extract features for clustering
                         storm_features = extract_storm_features(typhoon_data)
                         if storm_features is None:
-                            return None, "Error: Could not extract storm features"
-                        fig, stats, _ = create_advanced_clustering_visualization(storm_features, typhoon_data, method.lower(), show_routes)
-                        return fig, stats
+                            return None, None, None, None, "Error: Could not extract storm features"
+                        
+                        fig_cluster, fig_routes, fig_pressure, fig_wind, stats = create_separate_clustering_plots(
+                            storm_features, typhoon_data, method.lower()
+                        )
+                        return fig_cluster, fig_routes, fig_pressure, fig_wind, stats
                     except Exception as e:
                         import traceback
                         error_details = traceback.format_exc()
-                        return None, f"Error: {str(e)}\n\nDetails:\n{error_details}"
+                        error_msg = f"Error: {str(e)}\n\nDetails:\n{error_details}"
+                        return None, None, None, None, error_msg
                 
                 analyze_clusters_btn.click(
-                    fn=run_advanced_clustering_analysis,
-                    inputs=[reduction_method, show_routes],
-                    outputs=[cluster_plot, cluster_stats]
+                    fn=run_separate_clustering_analysis,
+                    inputs=[reduction_method],
+                    outputs=[cluster_plot, routes_plot, pressure_plot, wind_plot, cluster_stats]
                 )
                 
                 cluster_info_text = """
-                ### 📊 Advanced Clustering Features:
+                ### 📊 Enhanced Clustering Features:
+                - **Separate Visualizations**: Four distinct plots for comprehensive analysis
                 - **Multi-dimensional Analysis**: Uses 15+ storm characteristics including intensity, track shape, genesis location
-                - **Route Visualization**: Shows actual storm tracks colored by cluster membership
-                - **DBSCAN Clustering**: Automatically finds natural groupings without predefined cluster count
-                - **Comprehensive Stats**: Detailed cluster analysis including intensity, pressure, track length, curvature
-                - **Interactive**: Hover over points to see storm details, zoom and pan the route map
+                - **Route Visualization**: Geographic storm tracks colored by cluster membership
+                - **Temporal Analysis**: Pressure and wind evolution patterns by cluster
+                - **DBSCAN Clustering**: Automatic pattern discovery without predefined cluster count
+                - **Interactive**: Hover over points to see storm details, zoom and pan all plots
                 
                 ### 🎯 How to Interpret:
-                - **Left Plot**: Each dot is a storm positioned by similarity (close = similar characteristics)
-                - **Right Plot**: Actual geographic storm tracks, colored by which cluster they belong to
-                - **Cluster Colors**: Each cluster gets a unique color to identify similar storm patterns
-                - **Noise Points**: Gray points represent storms that don't fit clear patterns
+                - **Clustering Plot**: Each dot is a storm positioned by similarity (close = similar characteristics)
+                - **Routes Plot**: Actual geographic storm tracks, colored by which cluster they belong to
+                - **Pressure Plot**: Shows how pressure changes over time for storms in each cluster
+                - **Wind Plot**: Shows wind speed evolution patterns for each cluster
+                - **Cluster Colors**: Each cluster gets a unique color across all four visualizations
                 """
                 gr.Markdown(cluster_info_text)
 
@@ -2521,7 +2606,7 @@ def create_interface():
                 )
             
             with gr.Tab("🎬 Enhanced Track Animation"):
-                gr.Markdown("## 🎥 High-Quality Storm Track Visualization (All Categories Including TD)")
+                gr.Markdown("## 🎥 High-Quality Storm Track Visualization (Atlantic & Taiwan Standards)")
                 
                 with gr.Row():
                     year_dropdown = gr.Dropdown(
@@ -2538,9 +2623,10 @@ def create_interface():
                 with gr.Row():
                     typhoon_dropdown = gr.Dropdown(label="Storm Selection (All Categories Including TD)")
                     standard_dropdown = gr.Dropdown(
-                        label="Classification Standard",
+                        label="🎌 Classification Standard",
                         choices=['atlantic', 'taiwan'], 
-                        value='atlantic'
+                        value='atlantic',
+                        info="Atlantic: International standard | Taiwan: Local meteorological standard"
                     )
                 
                 generate_video_btn = gr.Button("🎬 Generate Enhanced Animation", variant="primary")
@@ -2563,6 +2649,7 @@ def create_interface():
                 
                 animation_info_text = """
                 ### 🎬 Enhanced Animation Features:
+                - **Dual Standards**: Full support for both Atlantic and Taiwan classification systems
                 - **Full TD Support**: Now displays Tropical Depressions (< 34 kt) in gray
                 - **2025 Compatibility**: Complete support for current year data
                 - **Enhanced Maps**: Better cartographic projections with terrain features
@@ -2570,6 +2657,12 @@ def create_interface():
                 - **Real-time Info**: Live position, time, and meteorological data display
                 - **Professional Styling**: Publication-quality animations with proper legends
                 - **Optimized Export**: Fast rendering with web-compatible video formats
+                
+                ### 🎌 Taiwan Standard Features:
+                - **m/s Display**: Shows both knots and meters per second
+                - **Local Categories**: TD → Mild → Medium → Strong Typhoon
+                - **Color Coding**: Gray → Yellow → Orange → Red
+                - **CWB Compatible**: Matches Central Weather Bureau classifications
                 """
                 gr.Markdown(animation_info_text)
 
@@ -2694,7 +2787,8 @@ def create_interface():
                 
                 ### 🚀 Platform Capabilities:
                 - **Complete TD Analysis** - First platform to include comprehensive TD tracking
-                - **Advanced ML Clustering** - DBSCAN pattern recognition with route visualization  
+                - **Dual Classification Systems** - Both Atlantic and Taiwan standards supported
+                - **Advanced ML Clustering** - DBSCAN pattern recognition with separate visualizations
                 - **Real-time Predictions** - Physics-based and optional CNN intensity forecasting
                 - **2025 Data Ready** - Full compatibility with current season data
                 - **Enhanced Animations** - Professional-quality storm track videos
@@ -2706,6 +2800,7 @@ def create_interface():
                 - Storm pattern classification
                 - ENSO-typhoon relationship analysis
                 - Intensity prediction model development
+                - Cross-regional classification comparisons
                 """
                 gr.Markdown(stats_text)