Update app.py

app.py

@@ -1038,7 +1038,7 @@ def cluster_storms(embedding, method='dbscan', eps=0.5, min_samples=3):
         return np.array([0] * len(embedding))
 
 def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'):
-    """Create separate plots for clustering analysis - FIXED VERSION"""
+    """Create separate plots for clustering analysis - ENHANCED CLARITY VERSION"""
     try:
         # Validate inputs
         if storm_features is None or storm_features.empty:
@@ -1073,34 +1073,102 @@ def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'
             storm_features_viz['NAME'] = 'UNNAMED'
             storm_features_viz['SEASON'] = 2000
         
-        # 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'
-            }
+        # Get unique clusters and assign distinct colors
+        unique_clusters = sorted([c for c in storm_features_viz['cluster'].unique() if c != -1])
+        noise_count = len(storm_features_viz[storm_features_viz['cluster'] == -1])
+        
+        # 1. Enhanced clustering scatter plot with clear cluster identification
+        fig_cluster = go.Figure()
+        
+        # Add noise points first
+        if noise_count > 0:
+            noise_data = storm_features_viz[storm_features_viz['cluster'] == -1]
+            fig_cluster.add_trace(
+                go.Scatter(
+                    x=noise_data['dim1'],
+                    y=noise_data['dim2'],
+                    mode='markers',
+                    marker=dict(color='lightgray', size=8, opacity=0.5, symbol='x'),
+                    name=f'Noise ({noise_count} storms)',
+                    hovertemplate=(
+                        '<b>%{customdata[0]}</b><br>'
+                        'Season: %{customdata[1]}<br>'
+                        'Cluster: Noise<br>'
+                        f'{method.upper()} Dim 1: %{{x:.2f}}<br>'
+                        f'{method.upper()} Dim 2: %{{y:.2f}}<br>'
+                        '<extra></extra>'
+                    ),
+                    customdata=np.column_stack((
+                        noise_data['NAME'].fillna('UNNAMED'),
+                        noise_data['SEASON'].fillna(2000)
+                    ))
+                )
+            )
+        
+        # Add clusters with distinct colors and shapes
+        cluster_symbols = ['circle', 'square', 'diamond', 'triangle-up', 'triangle-down', 
+                          'pentagon', 'hexagon', 'star', 'cross', 'circle-open']
+        
+        for i, cluster in enumerate(unique_clusters):
+            cluster_data = storm_features_viz[storm_features_viz['cluster'] == cluster]
+            color = CLUSTER_COLORS[i % len(CLUSTER_COLORS)]
+            symbol = cluster_symbols[i % len(cluster_symbols)]
+            
+            fig_cluster.add_trace(
+                go.Scatter(
+                    x=cluster_data['dim1'],
+                    y=cluster_data['dim2'],
+                    mode='markers',
+                    marker=dict(color=color, size=10, symbol=symbol, line=dict(width=1, color='white')),
+                    name=f'Cluster {cluster} ({len(cluster_data)} storms)',
+                    hovertemplate=(
+                        '<b>%{customdata[0]}</b><br>'
+                        'Season: %{customdata[1]}<br>'
+                        f'Cluster: {cluster}<br>'
+                        f'{method.upper()} Dim 1: %{{x:.2f}}<br>'
+                        f'{method.upper()} Dim 2: %{{y:.2f}}<br>'
+                        'Intensity: %{customdata[2]:.0f} kt<br>'
+                        '<extra></extra>'
+                    ),
+                    customdata=np.column_stack((
+                        cluster_data['NAME'].fillna('UNNAMED'),
+                        cluster_data['SEASON'].fillna(2000),
+                        cluster_data['USA_WIND_max'].fillna(0)
+                    ))
+                )
+            )
+        
+        fig_cluster.update_layout(
+            title=f'Storm Clustering Analysis using {method.upper()}<br><sub>Each symbol/color represents a distinct storm pattern group</sub>',
+            xaxis_title=f'{method.upper()} Dimension 1',
+            yaxis_title=f'{method.upper()} Dimension 2',
+            height=600,
+            showlegend=True
         )
         
-        # 2. Route map
+        # 2. ENHANCED route map with cluster legends and clearer representation
         fig_routes = go.Figure()
         
-        unique_clusters = sorted(storm_features_viz['cluster'].unique())
+        # Create a comprehensive legend showing cluster characteristics
+        cluster_info_text = []
+        
         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
+            # Get cluster statistics for legend
+            cluster_data = storm_features_viz[storm_features_viz['cluster'] == cluster]
+            avg_intensity = cluster_data['USA_WIND_max'].mean() if 'USA_WIND_max' in cluster_data.columns else 0
+            avg_pressure = cluster_data['USA_PRES_min'].mean() if 'USA_PRES_min' in cluster_data.columns else 1000
+            
+            cluster_info_text.append(
+                f"Cluster {cluster}: {len(cluster_storm_ids)} storms, "
+                f"Avg: {avg_intensity:.0f}kt/{avg_pressure:.0f}hPa"
+            )
+            
+            # Add multiple storms per cluster with clear identification
+            storms_added = 0
+            for j, sid in enumerate(cluster_storm_ids[:8]):  # Show up to 8 storms per cluster
                 try:
                     storm_track = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
                     if len(storm_track) > 1:
@@ -1110,33 +1178,73 @@ def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'
                         
                         if len(storm_track) > 1:
                             storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
+                            storm_season = storm_track['SEASON'].iloc[0] if 'SEASON' in storm_track.columns else 'Unknown'
+                            
+                            # Vary line style for different storms in same cluster
+                            line_styles = ['solid', 'dash', 'dot', 'dashdot']
+                            line_style = line_styles[j % len(line_styles)]
+                            line_width = 3 if j == 0 else 2  # First storm thicker
                             
                             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),
+                                    line=dict(color=color, width=line_width, dash=line_style),
+                                    marker=dict(color=color, size=3),
+                                    name=f'C{cluster}: {storm_name} ({storm_season})',
+                                    showlegend=True,
+                                    legendgroup=f'cluster_{cluster}',
                                     hovertemplate=(
-                                        f'<b>{storm_name}</b><br>'
+                                        f'<b>Cluster {cluster}: {storm_name}</b><br>'
                                         'Lat: %{lat:.1f}°<br>'
                                         'Lon: %{lon:.1f}°<br>'
-                                        f'Cluster: {cluster}<br>'
+                                        f'Season: {storm_season}<br>'
+                                        f'Pattern Group: {cluster}<br>'
                                         '<extra></extra>'
                                     )
                                 )
                             )
-                            tracks_added += 1
+                            storms_added += 1
                 except Exception as track_error:
                     logging.warning(f"Error adding track for storm {sid}: {track_error}")
                     continue
+            
+            # Add cluster centroid marker
+            if len(cluster_storm_ids) > 0:
+                # Calculate average genesis location for cluster
+                cluster_storms = storm_features_viz[storm_features_viz['cluster'] == cluster]
+                if 'genesis_lat' in cluster_storms.columns and 'genesis_lon' in cluster_storms.columns:
+                    avg_lat = cluster_storms['genesis_lat'].mean()
+                    avg_lon = cluster_storms['genesis_lon'].mean()
+                    
+                    fig_routes.add_trace(
+                        go.Scattergeo(
+                            lon=[avg_lon],
+                            lat=[avg_lat],
+                            mode='markers',
+                            marker=dict(
+                                color=color, 
+                                size=20, 
+                                symbol='star',
+                                line=dict(width=2, color='white')
+                            ),
+                            name=f'C{cluster} Center',
+                            showlegend=True,
+                            legendgroup=f'cluster_{cluster}',
+                            hovertemplate=(
+                                f'<b>Cluster {cluster} Genesis Center</b><br>'
+                                f'Avg Position: {avg_lat:.1f}°N, {avg_lon:.1f}°E<br>'
+                                f'Storms: {len(cluster_storm_ids)}<br>'
+                                f'Avg Intensity: {avg_intensity:.0f} kt<br>'
+                                '<extra></extra>'
+                            )
+                        )
+                    )
         
-        # Update route map layout
+        # Update route map layout with enhanced information
         fig_routes.update_layout(
-            title="Clustered Storm Routes",
+            title=f"Storm Routes by {method.upper()} Clusters<br><sub>Different line styles = different storms in same cluster | Stars = cluster centers</sub>",
             geo=dict(
                 projection_type="natural earth",
                 showland=True,
@@ -1146,20 +1254,33 @@ def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'
                 showcoastlines=True,
                 coastlinecolor="Gray",
                 center=dict(lat=20, lon=140)
-            )
+            ),
+            height=600,
+            showlegend=True
         )
         
-        # 3. Pressure evolution plot
+        # Add cluster info annotation
+        cluster_summary = "<br>".join(cluster_info_text)
+        fig_routes.add_annotation(
+            text=f"<b>Cluster Summary:</b><br>{cluster_summary}",
+            xref="paper", yref="paper",
+            x=0.02, y=0.98,
+            showarrow=False,
+            align="left",
+            bgcolor="rgba(255,255,255,0.8)",
+            bordercolor="gray",
+            borderwidth=1
+        )
+        
+        # 3. Enhanced pressure evolution plot with cluster identification
         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)]
             
-            for j, sid in enumerate(cluster_storm_ids[:3]):  # Limit to 3 storms per cluster
+            cluster_pressures = []
+            for j, sid in enumerate(cluster_storm_ids[:5]):  # Limit to 5 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:
@@ -1168,147 +1289,182 @@ def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'
                             storm_name = storm_track['NAME'].iloc[0] if pd.notna(storm_track['NAME'].iloc[0]) else 'UNNAMED'
                             time_hours = range(len(pressure_values))
                             
+                            # Normalize time to show relative progression
+                            normalized_time = np.linspace(0, 100, len(pressure_values))
+                            
                             fig_pressure.add_trace(
                                 go.Scatter(
-                                    x=time_hours,
+                                    x=normalized_time,
                                     y=pressure_values,
                                     mode='lines',
-                                    line=dict(color=color, width=2),
+                                    line=dict(color=color, width=2, dash='solid' if j == 0 else 'dash'),
                                     name=f'C{cluster}: {storm_name}' if j == 0 else None,
                                     showlegend=(j == 0),
+                                    legendgroup=f'pressure_cluster_{cluster}',
                                     hovertemplate=(
-                                        f'<b>{storm_name}</b><br>'
-                                        'Hour: %{x}<br>'
+                                        f'<b>Cluster {cluster}: {storm_name}</b><br>'
+                                        'Progress: %{x:.0f}%<br>'
                                         'Pressure: %{y:.0f} hPa<br>'
                                         '<extra></extra>'
-                                    )
+                                    ),
+                                    opacity=0.8 if j == 0 else 0.5
                                 )
                             )
+                            cluster_pressures.extend(pressure_values)
                 except Exception as e:
                     continue
+            
+            # Add cluster average line
+            if cluster_pressures:
+                avg_pressure = np.mean(cluster_pressures)
+                fig_pressure.add_hline(
+                    y=avg_pressure,
+                    line_dash="dot",
+                    line_color=color,
+                    annotation_text=f"C{cluster} Avg: {avg_pressure:.0f}",
+                    annotation_position="right"
+                )
         
         fig_pressure.update_layout(
-            title="Pressure Evolution by Cluster",
-            xaxis_title="Time (hours)",
-            yaxis_title="Pressure (hPa)"
+            title=f"Pressure Evolution by {method.upper()} Clusters<br><sub>Normalized timeline (0-100%) | Dotted lines = cluster averages</sub>",
+            xaxis_title="Storm Progress (%)",
+            yaxis_title="Pressure (hPa)",
+            height=500
         )
         
-        # 4. Wind evolution plot
+        # 4. Enhanced 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)]
             
-            for j, sid in enumerate(cluster_storm_ids[:3]):  # Limit to 3 storms per cluster
+            cluster_winds = []
+            for j, sid in enumerate(cluster_storm_ids[:5]):  # Limit to 5 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))
+                            
+                            # Normalize time to show relative progression
+                            normalized_time = np.linspace(0, 100, len(wind_values))
                             
                             fig_wind.add_trace(
                                 go.Scatter(
-                                    x=time_hours,
+                                    x=normalized_time,
                                     y=wind_values,
                                     mode='lines',
-                                    line=dict(color=color, width=2),
+                                    line=dict(color=color, width=2, dash='solid' if j == 0 else 'dash'),
                                     name=f'C{cluster}: {storm_name}' if j == 0 else None,
                                     showlegend=(j == 0),
+                                    legendgroup=f'wind_cluster_{cluster}',
                                     hovertemplate=(
-                                        f'<b>{storm_name}</b><br>'
-                                        'Hour: %{x}<br>'
+                                        f'<b>Cluster {cluster}: {storm_name}</b><br>'
+                                        'Progress: %{x:.0f}%<br>'
                                         'Wind: %{y:.0f} kt<br>'
                                         '<extra></extra>'
-                                    )
+                                    ),
+                                    opacity=0.8 if j == 0 else 0.5
                                 )
                             )
+                            cluster_winds.extend(wind_values)
                 except Exception as e:
                     continue
+            
+            # Add cluster average line
+            if cluster_winds:
+                avg_wind = np.mean(cluster_winds)
+                fig_wind.add_hline(
+                    y=avg_wind,
+                    line_dash="dot",
+                    line_color=color,
+                    annotation_text=f"C{cluster} Avg: {avg_wind:.0f}",
+                    annotation_position="right"
+                )
         
         fig_wind.update_layout(
-            title="Wind Speed Evolution by Cluster",
-            xaxis_title="Time (hours)",
-            yaxis_title="Wind Speed (kt)"
+            title=f"Wind Speed Evolution by {method.upper()} Clusters<br><sub>Normalized timeline (0-100%) | Dotted lines = cluster averages</sub>",
+            xaxis_title="Storm Progress (%)",
+            yaxis_title="Wind Speed (kt)",
+            height=500
         )
         
-        # Generate detailed cluster statistics - FIXED
+        # Generate enhanced cluster statistics with clear explanations
         try:
-            # Only use columns that actually exist
-            available_cols = {
-                'USA_WIND_max': 'USA_WIND_max',
-                'USA_PRES_min': 'USA_PRES_min',
-                'track_length': 'track_length',
-                'genesis_lat': 'genesis_lat',
-                'genesis_lon': 'genesis_lon',
-                'total_distance': 'total_distance',
-                'avg_curvature': 'avg_curvature',
-                'SID': 'SID'
-            }
-            
-            # Filter to only existing columns
-            existing_cols = {k: v for k, v in available_cols.items() if v in storm_features_viz.columns}
+            stats_text = f"ENHANCED {method.upper()} CLUSTER ANALYSIS RESULTS\n" + "="*60 + "\n\n"
+            stats_text += f"🔍 DIMENSIONALITY REDUCTION: {method.upper()}\n"
+            stats_text += f"🎯 CLUSTERING ALGORITHM: DBSCAN (automatic pattern discovery)\n"
+            stats_text += f"📊 TOTAL STORMS ANALYZED: {len(storm_features_viz)}\n"
+            stats_text += f"🎨 CLUSTERS DISCOVERED: {len(unique_clusters)}\n"
+            if noise_count > 0:
+                stats_text += f"❌ NOISE POINTS: {noise_count} storms (don't fit clear patterns)\n"
+            stats_text += "\n"
             
-            if len(existing_cols) > 1:  # Need at least SID + one other column
-                stats_text = "ADVANCED CLUSTER ANALYSIS RESULTS\n" + "="*50 + "\n\n"
-                
-                for cluster in sorted(storm_features_viz['cluster'].unique()):
-                    cluster_data = storm_features_viz[storm_features_viz['cluster'] == cluster]
-                    storm_count = len(cluster_data)
-                    
-                    if cluster == -1:
-                        stats_text += f"NOISE POINTS: {storm_count} storms\n\n"
-                        continue
-                    
-                    stats_text += f"CLUSTER {cluster}: {storm_count} storms\n"
-                    
-                    # Add available statistics
-                    if 'USA_WIND_max' in cluster_data.columns:
-                        wind_mean = cluster_data['USA_WIND_max'].mean()
-                        wind_std = cluster_data['USA_WIND_max'].std()
-                        stats_text += f"   Intensity: {wind_mean:.1f} +/- {wind_std:.1f} kt\n"
-                    
-                    if 'USA_PRES_min' in cluster_data.columns:
-                        pres_mean = cluster_data['USA_PRES_min'].mean()
-                        pres_std = cluster_data['USA_PRES_min'].std()
-                        stats_text += f"   Pressure: {pres_mean:.1f} +/- {pres_std:.1f} hPa\n"
-                    
-                    if 'track_length' in cluster_data.columns:
-                        track_mean = cluster_data['track_length'].mean()
-                        track_std = cluster_data['track_length'].std()
-                        stats_text += f"   Track Length: {track_mean:.1f} +/- {track_std:.1f} points\n"
-                    
-                    if 'genesis_lat' in cluster_data.columns and 'genesis_lon' in cluster_data.columns:
-                        lat_mean = cluster_data['genesis_lat'].mean()
-                        lon_mean = cluster_data['genesis_lon'].mean()
-                        stats_text += f"   Genesis Region: {lat_mean:.1f}°N, {lon_mean:.1f}°E\n"
-                    
-                    stats_text += "\n"
-                
-                # Add feature importance summary
-                stats_text += "CLUSTERING FEATURES USED:\n"
-                stats_text += f"   - Total features: {len(feature_cols)}\n"
-                stats_text += f"   - Available features: {', '.join(feature_cols[:5])}...\n\n"
+            for cluster in sorted(storm_features_viz['cluster'].unique()):
+                cluster_data = storm_features_viz[storm_features_viz['cluster'] == cluster]
+                storm_count = len(cluster_data)
+                
+                if cluster == -1:
+                    stats_text += f"❌ NOISE GROUP: {storm_count} storms\n"
+                    stats_text += "   → These storms don't follow the main patterns\n"
+                    stats_text += "   → May represent unique or rare storm behaviors\n\n"
+                    continue
                 
-                stats_text += f"ALGORITHM: {method.upper()} + DBSCAN clustering\n"
-                stats_text += f"CLUSTERS FOUND: {len([c for c in storm_features_viz['cluster'].unique() if c != -1])}\n"
+                stats_text += f"🎯 CLUSTER {cluster}: {storm_count} storms\n"
+                stats_text += f"   🎨 Color: {CLUSTER_COLORS[cluster % len(CLUSTER_COLORS)]}\n"
+                
+                # Add detailed statistics if available
+                if 'USA_WIND_max' in cluster_data.columns:
+                    wind_mean = cluster_data['USA_WIND_max'].mean()
+                    wind_std = cluster_data['USA_WIND_max'].std()
+                    stats_text += f"   💨 Intensity: {wind_mean:.1f} ± {wind_std:.1f} kt\n"
+                
+                if 'USA_PRES_min' in cluster_data.columns:
+                    pres_mean = cluster_data['USA_PRES_min'].mean()
+                    pres_std = cluster_data['USA_PRES_min'].std()
+                    stats_text += f"   🌡️ Pressure: {pres_mean:.1f} ± {pres_std:.1f} hPa\n"
+                
+                if 'track_length' in cluster_data.columns:
+                    track_mean = cluster_data['track_length'].mean()
+                    stats_text += f"   📏 Avg Track Length: {track_mean:.1f} points\n"
+                
+                if 'genesis_lat' in cluster_data.columns and 'genesis_lon' in cluster_data.columns:
+                    lat_mean = cluster_data['genesis_lat'].mean()
+                    lon_mean = cluster_data['genesis_lon'].mean()
+                    stats_text += f"   🎯 Genesis Region: {lat_mean:.1f}°N, {lon_mean:.1f}°E\n"
+                
+                # Add interpretation
+                if wind_mean < 50:
+                    stats_text += "   💡 Pattern: Weaker storm group\n"
+                elif wind_mean > 100:
+                    stats_text += "   💡 Pattern: Intense storm group\n"
+                else:
+                    stats_text += "   💡 Pattern: Moderate intensity group\n"
                 
-            else:
-                stats_text = "Limited cluster statistics available due to missing feature columns."
+                stats_text += "\n"
+            
+            # Add explanation of the analysis
+            stats_text += "📖 INTERPRETATION GUIDE:\n"
+            stats_text += f"• {method.upper()} reduces storm characteristics to 2D for visualization\n"
+            stats_text += "• DBSCAN finds natural groupings without preset number of clusters\n"
+            stats_text += "• Each cluster represents storms with similar behavior patterns\n"
+            stats_text += "• Route colors match cluster colors from the similarity plot\n"
+            stats_text += "• Stars on map show average genesis locations for each cluster\n"
+            stats_text += "• Temporal plots show how each cluster behaves over time\n\n"
+            
+            stats_text += f"🔧 FEATURES USED FOR CLUSTERING:\n"
+            stats_text += f"   Total: {len(feature_cols)} storm characteristics\n"
+            stats_text += f"   Including: intensity, pressure, track shape, genesis location\n"
             
         except Exception as stats_error:
-            logging.error(f"Error generating cluster statistics: {stats_error}")
-            stats_text = f"Error generating cluster statistics: {str(stats_error)}"
+            stats_text = f"Error generating enhanced statistics: {str(stats_error)}"
         
         return fig_cluster, fig_routes, fig_pressure, fig_wind, stats_text
         
     except Exception as e:
-        logging.error(f"Error in clustering analysis: {e}")
+        logging.error(f"Error in enhanced clustering analysis: {e}")
         import traceback
         traceback.print_exc()
         
@@ -1562,21 +1718,13 @@ 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 - FIXED"""
+    """Create comprehensive route and intensity visualization - COMPLETELY 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 - FIXED
-        fig = make_subplots(
-            rows=1, cols=2,
-            subplot_titles=('Forecast Track', 'Intensity Evolution'),
-            specs=[[{"type": "geo"}, {"type": "xy"}]],  # Changed to xy for regular plot
-            column_widths=[0.6, 0.4]
-        )
-        
         # Extract data for plotting
         hours = [point['hour'] for point in route_data]
         lats = [point['lat'] for point in route_data]
@@ -1584,18 +1732,31 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
         intensities = [point['intensity_kt'] for point in route_data]
         categories = [point['category'] for point in route_data]
         
-        # Route visualization with intensity colors
+        # Create separate figures to avoid geo/regular plot conflicts
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Forecast Track', 'Intensity Evolution', 'Position Uncertainty', 'Category Timeline'),
+            specs=[[{"type": "geo", "colspan": 2}, None],
+                   [{"type": "xy"}, {"type": "xy"}]],
+            vertical_spacing=0.1
+        )
+        
+        # 1. Route visualization on geographic plot
         for i in range(len(route_data)):
             point = route_data[i]
             color = enhanced_color_map.get(point['category'], 'rgb(128,128,128)')
             
-            # Convert rgb string to rgba for transparency
+            # Convert rgb to regular color format
+            color_hex = rgb_string_to_hex(color)
+            
             if i == 0:  # Current position
                 marker_size = 15
                 opacity = 1.0
+                symbol = 'star'
             else:
-                marker_size = 10
-                opacity = 1.0 - (i / len(route_data)) * 0.5  # Fade with time
+                marker_size = 8 + (point['intensity_kt'] / 20)  # Size based on intensity
+                opacity = max(0.3, 1.0 - (i / len(route_data)) * 0.7)
+                symbol = 'circle'
             
             fig.add_trace(
                 go.Scattergeo(
@@ -1604,12 +1765,13 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
                     mode='markers',
                     marker=dict(
                         size=marker_size,
-                        color=color,
+                        color=color_hex,
                         opacity=opacity,
-                        line=dict(width=2, color='white')
+                        symbol=symbol,
+                        line=dict(width=1, color='white')
                     ),
-                    name=f"Hour {point['hour']}" if i % 4 == 0 else None,  # Show every 4th hour in legend
-                    showlegend=(i % 4 == 0),
+                    name=f"Hour {point['hour']}" if i % 6 == 0 else None,
+                    showlegend=(i % 6 == 0),
                     hovertemplate=(
                         f"<b>Hour {point['hour']}</b><br>"
                         f"Position: {point['lat']:.1f}°N, {point['lon']:.1f}°E<br>"
@@ -1627,7 +1789,7 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
                 lon=lons,
                 lat=lats,
                 mode='lines',
-                line=dict(color='black', width=2, dash='dash'),
+                line=dict(color='black', width=3, dash='solid'),
                 name='Forecast Track',
                 showlegend=True
             ),
@@ -1642,15 +1804,12 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
             uncertainty_lons_lower = []
             
             for i, point in enumerate(route_data):
-                # Uncertainty grows with time
-                uncertainty = 0.5 + (i / len(route_data)) * 2.0  # degrees
-                
+                uncertainty = 0.3 + (i / len(route_data)) * 1.5
                 uncertainty_lats_upper.append(point['lat'] + uncertainty)
                 uncertainty_lats_lower.append(point['lat'] - uncertainty)
                 uncertainty_lons_upper.append(point['lon'] + uncertainty)
                 uncertainty_lons_lower.append(point['lon'] - uncertainty)
             
-            # Add uncertainty cone
             uncertainty_lats = uncertainty_lats_upper + uncertainty_lats_lower[::-1]
             uncertainty_lons = uncertainty_lons_upper + uncertainty_lons_lower[::-1]
             
@@ -1660,54 +1819,69 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
                     lat=uncertainty_lats,
                     mode='lines',
                     fill='toself',
-                    fillcolor='rgba(128,128,128,0.2)',
-                    line=dict(color='rgba(128,128,128,0.3)', width=1),
+                    fillcolor='rgba(128,128,128,0.15)',
+                    line=dict(color='rgba(128,128,128,0.4)', width=1),
                     name='Uncertainty Cone',
                     showlegend=True
                 ),
                 row=1, col=1
             )
         
-        # Intensity evolution plot - FIXED to use regular scatter plot
+        # 2. Intensity evolution plot (regular subplot - no geo conflicts)
         fig.add_trace(
             go.Scatter(
                 x=hours,
                 y=intensities,
                 mode='lines+markers',
                 line=dict(color='red', width=3),
-                marker=dict(size=8, color='red'),
-                name='Intensity Forecast',
-                hovertemplate=(
-                    "Hour: %{x}<br>"
-                    "Intensity: %{y:.0f} kt<br>"
-                    "<extra></extra>"
-                )
+                marker=dict(size=6, color='red'),
+                name='Intensity',
+                showlegend=False
             ),
-            row=1, col=2
+            row=2, col=1
         )
         
-        # Add category thresholds
+        # Add category threshold lines (NOT using add_hline to avoid geo conflicts)
         thresholds = [34, 64, 83, 96, 113, 137]
         threshold_names = ['TS', 'C1', 'C2', 'C3', 'C4', 'C5']
         
         for thresh, name in zip(thresholds, threshold_names):
-            fig.add_hline(
-                y=thresh,
-                line_dash="dash",
-                line_color="gray",
-                annotation_text=name,
-                annotation_position="left",
-                row=1, col=2
+            fig.add_trace(
+                go.Scatter(
+                    x=[min(hours), max(hours)],
+                    y=[thresh, thresh],
+                    mode='lines',
+                    line=dict(color='gray', width=1, dash='dash'),
+                    name=name,
+                    showlegend=False,
+                    hovertemplate=f"{name} Threshold: {thresh} kt<extra></extra>"
+                ),
+                row=2, col=1
             )
         
+        # 3. Position uncertainty plot
+        uncertainties = [0.3 + (i / len(route_data)) * 1.5 for i in range(len(route_data))]
+        fig.add_trace(
+            go.Scatter(
+                x=hours,
+                y=uncertainties,
+                mode='lines+markers',
+                line=dict(color='orange', width=2),
+                marker=dict(size=4, color='orange'),
+                name='Position Error',
+                showlegend=False
+            ),
+            row=2, col=2
+        )
+        
         # Update layout
         fig.update_layout(
-            title_text="Advanced Storm Forecast: Track and Intensity Evolution",
+            title_text="Comprehensive Storm Forecast Analysis",
             showlegend=True,
-            height=600
+            height=800
         )
         
-        # Update geo layout - FIXED: Only update geo subplot
+        # Update geo layout (only for geo subplot)
         fig.update_geos(
             projection_type="natural earth",
             showland=True,
@@ -1716,14 +1890,16 @@ def create_route_visualization(prediction_results, show_uncertainty=True):
             oceancolor="LightBlue",
             showcoastlines=True,
             coastlinecolor="Gray",
-            center=dict(lat=lats[0], lon=lons[0]),
+            center=dict(lat=np.mean(lats), lon=np.mean(lons)),
             resolution=50,
             row=1, col=1
         )
         
-        # 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)
+        # Update regular subplot axes (NOT geo)
+        fig.update_xaxes(title_text="Forecast Hour", row=2, col=1)
+        fig.update_yaxes(title_text="Intensity (kt)", row=2, col=1)
+        fig.update_xaxes(title_text="Forecast Hour", row=2, col=2)
+        fig.update_yaxes(title_text="Position Error (°)", row=2, col=2)
         
         # Generate detailed forecast text
         current = prediction_results['current_prediction']
@@ -1738,14 +1914,14 @@ CURRENT CONDITIONS:
 
 FORECAST TRACK (72-HOUR):
 • Initial Position: {lats[0]:.1f}°N, {lons[0]:.1f}°E
-• 24-hour Position: {lats[4]:.1f}°N, {lons[4]:.1f}°E
-• 48-hour Position: {lats[8]:.1f}°N, {lons[8]:.1f}°E
+• 24-hour Position: {lats[min(4, len(lats)-1)]:.1f}°N, {lons[min(4, len(lons)-1)]:.1f}°E
+• 48-hour Position: {lats[min(8, len(lats)-1)]:.1f}°N, {lons[min(8, len(lons)-1)]:.1f}°E
 • 72-hour Position: {lats[-1]:.1f}°N, {lons[-1]:.1f}°E
 
 INTENSITY EVOLUTION:
 • Current: {intensities[0]:.0f} kt ({categories[0]})
-• 24-hour: {intensities[4]:.0f} kt ({categories[4]})
-• 48-hour: {intensities[8]:.0f} kt ({categories[8]})
+• 24-hour: {intensities[min(4, len(intensities)-1)]:.0f} kt ({categories[min(4, len(categories)-1)]})
+• 48-hour: {intensities[min(8, len(intensities)-1)]:.0f} kt ({categories[min(8, len(categories)-1)]})
 • 72-hour: {intensities[-1]:.0f} kt ({categories[-1]})
 
 CONFIDENCE LEVELS:
@@ -1760,7 +1936,11 @@ MODEL: {prediction_results['model_info']}
         return fig, forecast_text.strip()
         
     except Exception as e:
-        return None, f"Error creating route visualization: {str(e)}"
+        error_msg = f"Error creating route visualization: {str(e)}"
+        print(error_msg)
+        import traceback
+        traceback.print_exc()
+        return None, error_msg
 
 # -----------------------------
 # Regression Functions (Original)