Update app.py

app.py

@@ -4,6 +4,7 @@ import joblib
 import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 
 os.environ["HOPSWORKS_API_KEY"] = "HLDlE8LYYNS4zTdX.GQvAhHVCPMDVOrXcbGK3IKrsUv2APbwSUzexJDgjhXHPRoC3aAjhOMKgkaM95UHt"
 
@@ -100,15 +101,14 @@ def predict_delay(carrier, arr_flights, arr_diverted, temperature, wind_speed, m
 
 import gradio as gr
 
-def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
+def create_terminal_crowd(delay_minutes, n_passengers=200):
     # Normalize delay to determine crowd behavior
     # Assume delay range from -1 to 5 minutes
     normalized_delay = min(max((delay_minutes + 1) / 6, 0), 1)  # 0 to 1 scale
     
     # Terminal layout dimensions
-    terminal_length = 100  # x-axis
-    terminal_width = 60    # y-axis
-    terminal_height = 10   # z-axis
+    terminal_width = 100
+    terminal_height = 60
     
     # Calculate crowd parameters based on delay
     crowd_density = normalized_delay * 0.8 + 0.2  # 0.2 to 1.0
@@ -117,26 +117,26 @@ def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
     # Generate passenger positions
     n_actual_passengers = int(n_passengers * crowd_density)
     
-    # Create different passenger groups with 3D positions
+    # Create different passenger groups
     # 1. Seated passengers (at gates)
     # 2. Moving passengers (walking through terminal)
     # 3. Clustered passengers (at info desks, security, etc.)
     
-    # Define gate areas (x, y, width, depth)
+    # Define gate areas (x, y, width, height)
     gates = [
-        [10, 5, 20, 15, "Gate A"],
-        [40, 5, 20, 15, "Gate B"],
-        [70, 5, 20, 15, "Gate C"],
-        [10, 40, 20, 15, "Gate D"],
-        [40, 40, 20, 15, "Gate E"],
-        [70, 40, 20, 15, "Gate F"]
+        [10, 5, 20, 10],   # Gate A
+        [40, 5, 20, 10],   # Gate B
+        [70, 5, 20, 10],   # Gate C
+        [10, 45, 20, 10],  # Gate D
+        [40, 45, 20, 10],  # Gate E
+        [70, 45, 20, 10]   # Gate F
     ]
     
     # Define info desk/security areas (x, y, radius)
     service_points = [
-        [50, 30, 6, "Information"],
-        [25, 30, 4, "Security 1"],
-        [75, 30, 4, "Security 2"]
+        [50, 30, 6],       # Main info desk
+        [25, 30, 4],       # Security point 1
+        [75, 30, 4]        # Security point 2
     ]
     
     # Allocate passengers to different areas based on delay
@@ -151,7 +151,6 @@ def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
     # Generate positions
     passenger_x = []
     passenger_y = []
-    passenger_z = []
     passenger_colors = []
     
     # 1. Seated passengers (distributed across gates)
@@ -178,12 +177,8 @@ def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
             x = max(min(x, gate[0] + gate[2]), gate[0])
             y = max(min(y, gate[1] + gate[3]), gate[1])
         
-        # Z-coordinate (seated passengers are sitting)
-        z = 1.5  # Average sitting height
-        
         passenger_x.append(x)
         passenger_y.append(y)
-        passenger_z.append(z)
         passenger_colors.append('blue')  # Seated passengers are blue
     
     # 2. Service point passengers (clustered at info desks/security)
@@ -206,42 +201,34 @@ def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
         y = point[1] + distance * np.sin(angle)
         
         # Keep within terminal bounds
-        x = max(min(x, terminal_length), 0)
-        y = max(min(y, terminal_width), 0)
-        
-        # Z-coordinate (standing passengers with some variation in height)
-        z = 3 + np.random.uniform(-0.5, 0.5)  # Standing height with variation
+        x = max(min(x, terminal_width), 0)
+        y = max(min(y, terminal_height), 0)
         
         passenger_x.append(x)
         passenger_y.append(y)
-        passenger_z.append(z)
         passenger_colors.append('red')  # Service point passengers are red (frustrated)
     
     # 3. Walking passengers (random paths in terminal)
-    central_path_y = terminal_width / 2
+    central_path_y = terminal_height / 2
     path_width = 20
     
     for i in range(n_walking):
         # With more delay, people tend to wander more randomly
         if normalized_delay < 0.4:
             # Mostly following the central path
-            x = np.random.uniform(0, terminal_length)
+            x = np.random.uniform(0, terminal_width)
             y = central_path_y + np.random.normal(0, path_width * 0.2)
         else:
             # More random movements
-            x = np.random.uniform(0, terminal_length)
-            y = np.random.uniform(0, terminal_width)
+            x = np.random.uniform(0, terminal_width)
+            y = np.random.uniform(0, terminal_height)
         
         # Keep within terminal bounds
-        x = max(min(x, terminal_length), 0)
-        y = max(min(y, terminal_width), 0)
-        
-        # Z-coordinate (walking passengers with some variation in height)
-        z = 3 + np.random.uniform(-0.5, 0.5)  # Standing height with variation
+        x = max(min(x, terminal_width), 0)
+        y = max(min(y, terminal_height), 0)
         
         passenger_x.append(x)
         passenger_y.append(y)
-        passenger_z.append(z)
         
         # Color walking passengers by delay frustration level
         if normalized_delay < 0.3:
@@ -251,11 +238,11 @@ def create_3d_terminal_crowd(delay_minutes, n_passengers=200):
         else:
             passenger_colors.append('red')  # High frustration
     
-    return passenger_x, passenger_y, passenger_z, passenger_colors, normalized_delay, gates, service_points
+    return passenger_x, passenger_y, passenger_colors, normalized_delay
 
 def predict_delay_interface(carrier, arr_flights, arr_diverted, temperature, wind_speed, month,
-                           arr_delay_lag1, arr_flights_lag2, weather_delay, security_delay,
-                           carrier_delay, arr_delay_lag1_lag2, arr_delay_lag1_lag3):
+                            arr_delay_lag1, arr_flights_lag2, weather_delay, security_delay,
+                            carrier_delay, arr_delay_lag1_lag2, arr_delay_lag1_lag3):
     # Get prediction
     delay_minutes = predict_delay(
         carrier, arr_flights, arr_diverted, temperature, wind_speed, month,
@@ -263,213 +250,155 @@ def predict_delay_interface(carrier, arr_flights, arr_diverted, temperature, win
         carrier_delay, arr_delay_lag1_lag2, arr_delay_lag1_lag3
     )
     
-    # Create 3D airport terminal crowd simulation
-    passenger_x, passenger_y, passenger_z, passenger_colors, normalized_delay, gates, service_points = create_3d_terminal_crowd(delay_minutes)
+    # Create airport terminal crowd simulation
+    passenger_x, passenger_y, passenger_colors, normalized_delay = create_terminal_crowd(delay_minutes)
+    
+    # Create terminal layout for visualization
+    fig = make_subplots(rows=1, cols=1)
     
-    # Create 3D plot
-    fig = go.Figure()
+    # Add terminal background
+    terminal_width = 100
+    terminal_height = 60
     
-    # Add floor of the terminal - slightly transparent
-    x_floor = [0, 100, 100, 0, 0]
-    y_floor = [0, 0, 60, 60, 0]
-    z_floor = [0, 0, 0, 0, 0]
+    # Draw terminal structure
+    # Main walking area
+    fig.add_shape(
+        type="rect",
+        x0=0, y0=0, x1=terminal_width, y1=terminal_height,
+        line=dict(width=2, color="gray"),
+        fillcolor="lightgray",
+        opacity=0.3
+    )
     
-    fig.add_trace(go.Mesh3d(
-        x=x_floor, y=y_floor, z=z_floor,
-        i=[0, 0],
-        j=[1, 2],
-        k=[2, 3],
-        opacity=0.7,
-        color='lightgray',
-        name='Terminal Floor'
-    ))
+    # Gates
+    gates = [
+        [10, 5, 20, 10, "Gate A"],
+        [40, 5, 20, 10, "Gate B"],
+        [70, 5, 20, 10, "Gate C"],
+        [10, 45, 20, 10, "Gate D"],
+        [40, 45, 20, 10, "Gate E"],
+        [70, 45, 20, 10, "Gate F"]
+    ]
     
-    # Add gate areas
     for gate in gates:
-        # Bottom face of gate area
-        x = [gate[0], gate[0]+gate[2], gate[0]+gate[2], gate[0], gate[0]]
-        y = [gate[1], gate[1], gate[1]+gate[3], gate[1]+gate[3], gate[1]]
-        z = [0, 0, 0, 0, 0]
-        
-        fig.add_trace(go.Scatter3d(
-            x=x, y=y, z=z,
-            mode='lines',
-            line=dict(color='blue', width=3),
-            name=gate[4]
-        ))
-        
+        fig.add_shape(
+            type="rect",
+            x0=gate[0], y0=gate[1], x1=gate[0]+gate[2], y1=gate[1]+gate[3],
+            line=dict(width=1, color="blue"),
+            fillcolor="lightblue",
+            opacity=0.4
+        )
         # Add gate label
-        fig.add_trace(go.Scatter3d(
-            x=[gate[0] + gate[2]/2],
-            y=[gate[1] + gate[3]/2],
-            z=[1],
-            mode='text',
-            text=[gate[4]],
-            textfont=dict(size=12, color='darkblue'),
-            name=''
-        ))
+        fig.add_annotation(
+            x=gate[0]+gate[2]/2, y=gate[1]+gate[3]/2,
+            text=gate[4],
+            showarrow=False,
+            font=dict(size=10)
+        )
     
-    # Add service points
-    for point in service_points:
-        # Create a circle of points for service desk
-        theta = np.linspace(0, 2*np.pi, 20)
-        x = point[0] + point[2] * np.cos(theta)
-        y = point[1] + point[2] * np.sin(theta)
-        z = np.zeros_like(theta)
-        
-        fig.add_trace(go.Scatter3d(
-            x=x, y=y, z=z,
-            mode='lines',
-            line=dict(color='darkgray', width=3),
-            name=point[3]
-        ))
-        
-        # Add service point label
-        fig.add_trace(go.Scatter3d(
-            x=[point[0]],
-            y=[point[1]],
-            z=[1],
-            mode='text',
-            text=[point[3]],
-            textfont=dict(size=12, color='darkred'),
-            name=''
-        ))
+    # Info desk and security points
+    service_points = [
+        [50, 30, 6, "Information"],
+        [25, 30, 4, "Security 1"],
+        [75, 30, 4, "Security 2"]
+    ]
     
-    # Add 3D passengers
-    # We'll use a marker shape that looks like a person from above
-    fig.add_trace(go.Scatter3d(
-        x=passenger_x,
-        y=passenger_y,
-        z=passenger_z,
-        mode='markers',
-        marker=dict(
-            size=5,
-            color=passenger_colors,
-            symbol='circle',
-            opacity=0.8
-        ),
-        name='Passengers'
-    ))
+    for point in service_points:
+        fig.add_shape(
+            type="circle",
+            x0=point[0]-point[2], y0=point[1]-point[2], 
+            x1=point[0]+point[2], y1=point[1]+point[2],
+            line=dict(width=1, color="darkgray"),
+            fillcolor="darkgray",
+            opacity=0.4
+        )
+        # Add label
+        fig.add_annotation(
+            x=point[0], y=point[1],
+            text=point[3],
+            showarrow=False,
+            font=dict(size=10, color="black")
+        )
     
-    # Calculate frustration metrics
-    total_passengers = len(passenger_x)
-    frustrated_passengers = passenger_colors.count('red') + passenger_colors.count('orange')
-    frustration_percent = round(frustrated_passengers / total_passengers * 100)
+    # Add passengers as scatter points
+    fig.add_trace(
+        go.Scatter(
+            x=passenger_x, y=passenger_y,
+            mode='markers',
+            marker=dict(
+                size=7,
+                color=passenger_colors,
+                opacity=0.7
+            ),
+            name='Passengers'
+        )
+    )
     
-    # Determine color for delay indication
+    # Add delay information
+    # Create color for delay text based on severity
     if delay_minutes < 0:
         delay_color = "green"
-        delay_status = "Early by"
+        delay_text = "Early by"
     elif delay_minutes < 1:
         delay_color = "green"
-        delay_status = "On time (+"
+        delay_text = "On time (+"
     elif delay_minutes < 3:
         delay_color = "orange"
-        delay_status = "Delayed by"
+        delay_text = "Delayed by"
     else:
         delay_color = "red"
-        delay_status = "Significantly delayed by"
+        delay_text = "Significantly delayed by"
     
-    # Add text annotation for delay information
-    fig.add_trace(go.Scatter3d(
-        x=[50],
-        y=[10],
-        z=[8],
-        mode='text',
-        text=[f"{delay_status} {abs(delay_minutes):.1f} minutes"],
-        textfont=dict(size=16, color=delay_color),
-        name=''
-    ))
+    # Add delay annotation
+    fig.add_annotation(
+        xref="paper", yref="paper",
+        x=0.5, y=0.97,
+        text=f"<b>{delay_text} {abs(delay_minutes):.1f} minutes</b>",
+        showarrow=False,
+        font=dict(size=16, color=delay_color),
+        align="center",
+        bgcolor="rgba(255, 255, 255, 0.8)",
+        bordercolor=delay_color,
+        borderwidth=2,
+        borderpad=4
+    )
     
-    # Add text annotation for frustration level
-    fig.add_trace(go.Scatter3d(
-        x=[50],
-        y=[50],
-        z=[8],
-        mode='text',
-        text=[f"Terminal Occupancy: {total_passengers} | Frustration Level: {frustration_percent}%"],
-        textfont=dict(size=14, color='black'),
-        name=''
-    ))
+    # Add passenger count and frustration level
+    total_passengers = len(passenger_x)
+    frustrated_passengers = passenger_colors.count('red') + passenger_colors.count('orange')
+    frustration_percent = round(frustrated_passengers / total_passengers * 100)
     
-    # Add 3D people flow based on delay level
-    if normalized_delay > 0.5:
-        # With higher delays, show increased movement patterns
-        # Generate flow lines between gates and service points
-        for gate in gates:
-            for point in service_points:
-                # Number of flow lines based on delay severity
-                num_flows = int(normalized_delay * 10)
-                for _ in range(num_flows):
-                    # Starting point - random position within gate
-                    start_x = gate[0] + np.random.uniform(0, gate[2])
-                    start_y = gate[1] + np.random.uniform(0, gate[3])
-                    
-                    # Ending point - near service point
-                    end_x = point[0] + np.random.normal(0, point[2] * 0.5)
-                    end_y = point[1] + np.random.normal(0, point[2] * 0.5)
-                    
-                    # Create flow line with multiple points for curved effect
-                    curve_points = 5
-                    x_flow = np.linspace(start_x, end_x, curve_points)
-                    y_flow = np.linspace(start_y, end_y, curve_points)
-                    
-                    # Add slight randomness to path
-                    x_flow += np.random.normal(0, 3, curve_points)
-                    y_flow += np.random.normal(0, 3, curve_points)
-                    
-                    # Height varies along path (starting seated, ending standing)
-                    z_flow = np.linspace(1.5, 3, curve_points)
-                    
-                    # Add flow line
-                    fig.add_trace(go.Scatter3d(
-                        x=x_flow,
-                        y=y_flow,
-                        z=z_flow,
-                        mode='lines',
-                        line=dict(
-                            color='orange' if normalized_delay < 0.7 else 'red',
-                            width=2,
-                            dash='dot'
-                        ),
-                        opacity=0.5,
-                        name='Passenger Flow'
-                    ))
+    fig.add_annotation(
+        xref="paper", yref="paper",
+        x=0.5, y=0.03,
+        text=f"Terminal occupancy: {total_passengers} passengers | Frustration level: {frustration_percent}%",
+        showarrow=False,
+        font=dict(size=12),
+        align="center",
+        bgcolor="rgba(255, 255, 255, 0.8)",
+        borderpad=4
+    )
     
-    # Customize 3D layout
+    # Customize layout
     fig.update_layout(
-        title=f"3D Airport Terminal Simulation - {carrier}",
-        scene=dict(
-            xaxis=dict(
-                title='',
-                range=[0, 100],
-                showticklabels=False,
-                showgrid=True,
-                gridcolor='lightgray'
-            ),
-            yaxis=dict(
-                title='',
-                range=[0, 60],
-                showticklabels=False,
-                showgrid=True,
-                gridcolor='lightgray'
-            ),
-            zaxis=dict(
-                title='',
-                range=[0, 10],
-                showticklabels=False,
-                showgrid=True,
-                gridcolor='lightgray'
-            ),
-            aspectmode='manual',
-            aspectratio=dict(x=1, y=0.6, z=0.3),
-            camera=dict(
-                eye=dict(x=0.8, y=-1.5, z=1.2),
-                up=dict(x=0, y=0, z=1)
-            )
-        ),
+        title=f"Airport Terminal Crowd Simulation - {carrier}",
         showlegend=False,
-        margin=dict(l=0, r=0, t=30, b=0)
+        xaxis=dict(
+            range=[-5, terminal_width+5],
+            showgrid=False,
+            zeroline=False,
+            visible=False
+        ),
+        yaxis=dict(
+            range=[-5, terminal_height+5],
+            showgrid=False,
+            zeroline=False,
+            visible=False,
+            scaleanchor="x",
+            scaleratio=1
+        ),
+        margin=dict(l=20, r=20, t=50, b=20),
+        plot_bgcolor='white'
     )
     
     return fig
@@ -491,12 +420,12 @@ inputs = [
     gr.Slider(minimum=slider_ranges['arr_delay_lag1_lag3']['min'], maximum=slider_ranges['arr_delay_lag1_lag3']['max'], step=0.1, label="Arrival Delay 3 Months Ago (Scaled)")
 ]
 
-outputs = gr.Plot(label="3D Airport Terminal Simulation")
+outputs = gr.Plot(label="Airport Terminal Crowd Simulation")
 
 gr.Interface(
     fn=predict_delay_interface,
     inputs=inputs,
     outputs=outputs,
-    title="Flight Delay Prediction with 3D Terminal Crowd Simulation",
-    description="Predict flight delays and visualize their impact in a 3D airport terminal environment. Passengers (colored dots) move between gates and service areas based on delay severity. Blue indicates calm passengers, orange shows mild frustration, and red represents high frustration. As delays increase, more movement patterns emerge between gates and information/security points."
-).launch
+    title="Flight Delay Prediction with Terminal Crowd Simulation",
+    description="Predict flight delays and visualize how they affect the airport terminal crowd. As delays increase, passengers shift from gates to information desks and security points, with increasing frustration levels (blue = calm, orange = mild frustration, red = high frustration)."
+).launch()