Update app.py

app.py

@@ -354,29 +354,95 @@ class TyphoonAnalyzer:
         }
 
     def create_tracks_plot(self, data):
+        """Create typhoon tracks visualization"""
         fig = go.Figure()
         
-        for _, storm in data.groupby('SID'):
-            fig.add_trace(go.Scattergeo(
-                lon=storm['LON'],
-                lat=storm['LAT'],
-                mode='lines',
-                name=storm['NAME'].iloc[0],
-                line=dict(
-                    width=2,
-                    color=COLOR_MAP[storm['Category'].iloc[0]]
-                ),
-                hovertemplate=(
-                    f"Name: {storm['NAME'].iloc[0]}<br>"
-                    f"Category: {storm['Category'].iloc[0]}<br>"
-                    f"Wind Speed: {storm['USA_WIND'].iloc[0]:.1f} kt<br>"
-                    f"Pressure: {storm['WMO_PRES'].iloc[0]:.1f} hPa<br>"
-                    f"Date: {storm['ISO_TIME'].iloc[0]:%Y-%m-%d}"
-                )
-            ))
+        fig.update_layout(
+            title={
+                'text': 'Typhoon Tracks',
+                'y':0.95,
+                'x':0.5,
+                'xanchor': 'center',
+                'yanchor': 'top'
+            },
+            showlegend=True,
+            legend=dict(
+                yanchor="top",
+                y=0.99,
+                xanchor="left",
+                x=0.01,
+                bgcolor='rgba(255, 255, 255, 0.8)'
+            ),
+            geo=dict(
+                projection_type='mercator',
+                showland=True,
+                showcoastlines=True,
+                landcolor='rgb(243, 243, 243)',
+                countrycolor='rgb(204, 204, 204)',
+                coastlinecolor='rgb(214, 214, 214)',
+                showocean=True,
+                oceancolor='rgb(230, 250, 255)',
+                showlakes=True,
+                lakecolor='rgb(230, 250, 255)',
+                lataxis=dict(range=[0, 50]),
+                lonaxis=dict(range=[100, 180]),
+                center=dict(lat=20, lon=140),
+                bgcolor='rgba(255, 255, 255, 0.5)'
+            ),
+            paper_bgcolor='rgba(255, 255, 255, 0.5)',
+            plot_bgcolor='rgba(255, 255, 255, 0.5)'
+        )
+
+        for category in COLOR_MAP.keys():
+            category_data = data[data['Category'] == category]
+            
+            # Group by SID to get individual typhoon tracks
+            for _, storm in category_data.groupby('SID'):
+                # Create single track for each typhoon
+                track_data = self.typhoon_data[self.typhoon_data['SID'] == storm['SID'].iloc[0]]
+                track_data = track_data.sort_values('ISO_TIME')
+                
+                fig.add_trace(go.Scattergeo(
+                    lon=track_data['LON'],
+                    lat=track_data['LAT'],
+                    mode='lines',
+                    line=dict(
+                        width=2,
+                        color=COLOR_MAP[category]
+                    ),
+                    name=category,
+                    legendgroup=category,
+                    showlegend=True if storm.iloc[0]['SID'] == category_data.iloc[0]['SID'] else False,
+                    hovertemplate=(
+                        f"Name: {storm['NAME'].iloc[0]}<br>" +
+                        f"Category: {category}<br>" +
+                        f"Wind Speed: {storm['USA_WIND'].iloc[0]:.1f} kt<br>" +
+                        f"Pressure: {storm['WMO_PRES'].iloc[0]:.1f} hPa<br>" +
+                        f"Date: {track_data['ISO_TIME'].dt.strftime('%Y-%m-%d %H:%M').iloc[0]}<br>" +
+                        f"Lat: %{lat:.2f}°N<br>" +
+                        f"Lon: %{lon:.2f}°E<br>" +
+                        "<extra></extra>"
+                    )
+                ))
+
+        return fig
+    def get_typhoons_for_year(self, year):
+        """Get list of typhoons for a specific year"""
+        year_data = self.typhoon_data[self.typhoon_data['ISO_TIME'].dt.year == year]
+        typhoons = year_data.groupby('SID').first()
+        return [{'label': f"{row['NAME']} ({row.name})", 'value': row.name} 
+                for _, row in typhoons.iterrows()]
+
+    def create_typhoon_animation(self, year, typhoon_id):
+        """Create animated visualization of typhoon path"""
+        storm_data = self.typhoon_data[self.typhoon_data['SID'] == typhoon_id]
+        storm_data = storm_data.sort_values('ISO_TIME')
+        
+        fig = go.Figure()
         
+        # Base map settings
         fig.update_layout(
-            title='Typhoon Tracks',
+            title=f"Typhoon Path Animation - {storm_data['NAME'].iloc[0]} ({year})",
             showlegend=True,
             geo=dict(
                 projection_type='mercator',
@@ -385,43 +451,71 @@ class TyphoonAnalyzer:
                 landcolor='rgb(243, 243, 243)',
                 countrycolor='rgb(204, 204, 204)',
                 coastlinecolor='rgb(214, 214, 214)',
+                showocean=True,
+                oceancolor='rgb(230, 250, 255)',
                 lataxis=dict(range=[0, 50]),
                 lonaxis=dict(range=[100, 180]),
+                center=dict(lat=20, lon=140)
             )
         )
-        
-        return fig
 
-    def create_wind_analysis(self, data):
-        fig = px.scatter(data,
-            x='ONI',
-            y='USA_WIND',
-            color='Category',
-            color_discrete_map=COLOR_MAP,
-            title='Wind Speed vs ONI Index',
-            labels={
-                'ONI': 'Oceanic Niño Index',
-                'USA_WIND': 'Maximum Wind Speed (kt)'
-            },
-            hover_data=['NAME', 'ISO_TIME']
-        )
-        
-        # Add regression line
-        x = data['ONI']
-        y = data['USA_WIND']
-        slope, intercept = np.polyfit(x, y, 1)
-        fig.add_trace(
-            go.Scatter(
-                x=x,
-                y=slope * x + intercept,
-                mode='lines',
-                name=f'Regression (slope={slope:.2f})',
-                line=dict(color='black', dash='dash')
+        # Create animation frames
+        frames = []
+        for i in range(len(storm_data)):
+            frame = go.Frame(
+                data=[
+                    go.Scattergeo(
+                        lon=storm_data['LON'].iloc[:i+1],
+                        lat=storm_data['LAT'].iloc[:i+1],
+                        mode='lines+markers',
+                        line=dict(width=2, color='red'),
+                        marker=dict(size=8, color='red'),
+                        name='Path'
+                    )
+                ],
+                name=f'frame{i}'
             )
+            frames.append(frame)
+
+        fig.frames = frames
+
+        # Add animation controls
+        fig.update_layout(
+            updatemenus=[{
+                'buttons': [
+                    {
+                        'args': [None, {'frame': {'duration': 100, 'redraw': True},
+                                      'fromcurrent': True}],
+                        'label': 'Play',
+                        'method': 'animate'
+                    },
+                    {
+                        'args': [[None], {'frame': {'duration': 0, 'redraw': True},
+                                        'mode': 'immediate',
+                                        'transition': {'duration': 0}}],
+                        'label': 'Pause',
+                        'method': 'animate'
+                    }
+                ],
+                'type': 'buttons',
+                'showactive': False,
+                'x': 0.1,
+                'y': 0,
+                'xanchor': 'right',
+                'yanchor': 'top'
+            }]
         )
-        
-        return fig
 
+        info_text = f"""
+        ### Typhoon Information
+        - Name: {storm_data['NAME'].iloc[0]}
+        - Start Date: {storm_data['ISO_TIME'].iloc[0]:%Y-%m-%d %H:%M}
+        - End Date: {storm_data['ISO_TIME'].iloc[-1]:%Y-%m-%d %H:%M}
+        - Maximum Wind Speed: {storm_data['USA_WIND'].max():.1f} kt
+        - Minimum Pressure: {storm_data['WMO_PRES'].min():.1f} hPa
+        """
+
+        return fig, info_text
     def create_pressure_analysis(self, data):
         fig = px.scatter(data,
             x='ONI',
@@ -513,7 +607,100 @@ class TyphoonAnalyzer:
         )
         
         return fig
+    def get_typhoons_for_year(self, year):
+        """Get list of typhoons for a specific year"""
+        year_data = self.typhoon_data[self.typhoon_data['SEASON'] == year]
+        unique_typhoons = year_data.groupby('SID').first().reset_index()
+        return [
+            {'label': f"{row['NAME']} ({row['ISO_TIME'].strftime('%Y-%m-%d')})", 
+             'value': row['SID']} 
+            for _, row in unique_typhoons.iterrows()
+        ]
 
+    def search_typhoon_details(self, year, typhoon_id):
+        """Get detailed information for a specific typhoon"""
+        if not typhoon_id:
+            return None, "Please select a typhoon"
+            
+        storm_data = self.typhoon_data[self.typhoon_data['SID'] == typhoon_id]
+        storm_data = storm_data.sort_values('ISO_TIME')
+        
+        # Create track plot
+        fig = self.create_single_typhoon_plot(storm_data)
+        
+        # Create detailed information text
+        info = self.create_typhoon_info_text(storm_data)
+        
+        return fig, info
+
+    def create_single_typhoon_plot(self, storm_data):
+        """Create a detailed plot for a single typhoon"""
+        fig = go.Figure()
+        
+        fig.update_layout(
+            title=f"Typhoon Track - {storm_data['NAME'].iloc[0]} ({storm_data['SEASON'].iloc[0]})",
+            showlegend=True,
+            geo=dict(
+                projection_type='mercator',
+                showland=True,
+                showcoastlines=True,
+                landcolor='rgb(243, 243, 243)',
+                countrycolor='rgb(204, 204, 204)',
+                coastlinecolor='rgb(214, 214, 214)',
+                showocean=True,
+                oceancolor='rgb(230, 250, 255)',
+                lataxis=dict(range=[0, 50]),
+                lonaxis=dict(range=[100, 180]),
+                center=dict(lat=20, lon=140)
+            )
+        )
+        
+        # Add main track
+        fig.add_trace(go.Scattergeo(
+            lon=storm_data['LON'],
+            lat=storm_data['LAT'],
+            mode='lines+markers',
+            line=dict(width=2, color='red'),
+            marker=dict(
+                size=8,
+                color=storm_data['USA_WIND'],
+                colorscale='Viridis',
+                showscale=True,
+                colorbar=dict(title='Wind Speed (kt)')
+            ),
+            text=[f"Time: {time:%Y-%m-%d %H:%M}<br>Wind: {wind:.1f} kt<br>Pressure: {pres:.1f} hPa"
+                  for time, wind, pres in zip(storm_data['ISO_TIME'], 
+                                            storm_data['USA_WIND'],
+                                            storm_data['WMO_PRES'])],
+            hoverinfo='text'
+        ))
+        
+        return fig
+
+    def create_typhoon_info_text(self, storm_data):
+        """Create detailed information text for a typhoon"""
+        max_wind = storm_data['USA_WIND'].max()
+        min_pressure = storm_data['WMO_PRES'].min()
+        duration = (storm_data['ISO_TIME'].max() - storm_data['ISO_TIME'].min()).total_seconds() / 3600  # hours
+        
+        return f"""
+        ### Typhoon Details: {storm_data['NAME'].iloc[0]}
+        
+        **Timing Information:**
+        - Start: {storm_data['ISO_TIME'].min():%Y-%m-%d %H:%M}
+        - End: {storm_data['ISO_TIME'].max():%Y-%m-%d %H:%M}
+        - Duration: {duration:.1f} hours
+        
+        **Intensity Metrics:**
+        - Maximum Wind Speed: {max_wind:.1f} kt
+        - Minimum Pressure: {min_pressure:.1f} hPa
+        - Maximum Category: {self.categorize_typhoon(max_wind)}
+        
+        **Track Information:**
+        - Starting Position: {storm_data['LAT'].iloc[0]:.1f}°N, {storm_data['LON'].iloc[0]:.1f}°E
+        - Ending Position: {storm_data['LAT'].iloc[-1]:.1f}°N, {storm_data['LON'].iloc[-1]:.1f}°E
+        - Total Track Points: {len(storm_data)}
+        """
     def generate_statistics(self, data):
         stats = {
             'total_typhoons': len(data['SID'].unique()),
@@ -566,69 +753,123 @@ def create_interface():
                 
                 analyze_btn = gr.Button("Analyze")
                 
-                plots_tabs = gr.Tabs()
-                with plots_tabs:
-                    with gr.Tab("Tracks"):
-                        tracks_plot = gr.Plot()
-                    with gr.Tab("Wind Analysis"):
-                        wind_plot = gr.Plot()
-                    with gr.Tab("Pressure Analysis"):
-                        pressure_plot = gr.Plot()
-                    with gr.Tab("Clusters"):
-                        cluster_plot = gr.Plot()
+                with gr.Row():
+                    tracks_plot = gr.Plot()
+                with gr.Row():
+                    wind_plot = gr.Plot()
+                    pressure_plot = gr.Plot()
                 
                 stats_text = gr.Markdown()
 
+            # Clustering Analysis Tab
+            with gr.Tab("Clustering Analysis"):
+                with gr.Row():
+                    cluster_year = gr.Slider(1900, 2024, 2000, label="Year")
+                    n_clusters = gr.Slider(2, 20, 5, label="Number of Clusters")
+                
+                cluster_btn = gr.Button("Analyze Clusters")
+                cluster_plot = gr.Plot()
+                cluster_stats = gr.Markdown()
+
+            # Animation Tab
+            with gr.Tab("Typhoon Animation"):
+                with gr.Row():
+                    animation_year = gr.Slider(
+                        minimum=1900,
+                        maximum=2024,
+                        value=2024,
+                        step=1,
+                        label="Select Year"
+                    )
+                
+                with gr.Row():
+                    animation_typhoon = gr.Dropdown(
+                        choices=[],
+                        label="Select Typhoon",
+                        interactive=True
+                    )
+                
+                animation_btn = gr.Button("Animate Typhoon Path", variant="primary")
+                animation_plot = gr.Plot()
+                animation_info = gr.Markdown()
+
             # Search Tab
             with gr.Tab("Typhoon Search"):
                 with gr.Row():
-                    search_input = gr.Textbox(label="Search Typhoon Name")
-                    search_btn = gr.Button("Search")
-                search_results = gr.Plot()
-                typhoon_info = gr.Markdown()
+                    search_year = gr.Slider(
+                        minimum=1900,
+                        maximum=2024,
+                        value=2024,
+                        step=1,
+                        label="Select Year"
+                    )
+                
+                with gr.Row():
+                    search_typhoon = gr.Dropdown(
+                        choices=[],
+                        label="Select Typhoon",
+                        interactive=True
+                    )
+                
+                search_btn = gr.Button("Show Typhoon Details", variant="primary")
+                search_plot = gr.Plot()
+                search_info = gr.Markdown()
 
+        # Event handlers
         def analyze_callback(start_y, start_m, end_y, end_m, enso):
             results = analyzer.analyze_typhoon(start_y, start_m, end_y, end_m, enso)
             return [
                 results['tracks'],
                 results['wind'],
                 results['pressure'],
-                results['clusters'],
                 results['stats']
             ]
 
+        def cluster_callback(year, n_clusters):
+            return analyzer.analyze_clusters(year, n_clusters)
+
+        def update_typhoon_choices(year):
+            typhoons = analyzer.get_typhoons_for_year(year)
+            return gr.Dropdown.update(choices=typhoons, value=None)
+
+        # Connect events for main analysis
         analyze_btn.click(
             analyze_callback,
             inputs=[start_year, start_month, end_year, end_month, enso_dropdown],
-            outputs=[tracks_plot, wind_plot, pressure_plot, cluster_plot, stats_text]
+            outputs=[tracks_plot, wind_plot, pressure_plot, stats_text]
         )
 
-        def search_callback(query):
-            if not query:
-                return None, "Please enter a typhoon name to search."
-            
-            matches = analyzer.merged_data[
-                analyzer.merged_data['NAME'].str.contains(query, case=False, na=False)
-            ]
-            
-            if matches.empty:
-                return None, "No typhoons found matching your search."
-            
-            fig = analyzer.create_tracks_plot(matches)
-            
-            info = f"### Found {len(matches['SID'].unique())} matching typhoons:\n\n"
-            for _, storm in matches.groupby('SID'):
-                info += (f"- {storm['NAME'].iloc[0]} ({storm['ISO_TIME'].iloc[0]:%Y-%m-%d})\n"
-                        f"  - Category: {storm['Category'].iloc[0]}\n"
-                        f"  - Max Wind: {storm['USA_WIND'].iloc[0]:.1f} kt\n"
-                        f"  - Min Pressure: {storm['WMO_PRES'].iloc[0]:.1f} hPa\n")
-            
-            return fig, info
+        # Connect events for clustering
+        cluster_btn.click(
+            cluster_callback,
+            inputs=[cluster_year, n_clusters],
+            outputs=[cluster_plot, cluster_stats]
+        )
+
+        # Connect events for Animation tab
+        animation_year.change(
+            update_typhoon_choices,
+            inputs=[animation_year],
+            outputs=[animation_typhoon]
+        )
+
+        animation_btn.click(
+            analyzer.create_typhoon_animation,
+            inputs=[animation_year, animation_typhoon],
+            outputs=[animation_plot, animation_info]
+        )
+
+        # Connect events for Search tab
+        search_year.change(
+            update_typhoon_choices,
+            inputs=[search_year],
+            outputs=[search_typhoon]
+        )
 
         search_btn.click(
-            search_callback,
-            inputs=[search_input],
-            outputs=[search_results, typhoon_info]
+            analyzer.search_typhoon_details,
+            inputs=[search_year, search_typhoon],
+            outputs=[search_plot, search_info]
         )
 
     return demo