Update app.py

app.py

@@ -1149,315 +1149,184 @@ def create_genesis_animation(prediction_data, enable_animation=True):
     Following NHC/JTWC visualization standards with proper geographic map and time controls
     """
     try:
-        if 'daily_gpi_maps' not in prediction_data or not prediction_data['daily_gpi_maps']:
+        daily_maps = prediction_data.get('daily_gpi_maps', [])
+        if not daily_maps:
             return create_error_plot("No GPI data available for animation")
         
-        daily_maps = prediction_data['daily_gpi_maps']
         storm_predictions = prediction_data.get('storm_predictions', [])
         month = prediction_data['month']
         oni_value = prediction_data['oni_value']
         year = prediction_data.get('year', 2025)
         
-        # Create base figure with geographic map
-        fig = go.Figure()
+        # ---- Build animation frames ----
+        frames = []
+        
+        # Determine map bounds from all storm tracks
+        all_lats, all_lons = [], []
+        for storm in storm_predictions:
+            track = storm.get('track', [])
+            for pt in track:
+                all_lats.append(pt['lat'])
+                all_lons.append(pt['lon'])
+        map_bounds = {
+            'lat_min': min(5, min(all_lats) - 5) if all_lats else 5,
+            'lat_max': max(35, max(all_lats) + 5) if all_lats else 35,
+            'lon_min': min(110, min(all_lons) - 10) if all_lons else 110,
+            'lon_max': max(180, max(all_lons) + 10) if all_lons else 180
+        }
         
-        if enable_animation and len(daily_maps) > 1:
-            # PROFESSIONAL ANIMATION VERSION
-            frames = []
-            
-            # Get all storm track data for proper bounds
-            all_lats, all_lons = [], []
-            for storm in storm_predictions:
-                track = storm.get('track', [])
-                if track:
-                    all_lats.extend([pt['lat'] for pt in track])
-                    all_lons.extend([pt['lon'] for pt in track])
+        for day_idx, day_data in enumerate(daily_maps):
+            day = day_data['day']
+            gpi = day_data['gpi_field']
+            lats = day_data['lat_range']
+            lons = day_data['lon_range']
             
-            # Set map bounds (Western Pacific focus)
-            map_bounds = {
-                'lat_min': min(5, min(all_lats) - 5) if all_lats else 5,
-                'lat_max': max(35, max(all_lats) + 5) if all_lats else 35, 
-                'lon_min': min(110, min(all_lons) - 10) if all_lons else 110,
-                'lon_max': max(180, max(all_lons) + 10) if all_lons else 180
-            }
-            
-            # Create frames for each day
-            for day_idx, day_data in enumerate(daily_maps):
-                day = day_data['day']
-                frame_data = []
-                
-                # 1. GENESIS POTENTIAL BACKGROUND (GPI Contours)
-                gpi_field = day_data['gpi_field']
-                lat_range = day_data['lat_range']
-                lon_range = day_data['lon_range']
-                
-                frame_data.append(
-                    go.Scattergeo(
-                        lat=np.repeat(lat_range, len(lon_range)),
-                        lon=np.tile(lon_range, len(lat_range)),
-                        mode='markers',
-                        marker=dict(
-                            size=6,
-                            color=gpi_field.flatten(),
-                            colorscale='Viridis',
-                            cmin=0,
-                            cmax=3,
-                            opacity=0.6,
-                            showscale=(day_idx == 0),
-                            colorbar=dict(
-                                title="Genesis<br>Potential<br>Index",
-                                title_side="right"              # ← fixed here
-                            ) if day_idx == 0 else None
-                        ),
-                        name='Genesis Potential',
-                        showlegend=(day_idx == 0),
-                        hovertemplate=(
-                            'Genesis Potential<br>'
-                            'Lat: %{lat:.1f}°N<br>'
-                            'Lon: %{lon:.1f}°E<br>'
-                            'GPI: %{marker.color:.2f}<br>'
-                            f'Day {day} of {month:02d}/{year}<br>'
-                            '<extra></extra>'
+            traces = []
+            # 1) Genesis Potential dots
+            traces.append(go.Scattergeo(
+                lat=np.repeat(lats, len(lons)),
+                lon=np.tile(lons, len(lats)),
+                mode='markers',
+                marker=dict(
+                    size=6,
+                    color=gpi.flatten(),
+                    colorscale='Viridis',
+                    cmin=0, cmax=3, opacity=0.6,
+                    showscale=(day_idx == 0),
+                    colorbar=(dict(
+                        title=dict(
+                            text="Genesis<br>Potential<br>Index",
+                            side="right"
                         )
-                    )
+                    ) if day_idx == 0 else None)
+                ),
+                name='Genesis Potential',
+                showlegend=(day_idx == 0),
+                hovertemplate=(
+                    'GPI: %{marker.color:.2f}<br>' +
+                    'Lat: %{lat:.1f}°N<br>' +
+                    'Lon: %{lon:.1f}°E<br>' +
+                    f'Day {day} of {month:02d}/{year}<extra></extra>'
                 )
+            ))
+            
+            # 2) Storm tracks up to this day
+            for storm in storm_predictions:
+                track = [pt for pt in storm.get('track', []) if pt['day'] <= day]
+                if not track:
+                    continue
+                track_lats = [pt['lat'] for pt in track]
+                track_lons = [pt['lon'] for pt in track]
+                intensities = [pt['intensity'] for pt in track]
+                categories = [pt['category'] for pt in track]
                 
-                # 2. STORM TRACKS (Progressive reveal like NHC)
-                for storm_idx, storm in enumerate(storm_predictions):
-                    track = storm['track']
-                    storm_id = storm['storm_id']
-                    
-                    # Get track points up to current day
-                    current_track = [pt for pt in track if pt['day'] <= day]
-                    
-                    if current_track and len(current_track) > 0:
-                        lats = [pt['lat'] for pt in current_track]
-                        lons = [pt['lon'] for pt in current_track]
-                        intensities = [pt['intensity'] for pt in current_track]
-                        categories = [pt['category'] for pt in current_track]
-                        
-                        # Get colors based on intensity (Saffir-Simpson-like scale)
-                        colors = []
-                        for intensity in intensities:
-                            if intensity < 34:
-                                colors.append('#80808080')  # Gray - TD
-                            elif intensity < 64:
-                                colors.append('#0000FF80')  # Blue - TS  
-                            elif intensity < 83:
-                                colors.append('#00FF0080')  # Green - Cat 1
-                            elif intensity < 96:
-                                colors.append('#FFFF0080')  # Yellow - Cat 2
-                            elif intensity < 113:
-                                colors.append('#FFA50080')  # Orange - Cat 3
-                            elif intensity < 137:
-                                colors.append('#FF000080')  # Red - Cat 4
-                            else:
-                                colors.append('#8B000080')  # DarkRed - Cat 5
-                        
-                        # Historical track line
-                        frame_data.append(
-                            go.Scattergeo(
-                                lat=lats,
-                                lon=lons,
-                                mode='lines',
-                                line=dict(
-                                    width=2,
-                                    color='gray'
-                                ),
-                                name=f"{storm_id} Track",
-                                showlegend=(day_idx == 0),
-                                hoverinfo='skip'
-                            )
-                        )
-                        
-                        # Current position marker
-                        frame_data.append(
-                            go.Scattergeo(
-                                lat=[lats[-1]],
-                                lon=[lons[-1]],
-                                mode='markers',
-                                marker=dict(
-                                    size=10,
-                                    symbol='circle',
-                                    color=colors[-1]
-                                ),
-                                name=f"{storm_id} Position",
-                                showlegend=(day_idx == 0),
-                                hovertemplate=(
-                                    f"{storm_id}<br>"
-                                    f"Lat: {lats[-1]:.1f}°N<br>"
-                                    f"Lon: {lons[-1]:.1f}°E<br>"
-                                    f"Intensity: {intensities[-1]} kt<br>"
-                                    f"Category: {categories[-1]}<br>"
-                                    '<extra></extra>'
-                                )
-                            )
-                        )
-                
-                # Create frame
-                frames.append(go.Frame(
-                    data=frame_data,
-                    name=str(day),
-                    layout=go.Layout(
-                        title=f"Typhoon Development Forecast - Day {day}, {month:02d}/{year} | ONI: {oni_value:.2f}",
-                        geo=dict(
-                            projection_type="natural earth",
-                            showland=True,
-                            landcolor="lightgray",
-                            showocean=True,
-                            oceancolor="lightblue",
-                            showcoastlines=True,
-                            coastlinecolor="darkgray",
-                            center=dict(
-                                lat=(map_bounds['lat_min'] + map_bounds['lat_max']) / 2,
-                                lon=(map_bounds['lon_min'] + map_bounds['lon_max']) / 2
-                            ),
-                            lonaxis_range=[map_bounds['lon_min'], map_bounds['lon_max']],
-                            lataxis_range=[map_bounds['lat_min'], map_bounds['lat_max']],
-                            resolution=50
-                        )
+                # a) historical line
+                traces.append(go.Scattergeo(
+                    lat=track_lats, lon=track_lons, mode='lines',
+                    line=dict(width=2, color='gray'),
+                    name=f"{storm['storm_id']} Track",
+                    showlegend=(day_idx == 0),
+                    hoverinfo='skip'
+                ))
+                # b) current position
+                traces.append(go.Scattergeo(
+                    lat=[track_lats[-1]], lon=[track_lons[-1]], mode='markers',
+                    marker=dict(size=10, symbol='circle', color='red'),
+                    name=f"{storm['storm_id']} Position",
+                    showlegend=(day_idx == 0),
+                    hovertemplate=(
+                        f"{storm['storm_id']}<br>"
+                        f"Intensity: {intensities[-1]} kt<br>"
+                        f"Category: {categories[-1]}<extra></extra>"
                     )
                 ))
             
-            fig.frames = frames
+            frames.append(go.Frame(
+                data=traces,
+                name=str(day),
+                layout=go.Layout(
+                    geo=dict(
+                        projection_type="natural earth",
+                        showland=True, landcolor="lightgray",
+                        showocean=True, oceancolor="lightblue",
+                        showcoastlines=True, coastlinecolor="darkgray",
+                        center=dict(
+                            lat=(map_bounds['lat_min'] + map_bounds['lat_max'])/2,
+                            lon=(map_bounds['lon_min'] + map_bounds['lon_max'])/2
+                        ),
+                        lonaxis_range=[map_bounds['lon_min'], map_bounds['lon_max']],
+                        lataxis_range=[map_bounds['lat_min'], map_bounds['lat_max']],
+                        resolution=50
+                    ),
+                    title=f"Day {day} of {month:02d}/{year}   ONI: {oni_value:.2f}"
+                )
+            ))
+        
+        # ---- Initialize Figure with first frame’s data ----
+        if enable_animation and len(frames) > 1:
+            fig = go.Figure(
+                data=frames[0].data,
+                frames=frames
+            )
             
-            # Set up initial frame, add play/pause controls, sliders, etc.
-            slider_steps = [
-                dict(method="animate",
-                     args=[[frame.name], {
-                         "mode": "immediate",
-                         "frame": {"duration": 500, "redraw": True},
-                         "transition": {"duration": 0}
-                     }],
-                     label=frame.name)
-                for frame in frames
-            ]
+            # Build slider steps
+            steps = []
+            for fr in frames:
+                steps.append(dict(
+                    method="animate",
+                    args=[[fr.name], {"mode":"immediate","frame":{"duration":600,"redraw":True},"transition":{"duration":0}}],
+                    label=fr.name
+                ))
             
             fig.update_layout(
                 updatemenus=[dict(
-                    type="buttons",
-                    showactive=False,
-                    y=0,
-                    x=1.05,
-                    xanchor="right",
-                    yanchor="top",
-                    pad=dict(t=0, r=10),
+                    type="buttons", showactive=False,
+                    x=1.05, y=0.05, xanchor="right", yanchor="bottom",
                     buttons=[
-                        dict(label="▶️ Play",
-                             method="animate",
-                             args=[None, {
-                                 "frame": {"duration": 500, "redraw": True},
-                                 "fromcurrent": True,
-                                 "transition": {"duration": 0}
-                             }]),
-                        dict(label="⏸️ Pause",
-                             method="animate",
-                             args=[[None], {
-                                 "frame": {"duration": 0, "redraw": False},
-                                 "mode": "immediate",
-                                 "transition": {"duration": 0}
-                             }])
+                        dict(label="▶ Play", method="animate",
+                             args=[None, {"frame":{"duration":600,"redraw":True},"fromcurrent":True,"transition":{"duration":0}}]),
+                        dict(label="⏸ Pause", method="animate",
+                             args=[[None], {"frame":{"duration":0,"redraw":False},"mode":"immediate"}])
                     ]
                 )],
                 sliders=[dict(
-                    active=0,
-                    pad=dict(t=50),
-                    steps=slider_steps
+                    active=0, pad=dict(t=50),
+                    steps=steps
                 )]
             )
-        
         else:
-            # STATIC VERSION (Final state overview)
-            final_day = daily_maps[-1]
-            gpi_field = final_day['gpi_field']
-            lat_range = final_day['lat_range']
-            lon_range = final_day['lon_range']
-            
-            fig.add_trace(
-                go.Scattergeo(
-                    lat=np.repeat(lat_range, len(lon_range)),
-                    lon=np.tile(lon_range, len(lat_range)),
-                    mode='markers',
-                    marker=dict(
-                        size=6,
-                        color=gpi_field.flatten(),
-                        colorscale='Viridis',
-                        opacity=0.6,
-                        showscale=True,
-                        colorbar=dict(
-                            title="Genesis Potential Index"
-                        )
-                    ),
-                    name='Genesis Potential'
-                )
-            )
-            
-            # Add complete storm tracks
-            for storm in storm_predictions:
-                track = storm['track']
-                if track:
-                    lats = [pt['lat'] for pt in track]
-                    lons = [pt['lon'] for pt in track]
-                    fig.add_trace(
-                        go.Scattergeo(
-                            lat=lats,
-                            lon=lons,
-                            mode='lines+markers',
-                            line=dict(width=2, color='gray'),
-                            marker=dict(
-                                size=6,
-                                symbol='circle',
-                                color='red'
-                            ),
-                            name=f"{storm['storm_id']} Full Track"
-                        )
-                    )
+            # STATIC fallback: show only final day
+            final = frames[-1].data
+            fig = go.Figure(data=final)
         
-        # FINAL LAYOUT (Professional meteorological style)
+        # ---- Shared final layout styling ----
         fig.update_layout(
             title={
-                'text': f"🌊 Typhoon Genesis & Development Forecast<br><sub>{month:02d}/{year} | ONI: {oni_value:.2f} | " + 
-                       ("Interactive Animation" if enable_animation else "Monthly Summary") + "</sub>",
-                'x': 0.5,
-                'font': {'size': 18}
+                'text': f"🌊 Typhoon Genesis & Development Forecast<br><sub>{month:02d}/{year} | ONI: {oni_value:.2f}</sub>",
+                'x':0.5, 'font':{'size':18}
             },
             geo=dict(
                 projection_type="natural earth",
-                showland=True,
-                landcolor="lightgray",
-                showocean=True,
-                oceancolor="lightblue",
-                showcoastlines=True,
-                coastlinecolor="darkgray",
-                showlakes=True,
-                lakecolor="lightblue",
-                showcountries=True,
-                countrycolor="gray",
+                showland=True, landcolor="lightgray",
+                showocean=True, oceancolor="lightblue",
+                showcoastlines=True, coastlinecolor="darkgray",
+                showlakes=True, lakecolor="lightblue",
+                showcountries=True, countrycolor="gray",
                 resolution=50,
                 center=dict(lat=20, lon=140),
-                lonaxis_range=[110, 180],
-                lataxis_range=[5, 35]
+                lonaxis_range=[110,180], lataxis_range=[5,35]
             ),
-            width=1200,
-            height=800,
+            width=1100, height=750,
             showlegend=True,
-            legend=dict(
-                x=0.02,
-                y=0.98,
-                bgcolor="rgba(255,255,255,0.8)",
-                bordercolor="gray",
-                borderwidth=1
-            )
+            legend=dict(x=0.02, y=0.98, bgcolor="rgba(255,255,255,0.7)", bordercolor="gray", borderwidth=1)
         )
         
         return fig
-        
+
     except Exception as e:
         logging.error(f"Error creating professional genesis animation: {e}")
-        import traceback
-        traceback.print_exc()
-        return create_error_plot(f"Animation error: {str(e)}")
-
+        import traceback; traceback.print_exc()
+        return create_error_plot(f"Animation error: {e}")
 def create_error_plot(error_message):
     """Create a simple error plot"""
     fig = go.Figure()