Update app.py

app.py

@@ -1,7 +1,7 @@
 import os
 import json
 from collections import deque, defaultdict
-from typing import List, Tuple, Dict, Optional, Union
+from typing import List, Tuple, Dict, Optional, Union, Any
 from io import BytesIO
 import base64
 
@@ -51,24 +51,28 @@ CLIENT = InferenceHTTPClient(
 PLAYER_DETECTION_MODEL_ID = "football-players-detection-3zvbc/11"
 FIELD_DETECTION_MODEL_ID = "football-field-detection-f07vi/14"
 
+
 def infer_with_confidence(model_id: str, frame: np.ndarray, confidence_threshold: float = 0.3):
     """Run inference and filter by confidence threshold"""
     result = CLIENT.infer(frame, model_id=model_id)
     detections = sv.Detections.from_inference(result)
-    # Filter by confidence
     if len(detections) > 0:
         detections = detections[detections.confidence > confidence_threshold]
     return result, detections
 
+
 # ==============================================
 # SIGLIP MODEL (Embeddings)
 # ==============================================
 SIGLIP_MODEL_PATH = "google/siglip-base-patch16-224"
-EMBEDDINGS_MODEL = SiglipVisionModel.from_pretrained(SIGLIP_MODEL_PATH, token=HF_TOKEN).to(DEVICE)
+EMBEDDINGS_MODEL = SiglipVisionModel.from_pretrained(
+    SIGLIP_MODEL_PATH,
+    token=HF_TOKEN
+).to(DEVICE)
 EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF_TOKEN)
 
 # ==============================================
-# TEAM CLASSIFIER & CONFIG
+# TEAM CONFIG
 # ==============================================
 CONFIG = SoccerPitchConfiguration()
 
@@ -79,7 +83,7 @@ def replace_outliers_based_on_distance(
     positions: List[np.ndarray],
     distance_threshold: float
 ) -> List[np.ndarray]:
-    """Remove outlier positions based on distance threshold"""
+    """Remove outlier positions based on distance threshold (in pitch units)."""
     last_valid_position: Union[np.ndarray, None] = None
     cleaned_positions: List[np.ndarray] = []
 
@@ -106,12 +110,12 @@ def replace_outliers_based_on_distance(
 # ==============================================
 class PlayerPerformanceTracker:
     """Track individual player performance metrics and generate heatmaps"""
-    
+
     def __init__(self, pitch_config):
         self.config = pitch_config
-        self.player_positions = defaultdict(list)  # (x, y, frame)
-        self.player_velocities = defaultdict(list)  # cm/s
-        self.player_distances = defaultdict(float)  # cm
+        self.player_positions = defaultdict(list)
+        self.player_velocities = defaultdict(list)
+        self.player_distances = defaultdict(float)
         self.player_team = {}
         self.player_stats = defaultdict(lambda: {
             'frames_visible': 0,
@@ -121,28 +125,30 @@ class PlayerPerformanceTracker:
             'time_in_defensive_third': 0,
             'time_in_middle_third': 0
         })
-        
-    def update(self, tracker_id: int, position: np.ndarray, team_id: int, frame: int):
+
+    def update(self, tracker_id: int, position: np.ndarray, team_id: int, frame: int, fps: float):
         """Update player position and calculate metrics"""
         if len(position) != 2:
             return
-            
+
         self.player_team[tracker_id] = team_id
         self.player_positions[tracker_id].append((position[0], position[1], frame))
         self.player_stats[tracker_id]['frames_visible'] += 1
-        
+
         if len(self.player_positions[tracker_id]) > 1:
             prev_pos = np.array(self.player_positions[tracker_id][-2][:2])
             curr_pos = np.array(position)
             distance = np.linalg.norm(curr_pos - prev_pos)
             self.player_distances[tracker_id] += distance
-            
-            velocity = distance * 30  # cm/s assuming 30fps
+
+            # pitch units per second -> just relative for now
+            dt = 1.0 / max(fps, 1.0)
+            velocity = distance / dt
             self.player_velocities[tracker_id].append(velocity)
-            
+
             if velocity > self.player_stats[tracker_id]['max_velocity']:
                 self.player_stats[tracker_id]['max_velocity'] = velocity
-        
+
         pitch_length = self.config.length
         if position[0] < pitch_length / 3:
             self.player_stats[tracker_id]['time_in_defensive_third'] += 1
@@ -150,45 +156,46 @@ class PlayerPerformanceTracker:
             self.player_stats[tracker_id]['time_in_middle_third'] += 1
         else:
             self.player_stats[tracker_id]['time_in_attacking_third'] += 1
-    
+
     def get_player_stats(self, tracker_id: int) -> dict:
         """Get comprehensive stats for a player"""
         stats = self.player_stats[tracker_id].copy()
-        
+
         if len(self.player_velocities[tracker_id]) > 0:
             stats['avg_velocity'] = float(np.mean(self.player_velocities[tracker_id]))
-        
+
+        # treat pitch units as cm-ish; convert to meters for readability
         stats['total_distance'] = float(self.player_distances[tracker_id])
-        stats['total_distance_meters'] = self.player_distances[tracker_id] / 100.0
-        stats['team_id'] = int(self.player_team.get(tracker_id, -1))
-        
+        stats['total_distance_meters'] = float(self.player_distances[tracker_id] / 100.0)
+        stats['team_id'] = self.player_team.get(tracker_id, -1)
+
         return stats
-    
+
     def generate_heatmap(self, tracker_id: int, resolution: int = 100) -> np.ndarray:
         """Generate heatmap for a specific player"""
         if tracker_id not in self.player_positions or len(self.player_positions[tracker_id]) == 0:
             return np.zeros((resolution, resolution))
-        
+
         positions = np.array([(x, y) for x, y, _ in self.player_positions[tracker_id]])
-        
+
         pitch_length = self.config.length
         pitch_width = self.config.width
-        
+
         heatmap, xedges, yedges = np.histogram2d(
             positions[:, 0], positions[:, 1],
             bins=[resolution, resolution],
             range=[[0, pitch_length], [0, pitch_width]]
         )
-        
+
         heatmap = gaussian_filter(heatmap, sigma=3)
-        
+
         return heatmap.T
-    
+
     def get_all_players_by_team(self) -> Dict[int, List[int]]:
         """Get all player IDs grouped by team"""
         teams = defaultdict(list)
         for tracker_id, team_id in self.player_team.items():
-            teams[int(team_id)].append(int(tracker_id))
+            teams[team_id].append(tracker_id)
         return teams
 
 
@@ -197,38 +204,38 @@ class PlayerPerformanceTracker:
 # ==============================================
 class PlayerTrackingManager:
     """Manages persistent player tracking with team assignment stability"""
-    
+
     def __init__(self, max_history=10):
         self.tracker_team_history: Dict[int, List[int]] = defaultdict(list)
         self.max_history = max_history
         self.active_trackers = set()
-        
+
     def update_team_assignment(self, tracker_id: int, team_id: int):
         """Store team assignment history for each tracker"""
-        self.tracker_team_history[int(tracker_id)].append(int(team_id))
-        if len(self.tracker_team_history[int(tracker_id)]) > self.max_history:
-            self.tracker_team_history[int(tracker_id)].pop(0)
-        self.active_trackers.add(int(tracker_id))
-    
+        self.tracker_team_history[tracker_id].append(team_id)
+        if len(self.tracker_team_history[tracker_id]) > self.max_history:
+            self.tracker_team_history[tracker_id].pop(0)
+        self.active_trackers.add(tracker_id)
+
     def get_stable_team_id(self, tracker_id: int, current_team_id: int) -> int:
         """Get stable team ID using majority voting from history"""
         if tracker_id not in self.tracker_team_history or len(self.tracker_team_history[tracker_id]) < 3:
-            return int(current_team_id)
-        
+            return current_team_id
+
         history = self.tracker_team_history[tracker_id]
         team_counts = np.bincount(history)
         stable_team = int(np.argmax(team_counts))
         return stable_team
-    
+
     def get_player_count_by_team(self) -> Dict[int, int]:
         """Get current count of players per team"""
         team_counts = defaultdict(int)
         for tracker_id in self.active_trackers:
             if tracker_id in self.tracker_team_history and len(self.tracker_team_history[tracker_id]) > 0:
                 stable_team = self.get_stable_team_id(tracker_id, self.tracker_team_history[tracker_id][-1])
-                team_counts[int(stable_team)] += 1
+                team_counts[stable_team] += 1
         return team_counts
-    
+
     def reset_frame(self):
         """Reset active trackers for new frame"""
         self.active_trackers = set()
@@ -237,154 +244,155 @@ class PlayerTrackingManager:
 # ==============================================
 # VISUALIZATION FUNCTIONS
 # ==============================================
-def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker, 
+def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker,
                                        tracker_id: int) -> np.ndarray:
     """Create a single player heatmap overlay on pitch"""
     pitch = draw_pitch(CONFIG)
     heatmap = performance_tracker.generate_heatmap(tracker_id, resolution=150)
-    
+
     if heatmap.max() > 0:
         heatmap = heatmap / heatmap.max()
-    
+
     padding = 50
-    
     pitch_height, pitch_width = pitch.shape[:2]
-    heatmap_resized = cv2.resize(heatmap, (pitch_width - 2*padding, pitch_height - 2*padding))
-    
+    heatmap_resized = cv2.resize(heatmap, (pitch_width - 2 * padding, pitch_height - 2 * padding))
+
     heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), cv2.COLORMAP_JET)
-    
+
     overlay = pitch.copy()
-    overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
-    
+    overlay[padding:pitch_height - padding, padding:pitch_width - padding] = heatmap_colored
+
     result = cv2.addWeighted(pitch, 0.6, overlay, 0.4, 0)
-    
+
     stats = performance_tracker.get_player_stats(tracker_id)
     team_color = "Blue" if stats['team_id'] == 0 else "Pink"
-    
+
     text_lines = [
         f"Player #{tracker_id} ({team_color} Team)",
         f"Distance: {stats['total_distance_meters']:.1f}m",
-        f"Avg Speed: {stats['avg_velocity']/100:.2f}m/s",
-        f"Max Speed: {stats['max_velocity']/100:.2f}m/s",
+        f"Avg Speed (rel): {stats['avg_velocity']:.2f}",
+        f"Max Speed (rel): {stats['max_velocity']:.2f}",
         f"Frames: {stats['frames_visible']}"
     ]
-    
+
     y_offset = 30
     for line in text_lines:
-        cv2.putText(result, line, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 
-                   0.6, (255, 255, 255), 2, cv2.LINE_AA)
+        cv2.putText(result, line, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX,
+                    0.6, (255, 255, 255), 2, cv2.LINE_AA)
         y_offset += 25
-    
+
     return result
 
 
 def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -> go.Figure:
     """Create interactive performance comparison plots"""
     teams = performance_tracker.get_all_players_by_team()
-    
+
     fig = make_subplots(
         rows=2, cols=2,
-        subplot_titles=('Distance Covered', 'Average Speed', 'Max Speed', 'Activity by Zone'),
+        subplot_titles=('Distance Covered (m)', 'Avg Speed (rel)', 'Max Speed (rel)', 'Activity in Attacking Third'),
         specs=[[{'type': 'bar'}, {'type': 'bar'}],
                [{'type': 'bar'}, {'type': 'bar'}]]
     )
-    
+
     colors = {0: '#00BFFF', 1: '#FF1493'}
     team_names = {0: 'Team 0 (Blue)', 1: 'Team 1 (Pink)'}
-    
+
     for team_id, player_ids in teams.items():
         if team_id not in [0, 1]:
             continue
-            
+
         distances = []
         avg_speeds = []
         max_speeds = []
         attacking_time = []
-        
+
         for pid in player_ids:
             stats = performance_tracker.get_player_stats(pid)
             distances.append(stats['total_distance_meters'])
-            avg_speeds.append(stats['avg_velocity']/100.0)
-            max_speeds.append(stats['max_velocity']/100.0)
+            avg_speeds.append(stats['avg_velocity'])
+            max_speeds.append(stats['max_velocity'])
             attacking_time.append(stats['time_in_attacking_third'])
-        
+
         player_labels = [f"#{pid}" for pid in player_ids]
-        
+
         fig.add_trace(
             go.Bar(x=player_labels, y=distances, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=True),
+                   marker_color=colors[team_id], showlegend=True),
             row=1, col=1
         )
-        
+
         fig.add_trace(
             go.Bar(x=player_labels, y=avg_speeds, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
+                   marker_color=colors[team_id], showlegend=False),
             row=1, col=2
         )
-        
+
         fig.add_trace(
             go.Bar(x=player_labels, y=max_speeds, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
+                   marker_color=colors[team_id], showlegend=False),
             row=2, col=1
         )
-        
+
         fig.add_trace(
             go.Bar(x=player_labels, y=attacking_time, name=team_names[team_id],
-                  marker_color=colors[team_id], showlegend=False),
+                   marker_color=colors[team_id], showlegend=False),
             row=2, col=2
         )
-    
+
     fig.update_xaxes(title_text="Players", row=1, col=1)
     fig.update_xaxes(title_text="Players", row=1, col=2)
     fig.update_xaxes(title_text="Players", row=2, col=1)
     fig.update_xaxes(title_text="Players", row=2, col=2)
-    
+
     fig.update_yaxes(title_text="Distance (m)", row=1, col=1)
-    fig.update_yaxes(title_text="Speed (m/s)", row=1, col=2)
-    fig.update_yaxes(title_text="Speed (m/s)", row=2, col=1)
-    fig.update_yaxes(title_text="Frames in Zone", row=2, col=2)
-    
+    fig.update_yaxes(title_text="Speed (rel units)", row=1, col=2)
+    fig.update_yaxes(title_text="Speed (rel units)", row=2, col=1)
+    fig.update_yaxes(title_text="Frames in Attacking Third", row=2, col=2)
+
     fig.update_layout(height=800, title_text="Team Performance Comparison", barmode='group')
-    
+
     return fig
 
 
 def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> np.ndarray:
     """Create side-by-side team heatmaps"""
     teams = performance_tracker.get_all_players_by_team()
-    
+
     team_heatmaps = []
     for team_id in [0, 1]:
         if team_id not in teams:
             continue
-            
+
         combined_heatmap = np.zeros((150, 150))
         for pid in teams[team_id]:
             player_heatmap = performance_tracker.generate_heatmap(pid, resolution=150)
             combined_heatmap += player_heatmap
-        
+
         if combined_heatmap.max() > 0:
             combined_heatmap = combined_heatmap / combined_heatmap.max()
-        
+
         pitch = draw_pitch(CONFIG)
         padding = 50
         pitch_height, pitch_width = pitch.shape[:2]
-        heatmap_resized = cv2.resize(combined_heatmap, 
-                                    (pitch_width - 2*padding, pitch_height - 2*padding))
-        
+        heatmap_resized = cv2.resize(
+            combined_heatmap,
+            (pitch_width - 2 * padding, pitch_height - 2 * padding)
+        )
+
         colormap = cv2.COLORMAP_JET if team_id == 0 else cv2.COLORMAP_HOT
         heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), colormap)
-        
+
         overlay = pitch.copy()
-        overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
+        overlay[padding:pitch_height - padding, padding:pitch_width - padding] = heatmap_colored
         result = cv2.addWeighted(pitch, 0.5, overlay, 0.5, 0)
-        
+
         team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
-        cv2.putText(result, team_name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
-                   1, (255, 255, 255), 2, cv2.LINE_AA)
-        
+        cv2.putText(result, team_name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
+                    1, (255, 255, 255), 2, cv2.LINE_AA)
+
         team_heatmaps.append(result)
-    
+
     if len(team_heatmaps) == 2:
         return np.hstack(team_heatmaps)
     elif len(team_heatmaps) == 1:
@@ -410,11 +418,11 @@ def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detectio
     ])
 
 
-def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id, 
-                           pitch_referees_xy, ball_path=None):
+def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
+                            pitch_referees_xy, ball_path=None):
     """Create game-style radar view with ball trail effect"""
     annotated_frame = draw_pitch(CONFIG)
-    
+
     # Draw ball trail with fading effect
     if ball_path is not None and len(ball_path) > 0:
         valid_path = [coords for coords in ball_path if len(coords) > 0]
@@ -425,68 +433,64 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
                 alpha = (i + 1) / min(20, len(valid_path))
                 color = sv.Color(int(255 * alpha), int(255 * alpha), int(255 * alpha))
                 annotated_frame = draw_points_on_pitch(
-                    CONFIG, coords, 
-                    face_color=color, 
-                    edge_color=sv.Color.BLACK, 
+                    CONFIG, coords,
+                    face_color=color,
+                    edge_color=sv.Color.BLACK,
                     radius=int(6 + alpha * 4),
                     pitch=annotated_frame
                 )
-    
+
     # Draw current ball position
     if len(pitch_ball_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_ball_xy, 
-            face_color=sv.Color.WHITE, 
-            edge_color=sv.Color.BLACK, 
-            radius=10, 
+            CONFIG, pitch_ball_xy,
+            face_color=sv.Color.WHITE,
+            edge_color=sv.Color.BLACK,
+            radius=10,
             pitch=annotated_frame
         )
-    
+
     # Draw players
     for team_id, color_hex in zip([0, 1], ["00BFFF", "FF1493"]):
         mask = players_class_id == team_id
         if np.any(mask):
             annotated_frame = draw_points_on_pitch(
-                CONFIG, pitch_players_xy[mask], 
-                face_color=sv.Color.from_hex(color_hex), 
-                edge_color=sv.Color.BLACK, 
-                radius=16, 
+                CONFIG, pitch_players_xy[mask],
+                face_color=sv.Color.from_hex(color_hex),
+                edge_color=sv.Color.BLACK,
+                radius=16,
                 pitch=annotated_frame
             )
-    
+
     # Draw referees
     if len(pitch_referees_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_referees_xy, 
-            face_color=sv.Color.from_hex("FFD700"), 
-            edge_color=sv.Color.BLACK, 
-            radius=16, 
+            CONFIG, pitch_referees_xy,
+            face_color=sv.Color.from_hex("FFD700"),
+            edge_color=sv.Color.BLACK,
+            radius=16,
             pitch=annotated_frame
         )
-    
+
     return annotated_frame
 
 
 # ==============================================
-# MAIN ANALYSIS PIPELINE WITH EVENTS + STATS
+# MAIN ANALYSIS PIPELINE
 # ==============================================
 def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     """
     Complete football analysis pipeline:
-      - Player & ball detection + tracking
-      - Team classification with stable assignment
-      - Field homography, ball path cleaning
-      - Player performance tracking
-      - Event & possession analysis
-      - Annotated match video
-      - Heatmaps, comparison plots
-      - Per-player stats table
-      - Event timeline + downloadable JSON
+      - Player detection & tracking
+      - Team classification
+      - Homography to pitch coordinates
+      - Player speed & distance overlays
+      - Ball path cleaning
+      - Heatmaps & comparisons
+      - Event + possession stats
     """
     if not video_path:
-        return (None, None, None, None, None,
-                "❌ Please upload a video file.",
-                None, None, None)
+        return (None,) * 9
 
     try:
         progress(0, desc="🔧 Initializing...")
@@ -501,26 +505,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         tracking_manager = PlayerTrackingManager(max_history=10)
         performance_tracker = PlayerPerformanceTracker(CONFIG)
 
-        # Event & possession tracking
-        possession_time_player = defaultdict(float)   # tid -> seconds
-        possession_time_team = defaultdict(float)     # team_id -> seconds
-        team_of_player: Dict[int, int] = {}
-        events: List[Dict[str, Any]] = []
-
-        prev_owner_tid: Optional[int] = None
-        prev_ball_pos_pitch: Optional[np.ndarray] = None
-
-        # Simple goal centers (for shot vs clearance direction)
-        goal_centers = {
-            0: np.array([0.0, CONFIG.width / 2.0]),
-            1: np.array([CONFIG.length, CONFIG.width / 2.0]),
-        }
-
-        def register_event(ev: Dict[str, Any], text: str):
-            # We just register events here; text is for optional future HUD
-            events.append(ev)
-
-        # Annotators with exact colors from notebook
+        # Annotators
         ellipse_annotator = sv.EllipseAnnotator(
             color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']),
             thickness=2
@@ -549,30 +534,27 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         # Video setup
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            return (None, None, None, None, None,
-                    f"❌ Failed to open video: {video_path}",
-                    None, None, None)
+            return (None, None, None, None, None, f"❌ Failed to open video: {video_path}", None, None, None)
 
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        fps = fps if fps > 0 else 30.0
-        dt = 1.0 / fps
-
+        fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
         print(f"📹 Video: {width}x{height}, {fps}fps, {total_frames} frames")
 
         fourcc = cv2.VideoWriter_fourcc(*"mp4v")
         output_path = "/tmp/annotated_football.mp4"
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
 
-        # ========================================
+        dt = 1.0 / fps
+
+        # ===================================================
         # STEP 1: Collect Player Crops for Team Classifier
-        # ========================================
+        # ===================================================
         progress(0.05, desc="🏃 Collecting player samples (Step 1/7)...")
         player_crops = []
         frame_count = 0
-        
+
         while frame_count < min(total_frames, 300):
             ret, frame = cap.read()
             if not ret:
@@ -590,37 +572,63 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             frame_count += 1
 
         if len(player_crops) == 0:
-            cap.release()
-            out.release()
             return (None, None, None, None, None,
-                    "❌ No player crops collected.",
-                    None, None, None)
+                    "❌ No player crops collected.", None, None, None)
 
         print(f"✅ Collected {len(player_crops)} player samples")
 
-        # ========================================
+        # ===================================================
         # STEP 2: Train Team Classifier
-        # ========================================
+        # ===================================================
         progress(0.15, desc="🎯 Training team classifier (Step 2/7)...")
         team_classifier = TeamClassifier(device=DEVICE)
         team_classifier.fit(player_crops)
         print("✅ Team classifier trained")
 
-        # ========================================
+        # ===================================================
         # STEP 3: Process Full Video with Tracking + Events
-        # ========================================
+        # ===================================================
         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
         frame_count = 0
         M = deque(maxlen=MAXLEN)  # Transformation matrix smoothing
-        ball_path_raw = []
-        
-        # Store last frame data for radar
+        ball_path_raw: List[np.ndarray] = []
+
+        # For radar
         last_pitch_players_xy = None
         last_players_class_id = None
         last_pitch_referees_xy = None
 
+        # Event & possession stats
+        distance_covered_m = defaultdict(float)        # per player
+        possession_time_player_s = defaultdict(float)  # per player
+        possession_time_team_s = defaultdict(float)    # per team
+        team_of_player: Dict[int, int] = {}
+        events: List[Dict[str, Any]] = []
+
+        last_pitch_pos: Dict[int, np.ndarray] = {}
+        prev_owner_tid: Optional[int] = None
+        prev_ball_pos_pitch: Optional[np.ndarray] = None
+
+        # simple goal centers in pitch coordinates
+        goal_centers = {
+            0: np.array([0.0, CONFIG.width / 2.0]),
+            1: np.array([CONFIG.length, CONFIG.width / 2.0]),
+        }
+
+        # HUD event text (optional)
+        current_event_text = ""
+        event_text_frames_left = 0
+        EVENT_TEXT_DURATION_FRAMES = int(2.0 * fps)
+
+        def register_event(ev: Dict[str, Any], text: str):
+            nonlocal current_event_text, event_text_frames_left
+            events.append(ev)
+            if text:
+                current_event_text = text
+                event_text_frames_left = EVENT_TEXT_DURATION_FRAMES
+
         progress(0.2, desc="🎬 Processing video frames (Step 3/7)...")
-        
+
         while True:
             ret, frame = cap.read()
             if not ret:
@@ -628,12 +636,12 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
             frame_count += 1
             tracking_manager.reset_frame()
-            
+
             if frame_count % 30 == 0:
-                progress(0.2 + 0.35 * (frame_count / max(total_frames, 1)), 
-                        desc=f"🎬 Processing frame {frame_count}/{total_frames}")
+                progress(0.2 + 0.3 * (frame_count / max(total_frames, 1)),
+                         desc=f"🎬 Processing frame {frame_count}/{total_frames}")
 
-            # Player and ball detection
+            # ----------------- Detection & Tracking -----------------
             _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
 
             if len(detections.xyxy) == 0:
@@ -641,129 +649,150 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 ball_path_raw.append(np.empty((0, 2)))
                 continue
 
-            # Separate ball from other detections
+            # ball
             ball_detections = detections[detections.class_id == BALL_ID]
             ball_detections.xyxy = sv.pad_boxes(xyxy=ball_detections.xyxy, px=10)
-            
+
+            # rest
             all_detections = detections[detections.class_id != BALL_ID]
             all_detections = all_detections.with_nms(threshold=0.5, class_agnostic=True)
-            
-            # Track detections
+
+            # track
             all_detections = tracker.update_with_detections(detections=all_detections)
 
-            # Separate by type
+            # split by type
             goalkeepers_detections = all_detections[all_detections.class_id == GOALKEEPER_ID]
             players_detections = all_detections[all_detections.class_id == PLAYER_ID]
             referees_detections = all_detections[all_detections.class_id == REFEREE_ID]
 
-            # Team prediction with stability
+            # ----------------- Team classification -----------------
             if len(players_detections.xyxy) > 0:
                 crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
                 predicted_teams = team_classifier.predict(crops)
-                
-                # Apply stable team assignment
+
                 for idx, tracker_id in enumerate(players_detections.tracker_id):
                     tracking_manager.update_team_assignment(int(tracker_id), int(predicted_teams[idx]))
                     predicted_teams[idx] = tracking_manager.get_stable_team_id(
                         int(tracker_id), int(predicted_teams[idx])
                     )
-                
+
                 players_detections.class_id = predicted_teams
 
-            # Assign goalkeeper teams
-            if len(goalkeepers_detections) > 0 and len(players_detections) > 0:
-                goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
-                    players_detections, goalkeepers_detections
-                )
+            # assign GK teams
+            goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
+                players_detections, goalkeepers_detections
+            )
 
-            # Adjust referee class_id
+            # referees class shift
             referees_detections.class_id -= 1
 
-            # Merge all detections (players + keepers + refs)
-            all_detections_vis = sv.Detections.merge([
+            # merge for drawing
+            all_dets_for_draw = sv.Detections.merge([
                 players_detections, goalkeepers_detections, referees_detections
             ])
-            all_detections_vis.class_id = all_detections_vis.class_id.astype(int)
+            all_dets_for_draw.class_id = all_dets_for_draw.class_id.astype(int)
 
-            # ========================================
-            # STEP 4: Field Detection & Transformation
-            # ========================================
+            # ----------------- Field homography & pitch coords -----------------
             frame_ball_pos_pitch = None
-            pitch_players_xy = None
+            frame_players_xy_pitch = None
 
             try:
                 result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 0.3)
                 key_points = sv.KeyPoints.from_inference(result_field)
-                
-                # Filter confident keypoints
+
                 filter_mask = key_points.confidence[0] > 0.5
                 frame_ref_pts = key_points.xy[0][filter_mask]
                 pitch_ref_pts = np.array(CONFIG.vertices)[filter_mask]
-                
-                if len(frame_ref_pts) >= 4:  # Need at least 4 points for homography
+
+                if len(frame_ref_pts) >= 4:
                     transformer = ViewTransformer(source=frame_ref_pts, target=pitch_ref_pts)
                     M.append(transformer.m)
                     transformer.m = np.mean(np.array(M), axis=0)
 
-                    # Transform ball position
+                    # ball
                     frame_ball_xy = ball_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_ball_xy = transformer.transform_points(frame_ball_xy) if len(frame_ball_xy) > 0 else np.empty((0, 2))
+                    pitch_ball_xy = transformer.transform_points(frame_ball_xy)
                     ball_path_raw.append(pitch_ball_xy)
                     if len(pitch_ball_xy) > 0:
                         frame_ball_pos_pitch = pitch_ball_xy[0]
 
-                    # Transform all players (including goalkeepers)
+                    # players + gk
                     all_players = sv.Detections.merge([players_detections, goalkeepers_detections])
-                    players_xy = all_players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_players_xy = transformer.transform_points(players_xy) if len(players_xy) > 0 else np.empty((0, 2))
-                    
-                    # Transform referees
-                    referees_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                    pitch_referees_xy = transformer.transform_points(referees_xy) if len(referees_xy) > 0 else np.empty((0, 2))
-                    
-                    # Store for radar view
-                    last_pitch_players_xy = pitch_players_xy
-                    last_players_class_id = all_players.class_id
-                    last_pitch_referees_xy = pitch_referees_xy
-                    
-                    # Update performance tracker + team_of_player
-                    for idx, tracker_id in enumerate(all_players.tracker_id):
-                        if idx < len(pitch_players_xy):
-                            tid_int = int(tracker_id)
+                    if len(all_players) > 0:
+                        players_xy = all_players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                        pitch_players_xy = transformer.transform_points(players_xy)
+                        frame_players_xy_pitch = pitch_players_xy
+
+                        # referees
+                        refs_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                        pitch_referees_xy = transformer.transform_points(refs_xy) if len(refs_xy) > 0 else np.empty((0, 2))
+
+                        last_pitch_players_xy = pitch_players_xy
+                        last_players_class_id = all_players.class_id
+                        last_pitch_referees_xy = pitch_referees_xy
+
+                        # --------- update per-player stats & speed/distance ---------
+                        current_speed_kmh: Dict[int, float] = {}
+
+                        for idx, tracker_id in enumerate(all_players.tracker_id):
+                            tid = int(tracker_id)
                             team_id = int(all_players.class_id[idx])
-                            team_of_player[tid_int] = team_id
+                            pos_pitch = pitch_players_xy[idx]
+
+                            # performance tracker (for heatmaps, zone time, etc.)
                             performance_tracker.update(
-                                tid_int, 
-                                pitch_players_xy[idx], 
+                                tid,
+                                pos_pitch,
                                 team_id,
-                                frame_count
+                                frame_count,
+                                fps
                             )
+
+                            # distance & speed for overlays (assuming pitch units ≈ cm)
+                            prev_pos = last_pitch_pos.get(tid)
+                            if prev_pos is not None:
+                                dist_units = float(np.linalg.norm(pos_pitch - prev_pos))
+                                distance_covered_m[tid] += dist_units / 100.0  # convert to meters approx
+                                speed_mps = (dist_units / 100.0) / dt
+                                speed_kmh = speed_mps * 3.6
+                            else:
+                                speed_kmh = 0.0
+                            current_speed_kmh[tid] = speed_kmh
+                            last_pitch_pos[tid] = pos_pitch
+                            team_of_player[tid] = team_id
+                    else:
+                        pitch_referees_xy = np.empty((0, 2))
                 else:
                     ball_path_raw.append(np.empty((0, 2)))
-            except Exception as e:
+                    pitch_referees_xy = np.empty((0, 2))
+                    current_speed_kmh = {}
+            except Exception:
                 ball_path_raw.append(np.empty((0, 2)))
+                pitch_referees_xy = np.empty((0, 2))
+                current_speed_kmh = {}
+                frame_players_xy_pitch = None
 
-            # ========================================
-            # STEP 5: POSSESSION & EVENTS (only if we have ball + players in pitch coords)
-            # ========================================
+            # ----------------- Possession & Events -----------------
             owner_tid: Optional[int] = None
             POSSESSION_RADIUS_M = 5.0
 
-            if frame_ball_pos_pitch is not None and pitch_players_xy is not None and len(pitch_players_xy) > 0:
-                dists = np.linalg.norm(pitch_players_xy - frame_ball_pos_pitch, axis=1)
+            if frame_ball_pos_pitch is not None and frame_players_xy_pitch is not None and len(players_detections) > 0:
+                # only real players (exclude gk's if you want, but here include all_players)
+                # for possession, use players_detections only
+                players_xy_img = players_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                pitch_players_xy_pos = transformer.transform_points(players_xy_img)
+                dists = np.linalg.norm(pitch_players_xy_pos - frame_ball_pos_pitch, axis=1)
                 j = int(np.argmin(dists))
                 if dists[j] < POSSESSION_RADIUS_M:
-                    if 'all_players' in locals() and len(all_players.tracker_id) > j:
-                        owner_tid = int(all_players.tracker_id[j])
+                    owner_tid = int(players_detections.tracker_id[j])
 
-            # accumulate possession time
             if owner_tid is not None:
-                possession_time_player[owner_tid] += dt
+                possession_time_player_s[owner_tid] += dt
                 owner_team = team_of_player.get(owner_tid)
                 if owner_team is not None:
-                    possession_time_team[owner_team] += dt
+                    possession_time_team_s[owner_team] += dt
 
-            # possession change events, passes, tackles, interceptions
+            # detect passes / tackles / interceptions
             if owner_tid != prev_owner_tid:
                 if owner_tid is not None and prev_owner_tid is not None:
                     prev_team = team_of_player.get(prev_owner_tid)
@@ -771,7 +800,8 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
                     travel_m = 0.0
                     if prev_ball_pos_pitch is not None and frame_ball_pos_pitch is not None:
-                        travel_m = float(np.linalg.norm(frame_ball_pos_pitch - prev_ball_pos_pitch))
+                        travel_units = float(np.linalg.norm(frame_ball_pos_pitch - prev_ball_pos_pitch))
+                        travel_m = travel_units / 100.0
 
                     MIN_PASS_TRAVEL_M = 3.0
 
@@ -781,35 +811,32 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                             register_event(
                                 {
                                     "type": "pass",
-                                    "t": float(frame_count * dt),
+                                    "time_s": float(frame_count * dt),
                                     "from_tid": int(prev_owner_tid),
                                     "to_tid": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "extra": {"distance_m": float(travel_m)},
+                                    "distance_m": travel_m,
                                 },
                                 f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team})",
                             )
                         elif prev_team != cur_team:
                             # tackle vs interception
                             d_pp = 999.0
-                            if pitch_players_xy is not None and len(pitch_players_xy) > 0:
-                                pos_prev = None
-                                pos_cur = None
-                                if 'all_players' in locals():
-                                    # approximate positions using last known from perf tracker
-                                    pos_prev = None
-                                    pos_cur = None
-                                # we don't strictly need d_pp for coach view; keep simple
-                            ev_type = "tackle"  # simplified
-                            label = "Tackle"
+                            pos_prev = last_pitch_pos.get(int(prev_owner_tid))
+                            pos_cur = last_pitch_pos.get(int(owner_tid))
+                            if pos_prev is not None and pos_cur is not None:
+                                d_pp = float(np.linalg.norm(pos_prev - pos_cur))
+                            ev_type = "tackle" if d_pp < 3.0 else "interception"
+                            label = "Tackle" if ev_type == "tackle" else "Interception"
                             register_event(
                                 {
                                     "type": ev_type,
-                                    "t": float(frame_count * dt),
+                                    "time_s": float(frame_count * dt),
                                     "from_tid": int(prev_owner_tid),
                                     "to_tid": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "extra": {"ball_travel_m": float(travel_m)},
+                                    "player_distance_units": d_pp,
+                                    "ball_travel_m": travel_m,
                                 },
                                 f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}",
                             )
@@ -818,23 +845,20 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 register_event(
                     {
                         "type": "possession_change",
-                        "t": float(frame_count * dt),
+                        "time_s": float(frame_count * dt),
                         "from_tid": int(prev_owner_tid) if prev_owner_tid is not None else None,
                         "to_tid": int(owner_tid) if owner_tid is not None else None,
                         "team_id": int(team_of_player.get(owner_tid)) if owner_tid is not None else None,
-                        "extra": {},
                     },
-                    ""  # no banner text here
+                    "" if owner_tid is None else f"Team {team_of_player.get(owner_tid)} in possession",
                 )
 
-            # shot / clearance based on ball speed & direction
-            if (
-                prev_ball_pos_pitch is not None
-                and frame_ball_pos_pitch is not None
-                and owner_tid is not None
-            ):
-                v = (frame_ball_pos_pitch - prev_ball_pos_pitch) / dt  # m/s
-                speed_mps = float(np.linalg.norm(v))
+            # shots / clearances
+            if prev_ball_pos_pitch is not None and frame_ball_pos_pitch is not None and owner_tid is not None:
+                v_units = (frame_ball_pos_pitch - prev_ball_pos_pitch) / dt
+                speed_units = float(np.linalg.norm(v_units))
+                # convert approximate -> m/s (assuming pitch units ~ cm)
+                speed_mps = speed_units / 100.0
                 speed_kmh = speed_mps * 3.6
                 HIGH_SPEED_KMH = 18.0
 
@@ -844,19 +868,17 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                         target_goal = goal_centers[1 - shooter_team]
                         direction = target_goal - frame_ball_pos_pitch
                         cos_angle = float(
-                            np.dot(v, direction)
-                            / (np.linalg.norm(v) * np.linalg.norm(direction) + 1e-6)
+                            np.dot(v_units, direction)
+                            / (np.linalg.norm(v_units) * np.linalg.norm(direction) + 1e-6)
                         )
-
                         if cos_angle > 0.8:
                             register_event(
                                 {
                                     "type": "shot",
-                                    "t": float(frame_count * dt),
+                                    "time_s": float(frame_count * dt),
                                     "from_tid": int(owner_tid),
-                                    "to_tid": None,
                                     "team_id": int(shooter_team),
-                                    "extra": {"speed_kmh": float(speed_kmh)},
+                                    "speed_kmh": speed_kmh,
                                 },
                                 f"Shot by #{owner_tid} (Team {shooter_team}) – {speed_kmh:.1f} km/h",
                             )
@@ -864,11 +886,10 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                             register_event(
                                 {
                                     "type": "clearance",
-                                    "t": float(frame_count * dt),
+                                    "time_s": float(frame_count * dt),
                                     "from_tid": int(owner_tid),
-                                    "to_tid": None,
                                     "team_id": int(shooter_team),
-                                    "extra": {"speed_kmh": float(speed_kmh)},
+                                    "speed_kmh": speed_kmh,
                                 },
                                 f"Clearance by #{owner_tid} (Team {shooter_team})",
                             )
@@ -876,35 +897,66 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             prev_owner_tid = owner_tid
             prev_ball_pos_pitch = frame_ball_pos_pitch
 
-            # ========================================
-            # FRAME ANNOTATION (with speed & distance per player)
-            # ========================================
+            # ----------------- Annotate Frame -----------------
             annotated_frame = frame.copy()
 
-            # Build labels for players: id + team + avg speed + total distance
-            if len(players_detections) > 0:
-                player_labels = []
-                for tid, team_id in zip(players_detections.tracker_id, players_detections.class_id):
-                    tid_int = int(tid)
-                    stats = performance_tracker.get_player_stats(tid_int)
-                    avg_speed_ms = stats['avg_velocity'] / 100.0
-                    total_dist_m = stats['total_distance_meters']
-                    player_labels.append(
-                        f"#{tid_int} T{int(team_id)} {avg_speed_ms:4.2f} m/s {total_dist_m:.1f} m"
-                    )
+            # build labels: ID + team + speed + distance
+            labels = []
+            for i, tid in enumerate(all_dets_for_draw.tracker_id):
+                tid_int = int(tid)
+                team_id = int(all_dets_for_draw.class_id[i])
+                spd = 0.0
+                if 'current_speed_kmh' in locals():
+                    spd = current_speed_kmh.get(tid_int, 0.0)
+                dist = distance_covered_m.get(tid_int, 0.0)
+                if team_id in [0, 1]:
+                    labels.append(f"#{tid_int} T{team_id} {spd:4.1f} km/h {dist:.1f} m")
+                else:
+                    labels.append(f"#{tid_int}")
 
-                annotated_frame = ellipse_annotator.annotate(annotated_frame, players_detections)
-                annotated_frame = label_annotator.annotate(
-                    annotated_frame, players_detections, labels=player_labels
-                )
+            annotated_frame = ellipse_annotator.annotate(annotated_frame, all_dets_for_draw)
+            annotated_frame = label_annotator.annotate(annotated_frame, all_dets_for_draw, labels=labels)
+            annotated_frame = triangle_annotator.annotate(annotated_frame, ball_detections)
 
-            # Draw goalkeepers & referees as ellipses (without extra labels for now)
-            rest_dets = sv.Detections.merge([goalkeepers_detections, referees_detections])
-            if len(rest_dets) > 0:
-                annotated_frame = ellipse_annotator.annotate(annotated_frame, rest_dets)
+            # HUD: team possession percentages
+            total_poss_time = sum(possession_time_team_s.values()) + 1e-6
+            team0_pct = 100.0 * possession_time_team_s.get(0, 0.0) / total_poss_time
+            team1_pct = 100.0 * possession_time_team_s.get(1, 0.0) / total_poss_time
+            hud_text = f"Team 0 Possession: {team0_pct:5.1f}%   Team 1 Possession: {team1_pct:5.1f}%"
+
+            cv2.rectangle(
+                annotated_frame,
+                (20, annotated_frame.shape[0] - 60),
+                (annotated_frame.shape[1] - 20, annotated_frame.shape[0] - 20),
+                (255, 255, 255),
+                -1,
+            )
+            cv2.putText(
+                annotated_frame,
+                hud_text,
+                (30, annotated_frame.shape[0] - 30),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.8,
+                (0, 0, 0),
+                2,
+                cv2.LINE_AA,
+            )
 
-            # Draw ball
-            annotated_frame = triangle_annotator.annotate(annotated_frame, ball_detections)
+            # Top banner for recent event
+            if event_text_frames_left > 0 and current_event_text:
+                cv2.rectangle(annotated_frame, (20, 20), (annotated_frame.shape[1] - 20, 90),
+                              (255, 255, 255), -1)
+                cv2.putText(
+                    annotated_frame,
+                    current_event_text,
+                    (30, 70),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    1.0,
+                    (0, 0, 0),
+                    2,
+                    cv2.LINE_AA,
+                )
+                event_text_frames_left -= 1
 
             out.write(annotated_frame)
 
@@ -912,11 +964,11 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         out.release()
         print(f"✅ Processed {frame_count} frames")
 
-        # ========================================
-        # STEP 6: Clean Ball Path (Remove Outliers)
-        # ========================================
-        progress(0.6, desc="🧹 Cleaning ball trajectory (Step 4/7)...")
-        
+        # ===================================================
+        # STEP 4: Clean Ball Path
+        # ===================================================
+        progress(0.55, desc="🧹 Cleaning ball trajectory (Step 4/7)...")
+
         path_for_cleaning = []
         for coords in ball_path_raw:
             if len(coords) == 0:
@@ -925,72 +977,70 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 path_for_cleaning.append(np.empty((0, 2), dtype=np.float32))
             else:
                 path_for_cleaning.append(coords)
-        
+
         cleaned_path = replace_outliers_based_on_distance(
             [np.array(p).reshape(-1, 2) if len(p) > 0 else np.empty((0, 2)) for p in path_for_cleaning],
             MAX_DISTANCE_THRESHOLD
         )
-        
+
         print(f"✅ Ball path cleaned: {len([p for p in cleaned_path if len(p) > 0])} valid points")
 
-        # ========================================
-        # STEP 7: Generate Performance Analytics, Stats Table & Events
-        # ========================================
+        # ===================================================
+        # STEP 5: Performance Analytics
+        # ===================================================
         progress(0.7, desc="📊 Generating performance analytics (Step 5/7)...")
-        
-        # Team comparison charts
+
         comparison_fig = create_team_comparison_plot(performance_tracker)
-        
-        # Combined team heatmaps
+
         team_heatmaps_path = "/tmp/team_heatmaps.png"
         team_heatmaps = create_combined_heatmaps(performance_tracker)
         cv2.imwrite(team_heatmaps_path, team_heatmaps)
-        
+
         # Individual player heatmaps (top 6 by distance)
-        progress(0.8, desc="🗺️ Creating individual heatmaps...")
         teams = performance_tracker.get_all_players_by_team()
         top_players = []
-        
         for team_id in [0, 1]:
             if team_id in teams:
                 team_players = teams[team_id]
-                player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance']) 
-                                  for pid in team_players]
+                player_distances = [
+                    (pid, performance_tracker.get_player_stats(pid)['total_distance'])
+                    for pid in team_players
+                ]
                 player_distances.sort(key=lambda x: x[1], reverse=True)
                 top_players.extend([pid for pid, _ in player_distances[:3]])
-        
+
         individual_heatmaps = []
         for pid in top_players[:6]:
             heatmap = create_player_heatmap_visualization(performance_tracker, pid)
             individual_heatmaps.append(heatmap)
-        
-        # Arrange individual heatmaps in grid (3 columns)
+
         if len(individual_heatmaps) > 0:
             rows = []
             for i in range(0, len(individual_heatmaps), 3):
-                row_maps = individual_heatmaps[i:i+3]
+                row_maps = individual_heatmaps[i:i + 3]
                 if len(row_maps) == 3:
                     rows.append(np.hstack(row_maps))
                 elif len(row_maps) == 2:
                     rows.append(np.hstack([row_maps[0], row_maps[1]]))
                 else:
                     rows.append(row_maps[0])
-            
+
             individual_grid = np.vstack(rows) if len(rows) > 1 else rows[0]
             individual_heatmaps_path = "/tmp/individual_heatmaps.png"
             cv2.imwrite(individual_heatmaps_path, individual_grid)
         else:
             individual_heatmaps_path = None
 
-        # ========================================
-        # Game-Style Radar View
-        # ========================================
-        progress(0.85, desc="🗺️ Creating game-style radar view (Step 6/7)...")
+        # ===================================================
+        # STEP 6: Radar View
+        # ===================================================
+        progress(0.8, desc="🗺️ Creating game-style radar view (Step 6/7)...")
         radar_path = "/tmp/radar_view_enhanced.png"
         try:
             if last_pitch_players_xy is not None:
+                last_ball = cleaned_path[-1] if cleaned_path else np.empty((0, 2))
                 radar_frame = create_game_style_radar(
-                    pitch_ball_xy=cleaned_path[-1] if cleaned_path else np.empty((0, 2)),
+                    pitch_ball_xy=last_ball,
                     pitch_players_xy=last_pitch_players_xy,
                     players_class_id=last_players_class_id,
                     pitch_referees_xy=last_pitch_referees_xy if last_pitch_referees_xy is not None else np.empty((0, 2)),
@@ -1003,169 +1053,138 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             print(f"⚠️ Radar view creation failed: {e}")
             radar_path = None
 
-        # ========================================
-        # Build Player Stats Table (for coaches)
-        # ========================================
-        progress(0.9, desc="📋 Building player stats & event timeline (Step 7/7)...")
-
-        total_poss_time = sum(possession_time_team.values()) + 1e-6
-
-        # stats table headers:
-        # Player ID, Team, Distance (m), Avg Speed (m/s), Max Speed (m/s),
-        # Frames, Def 3rd, Mid 3rd, Att 3rd, Possession (s), Poss % Team, Poss % Game
-        stats_rows = []
-
-        for team_id in [0, 1]:
-            if team_id not in teams:
-                continue
-            team_players = teams[team_id]
-            team_poss_time = sum(possession_time_player[pid] for pid in team_players) + 1e-6
-            for pid in team_players:
-                stats = performance_tracker.get_player_stats(pid)
-                poss_s = float(possession_time_player[pid])
-                poss_pct_team = 100.0 * poss_s / team_poss_time
-                poss_pct_game = 100.0 * poss_s / total_poss_time
-
-                stats_rows.append([
-                    int(pid),
-                    int(team_id),
-                    float(stats['total_distance_meters']),
-                    float(stats['avg_velocity']) / 100.0,
-                    float(stats['max_velocity']) / 100.0,
-                    int(stats['frames_visible']),
-                    int(stats['time_in_defensive_third']),
-                    int(stats['time_in_middle_third']),
-                    int(stats['time_in_attacking_third']),
-                    poss_s,
-                    poss_pct_team,
-                    poss_pct_game
-                ])
-
-        # ========================================
-        # Build Event Timeline Table + JSON
-        # ========================================
-        events_sorted = sorted(events, key=lambda e: e.get("t", 0.0))
-        event_rows = []
-        for ev in events_sorted:
-            t = float(ev.get("t", 0.0))
-            ev_type = ev.get("type", "")
-            team_id = ev.get("team_id", None)
-            from_tid = ev.get("from_tid", None)
-            to_tid = ev.get("to_tid", None)
-            extra = ev.get("extra", {})
-
-            detail_str = ""
-            if ev_type == "pass":
-                if "distance_m" in extra:
-                    detail_str = f"distance={extra['distance_m']:.1f}m"
-            elif ev_type in ["shot", "clearance"]:
-                if "speed_kmh" in extra:
-                    detail_str = f"speed={extra['speed_kmh']:.1f}km/h"
-            elif ev_type in ["tackle", "interception"]:
-                if "ball_travel_m" in extra:
-                    detail_str = f"ball_travel={extra['ball_travel_m']:.1f}m"
-
-            event_rows.append([
-                t,
-                ev_type,
-                int(team_id) if team_id is not None else None,
-                int(from_tid) if from_tid is not None else None,
-                int(to_tid) if to_tid is not None else None,
-                detail_str
-            ])
-
-        # JSON file for events
-        events_serializable = []
-        for ev in events_sorted:
-            ev_out = {
-                "type": ev.get("type"),
-                "t": float(ev.get("t", 0.0)),
-                "from_tid": int(ev["from_tid"]) if ev.get("from_tid") is not None else None,
-                "to_tid": int(ev["to_tid"]) if ev.get("to_tid") is not None else None,
-                "team_id": int(ev["team_id"]) if ev.get("team_id") is not None else None,
-                "extra": {}
-            }
-            for k, v in ev.get("extra", {}).items():
-                try:
-                    ev_out["extra"][k] = float(v)
-                except Exception:
-                    ev_out["extra"][k] = v
-            events_serializable.append(ev_out)
-
-        events_json_path = "/tmp/events.json"
-        with open(events_json_path, "w", encoding="utf-8") as f:
-            json.dump(events_serializable, f, indent=2)
+        # ===================================================
+        # STEP 7: Summaries + Tables + Events JSON
+        # ===================================================
+        progress(0.9, desc="📝 Generating summary & tables (Step 7/7)...")
 
-        # ========================================
-        # Generate Summary Report
-        # ========================================
-        teams_dict = performance_tracker.get_all_players_by_team()
-        
+        # Summary text
         summary_lines = ["✅ **Analysis Complete!**\n"]
-        summary_lines.append(f"**Video Statistics:**")
+        summary_lines.append("**Video Statistics:**")
         summary_lines.append(f"- Total Frames Processed: {frame_count}")
         summary_lines.append(f"- Video Resolution: {width}x{height}")
         summary_lines.append(f"- Frame Rate: {fps:.2f} fps")
         summary_lines.append(f"- Ball Trajectory Points: {len([p for p in cleaned_path if len(p) > 0])}\n")
 
-        # Possession summary
-        team0_poss_pct = 100.0 * possession_time_team.get(0, 0.0) / total_poss_time
-        team1_poss_pct = 100.0 * possession_time_team.get(1, 0.0) / total_poss_time
-        summary_lines.append(f"**Ball Possession:**")
-        summary_lines.append(f"- Team 0 (Blue): {team0_poss_pct:.1f}%")
-        summary_lines.append(f"- Team 1 (Pink): {team1_poss_pct:.1f}%\n")
-        
+        teams = performance_tracker.get_all_players_by_team()
         for team_id in [0, 1]:
-            if team_id not in teams_dict:
+            if team_id not in teams:
                 continue
-            
+
             team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
             summary_lines.append(f"\n**{team_name}:**")
-            summary_lines.append(f"- Players Tracked: {len(teams_dict[team_id])}")
-            
-            total_dist = sum(performance_tracker.get_player_stats(pid)['total_distance_meters'] 
-                           for pid in teams_dict[team_id])
-            avg_dist = total_dist / len(teams_dict[team_id]) if len(teams_dict[team_id]) > 0 else 0
+            summary_lines.append(f"- Players Tracked: {len(teams[team_id])}")
+
+            total_dist = sum(performance_tracker.get_player_stats(pid)['total_distance_meters']
+                             for pid in teams[team_id])
+            avg_dist = total_dist / len(teams[team_id]) if len(teams[team_id]) > 0 else 0
             summary_lines.append(f"- Team Total Distance: {total_dist:.1f}m")
             summary_lines.append(f"- Average Distance per Player: {avg_dist:.1f}m")
-            
+
             # Top 3 performers
-            player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters']) 
-                              for pid in teams_dict[team_id]]
+            player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters'])
+                                for pid in teams[team_id]]
             player_distances.sort(key=lambda x: x[1], reverse=True)
-            
+
             summary_lines.append(f"\n  **Top 3 Performers:**")
             for i, (pid, dist) in enumerate(player_distances[:3], 1):
                 stats = performance_tracker.get_player_stats(pid)
                 summary_lines.append(
                     f"  {i}. Player #{pid}: {dist:.1f}m, "
-                    f"Avg: {stats['avg_velocity']/100:.2f}m/s, "
-                    f"Max: {stats['max_velocity']/100:.2f}m/s"
+                    f"Avg Speed (rel): {stats['avg_velocity']:.2f}, "
+                    f"Max Speed (rel): {stats['max_velocity']:.2f}"
                 )
-        
+
+        # Possession summary
+        total_poss = sum(possession_time_team_s.values()) + 1e-6
+        poss_summary = []
+        for team_id in sorted(possession_time_team_s.keys()):
+            pct = 100.0 * possession_time_team_s[team_id] / total_poss
+            poss_summary.append(f"- Team {team_id} Possession: {pct:.1f}% ({possession_time_team_s[team_id]:.1f}s)")
+        if poss_summary:
+            summary_lines.append("\n**Team Possession:**")
+            summary_lines.extend(poss_summary)
+
         summary_lines.append("\n**Pipeline Steps Completed:**")
         summary_lines.append("✅ 1. Player crop collection")
         summary_lines.append("✅ 2. Team classifier training")
-        summary_lines.append("✅ 3. Video processing with tracking & events")
+        summary_lines.append("✅ 3. Video processing with tracking + events")
         summary_lines.append("✅ 4. Ball trajectory cleaning")
         summary_lines.append("✅ 5. Performance analytics generation")
         summary_lines.append("✅ 6. Visualization creation")
-        summary_lines.append("✅ 7. Stats & event export")
-        
+        summary_lines.append("✅ 7. Event & possession stats")
         summary_msg = "\n".join(summary_lines)
 
+        # Player stats table (for DataFrame)
+        player_stats_rows = []
+        all_player_ids = sorted(performance_tracker.player_positions.keys())
+        for tid in all_player_ids:
+            stats = performance_tracker.get_player_stats(tid)
+            row = {
+                "player_id": int(tid),
+                "team_id": int(stats["team_id"]),
+                "distance_m": float(stats["total_distance_meters"]),
+                "avg_speed_rel": float(stats["avg_velocity"]),
+                "max_speed_rel": float(stats["max_velocity"]),
+                "frames_visible": int(stats["frames_visible"]),
+                "time_def_third": int(stats["time_in_defensive_third"]),
+                "time_mid_third": int(stats["time_in_middle_third"]),
+                "time_att_third": int(stats["time_in_attacking_third"]),
+                "possession_time_s": float(possession_time_player_s.get(tid, 0.0)),
+            }
+            player_stats_rows.append(row)
+
+        # Event timeline (text)
+        events_sorted = sorted(events, key=lambda e: e.get("time_s", 0.0))
+        timeline_lines = []
+        for ev in events_sorted:
+            t = ev.get("time_s", 0.0)
+            ev_type = ev.get("type", "event")
+            if ev_type == "pass":
+                timeline_lines.append(
+                    f"[{t:6.2f}s] PASS  - Team {ev.get('team_id')} #{ev.get('from_tid')} → #{ev.get('to_tid')} "
+                    f"({ev.get('distance_m', 0.0):.1f}m)"
+                )
+            elif ev_type in ["tackle", "interception"]:
+                timeline_lines.append(
+                    f"[{t:6.2f}s] {ev_type.upper():9} - #{ev.get('to_tid')} from #{ev.get('from_tid')}"
+                )
+            elif ev_type == "shot":
+                timeline_lines.append(
+                    f"[{t:6.2f}s] SHOT  - Team {ev.get('team_id')} #{ev.get('from_tid')} "
+                    f"({ev.get('speed_kmh', 0.0):.1f} km/h)"
+                )
+            elif ev_type == "clearance":
+                timeline_lines.append(
+                    f"[{t:6.2f}s] CLEAR - Team {ev.get('team_id')} #{ev.get('from_tid')} "
+                    f"({ev.get('speed_kmh', 0.0):.1f} km/h)"
+                )
+            elif ev_type == "possession_change":
+                timeline_lines.append(
+                    f"[{t:6.2f}s] POSS  - {ev.get('from_tid')} → {ev.get('to_tid')} "
+                    f"(Team {ev.get('team_id')})"
+                )
+            else:
+                timeline_lines.append(f"[{t:6.2f}s] {ev_type.upper()}")
+        events_timeline_text = "\n".join(timeline_lines) if timeline_lines else "No events detected."
+
+        # Events JSON file
+        events_json_path = "/tmp/events.json"
+        with open(events_json_path, "w", encoding="utf-8") as f:
+            json.dump(events_sorted, f, indent=2)
+
         progress(1.0, desc="✅ Analysis Complete!")
 
         return (
-            output_path,          # video_output
-            comparison_fig,       # comparison_output
-            team_heatmaps_path,   # team_heatmaps_output
-            individual_heatmaps_path,  # individual_heatmaps_output
-            radar_path,           # radar_output
-            summary_msg,          # status_output
-            stats_rows,           # stats_table_output
-            event_rows,           # events_table_output
-            events_json_path      # events_json_output
+            output_path,            # video
+            comparison_fig,         # plot
+            team_heatmaps_path,     # image
+            individual_heatmaps_path,
+            radar_path,
+            summary_msg,            # text summary
+            player_stats_rows,      # DataFrame
+            events_timeline_text,   # text
+            events_json_path        # downloadable JSON
         )
 
     except Exception as e:
@@ -1173,82 +1192,76 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         print(error_msg)
         import traceback
         traceback.print_exc()
-        return (
-            None, None, None, None, None,
-            error_msg,
-            None, None, None
-        )
+        return (None, None, None, None, None, error_msg, None, None, None)
 
 
 # ==============================================
-# GRADIO INTERFACE (with new stats & events)
+# GRADIO INTERFACE
 # ==============================================
 with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
     # ⚽ Advanced Football Video Analyzer
-    ### Complete Pipeline Implementation
-    
-    This application:
-    1. **Detects players & ball** using Roboflow
-    2. **Classifies teams** using SigLIP embeddings  
-    3. **Tracks players** with ByteTrack and stable IDs
-    4. **Transforms field view** and tracks ball trajectory
-    5. **Computes events & possession** (passes, tackles, shots, clearances)
-    6. **Generates heatmaps & stats** per player and per team
-    7. **Exports event JSON** for further analysis
-    
-    Upload a football match video to get comprehensive performance analytics!
+    ### End-to-end Tactical & Performance Analysis
+
+    This app performs:
+    1. **Player Detection & Tracking** (Roboflow + ByteTrack)
+    2. **Team Classification** (SigLIP-based)
+    3. **Pitch Projection** (homography)
+    4. **Speed & Distance** per player (overlay on video)
+    5. **Ball Trajectory** with outlier removal
+    6. **Performance Analytics** (heatmaps, distance, zones)
+    7. **Events & Possession** (passes, tackles, shots, clearances, possession changes)
     """)
-    
+
     with gr.Row():
         video_input = gr.Video(label="📤 Upload Football Video")
-    
-    analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary", size="lg")
-    
+
+    analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary")
+
     with gr.Row():
         status_output = gr.Textbox(label="📊 Analysis Summary & Statistics", lines=25)
-    
+
     with gr.Tabs():
         with gr.Tab("📹 Annotated Video"):
-            gr.Markdown("### Full video with player tracking, team colors, and ball detection + speed & distance overlays")
+            gr.Markdown("### Full video with player IDs, team colors, speed & distance, and event banners")
             video_output = gr.Video(label="Processed Video")
-        
+
         with gr.Tab("📊 Performance Comparison"):
             gr.Markdown("### Interactive charts comparing player performance metrics")
             comparison_output = gr.Plot(label="Team Performance Metrics")
-        
+
         with gr.Tab("🗺️ Team Heatmaps"):
             gr.Markdown("### Combined activity heatmaps showing team positioning")
             team_heatmaps_output = gr.Image(label="Team Activity Heatmaps")
-        
+
         with gr.Tab("👤 Individual Heatmaps"):
             gr.Markdown("### Top 6 players with detailed activity analysis")
             individual_heatmaps_output = gr.Image(label="Top Players Heatmaps")
-        
+
         with gr.Tab("🎮 Game Radar View"):
-            gr.Markdown("### Game-style tactical view with ball trail")
+            gr.Markdown("### Game-style tactical radar view with ball trail")
             radar_output = gr.Image(label="Tactical Radar View")
 
-        with gr.Tab("📋 Player Stats & Events"):
-            gr.Markdown("### Detailed per-player stats and full event timeline")
-            stats_table_output = gr.Dataframe(
-                headers=[
-                    "Player ID", "Team",
-                    "Distance (m)", "Avg Speed (m/s)", "Max Speed (m/s)",
-                    "Frames", "Def 1/3", "Mid 1/3", "Att 1/3",
-                    "Possession (s)", "Poss % Team", "Poss % Game"
-                ],
-                row_count=(0, "dynamic"),
-                label="Per-player Stats"
-            )
-            events_table_output = gr.Dataframe(
+        with gr.Tab("📋 Player Stats Table"):
+            gr.Markdown("### Per-player stats (distance, speed, zones, possession time)")
+            player_stats_output = gr.Dataframe(
                 headers=[
-                    "Time (s)", "Type", "Team", "From Player", "To Player", "Details"
+                    "player_id", "team_id", "distance_m", "avg_speed_rel", "max_speed_rel",
+                    "frames_visible", "time_def_third", "time_mid_third", "time_att_third",
+                    "possession_time_s"
                 ],
-                row_count=(0, "dynamic"),
-                label="Event Timeline"
+                datatype=["number", "number", "number", "number", "number",
+                          "number", "number", "number", "number", "number"],
+                label="Player Stats"
             )
-            events_json_output = gr.File(label="Download Events JSON")
+
+        with gr.Tab("📜 Event Timeline"):
+            gr.Markdown("### Detected events: passes, tackles, interceptions, shots, clearances, possession changes")
+            events_timeline_output = gr.Textbox(label="Event Timeline", lines=30)
+
+        with gr.Tab("⬇️ Events JSON"):
+            gr.Markdown("### Download full raw event data as JSON")
+            events_json_output = gr.File(label="Events JSON")
 
     analyze_btn.click(
         fn=analyze_football_video,
@@ -1260,50 +1273,12 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             individual_heatmaps_output,
             radar_output,
             status_output,
-            stats_table_output,
-            events_table_output,
-            events_json_output
+            player_stats_output,
+            events_timeline_output,
+            events_json_output,
         ]
     )
-    
-    gr.Markdown("""
-    ---
-    ### 🔧 Technical Details:
-    
-    **Detection Models:**
-    - Player/Ball/Referee Detection: `football-players-detection-3zvbc/11`
-    - Field Keypoint Detection: `football-field-detection-f07vi/14`
-    
-    **Tracking & Classification:**
-    - ByteTrack for persistent player IDs (60-frame buffer)
-    - SigLIP embeddings for team classification
-    - Majority voting for stable team assignments
-    
-    **Performance Metrics:**
-    - Distance covered (meters)
-    - Average & maximum speed (m/s)
-    - Zone activity (defensive/middle/attacking thirds)
-    - Position heatmaps with Gaussian smoothing
-    - Possession time per player and per team
-    
-    **Events & Decisions:**
-    - Passes (distance-based)
-    - Tackles & interceptions (possession changes between teams)
-    - Shots vs clearances (ball speed + direction toward goal)
-    - Full timeline export as JSON for downstream analysis
-    
-    **Ball Tracking:**
-    - Field homography transformation
-    - Outlier removal (500cm threshold)
-    - Transformation matrix smoothing (5-frame window)
-    
-    ### 📈 Output Files:
-    - Annotated video: `/tmp/annotated_football.mp4`
-    - Team heatmaps: `/tmp/team_heatmaps.png`
-    - Individual heatmaps: `/tmp/individual_heatmaps.png`
-    - Radar view: `/tmp/radar_view_enhanced.png`
-    - Event log: `/tmp/events.json`
-    """)
 
 if __name__ == "__main__":
-    iface.launch(share=True)
+    # On Spaces, just iface.launch()
+    iface.launch()