Update app.py

app.py

@@ -40,6 +40,9 @@ if not HF_TOKEN or not ROBOFLOW_API_KEY:
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🖥️ Using device: {DEVICE}")
 
+# Distance units: pitch coordinates are effectively in centimeters
+CM_PER_METER = 100.0
+
 # ==============================================
 # ROBOFLOW INFERENCE CLIENT
 # ==============================================
@@ -65,10 +68,7 @@ def infer_with_confidence(model_id: str, frame: np.ndarray, confidence_threshold
 # 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)
 
 # ==============================================
@@ -76,6 +76,7 @@ EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF
 # ==============================================
 CONFIG = SoccerPitchConfiguration()
 
+
 # ==============================================
 # BALL PATH OUTLIER REMOVAL
 # ==============================================
@@ -83,7 +84,7 @@ def replace_outliers_based_on_distance(
     positions: List[np.ndarray],
     distance_threshold: float
 ) -> List[np.ndarray]:
-    """Remove outlier positions based on distance threshold (in pitch units)."""
+    """Remove outlier positions based on distance threshold (in same units as positions)"""
     last_valid_position: Union[np.ndarray, None] = None
     cleaned_positions: List[np.ndarray] = []
 
@@ -113,62 +114,82 @@ class PlayerPerformanceTracker:
 
     def __init__(self, pitch_config):
         self.config = pitch_config
-        self.player_positions = defaultdict(list)
-        self.player_velocities = defaultdict(list)
-        self.player_distances = defaultdict(float)
+        self.player_positions = defaultdict(list)  # (x_cm, y_cm, frame)
+        self.player_velocities = defaultdict(list)  # cm/s
+        self.player_distances_cm = defaultdict(float)
         self.player_team = {}
         self.player_stats = defaultdict(lambda: {
             'frames_visible': 0,
-            'avg_velocity': 0,
-            'max_velocity': 0,
-            'time_in_attacking_third': 0,
-            'time_in_defensive_third': 0,
-            'time_in_middle_third': 0
+            'avg_velocity_cm_s': 0.0,
+            'max_velocity_cm_s': 0.0,
+            'time_in_attacking_third_frames': 0,
+            'time_in_defensive_third_frames': 0,
+            'time_in_middle_third_frames': 0
         })
 
-    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:
+    def update(self, tracker_id: int, position_cm: np.ndarray, team_id: int, frame: int, fps: float):
+        """Update player position and calculate metrics (position in pitch units, treated as cm)."""
+        if len(position_cm) != 2:
             return
 
         self.player_team[tracker_id] = team_id
-        self.player_positions[tracker_id].append((position[0], position[1], frame))
+        self.player_positions[tracker_id].append((position_cm[0], position_cm[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
-
-            # 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
-        elif position[0] < 2 * pitch_length / 3:
-            self.player_stats[tracker_id]['time_in_middle_third'] += 1
+            curr_pos = np.array(position_cm)
+            distance_cm = np.linalg.norm(curr_pos - prev_pos)
+            self.player_distances_cm[tracker_id] += distance_cm
+
+            dt = 1.0 / fps
+            velocity_cm_s = distance_cm / dt
+            self.player_velocities[tracker_id].append(velocity_cm_s)
+
+            if velocity_cm_s > self.player_stats[tracker_id]['max_velocity_cm_s']:
+                self.player_stats[tracker_id]['max_velocity_cm_s'] = velocity_cm_s
+
+        pitch_length_cm = self.config.length  # same units as transform
+        x = position_cm[0]
+        if x < pitch_length_cm / 3:
+            self.player_stats[tracker_id]['time_in_defensive_third_frames'] += 1
+        elif x < 2 * pitch_length_cm / 3:
+            self.player_stats[tracker_id]['time_in_middle_third_frames'] += 1
         else:
-            self.player_stats[tracker_id]['time_in_attacking_third'] += 1
+            self.player_stats[tracker_id]['time_in_attacking_third_frames'] += 1
 
-    def get_player_stats(self, tracker_id: int) -> dict:
-        """Get comprehensive stats for a player"""
+    def get_player_stats(self, tracker_id: int, fps: float) -> dict:
+        """Get comprehensive stats for a player (distances in m, speed in m/s and km/h)."""
         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]))
+            stats['avg_velocity_cm_s'] = 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'] = float(self.player_distances[tracker_id] / 100.0)
+        # convert distances from cm to m
+        total_distance_m = self.player_distances_cm[tracker_id] / CM_PER_METER
+
+        stats['total_distance_m'] = total_distance_m
         stats['team_id'] = self.player_team.get(tracker_id, -1)
 
+        # frames in zones -> seconds
+        stats['time_in_defensive_third_s'] = (
+            stats['time_in_defensive_third_frames'] / fps
+        )
+        stats['time_in_middle_third_s'] = (
+            stats['time_in_middle_third_frames'] / fps
+        )
+        stats['time_in_attacking_third_s'] = (
+            stats['time_in_attacking_third_frames'] / fps
+        )
+
+        # convert cm/s -> m/s and km/h
+        avg_v_m_s = stats['avg_velocity_cm_s'] / CM_PER_METER
+        max_v_m_s = stats['max_velocity_cm_s'] / CM_PER_METER
+        stats['avg_speed_m_s'] = avg_v_m_s
+        stats['max_speed_m_s'] = max_v_m_s
+        stats['avg_speed_km_h'] = avg_v_m_s * 3.6
+        stats['max_speed_km_h'] = max_v_m_s * 3.6
+
         return stats
 
     def generate_heatmap(self, tracker_id: int, resolution: int = 100) -> np.ndarray:
@@ -224,7 +245,7 @@ class PlayerTrackingManager:
 
         history = self.tracker_team_history[tracker_id]
         team_counts = np.bincount(history)
-        stable_team = int(np.argmax(team_counts))
+        stable_team = np.argmax(team_counts)
         return stable_team
 
     def get_player_count_by_team(self) -> Dict[int, int]:
@@ -232,7 +253,9 @@ class PlayerTrackingManager:
         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])
+                stable_team = self.get_stable_team_id(
+                    tracker_id, self.tracker_team_history[tracker_id][-1]
+                )
                 team_counts[stable_team] += 1
         return team_counts
 
@@ -245,7 +268,8 @@ class PlayerTrackingManager:
 # VISUALIZATION FUNCTIONS
 # ==============================================
 def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker,
-                                       tracker_id: int) -> np.ndarray:
+                                        tracker_id: int,
+                                        fps: float) -> np.ndarray:
     """Create a single player heatmap overlay on pitch"""
     pitch = draw_pitch(CONFIG)
     heatmap = performance_tracker.generate_heatmap(tracker_id, resolution=150)
@@ -255,42 +279,50 @@ def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTr
 
     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)
+    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
 
     result = cv2.addWeighted(pitch, 0.6, overlay, 0.4, 0)
 
-    stats = performance_tracker.get_player_stats(tracker_id)
+    stats = performance_tracker.get_player_stats(tracker_id, fps)
     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 (rel): {stats['avg_velocity']:.2f}",
-        f"Max Speed (rel): {stats['max_velocity']:.2f}",
+        f"Distance: {stats['total_distance_m']:.1f} m",
+        f"Avg Speed: {stats['avg_speed_km_h']:.2f} km/h",
+        f"Max Speed: {stats['max_speed_km_h']:.2f} km/h",
         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:
+def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker,
+                                fps: float) -> 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 (m)', 'Avg Speed (rel)', 'Max Speed (rel)', 'Activity in Attacking Third'),
+        subplot_titles=('Distance Covered', 'Average Speed', 'Max Speed', 'Activity by Zone'),
         specs=[[{'type': 'bar'}, {'type': 'bar'}],
                [{'type': 'bar'}, {'type': 'bar'}]]
     )
@@ -308,11 +340,11 @@ def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -
         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'])
-            max_speeds.append(stats['max_velocity'])
-            attacking_time.append(stats['time_in_attacking_third'])
+            stats = performance_tracker.get_player_stats(pid, fps)
+            distances.append(stats['total_distance_m'])
+            avg_speeds.append(stats['avg_speed_km_h'])
+            max_speeds.append(stats['max_speed_km_h'])
+            attacking_time.append(stats['time_in_attacking_third_s'])
 
         player_labels = [f"#{pid}" for pid in player_ids]
 
@@ -346,16 +378,17 @@ def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -
     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 (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_yaxes(title_text="Speed (km/h)", row=1, col=2)
+    fig.update_yaxes(title_text="Speed (km/h)", row=2, col=1)
+    fig.update_yaxes(title_text="Time in attacking third (s)", 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:
+def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker,
+                             fps: float) -> np.ndarray:
     """Create side-by-side team heatmaps"""
     teams = performance_tracker.get_all_players_by_team()
 
@@ -376,20 +409,23 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> n
         padding = 50
         pitch_height, pitch_width = pitch.shape[:2]
         heatmap_resized = cv2.resize(
-            combined_heatmap,
-            (pitch_width - 2 * padding, pitch_height - 2 * padding)
+            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)
+        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
         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)
 
@@ -478,30 +514,41 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
 # ==============================================
 # MAIN ANALYSIS PIPELINE
 # ==============================================
-def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
+def analyze_football_video(video_path: str, progress=gr.Progress()
+                           ) -> Tuple[
+                               Optional[str],
+                               Optional[go.Figure],
+                               Optional[str],
+                               Optional[str],
+                               Optional[str],
+                               str,
+                               List[List[float]],
+                               str,
+                               Optional[str]
+                           ]:
     """
     Complete football analysis pipeline:
-      - Player detection & tracking
-      - Team classification
-      - Homography to pitch coordinates
-      - Player speed & distance overlays
-      - Ball path cleaning
-      - Heatmaps & comparisons
-      - Event + possession stats
+      * team classification
+      * tracking + speeds/distances
+      * possession per team & per player
+      * events: passes, tackles, interceptions, shots, clearances, possession changes
+      * heatmaps + radar
     """
     if not video_path:
-        return (None,) * 9
+        return (None, None, None, None, None,
+                "❌ Please upload a video file.",
+                [], "No events detected.", None)
 
     try:
         progress(0, desc="🔧 Initializing...")
 
         # IDs from Roboflow model
         BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
-        STRIDE = 30  # Frame sampling for training
-        MAXLEN = 5   # Transformation matrix smoothing
-        MAX_DISTANCE_THRESHOLD = 500  # Ball path outlier threshold
+        STRIDE = 30
+        MAXLEN = 5
+        MAX_DISTANCE_THRESHOLD = 500.0  # in 'cm' units of pitch
 
-        # Initialize managers
+        # Managers
         tracking_manager = PlayerTrackingManager(max_history=10)
         performance_tracker = PlayerPerformanceTracker(CONFIG)
 
@@ -522,7 +569,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             height=17
         )
 
-        # ByteTrack tracker with optimized settings
+        # Tracker
         tracker = sv.ByteTrack(
             track_activation_threshold=0.4,
             lost_track_buffer=60,
@@ -531,171 +578,165 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         )
         tracker.reset()
 
-        # 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}",
+                    [], "No events detected.", 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) or 30.0
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        if fps <= 0:
+            fps = 25.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
-        # ===================================================
+        # -----------------------------------
+        # STEP 1: Train team classifier
+        # -----------------------------------
         progress(0.05, desc="🏃 Collecting player samples (Step 1/7)...")
         player_crops = []
-        frame_count = 0
-
-        while frame_count < min(total_frames, 300):
+        frame_idx = 0
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        while frame_idx < min(total_frames, 300):
             ret, frame = cap.read()
             if not ret:
                 break
-
-            if frame_count % STRIDE == 0:
+            if frame_idx % STRIDE == 0:
                 _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
                 detections = detections.with_nms(threshold=0.5, class_agnostic=True)
                 players_detections = detections[detections.class_id == PLAYER_ID]
-
                 if len(players_detections.xyxy) > 0:
                     crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
                     player_crops.extend(crops)
-
-            frame_count += 1
+            frame_idx += 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.",
+                    [], "No events detected.", 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
-        # ===================================================
+        # -----------------------------------
+        # STEP 2: Full video processing + events
+        # -----------------------------------
         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-        frame_count = 0
-        M = deque(maxlen=MAXLEN)  # Transformation matrix smoothing
+        frame_idx = 0
+        M = deque(maxlen=MAXLEN)
         ball_path_raw: List[np.ndarray] = []
 
-        # For radar
+        # 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
+        # stats for events / possession
+        dt = 1.0 / fps
+        distance_covered_per_player_m = defaultdict(float)  # using correct meters
+        possession_time_player_s = defaultdict(float)
+        possession_time_team_s = defaultdict(float)
         team_of_player: Dict[int, int] = {}
         events: List[Dict[str, Any]] = []
 
-        last_pitch_pos: Dict[int, np.ndarray] = {}
+        # event HUD
+        current_event_text = ""
+        event_frames_left = 0
+        EVENT_TEXT_DURATION_FRAMES = int(2.0 * fps)
+
         prev_owner_tid: Optional[int] = None
-        prev_ball_pos_pitch: Optional[np.ndarray] = None
+        prev_ball_pos_pitch_cm: Optional[np.ndarray] = None
 
-        # simple goal centers in pitch coordinates
+        # approximate goal centers in pitch coords (same units)
         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)
+        # thresholds in cm units
+        POSSESSION_RADIUS_M = 5.0
+        POSSESSION_RADIUS_CM = POSSESSION_RADIUS_M * CM_PER_METER
+        MIN_PASS_TRAVEL_M = 3.0
+        MIN_PASS_TRAVEL_CM = MIN_PASS_TRAVEL_M * CM_PER_METER
+        HIGH_SHOT_SPEED_KM_H = 18.0
 
         def register_event(ev: Dict[str, Any], text: str):
-            nonlocal current_event_text, event_text_frames_left
+            nonlocal current_event_text, event_frames_left
             events.append(ev)
             if text:
                 current_event_text = text
-                event_text_frames_left = EVENT_TEXT_DURATION_FRAMES
+                event_frames_left = EVENT_TEXT_DURATION_FRAMES
 
-        progress(0.2, desc="🎬 Processing video frames (Step 3/7)...")
+        progress(0.20, desc="🎬 Processing video frames (Step 3/7)...")
 
         while True:
             ret, frame = cap.read()
             if not ret:
                 break
-
-            frame_count += 1
+            frame_idx += 1
             tracking_manager.reset_frame()
 
-            if frame_count % 30 == 0:
-                progress(0.2 + 0.3 * (frame_count / max(total_frames, 1)),
-                         desc=f"🎬 Processing frame {frame_count}/{total_frames}")
+            if frame_idx % 30 == 0:
+                progress(0.20 + 0.30 * (frame_idx / max(total_frames, 1)),
+                         desc=f"🎬 Processing frame {frame_idx}/{total_frames}")
 
-            # ----------------- Detection & Tracking -----------------
+            # --- detections ---
             _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
-
             if len(detections.xyxy) == 0:
                 out.write(frame)
                 ball_path_raw.append(np.empty((0, 2)))
                 continue
 
-            # 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
             all_detections = tracker.update_with_detections(detections=all_detections)
 
-            # 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 classification -----------------
+            # --- team prediction + stabilisation ---
             if len(players_detections.xyxy) > 0:
                 crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
                 predicted_teams = team_classifier.predict(crops)
-
                 for idx, tracker_id in enumerate(players_detections.tracker_id):
-                    tracking_manager.update_team_assignment(int(tracker_id), int(predicted_teams[idx]))
+                    tracking_manager.update_team_assignment(tracker_id, predicted_teams[idx])
                     predicted_teams[idx] = tracking_manager.get_stable_team_id(
-                        int(tracker_id), int(predicted_teams[idx])
+                        tracker_id, predicted_teams[idx]
                     )
-
                 players_detections.class_id = predicted_teams
 
-            # assign GK teams
-            goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
-                players_detections, goalkeepers_detections
-            )
+            # goalkeeper teams
+            if len(goalkeepers_detections) > 0 and len(players_detections) > 0:
+                goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
+                    players_detections, goalkeepers_detections
+                )
 
-            # referees class shift
+            # adjust referee class_id
             referees_detections.class_id -= 1
 
-            # merge for drawing
-            all_dets_for_draw = sv.Detections.merge([
-                players_detections, goalkeepers_detections, referees_detections
-            ])
-            all_dets_for_draw.class_id = all_dets_for_draw.class_id.astype(int)
-
-            # ----------------- Field homography & pitch coords -----------------
-            frame_ball_pos_pitch = None
-            frame_players_xy_pitch = None
+            # merged for drawing
+            merged_dets = sv.Detections.merge(
+                [players_detections, goalkeepers_detections, referees_detections]
+            )
+            merged_dets.class_id = merged_dets.class_id.astype(int)
 
+            # --- field homography ---
             try:
                 result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 0.3)
                 key_points = sv.KeyPoints.from_inference(result_field)
@@ -704,225 +745,243 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 frame_ref_pts = key_points.xy[0][filter_mask]
                 pitch_ref_pts = np.array(CONFIG.vertices)[filter_mask]
 
+                frame_ball_pos_pitch_cm = None
+                frame_players_xy_pitch_cm = None
+
                 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)
 
-                    # ball
+                    # ball position in pitch coords (cm)
                     frame_ball_xy = ball_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
                     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]
+                        frame_ball_pos_pitch_cm = pitch_ball_xy[0]
 
-                    # players + gk
+                    # all players (incl. keepers)
                     all_players = sv.Detections.merge([players_detections, goalkeepers_detections])
-                    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])
-                            pos_pitch = pitch_players_xy[idx]
-
-                            # performance tracker (for heatmaps, zone time, etc.)
-                            performance_tracker.update(
-                                tid,
-                                pos_pitch,
-                                team_id,
-                                frame_count,
-                                fps
-                            )
+                    players_xy = all_players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    pitch_players_xy = transformer.transform_points(players_xy)
+
+                    # referees
+                    referees_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    pitch_referees_xy = transformer.transform_points(referees_xy)
+
+                    last_pitch_players_xy = pitch_players_xy
+                    last_players_class_id = all_players.class_id
+                    last_pitch_referees_xy = pitch_referees_xy
+
+                    frame_players_xy_pitch_cm = pitch_players_xy
+
+                    # update performance tracker + distance/speed stats
+                    for idx, tracker_id in enumerate(all_players.tracker_id):
+                        tid_int = int(tracker_id)
+                        team_id = int(all_players.class_id[idx])
+                        pos_cm = pitch_players_xy[idx]
+                        performance_tracker.update(
+                            tid_int, pos_cm, team_id, frame_idx, 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))
+                        # distance & speed (m) for HUD + per-player
+                        prev_pos_cm = performance_tracker.player_positions[tid_int][-2][:2] \
+                            if len(performance_tracker.player_positions[tid_int]) > 1 else None
+                        if prev_pos_cm is not None:
+                            prev_pos_cm = np.array(prev_pos_cm)
+                            dist_cm = float(np.linalg.norm(pos_cm - prev_pos_cm))
+                            dist_m = dist_cm / CM_PER_METER
+                            distance_covered_per_player_m[tid_int] += dist_m
+
+                        team_of_player[tid_int] = team_id
                 else:
                     ball_path_raw.append(np.empty((0, 2)))
-                    pitch_referees_xy = np.empty((0, 2))
-                    current_speed_kmh = {}
+                    frame_ball_pos_pitch_cm = None
+                    frame_players_xy_pitch_cm = None
             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
+                frame_ball_pos_pitch_cm = None
+                frame_players_xy_pitch_cm = None
 
-            # ----------------- Possession & Events -----------------
+            # --- possession owner ---
             owner_tid: Optional[int] = None
-            POSSESSION_RADIUS_M = 5.0
-
-            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:
-                    owner_tid = int(players_detections.tracker_id[j])
+            if frame_ball_pos_pitch_cm is not None and frame_players_xy_pitch_cm is not None:
+                dists_cm = np.linalg.norm(
+                    frame_players_xy_pitch_cm - frame_ball_pos_pitch_cm, axis=1
+                )
+                j = int(np.argmin(dists_cm))
+                if dists_cm[j] < POSSESSION_RADIUS_CM:
+                    owner_tid = int(all_players.tracker_id[j])
 
+            # accumulate possession time
             if owner_tid is not None:
                 possession_time_player_s[owner_tid] += dt
                 owner_team = team_of_player.get(owner_tid)
                 if owner_team is not None:
                     possession_time_team_s[owner_team] += dt
 
-            # detect passes / tackles / interceptions
+            # --- events (pass, tackle, interception, shot, clearance, possession change) ---
+            t_s = frame_idx * dt
+
             if owner_tid != prev_owner_tid:
-                if owner_tid is not None and prev_owner_tid is not None:
+                if owner_tid is not None and prev_owner_tid is not None \
+                        and frame_ball_pos_pitch_cm is not None and prev_ball_pos_pitch_cm is not None:
+                    # ball travel
+                    travel_cm = float(
+                        np.linalg.norm(frame_ball_pos_pitch_cm - prev_ball_pos_pitch_cm)
+                    )
                     prev_team = team_of_player.get(prev_owner_tid)
                     cur_team = team_of_player.get(owner_tid)
 
-                    travel_m = 0.0
-                    if prev_ball_pos_pitch is not None and frame_ball_pos_pitch is not None:
-                        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
-
                     if prev_team is not None and cur_team is not None:
-                        if prev_team == cur_team and travel_m > MIN_PASS_TRAVEL_M:
+                        if prev_team == cur_team and travel_cm > MIN_PASS_TRAVEL_CM:
                             # pass
+                            dist_m = travel_cm / CM_PER_METER
                             register_event(
                                 {
                                     "type": "pass",
-                                    "time_s": float(frame_count * dt),
-                                    "from_tid": int(prev_owner_tid),
-                                    "to_tid": int(owner_tid),
+                                    "time_s": t_s,
+                                    "frame_idx": frame_idx,
+                                    "from_player_id": int(prev_owner_tid),
+                                    "to_player_id": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "distance_m": travel_m,
+                                    "distance_m": dist_m,
                                 },
-                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team})",
+                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team}, {dist_m:.1f} m)"
                             )
                         elif prev_team != cur_team:
-                            # tackle vs interception
-                            d_pp = 999.0
-                            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"
+                            # tackle vs interception based on player distance
+                            d_pp_m = None
+                            if frame_players_xy_pitch_cm is not None:
+                                pos_prev = performance_tracker.player_positions[int(prev_owner_tid)][-1][:2] \
+                                    if performance_tracker.player_positions[int(prev_owner_tid)] else None
+                                pos_cur = performance_tracker.player_positions[int(owner_tid)][-1][:2] \
+                                    if performance_tracker.player_positions[int(owner_tid)] else None
+                                if pos_prev is not None and pos_cur is not None:
+                                    pos_prev = np.array(pos_prev)
+                                    pos_cur = np.array(pos_cur)
+                                    d_pp_cm = float(np.linalg.norm(pos_prev - pos_cur))
+                                    d_pp_m = d_pp_cm / CM_PER_METER
+
+                            ev_type = "tackle"
+                            label = "Tackle"
+                            if d_pp_m is not None and d_pp_m > 3.0:
+                                ev_type = "interception"
+                                label = "Interception"
                             register_event(
                                 {
                                     "type": ev_type,
-                                    "time_s": float(frame_count * dt),
-                                    "from_tid": int(prev_owner_tid),
-                                    "to_tid": int(owner_tid),
+                                    "time_s": t_s,
+                                    "frame_idx": frame_idx,
+                                    "from_player_id": int(prev_owner_tid),
+                                    "to_player_id": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "player_distance_units": d_pp,
-                                    "ball_travel_m": travel_m,
+                                    "player_distance_m": float(d_pp_m) if d_pp_m is not None else None,
                                 },
-                                f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}",
+                                f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}"
                             )
 
-                # generic possession-change event
-                register_event(
-                    {
-                        "type": "possession_change",
-                        "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,
-                    },
-                    "" if owner_tid is None else f"Team {team_of_player.get(owner_tid)} in possession",
-                )
-
-            # 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
+                # explicit possession change event (only when someone gains it)
+                if owner_tid is not None:
+                    register_event(
+                        {
+                            "type": "possession_change",
+                            "time_s": t_s,
+                            "frame_idx": frame_idx,
+                            "from_player_id": int(prev_owner_tid) if prev_owner_tid is not None else None,
+                            "to_player_id": int(owner_tid),
+                            "team_id": int(team_of_player.get(owner_tid, -1)),
+                        },
+                        f"Team {team_of_player.get(owner_tid, -1)} now in possession"
+                    )
 
-                if speed_kmh > HIGH_SPEED_KMH:
+            # shot / clearance
+            if prev_ball_pos_pitch_cm is not None and frame_ball_pos_pitch_cm is not None \
+                    and owner_tid is not None:
+                v_cm = (frame_ball_pos_pitch_cm - prev_ball_pos_pitch_cm) / dt
+                speed_cm_s = float(np.linalg.norm(v_cm))
+                speed_m_s = speed_cm_s / CM_PER_METER
+                speed_km_h = speed_m_s * 3.6
+                if speed_km_h > HIGH_SHOT_SPEED_KM_H:
                     shooter_team = team_of_player.get(owner_tid)
                     if shooter_team is not None:
                         target_goal = goal_centers[1 - shooter_team]
-                        direction = target_goal - frame_ball_pos_pitch
+                        direction = target_goal - frame_ball_pos_pitch_cm
                         cos_angle = float(
-                            np.dot(v_units, direction)
-                            / (np.linalg.norm(v_units) * np.linalg.norm(direction) + 1e-6)
+                            np.dot(v_cm, direction) /
+                            (np.linalg.norm(v_cm) * np.linalg.norm(direction) + 1e-6)
                         )
                         if cos_angle > 0.8:
                             register_event(
                                 {
                                     "type": "shot",
-                                    "time_s": float(frame_count * dt),
-                                    "from_tid": int(owner_tid),
+                                    "time_s": t_s,
+                                    "frame_idx": frame_idx,
+                                    "from_player_id": int(owner_tid),
                                     "team_id": int(shooter_team),
-                                    "speed_kmh": speed_kmh,
+                                    "speed_km_h": speed_km_h,
                                 },
-                                f"Shot by #{owner_tid} (Team {shooter_team}) – {speed_kmh:.1f} km/h",
+                                f"Shot by #{owner_tid} (Team {shooter_team}) – {speed_km_h:.1f} km/h"
                             )
                         else:
                             register_event(
                                 {
                                     "type": "clearance",
-                                    "time_s": float(frame_count * dt),
-                                    "from_tid": int(owner_tid),
+                                    "time_s": t_s,
+                                    "frame_idx": frame_idx,
+                                    "from_player_id": int(owner_tid),
                                     "team_id": int(shooter_team),
-                                    "speed_kmh": speed_kmh,
+                                    "speed_km_h": speed_km_h,
                                 },
-                                f"Clearance by #{owner_tid} (Team {shooter_team})",
+                                f"Clearance by #{owner_tid} (Team {shooter_team})"
                             )
 
             prev_owner_tid = owner_tid
-            prev_ball_pos_pitch = frame_ball_pos_pitch
+            prev_ball_pos_pitch_cm = frame_ball_pos_pitch_cm
 
-            # ----------------- Annotate Frame -----------------
+            # --- draw frame ---
             annotated_frame = frame.copy()
 
-            # 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}")
+            # labels with speed + distance
+            player_labels = []
+            if last_pitch_players_xy is not None and len(players_detections) > 0:
+                for idx, tid in enumerate(players_detections.tracker_id):
+                    tid_int = int(tid)
+                    # estimate instantaneous speed from last two positions in performance tracker
+                    pos_list = performance_tracker.player_positions[tid_int]
+                    speed_km_h = 0.0
+                    if len(pos_list) >= 2:
+                        prev_cm = np.array(pos_list[-2][:2])
+                        curr_cm = np.array(pos_list[-1][:2])
+                        dist_cm = float(np.linalg.norm(curr_cm - prev_cm))
+                        dist_m = dist_cm / CM_PER_METER
+                        speed_km_h = (dist_m / dt) * 3.6
+
+                    d_total_m = distance_covered_per_player_m[tid_int]
+                    team_id = team_of_player.get(tid_int, -1)
+                    player_labels.append(
+                        f"#{tid_int} T{team_id} {speed_km_h:4.1f} km/h {d_total_m:.1f} m"
+                    )
 
-            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)
+                annotated_frame = ellipse_annotator.annotate(
+                    scene=annotated_frame, detections=players_detections
+                )
+                annotated_frame = label_annotator.annotate(
+                    scene=annotated_frame, detections=players_detections, labels=player_labels
+                )
+
+            annotated_frame = triangle_annotator.annotate(
+                scene=annotated_frame, detections=ball_detections
+            )
 
-            # HUD: team possession percentages
+            # possession HUD
             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}%"
+            hud_text = (
+                f"Team 0 Possession: {team0_pct:5.1f}%   "
+                f"Team 1 Possession: {team1_pct:5.1f}%"
+            )
 
             cv2.rectangle(
                 annotated_frame,
@@ -942,10 +1001,13 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 cv2.LINE_AA,
             )
 
-            # 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)
+            # event banner
+            if event_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,
@@ -956,18 +1018,18 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                     2,
                     cv2.LINE_AA,
                 )
-                event_text_frames_left -= 1
+                event_frames_left -= 1
 
             out.write(annotated_frame)
 
         cap.release()
         out.release()
-        print(f"✅ Processed {frame_count} frames")
+        print(f"✅ Processed {frame_idx} frames")
 
-        # ===================================================
-        # STEP 4: Clean Ball Path
-        # ===================================================
-        progress(0.55, desc="🧹 Cleaning ball trajectory (Step 4/7)...")
+        # -----------------------------------
+        # STEP 3: clean ball path
+        # -----------------------------------
+        progress(0.60, desc="🧹 Cleaning ball trajectory (Step 4/7)...")
 
         path_for_cleaning = []
         for coords in ball_path_raw:
@@ -979,31 +1041,31 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 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],
+            [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 5: Performance Analytics
-        # ===================================================
-        progress(0.7, desc="📊 Generating performance analytics (Step 5/7)...")
+        # -----------------------------------
+        # STEP 4: performance analytics
+        # -----------------------------------
+        progress(0.70, desc="📊 Generating performance analytics (Step 5/7)...")
 
-        comparison_fig = create_team_comparison_plot(performance_tracker)
+        comparison_fig = create_team_comparison_plot(performance_tracker, fps)
 
         team_heatmaps_path = "/tmp/team_heatmaps.png"
-        team_heatmaps = create_combined_heatmaps(performance_tracker)
+        team_heatmaps = create_combined_heatmaps(performance_tracker, fps)
         cv2.imwrite(team_heatmaps_path, team_heatmaps)
 
-        # Individual player heatmaps (top 6 by distance)
+        # individual heatmaps (top 6 by distance)
         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'])
+                    (pid, performance_tracker.get_player_stats(pid, fps)['total_distance_m'])
                     for pid in team_players
                 ]
                 player_distances.sort(key=lambda x: x[1], reverse=True)
@@ -1011,7 +1073,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
         individual_heatmaps = []
         for pid in top_players[:6]:
-            heatmap = create_player_heatmap_visualization(performance_tracker, pid)
+            heatmap = create_player_heatmap_visualization(performance_tracker, pid, fps)
             individual_heatmaps.append(heatmap)
 
         if len(individual_heatmaps) > 0:
@@ -1024,26 +1086,24 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                     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
 
-        # ===================================================
-        # STEP 6: Radar View
-        # ===================================================
-        progress(0.8, desc="🗺️ Creating game-style radar view (Step 6/7)...")
+        # -----------------------------------
+        # STEP 5: radar view
+        # -----------------------------------
+        progress(0.85, 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=last_ball,
+                    pitch_ball_xy=cleaned_path[-1] if cleaned_path else np.empty((0, 2)),
                     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)),
+                    pitch_referees_xy=last_pitch_referees_xy,
                     ball_path=cleaned_path
                 )
                 cv2.imwrite(radar_path, radar_frame)
@@ -1053,146 +1113,131 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             print(f"⚠️ Radar view creation failed: {e}")
             radar_path = None
 
-        # ===================================================
-        # STEP 7: Summaries + Tables + Events JSON
-        # ===================================================
-        progress(0.9, desc="📝 Generating summary & tables (Step 7/7)...")
+        # -----------------------------------
+        # STEP 6: summary + tabular stats + events
+        # -----------------------------------
+        progress(0.92, desc="📝 Building summary & tables (Step 7/7)...")
 
-        # Summary text
         summary_lines = ["✅ **Analysis Complete!**\n"]
         summary_lines.append("**Video Statistics:**")
-        summary_lines.append(f"- Total Frames Processed: {frame_count}")
+        summary_lines.append(f"- Total Frames Processed: {frame_idx}")
         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")
+        summary_lines.append(
+            f"- Ball Trajectory Points: {len([p for p in cleaned_path if len(p) > 0])}\n"
+        )
 
         teams = performance_tracker.get_all_players_by_team()
         for team_id in [0, 1]:
             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[team_id])}")
 
-            total_dist = sum(performance_tracker.get_player_stats(pid)['total_distance_meters']
-                             for pid in teams[team_id])
+            total_dist = sum(
+                performance_tracker.get_player_stats(pid, fps)['total_distance_m']
+                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[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 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(f"- Team Total Distance: {total_dist:.1f} m")
+            summary_lines.append(f"- Average Distance per Player: {avg_dist:.1f} m")
 
         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("✅ 4. Ball trajectory cleaning")
-        summary_lines.append("✅ 5. Performance analytics generation")
-        summary_lines.append("✅ 6. Visualization creation")
-        summary_lines.append("✅ 7. Event & possession stats")
+        summary_lines.append("✅ 1. Team classifier training")
+        summary_lines.append("✅ 2. Video processing with tracking & events")
+        summary_lines.append("✅ 3. Ball trajectory cleaning")
+        summary_lines.append("✅ 4. Performance analytics")
+        summary_lines.append("✅ 5. Heatmaps & radar generation")
+
         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 table for Gradio Dataframe ----------
+        player_ids = sorted(performance_tracker.player_positions.keys())
+        player_stats_rows: List[List[float]] = []
+
+        for pid in player_ids:
+            stats_p = performance_tracker.get_player_stats(pid, fps)
+            possession_s = possession_time_player_s.get(pid, 0.0)
+            row = [
+                int(pid),
+                int(stats_p['team_id']),
+                float(stats_p['total_distance_m']),
+                float(stats_p['avg_speed_km_h']),
+                float(stats_p['max_speed_km_h']),
+                float(stats_p['time_in_defensive_third_s']),
+                float(stats_p['time_in_middle_third_s']),
+                float(stats_p['time_in_attacking_third_s']),
+                float(possession_s),
+            ]
             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 timeline text ----------
+        if events:
+            lines = []
+            for ev in events:
+                t = ev.get("time_s", 0.0)
+                ev_type = ev.get("type", "")
+                team_id = ev.get("team_id", None)
+                from_id = ev.get("from_player_id", None)
+                to_id = ev.get("to_player_id", None)
+
+                prefix = f"{t:6.2f}s | {ev_type.upper():<16}"
+
+                if ev_type == "pass":
+                    dist_m = ev.get("distance_m", 0.0)
+                    lines.append(
+                        f"{prefix} | Team {team_id} | #{from_id} → #{to_id} ({dist_m:.1f} m)"
+                    )
+                elif ev_type in ("tackle", "interception"):
+                    lines.append(
+                        f"{prefix} | Team {team_id} | #{to_id} wins ball from #{from_id}"
+                    )
+                elif ev_type in ("shot", "clearance"):
+                    speed_kmh = ev.get("speed_km_h", 0.0)
+                    lines.append(
+                        f"{prefix} | Team {team_id} | #{from_id} | {ev_type} at {speed_kmh:.1f} km/h"
+                    )
+                elif ev_type == "possession_change":
+                    lines.append(
+                        f"{prefix} | Team {team_id} | Possession → #{to_id}"
+                    )
+                else:
+                    lines.append(f"{prefix} | {ev}")
+            events_text = "\n".join(lines)
+        else:
+            events_text = "No events detected."
 
-        # Events JSON file
+        # ---------- JSON file with events ----------
         events_json_path = "/tmp/events.json"
         with open(events_json_path, "w", encoding="utf-8") as f:
-            json.dump(events_sorted, f, indent=2)
+            json.dump(events, f, indent=2)
 
         progress(1.0, desc="✅ Analysis Complete!")
 
         return (
-            output_path,            # video
-            comparison_fig,         # plot
-            team_heatmaps_path,     # image
+            output_path,
+            comparison_fig,
+            team_heatmaps_path,
             individual_heatmaps_path,
             radar_path,
-            summary_msg,            # text summary
-            player_stats_rows,      # DataFrame
-            events_timeline_text,   # text
-            events_json_path        # downloadable JSON
+            summary_msg,
+            player_stats_rows,
+            events_text,
+            events_json_path,
         )
 
     except Exception as e:
-        error_msg = f"❌ Error: {str(e)}"
-        print(error_msg)
         import traceback
         traceback.print_exc()
-        return (None, None, None, None, None, error_msg, None, None, None)
+        error_msg = f"❌ Error: {str(e)}"
+        return (
+            None, None, None, None, None,
+            error_msg,
+            [],
+            "No events detected.",
+            None,
+        )
 
 
 # ==============================================
@@ -1201,16 +1246,16 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
     # ⚽ Advanced Football Video Analyzer
-    ### 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)
+    ### Complete Pipeline Implementation
+
+    This application computes:
+    - Player & team detection with Roboflow
+    - Team classification using SigLIP
+    - Persistent tracking with ByteTrack
+    - Distances, speeds, and zone activity
+    - Ball possession (per team & per player)
+    - Events: passes, tackles, interceptions, shots, clearances, possession changes
+    - Heatmaps and tactical radar view
     """)
 
     with gr.Row():
@@ -1219,11 +1264,11 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
     analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary")
 
     with gr.Row():
-        status_output = gr.Textbox(label="📊 Analysis Summary & Statistics", lines=25)
+        status_output = gr.Markdown(label="📊 Analysis Summary & Statistics")
 
     with gr.Tabs():
         with gr.Tab("📹 Annotated Video"):
-            gr.Markdown("### Full video with player IDs, team colors, speed & distance, and event banners")
+            gr.Markdown("### Full video with tracking, events, and possession HUD")
             video_output = gr.Video(label="Processed Video")
 
         with gr.Tab("📊 Performance Comparison"):
@@ -1239,29 +1284,34 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             individual_heatmaps_output = gr.Image(label="Top Players Heatmaps")
 
         with gr.Tab("🎮 Game Radar View"):
-            gr.Markdown("### Game-style tactical radar view with ball trail")
+            gr.Markdown("### Game-style tactical view with ball trail")
             radar_output = gr.Image(label="Tactical Radar View")
 
-        with gr.Tab("📋 Player Stats Table"):
+        with gr.Tab("📈 Player Stats & Events"):
             gr.Markdown("### Per-player stats (distance, speed, zones, possession time)")
-            player_stats_output = gr.Dataframe(
+            player_stats_df = gr.Dataframe(
                 headers=[
-                    "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"
+                    "player_id",
+                    "team_id",
+                    "total_distance_m",
+                    "avg_speed_km_h",
+                    "max_speed_km_h",
+                    "time_def_third_s",
+                    "time_mid_third_s",
+                    "time_att_third_s",
+                    "possession_time_s",
                 ],
-                datatype=["number", "number", "number", "number", "number",
-                          "number", "number", "number", "number", "number"],
-                label="Player Stats"
+                row_count=(0, "dynamic"),
+                col_count=(9, "fixed"),
+                label="Player Stats",
             )
 
-        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)
+            gr.Markdown(
+                "### Detected events: passes, tackles, interceptions, shots, clearances, possession changes"
+            )
+            events_timeline = gr.Markdown(label="Event Timeline")
 
-        with gr.Tab("⬇️ Events JSON"):
-            gr.Markdown("### Download full raw event data as JSON")
-            events_json_output = gr.File(label="Events JSON")
+            events_json_file = gr.File(label="Download events JSON")
 
     analyze_btn.click(
         fn=analyze_football_video,
@@ -1273,12 +1323,12 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             individual_heatmaps_output,
             radar_output,
             status_output,
-            player_stats_output,
-            events_timeline_output,
-            events_json_output,
-        ]
+            player_stats_df,
+            events_timeline,
+            events_json_file,
+        ],
     )
 
 if __name__ == "__main__":
-    # On Spaces, just iface.launch()
+    # `share=True` is not supported on HF Spaces, so keep default.
     iface.launch()