Update app.py

app.py

@@ -1,21 +1,10 @@
 import os
 import json
+import time
 from collections import deque, defaultdict
 from typing import List, Tuple, Dict, Optional, Union, Any
 from io import BytesIO
 import base64
-import time
-
-# Suppress optional model warnings BEFORE importing inference
-os.environ["CORE_MODEL_SAM_ENABLED"] = "False"
-os.environ["CORE_MODEL_SAM2_ENABLED"] = "False"
-os.environ["CORE_MODEL_SAM3_ENABLED"] = "False"
-os.environ["CORE_MODEL_GAZE_ENABLED"] = "False"
-os.environ["CORE_MODEL_GROUNDINGDINO_ENABLED"] = "False"
-os.environ["CORE_MODEL_YOLO_WORLD_ENABLED"] = "False"
-
-# Set stable ONNX providers
-os.environ["ONNXRUNTIME_EXECUTION_PROVIDERS"] = "CPUExecutionProvider"
 
 import cv2
 import numpy as np
@@ -39,6 +28,7 @@ from sklearn.cluster import KMeans
 import umap
 
 from inference_sdk import InferenceHTTPClient
+from inference_sdk.http.errors import HTTPCallErrorError
 
 # ==============================================
 # ENVIRONMENT VARIABLES
@@ -52,21 +42,9 @@ if not HF_TOKEN or not ROBOFLOW_API_KEY:
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🖥️ Using device: {DEVICE}")
 
-# ==============================================
-# REAL-WORLD PITCH DIMENSIONS
-# ==============================================
-CONFIG = SoccerPitchConfiguration()
+# Units: we treat pitch coordinates as *meters* (same units as SoccerPitchConfiguration)
+METERS_PER_UNIT = 1.0  # keep for clarity, but effectively identity
 
-# Standard football pitch dimensions in meters
-PITCH_LENGTH_M = 105.0  # meters (standard: 100-110m)
-PITCH_WIDTH_M = 68.0    # meters (standard: 64-75m)
-
-# Calculate scaling factors from config units to meters
-SCALE_X = PITCH_LENGTH_M / CONFIG.length
-SCALE_Y = PITCH_WIDTH_M / CONFIG.width
-
-print(f"📏 Pitch config units - Length: {CONFIG.length}, Width: {CONFIG.width}")
-print(f"📏 Scale factors - X: {SCALE_X:.6f} m/unit, Y: {SCALE_Y:.6f} m/unit")
 
 # ==============================================
 # ROBOFLOW INFERENCE CLIENT
@@ -79,57 +57,22 @@ CLIENT = InferenceHTTPClient(
 PLAYER_DETECTION_MODEL_ID = "football-players-detection-3zvbc/11"
 FIELD_DETECTION_MODEL_ID = "football-field-detection-f07vi/14"
 
-# IDs from Roboflow model
-BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
-
-
-def verify_roboflow_api():
-    """Verify Roboflow API key is valid at startup"""
-    try:
-        # Make a simple test request
-        import requests
-        response = requests.get(
-            "https://api.roboflow.com/",
-            params={"api_key": ROBOFLOW_API_KEY},
-            timeout=10
-        )
-        if response.status_code == 200:
-            print("✅ Roboflow API key verified")
-            return True
-        elif response.status_code == 403:
-            print("❌ Roboflow API key is invalid or you've hit usage limits")
-            print("   Please check your API key in Space secrets")
-            return False
-        else:
-            print(f"⚠️ Roboflow API returned status {response.status_code}")
-            return True  # Continue anyway
-    except Exception as e:
-        print(f"⚠️ Could not verify Roboflow API: {e}")
-        return True  # Continue anyway
-
-
-# Verify API at startup
-verify_roboflow_api()
-
 
 def infer_with_confidence(
     model_id: str,
     frame: np.ndarray,
     confidence_threshold: float = 0.3,
-    max_retries: int = 3
+    max_retries: int = 3,
+    retry_delay: float = 0.5,
 ):
     """
-    Run inference with retry logic for transient errors.
-    
-    Args:
-        model_id: The model ID to use
-        frame: Input frame
-        confidence_threshold: Confidence threshold for detections
-        max_retries: Maximum number of retry attempts
-    
-    Returns:
-        Tuple of (result, detections)
+    Run inference on Roboflow with retries and filter by confidence.
+
+    If Roboflow returns 5xx errors, we retry a few times. If it still fails,
+    we return an empty result and empty detections so the pipeline can keep running.
     """
+    last_error: Optional[Exception] = None
+
     for attempt in range(max_retries):
         try:
             result = CLIENT.infer(frame, model_id=model_id)
@@ -137,53 +80,56 @@ def infer_with_confidence(
             if len(detections) > 0:
                 detections = detections[detections.confidence > confidence_threshold]
             return result, detections
-        except Exception as e:
-            if attempt < max_retries - 1:
-                delay = 2 ** attempt  # exponential backoff: 1s, 2s, 4s
-                print(f"⚠️ Inference failed (attempt {attempt + 1}/{max_retries}), retrying in {delay}s...")
-                time.sleep(delay)
+
+        except HTTPCallErrorError as e:
+            last_error = e
+            status = getattr(e, "status_code", None)
+            # Retry only on 5xx
+            if status is None or 500 <= status < 600:
+                print(
+                    f"[infer_with_confidence] Roboflow 5xx on model {model_id} "
+                    f"(attempt {attempt+1}/{max_retries}): {e}"
+                )
+                time.sleep(retry_delay * (attempt + 1))
+                continue
             else:
-                print(f"❌ All inference attempts failed: {e}")
-                # Return empty detections to continue processing
-                return None, sv.Detections.empty()
+                # 4xx etc – configuration/auth issue; bubble up
+                raise
+
+        except Exception as e:
+            last_error = e
+            print(f"[infer_with_confidence] Unexpected error on model {model_id}: {e}")
+            break
+
+    # Give up and return empty detections so we don't crash the app
+    print(
+        f"[infer_with_confidence] Giving up on model {model_id} after "
+        f"{max_retries} attempts. Last error: {last_error}"
+    )
+    h, w = frame.shape[:2]
+    empty_result = {
+        "predictions": [],
+        "image": {"width": int(w), "height": int(h)},
+    }
+    empty_detections = sv.Detections.empty()
+    return empty_result, empty_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_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF_TOKEN)
+EMBEDDINGS_MODEL = SiglipVisionModel.from_pretrained(
+    SIGLIP_MODEL_PATH, token=HF_TOKEN
+).to(DEVICE)
+EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(
+    SIGLIP_MODEL_PATH, token=HF_TOKEN
+)
 
 # ==============================================
-# DISTANCE CALCULATION UTILITIES
+# TEAM CONFIG
 # ==============================================
-def calculate_real_distance(pos1: np.ndarray, pos2: np.ndarray) -> float:
-    """
-    Calculate real-world distance in meters between two pitch positions.
-    Handles all array shapes robustly.
-    
-    Args:
-        pos1, pos2: positions in pitch coordinate units (any shape with at least 2 elements)
-    
-    Returns:
-        distance in meters (0.0 if invalid input)
-    """
-    # Convert to flat arrays
-    p1 = pos1.flatten()
-    p2 = pos2.flatten()
-    
-    # Validate we have at least 2 elements
-    if p1.size < 2 or p2.size < 2:
-        return 0.0
-    
-    # Extract x, y coordinates
-    x1, y1 = float(p1[0]), float(p1[1])
-    x2, y2 = float(p2[0]), float(p2[1])
-    
-    dx = (x2 - x1) * SCALE_X
-    dy = (y2 - y1) * SCALE_Y
-    distance_m = np.sqrt(dx**2 + dy**2)
-    return float(distance_m)
+CONFIG = SoccerPitchConfiguration()
 
 
 # ==============================================
@@ -191,45 +137,26 @@ def calculate_real_distance(pos1: np.ndarray, pos2: np.ndarray) -> float:
 # ==============================================
 def replace_outliers_based_on_distance(
     positions: List[np.ndarray],
-    distance_threshold_m: float = 50.0  # 50 meters is realistic max between frames
+    distance_threshold: float
 ) -> List[np.ndarray]:
-    """
-    Remove outlier positions based on real-world distance threshold in meters.
-    Ball can't travel more than ~50m between frames at normal frame rates.
-    """
+    """Remove outlier positions based on distance threshold (same units as positions)."""
     last_valid_position: Union[np.ndarray, None] = None
     cleaned_positions: List[np.ndarray] = []
 
     for position in positions:
-        # Handle empty positions
-        if position.size == 0:
-            cleaned_positions.append(np.array([], dtype=np.float64))
-            continue
-        
-        # Flatten and validate
-        pos_flat = position.flatten()
-        if pos_flat.size < 2:
-            cleaned_positions.append(np.array([], dtype=np.float64))
-            continue
-        
-        # Take first 2 elements as [x, y]
-        current_pos = pos_flat[:2]
-        
-        if last_valid_position is None:
-            # First valid position
-            cleaned_positions.append(current_pos)
-            last_valid_position = current_pos
+        if len(position) == 0:
+            cleaned_positions.append(position)
         else:
-            # Calculate distance from last valid position
-            distance_m = calculate_real_distance(last_valid_position, current_pos)
-            
-            if distance_m > distance_threshold_m:
-                # Outlier: ball moved too far
-                cleaned_positions.append(np.array([], dtype=np.float64))
+            if last_valid_position is None:
+                cleaned_positions.append(position)
+                last_valid_position = position
             else:
-                # Valid position
-                cleaned_positions.append(current_pos)
-                last_valid_position = current_pos
+                distance = np.linalg.norm(position - last_valid_position)
+                if distance > distance_threshold:
+                    cleaned_positions.append(np.array([], dtype=np.float64))
+                else:
+                    cleaned_positions.append(position)
+                    last_valid_position = position
 
     return cleaned_positions
 
@@ -238,82 +165,86 @@ def replace_outliers_based_on_distance(
 # PLAYER PERFORMANCE TRACKING
 # ==============================================
 class PlayerPerformanceTracker:
-    """Track individual player performance metrics with correct real-world scaling"""
+    """Track individual player performance metrics and generate heatmaps (units in meters)."""
 
-    def __init__(self, pitch_config):
+    def __init__(self, pitch_config: SoccerPitchConfiguration):
         self.config = pitch_config
-        self.player_positions = defaultdict(list)  # (x, y, frame) in config units
-        self.player_velocities = defaultdict(list)  # m/s
+        self.player_positions = defaultdict(list)  # (x_m, y_m, frame)
+        self.player_velocities_m_s = defaultdict(list)
         self.player_distances_m = defaultdict(float)
         self.player_team = {}
         self.player_stats = defaultdict(lambda: {
-            'frames_visible': 0,
-            'avg_velocity_m_s': 0.0,
-            'max_velocity_m_s': 0.0,
-            'time_in_attacking_third_frames': 0,
-            'time_in_defensive_third_frames': 0,
-            'time_in_middle_third_frames': 0
+            "frames_visible": 0,
+            "avg_velocity_m_s": 0.0,
+            "max_velocity_m_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 in real meters."""
-        if len(position) != 2:
+    def update(self, tracker_id: int, position_m: np.ndarray, team_id: int, frame: int, fps: float):
+        """Update player position and calculate metrics (position in meters)."""
+        if len(position_m) != 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
+        self.player_positions[tracker_id].append((position_m[0], position_m[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)
-            
-            # Calculate REAL distance in meters
-            distance_m = calculate_real_distance(prev_pos, curr_pos)
+            curr_pos = np.array(position_m)
+            distance_m = np.linalg.norm(curr_pos - prev_pos)
             self.player_distances_m[tracker_id] += distance_m
 
-            # Calculate velocity in m/s
             dt = 1.0 / fps
             velocity_m_s = distance_m / dt
-            self.player_velocities[tracker_id].append(velocity_m_s)
+            self.player_velocities_m_s[tracker_id].append(velocity_m_s)
 
-            if velocity_m_s > self.player_stats[tracker_id]['max_velocity_m_s']:
-                self.player_stats[tracker_id]['max_velocity_m_s'] = velocity_m_s
+            if velocity_m_s > self.player_stats[tracker_id]["max_velocity_m_s"]:
+                self.player_stats[tracker_id]["max_velocity_m_s"] = velocity_m_s
 
-        # Zone calculation (thirds of pitch)
-        pitch_length = self.config.length
-        x = position[0]
-        if x < pitch_length / 3:
-            self.player_stats[tracker_id]['time_in_defensive_third_frames'] += 1
-        elif x < 2 * pitch_length / 3:
-            self.player_stats[tracker_id]['time_in_middle_third_frames'] += 1
+        pitch_length_m = self.config.length
+        x = position_m[0]
+        if x < pitch_length_m / 3:
+            self.player_stats[tracker_id]["time_in_defensive_third_frames"] += 1
+        elif x < 2 * pitch_length_m / 3:
+            self.player_stats[tracker_id]["time_in_middle_third_frames"] += 1
         else:
-            self.player_stats[tracker_id]['time_in_attacking_third_frames'] += 1
+            self.player_stats[tracker_id]["time_in_attacking_third_frames"] += 1
 
     def get_player_stats(self, tracker_id: int, fps: float) -> dict:
-        """Get comprehensive stats for a player in real-world units."""
+        """Get comprehensive stats for a player (meters, m/s, km/h, seconds)."""
         stats = self.player_stats[tracker_id].copy()
 
-        if len(self.player_velocities[tracker_id]) > 0:
-            stats['avg_velocity_m_s'] = float(np.mean(self.player_velocities[tracker_id]))
+        if len(self.player_velocities_m_s[tracker_id]) > 0:
+            stats["avg_velocity_m_s"] = float(np.mean(self.player_velocities_m_s[tracker_id]))
 
-        # Total distance is already in meters
-        stats['total_distance_m'] = self.player_distances_m[tracker_id]
-        stats['team_id'] = self.player_team.get(tracker_id, -1)
+        total_distance_m = self.player_distances_m[tracker_id]
+        stats["total_distance_m"] = total_distance_m
+        stats["team_id"] = self.player_team.get(tracker_id, -1)
 
-        # Convert frames to 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
+        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 m/s to km/h for display
-        stats['avg_speed_km_h'] = stats['avg_velocity_m_s'] * 3.6
-        stats['max_speed_km_h'] = stats['max_velocity_m_s'] * 3.6
+        avg_v_m_s = stats["avg_velocity_m_s"]
+        max_v_m_s = stats["max_velocity_m_s"]
+        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:
-        """Generate heatmap for a specific player"""
+        """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))
 
@@ -323,17 +254,17 @@ class PlayerPerformanceTracker:
         pitch_width = self.config.width
 
         heatmap, xedges, yedges = np.histogram2d(
-            positions[:, 0], positions[:, 1],
+            positions[:, 0],
+            positions[:, 1],
             bins=[resolution, resolution],
-            range=[[0, pitch_length], [0, pitch_width]]
+            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"""
+        """Get all player IDs grouped by team."""
         teams = defaultdict(list)
         for tracker_id, team_id in self.player_team.items():
             teams[team_id].append(tracker_id)
@@ -346,31 +277,31 @@ class PlayerPerformanceTracker:
 class PlayerTrackingManager:
     """Manages persistent player tracking with team assignment stability"""
 
-    def __init__(self, max_history=10):
+    def __init__(self, max_history: int = 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"""
+        """Store team assignment history for each tracker."""
         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"""
+        """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 current_team_id
 
         history = self.tracker_team_history[tracker_id]
         team_counts = np.bincount(history)
-        stable_team = np.argmax(team_counts)
+        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)
+        """Get current count of players per team."""
+        team_counts: Dict[int, int] = 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(
@@ -380,64 +311,19 @@ class PlayerTrackingManager:
         return team_counts
 
     def reset_frame(self):
-        """Reset active trackers for new frame"""
+        """Reset active trackers for new frame."""
         self.active_trackers = set()
 
 
-# ==============================================
-# VALIDATION UTILITIES
-# ==============================================
-def validate_player_stats(performance_tracker: PlayerPerformanceTracker, fps: float, total_frames: int) -> List[str]:
-    """
-    Validate that player statistics are realistic.
-    Returns warnings for unrealistic values.
-    """
-    warnings = []
-    
-    # Calculate clip duration
-    match_duration_minutes = (total_frames / fps) / 60.0
-    
-    # Professional player typically covers 9-13 km in a 90-minute match
-    # Scale proportionally for shorter clips
-    expected_max_distance = 13.0 * (match_duration_minutes / 90.0) * 1000  # in meters
-    
-    for tracker_id in performance_tracker.player_positions.keys():
-        stats = performance_tracker.get_player_stats(tracker_id, fps)
-        
-        distance = stats['total_distance_m']
-        max_speed_kmh = stats['max_speed_km_h']
-        avg_speed_kmh = stats['avg_speed_km_h']
-        
-        if distance > expected_max_distance * 1.5:
-            warnings.append(
-                f"⚠️ Player #{tracker_id}: Distance {distance:.1f}m seems high "
-                f"(expected max ~{expected_max_distance:.1f}m for {match_duration_minutes:.1f} min)"
-            )
-        
-        # Professional players rarely exceed 37 km/h
-        if max_speed_kmh > 40:
-            warnings.append(
-                f"⚠️ Player #{tracker_id}: Max speed {max_speed_kmh:.1f} km/h seems unrealistic "
-                f"(typical max is 30-37 km/h)"
-            )
-        
-        # Average speed during active play is typically 5-8 km/h
-        if avg_speed_kmh > 15:
-            warnings.append(
-                f"⚠️ Player #{tracker_id}: Avg speed {avg_speed_kmh:.1f} km/h seems too high "
-                f"(typical average is 5-8 km/h)"
-            )
-    
-    return warnings
-
-
 # ==============================================
 # VISUALIZATION FUNCTIONS
 # ==============================================
-def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker,
-                                        tracker_id: int,
-                                        fps: float) -> np.ndarray:
-    """Create a single player heatmap overlay on pitch"""
+def create_player_heatmap_visualization(
+    performance_tracker: PlayerPerformanceTracker,
+    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)
 
@@ -460,42 +346,55 @@ def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTr
     result = cv2.addWeighted(pitch, 0.6, overlay, 0.4, 0)
 
     stats = performance_tracker.get_player_stats(tracker_id, fps)
-    team_color = "Blue" if stats['team_id'] == 0 else "Pink"
+    team_color = "Blue" if stats["team_id"] == 0 else "Pink"
 
     text_lines = [
         f"Player #{tracker_id} ({team_color} Team)",
         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']}"
+        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
+            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,
-                                fps: float) -> go.Figure:
-    """Create interactive performance comparison plots"""
+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', 'Average Speed', 'Max Speed', 'Activity by Zone'),
-        specs=[[{'type': 'bar'}, {'type': 'bar'}],
-               [{'type': 'bar'}, {'type': 'bar'}]]
+        rows=2,
+        cols=2,
+        subplot_titles=(
+            "Distance Covered",
+            "Average Speed",
+            "Max Speed",
+            "Activity by Zone",
+        ),
+        specs=[[{"type": "bar"}, {"type": "bar"}],
+               [{"type": "bar"}, {"type": "bar"}]],
     )
 
-    colors = {0: '#00BFFF', 1: '#FF1493'}
-    team_names = {0: 'Team 0 (Blue)', 1: 'Team 1 (Pink)'}
+    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]:
@@ -508,35 +407,59 @@ def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker,
 
         for pid in player_ids:
             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'])
+            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]
 
         fig.add_trace(
-            go.Bar(x=player_labels, y=distances, name=team_names[team_id],
-                   marker_color=colors[team_id], showlegend=True),
-            row=1, col=1
+            go.Bar(
+                x=player_labels,
+                y=distances,
+                name=team_names[team_id],
+                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),
-            row=1, col=2
+            go.Bar(
+                x=player_labels,
+                y=avg_speeds,
+                name=team_names[team_id],
+                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),
-            row=2, col=1
+            go.Bar(
+                x=player_labels,
+                y=max_speeds,
+                name=team_names[team_id],
+                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),
-            row=2, col=2
+            go.Bar(
+                x=player_labels,
+                y=attacking_time,
+                name=team_names[team_id],
+                marker_color=colors[team_id],
+                showlegend=False,
+            ),
+            row=2,
+            col=2,
         )
 
     fig.update_xaxes(title_text="Players", row=1, col=1)
@@ -549,14 +472,20 @@ def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker,
     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')
+    fig.update_layout(
+        height=800,
+        title_text="Team Performance Comparison",
+        barmode="group",
+    )
 
     return fig
 
 
-def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker,
-                             fps: float) -> np.ndarray:
-    """Create side-by-side team heatmaps"""
+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()
 
     team_heatmaps = []
@@ -590,8 +519,14 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker,
 
         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
+            result,
+            team_name,
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
         )
 
         team_heatmaps.append(result)
@@ -608,25 +543,32 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker,
 # HELPER FUNCTIONS
 # ==============================================
 def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detections) -> np.ndarray:
-    """Assign goalkeepers to the nearest team centroid"""
+    """Assign goalkeepers to the nearest team centroid."""
     if len(goalkeepers) == 0 or len(players) == 0:
         return np.array([])
     goalkeepers_xy = goalkeepers.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
     players_xy = players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
     team_0_centroid = players_xy[players.class_id == 0].mean(axis=0)
     team_1_centroid = players_xy[players.class_id == 1].mean(axis=0)
-    return np.array([
-        0 if np.linalg.norm(gk - team_0_centroid) < np.linalg.norm(gk - team_1_centroid) else 1
-        for gk in goalkeepers_xy
-    ])
+    return np.array(
+        [
+            0 if np.linalg.norm(gk - team_0_centroid) < np.linalg.norm(gk - team_1_centroid) else 1
+            for gk in goalkeepers_xy
+        ]
+    )
 
 
-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"""
+def create_game_style_radar(
+    pitch_ball_xy: np.ndarray,
+    pitch_players_xy: np.ndarray,
+    players_class_id: np.ndarray,
+    pitch_referees_xy: np.ndarray,
+    ball_path: Optional[List[np.ndarray]] = None,
+) -> np.ndarray:
+    """Create game-style radar view with ball trail effect."""
     annotated_frame = draw_pitch(CONFIG)
 
-    # Draw ball trail with fading effect
+    # Ball trail
     if ball_path is not None and len(ball_path) > 0:
         valid_path = [coords for coords in ball_path if len(coords) > 0]
         if len(valid_path) > 1:
@@ -634,45 +576,53 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
                 if len(coords) == 0:
                     continue
                 alpha = (i + 1) / min(20, len(valid_path))
-                color = sv.Color(int(255 * alpha), int(255 * alpha), int(255 * alpha))
+                color = sv.Color(
+                    int(255 * alpha),
+                    int(255 * alpha),
+                    int(255 * alpha),
+                )
                 annotated_frame = draw_points_on_pitch(
-                    CONFIG, coords,
+                    CONFIG,
+                    coords,
                     face_color=color,
                     edge_color=sv.Color.BLACK,
                     radius=int(6 + alpha * 4),
-                    pitch=annotated_frame
+                    pitch=annotated_frame,
                 )
 
-    # Draw current ball position
+    # Current ball
     if len(pitch_ball_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_ball_xy,
+            CONFIG,
+            pitch_ball_xy,
             face_color=sv.Color.WHITE,
             edge_color=sv.Color.BLACK,
             radius=10,
-            pitch=annotated_frame
+            pitch=annotated_frame,
         )
 
-    # Draw players
+    # 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],
+                CONFIG,
+                pitch_players_xy[mask],
                 face_color=sv.Color.from_hex(color_hex),
                 edge_color=sv.Color.BLACK,
                 radius=16,
-                pitch=annotated_frame
+                pitch=annotated_frame,
             )
 
-    # Draw referees
+    # Referees
     if len(pitch_referees_xy) > 0:
         annotated_frame = draw_points_on_pitch(
-            CONFIG, pitch_referees_xy,
+            CONFIG,
+            pitch_referees_xy,
             face_color=sv.Color.from_hex("FFD700"),
             edge_color=sv.Color.BLACK,
             radius=16,
-            pitch=annotated_frame
+            pitch=annotated_frame,
         )
 
     return annotated_frame
@@ -681,104 +631,89 @@ 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[
-                               Optional[str],
-                               Optional[go.Figure],
-                               Optional[str],
-                               Optional[str],
-                               Optional[str],
-                               str,
-                               List[List[float]],
-                               str,
-                               Optional[str]
-                           ]:
+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 with proper distance/speed calculations
+    Complete football analysis pipeline:
+      * 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, None, None, None, None,
-                "❌ Please upload a video file.",
-                [], "No events detected.", None)
-    
-    # Test Roboflow API access before processing
-    print("🔍 Testing Roboflow API access...")
-    test_frame = np.zeros((640, 640, 3), dtype=np.uint8)
-    _, test_det = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, test_frame, 0.3, max_retries=1)
-    
-    if test_det is None or len(test_det) == 0:
-        # API test returned empty, which likely means 403 error
-        error_msg = """
-❌ **Roboflow API Access Error**
-
-Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
-
-**To fix this:**
-
-1. **Get a valid API key:**
-   - Go to https://app.roboflow.com/
-   - Sign in or create an account
-   - Click your profile → Settings → Roboflow API
-   - Copy your **Private API Key**
-
-2. **Update the key in your Space:**
-   - Go to your Space Settings → Variables and secrets
-   - Find `ROBOFLOW_API_KEY`
-   - Replace with your new API key
-   - Restart the Space
-
-3. **Check usage limits:**
-   - Free tier: 10,000 API calls/month
-   - Check your usage at https://app.roboflow.com/
-
-**Current API key:** `{}...{}`
-""".format(ROBOFLOW_API_KEY[:4], ROBOFLOW_API_KEY[-4:])
-        return (None, None, None, None, None, error_msg, [], "No events detected.", None)
-    
-    print("✅ Roboflow API is accessible")
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Please upload a video file.",
+            [],
+            "No events detected.",
+            None,
+        )
 
     try:
         progress(0, desc="🔧 Initializing...")
 
+        BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
         STRIDE = 30
         MAXLEN = 5
-        MAX_DISTANCE_THRESHOLD_M = 50.0  # realistic max ball travel between frames
+        MAX_DISTANCE_THRESHOLD = 50.0  # meters – generous for smoothing outliers
 
-        # Managers
         tracking_manager = PlayerTrackingManager(max_history=10)
         performance_tracker = PlayerPerformanceTracker(CONFIG)
 
-        # Annotators
         ellipse_annotator = sv.EllipseAnnotator(
-            color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']),
-            thickness=2
+            color=sv.ColorPalette.from_hex(["#00BFFF", "#FF1493", "#FFD700"]),
+            thickness=2,
         )
         label_annotator = sv.LabelAnnotator(
-            color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']),
-            text_color=sv.Color.from_hex('#FFFFFF'),
+            color=sv.ColorPalette.from_hex(["#00BFFF", "#FF1493", "#FFD700"]),
+            text_color=sv.Color.from_hex("#FFFFFF"),
             text_thickness=2,
-            text_position=sv.Position.BOTTOM_CENTER
+            text_position=sv.Position.BOTTOM_CENTER,
         )
         triangle_annotator = sv.TriangleAnnotator(
-            color=sv.Color.from_hex('#FFD700'),
+            color=sv.Color.from_hex("#FFD700"),
             base=20,
-            height=17
+            height=17,
         )
 
-        # Tracker
         tracker = sv.ByteTrack(
             track_activation_threshold=0.4,
             lost_track_buffer=60,
             minimum_matching_threshold=0.85,
-            frame_rate=30
+            frame_rate=30,
         )
         tracker.reset()
 
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            return (None, None, None, None, None,
-                    f"❌ Failed to open video: {video_path}",
-                    [], "No events detected.", 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))
@@ -804,20 +739,33 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             if not ret:
                 break
             if frame_idx % STRIDE == 0:
-                _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
+                _, 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]
+                    crops = [
+                        sv.crop_image(frame, xyxy)
+                        for xyxy in players_detections.xyxy
+                    ]
                     player_crops.extend(crops)
             frame_idx += 1
 
         if len(player_crops) == 0:
             cap.release()
             out.release()
-            return (None, None, None, None, None,
-                    "❌ No player crops collected.",
-                    [], "No events detected.", None)
+            return (
+                None,
+                None,
+                None,
+                None,
+                None,
+                "❌ No player crops collected.",
+                [],
+                "No events detected.",
+                None,
+            )
 
         print(f"✅ Collected {len(player_crops)} player samples")
 
@@ -834,12 +782,10 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         M = deque(maxlen=MAXLEN)
         ball_path_raw: List[np.ndarray] = []
 
-        # for radar
         last_pitch_players_xy = None
         last_players_class_id = None
         last_pitch_referees_xy = None
 
-        # stats for events / possession
         dt = 1.0 / fps
         distance_covered_per_player_m = defaultdict(float)
         possession_time_player_s = defaultdict(float)
@@ -847,7 +793,6 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         team_of_player: Dict[int, int] = {}
         events: List[Dict[str, Any]] = []
 
-        # event HUD
         current_event_text = ""
         event_frames_left = 0
         EVENT_TEXT_DURATION_FRAMES = int(2.0 * fps)
@@ -855,15 +800,13 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         prev_owner_tid: Optional[int] = None
         prev_ball_pos_pitch: Optional[np.ndarray] = None
 
-        # approximate goal centers in pitch coords
         goal_centers = {
             0: np.array([0.0, CONFIG.width / 2.0]),
             1: np.array([CONFIG.length, CONFIG.width / 2.0]),
         }
 
-        # thresholds
-        POSSESSION_RADIUS_M = 5.0
-        MIN_PASS_TRAVEL_M = 3.0
+        POSSESSION_RADIUS_M = 4.0
+        MIN_PASS_TRAVEL_M = 2.0
         HIGH_SHOT_SPEED_KM_H = 18.0
 
         def register_event(ev: Dict[str, Any], text: str):
@@ -883,8 +826,10 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             tracking_manager.reset_frame()
 
             if frame_idx % 30 == 0:
-                progress(0.20 + 0.30 * (frame_idx / max(total_frames, 1)),
-                         desc=f"🎬 Processing frame {frame_idx}/{total_frames}")
+                progress(
+                    0.20 + 0.30 * (frame_idx / max(total_frames, 1)),
+                    desc=f"🎬 Processing frame {frame_idx}/{total_frames}",
+                )
 
             # --- detections ---
             _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
@@ -900,31 +845,37 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             all_detections = all_detections.with_nms(threshold=0.5, class_agnostic=True)
             all_detections = tracker.update_with_detections(detections=all_detections)
 
-            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]
+            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 + stabilisation ---
+            # 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(tracker_id, predicted_teams[idx])
+                    tracking_manager.update_team_assignment(
+                        tracker_id, predicted_teams[idx]
+                    )
                     predicted_teams[idx] = tracking_manager.get_stable_team_id(
                         tracker_id, predicted_teams[idx]
                     )
                 players_detections.class_id = predicted_teams
 
-            # goalkeeper teams
+            # Goalkeeper teams
             if len(goalkeepers_detections) > 0 and len(players_detections) > 0:
                 goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
                     players_detections, goalkeepers_detections
                 )
 
-            # adjust referee class_id
             referees_detections.class_id -= 1
 
-            # merged for drawing
             merged_dets = sv.Detections.merge(
                 [players_detections, goalkeepers_detections, referees_detections]
             )
@@ -932,7 +883,9 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
 
             # --- field homography ---
             try:
-                result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 0.3)
+                result_field, _ = infer_with_confidence(
+                    FIELD_DETECTION_MODEL_ID, frame, 0.3
+                )
                 key_points = sv.KeyPoints.from_inference(result_field)
 
                 filter_mask = key_points.confidence[0] > 0.5
@@ -943,24 +896,31 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                 frame_players_xy_pitch = None
 
                 if len(frame_ref_pts) >= 4:
-                    transformer = ViewTransformer(source=frame_ref_pts, target=pitch_ref_pts)
+                    transformer = ViewTransformer(
+                        source=frame_ref_pts, target=pitch_ref_pts
+                    )
                     M.append(transformer.m)
                     transformer.m = np.mean(np.array(M), axis=0)
 
-                    # ball position in pitch coords
-                    frame_ball_xy = ball_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    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]
 
-                    # all players (incl. keepers)
-                    all_players = sv.Detections.merge([players_detections, goalkeepers_detections])
-                    players_xy = all_players.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    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)
 
-                    # referees
-                    referees_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    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
@@ -969,21 +929,18 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
 
                     frame_players_xy_pitch = pitch_players_xy
 
-                    # update performance tracker with REAL distance calculations
+                    # performance tracker + distance
                     for idx, tracker_id in enumerate(all_players.tracker_id):
                         tid_int = int(tracker_id)
                         team_id = int(all_players.class_id[idx])
-                        pos = pitch_players_xy[idx]
-                        performance_tracker.update(
-                            tid_int, pos, team_id, frame_idx, fps
-                        )
+                        pos_m = pitch_players_xy[idx]
+                        performance_tracker.update(tid_int, pos_m, team_id, frame_idx, fps)
 
-                        # distance for HUD
-                        prev_pos_list = performance_tracker.player_positions[tid_int]
-                        if len(prev_pos_list) > 1:
-                            prev_pos = np.array(prev_pos_list[-2][:2])
-                            curr_pos = np.array(prev_pos_list[-1][:2])
-                            dist_m = calculate_real_distance(prev_pos, curr_pos)
+                        if len(performance_tracker.player_positions[tid_int]) > 1:
+                            prev_pos = np.array(
+                                performance_tracker.player_positions[tid_int][-2][:2]
+                            )
+                            dist_m = float(np.linalg.norm(pos_m - prev_pos))
                             distance_covered_per_player_m[tid_int] += dist_m
 
                         team_of_player[tid_int] = team_id
@@ -999,39 +956,37 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             # --- possession owner ---
             owner_tid: Optional[int] = None
             if frame_ball_pos_pitch is not None and frame_players_xy_pitch is not None:
-                # Calculate distances in REAL meters
-                dists_m = []
-                for player_pos in frame_players_xy_pitch:
-                    dist = calculate_real_distance(frame_ball_pos_pitch, player_pos)
-                    dists_m.append(dist)
-                dists_m = np.array(dists_m)
-                
-                j = int(np.argmin(dists_m))
-                if dists_m[j] < POSSESSION_RADIUS_M:
+                dists = np.linalg.norm(
+                    frame_players_xy_pitch - frame_ball_pos_pitch, axis=1
+                )
+                j = int(np.argmin(dists))
+                if dists[j] < POSSESSION_RADIUS_M:
                     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
 
-            # --- events (pass, tackle, interception, shot, clearance, possession change) ---
+            # --- events ---
             t_s = frame_idx * dt
 
             if owner_tid != prev_owner_tid:
-                if owner_tid is not None and prev_owner_tid is not None \
-                        and frame_ball_pos_pitch is not None and prev_ball_pos_pitch is not None:
-                    # ball travel in REAL meters
-                    travel_m = calculate_real_distance(prev_ball_pos_pitch, frame_ball_pos_pitch)
-                    
+                if (
+                    owner_tid is not None
+                    and prev_owner_tid is not None
+                    and frame_ball_pos_pitch is not None
+                    and prev_ball_pos_pitch is not None
+                ):
+                    travel_m = float(
+                        np.linalg.norm(frame_ball_pos_pitch - prev_ball_pos_pitch)
+                    )
                     prev_team = team_of_player.get(prev_owner_tid)
                     cur_team = team_of_player.get(owner_tid)
 
                     if prev_team is not None and cur_team is not None:
                         if prev_team == cur_team and travel_m > MIN_PASS_TRAVEL_M:
-                            # pass
                             register_event(
                                 {
                                     "type": "pass",
@@ -1042,18 +997,22 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                                     "team_id": int(cur_team),
                                     "distance_m": travel_m,
                                 },
-                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team}, {travel_m:.1f} m)"
+                                f"Pass: #{prev_owner_tid} → #{owner_tid} "
+                                f"(Team {cur_team}, {travel_m:.1f} m)",
                             )
                         elif prev_team != cur_team:
-                            # tackle vs interception based on player distance
                             d_pp_m = None
-                            prev_pos_list = performance_tracker.player_positions.get(int(prev_owner_tid))
-                            cur_pos_list = performance_tracker.player_positions.get(int(owner_tid))
-                            
-                            if prev_pos_list and cur_pos_list and len(prev_pos_list) > 0 and len(cur_pos_list) > 0:
-                                pos_prev = np.array(prev_pos_list[-1][:2])
-                                pos_cur = np.array(cur_pos_list[-1][:2])
-                                d_pp_m = calculate_real_distance(pos_prev, pos_cur)
+                            if frame_players_xy_pitch is not None:
+                                pos_prev_list = performance_tracker.player_positions[
+                                    int(prev_owner_tid)
+                                ]
+                                pos_cur_list = performance_tracker.player_positions[
+                                    int(owner_tid)
+                                ]
+                                if pos_prev_list and pos_cur_list:
+                                    pos_prev = np.array(pos_prev_list[-1][:2])
+                                    pos_cur = np.array(pos_cur_list[-1][:2])
+                                    d_pp_m = float(np.linalg.norm(pos_prev - pos_cur))
 
                             ev_type = "tackle"
                             label = "Tackle"
@@ -1068,44 +1027,42 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                                     "from_player_id": int(prev_owner_tid),
                                     "to_player_id": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "player_distance_m": float(d_pp_m) if d_pp_m is not None else None,
+                                    "player_distance_m": d_pp_m,
                                 },
-                                f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}"
+                                f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}",
                             )
 
-                # explicit possession change event
                 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,
+                            "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"
+                        f"Team {team_of_player.get(owner_tid, -1)} now in possession",
                     )
 
-            # shot / clearance
-            if prev_ball_pos_pitch is not None and frame_ball_pos_pitch is not None \
-                    and owner_tid is not None:
-                # Calculate velocity in REAL m/s
-                v = (frame_ball_pos_pitch - prev_ball_pos_pitch)
-                v_scaled = np.array([v[0] * SCALE_X, v[1] * SCALE_Y])
-                speed_m_s = float(np.linalg.norm(v_scaled)) / dt
+            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
+                speed_m_s = float(np.linalg.norm(v))
                 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_scaled = np.array([direction[0] * SCALE_X, direction[1] * SCALE_Y])
-                        
                         cos_angle = float(
-                            np.dot(v_scaled, direction_scaled) /
-                            (np.linalg.norm(v_scaled) * np.linalg.norm(direction_scaled) + 1e-6)
+                            np.dot(v, direction)
+                            / (np.linalg.norm(v) * np.linalg.norm(direction) + 1e-6)
                         )
                         if cos_angle > 0.8:
                             register_event(
@@ -1117,7 +1074,8 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                                     "team_id": int(shooter_team),
                                     "speed_km_h": speed_km_h,
                                 },
-                                f"Shot by #{owner_tid} (Team {shooter_team}) – {speed_km_h:.1f} km/h"
+                                f"Shot by #{owner_tid} (Team {shooter_team}) – "
+                                f"{speed_km_h:.1f} km/h",
                             )
                         else:
                             register_event(
@@ -1129,27 +1087,25 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                                     "team_id": int(shooter_team),
                                     "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
 
-            # --- draw frame ---
+            # --- drawing ---
             annotated_frame = frame.copy()
 
-            # labels with speed + distance
             player_labels = []
-            if last_pitch_players_xy is not None and len(players_detections) > 0:
+            if len(players_detections) > 0:
                 for idx, tid in enumerate(players_detections.tracker_id):
                     tid_int = int(tid)
-                    # estimate instantaneous speed from last two positions
                     pos_list = performance_tracker.player_positions[tid_int]
                     speed_km_h = 0.0
                     if len(pos_list) >= 2:
-                        prev = np.array(pos_list[-2][:2])
-                        curr = np.array(pos_list[-1][:2])
-                        dist_m = calculate_real_distance(prev, curr)
+                        prev_m = np.array(pos_list[-2][:2])
+                        curr_m = np.array(pos_list[-1][:2])
+                        dist_m = float(np.linalg.norm(curr_m - prev_m))
                         speed_km_h = (dist_m / dt) * 3.6
 
                     d_total_m = distance_covered_per_player_m[tid_int]
@@ -1162,17 +1118,22 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                     scene=annotated_frame, detections=players_detections
                 )
                 annotated_frame = label_annotator.annotate(
-                    scene=annotated_frame, detections=players_detections, labels=player_labels
+                    scene=annotated_frame,
+                    detections=players_detections,
+                    labels=player_labels,
                 )
 
             annotated_frame = triangle_annotator.annotate(
                 scene=annotated_frame, detections=ball_detections
             )
 
-            # 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
+            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}%   "
                 f"Team 1 Possession: {team1_pct:5.1f}%"
@@ -1196,12 +1157,13 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                 cv2.LINE_AA,
             )
 
-            # event banner
             if event_frames_left > 0 and current_event_text:
                 cv2.rectangle(
-                    annotated_frame, (20, 20),
+                    annotated_frame,
+                    (20, 20),
                     (annotated_frame.shape[1] - 20, 90),
-                    (255, 255, 255), -1
+                    (255, 255, 255),
+                    -1,
                 )
                 cv2.putText(
                     annotated_frame,
@@ -1236,23 +1198,18 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
                 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_M
+            [
+                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"
         )
-        print(f"✅ Ball path cleaned: {len([p for p in cleaned_path if len(p) > 0])} valid points")
-
-        # -----------------------------------
-        # STEP 4: Validate stats
-        # -----------------------------------
-        warnings = validate_player_stats(performance_tracker, fps, frame_idx)
-        if warnings:
-            print("\n⚠️ VALIDATION WARNINGS:")
-            for warning in warnings:
-                print(warning)
 
         # -----------------------------------
-        # STEP 5: performance analytics
+        # STEP 4: performance analytics
         # -----------------------------------
         progress(0.70, desc="📊 Generating performance analytics (Step 5/7)...")
 
@@ -1262,14 +1219,18 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         team_heatmaps = create_combined_heatmaps(performance_tracker, fps)
         cv2.imwrite(team_heatmaps_path, team_heatmaps)
 
-        # 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, fps)['total_distance_m'])
+                    (
+                        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)
@@ -1277,13 +1238,15 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
 
         individual_heatmaps = []
         for pid in top_players[:6]:
-            heatmap = create_player_heatmap_visualization(performance_tracker, pid, fps)
+            heatmap = create_player_heatmap_visualization(
+                performance_tracker, pid, fps
+            )
             individual_heatmaps.append(heatmap)
 
         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:
@@ -1297,18 +1260,20 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             individual_heatmaps_path = None
 
         # -----------------------------------
-        # STEP 6: radar view
+        # 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:
                 radar_frame = create_game_style_radar(
-                    pitch_ball_xy=cleaned_path[-1] if cleaned_path else np.empty((0, 2)),
+                    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,
-                    ball_path=cleaned_path
+                    ball_path=cleaned_path,
                 )
                 cv2.imwrite(radar_path, radar_frame)
             else:
@@ -1318,7 +1283,7 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             radar_path = None
 
         # -----------------------------------
-        # STEP 7: summary + tabular stats + events
+        # STEP 6: summary + tables + events
         # -----------------------------------
         progress(0.92, desc="📝 Building summary & tables (Step 7/7)...")
 
@@ -1327,7 +1292,6 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         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"- Duration: {frame_idx/fps:.1f} seconds")
         summary_lines.append(
             f"- Ball Trajectory Points: {len([p for p in cleaned_path if len(p) > 0])}\n"
         )
@@ -1341,7 +1305,7 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
             summary_lines.append(f"- Players Tracked: {len(teams[team_id])}")
 
             total_dist = sum(
-                performance_tracker.get_player_stats(pid, fps)['total_distance_m']
+                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
@@ -1352,38 +1316,31 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         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. Distance/speed validation")
-        summary_lines.append("✅ 5. Performance analytics")
-        summary_lines.append("✅ 6. Heatmaps & radar generation")
-
-        if warnings:
-            summary_lines.append("\n⚠️ **Validation Warnings:**")
-            for warning in warnings[:5]:  # Show first 5 warnings
-                summary_lines.append(f"- {warning}")
+        summary_lines.append("✅ 4. Performance analytics")
+        summary_lines.append("✅ 5. Heatmaps & radar generation")
 
         summary_msg = "\n".join(summary_lines)
 
-        # ---------- player stats table for Gradio Dataframe ----------
+        # Player stats table
         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']),
+                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)
 
-        # ---------- events timeline text ----------
+        # Events timeline text
         if events:
             lines = []
             for ev in events:
@@ -1419,7 +1376,7 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
         else:
             events_text = "No events detected."
 
-        # ---------- JSON file with events ----------
+        # JSON file with events
         events_json_path = "/tmp/events.json"
         with open(events_json_path, "w", encoding="utf-8") as f:
             json.dump(events, f, indent=2)
@@ -1440,10 +1397,15 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
 
     except Exception as e:
         import traceback
+
         traceback.print_exc()
         error_msg = f"❌ Error: {str(e)}"
         return (
-            None, None, None, None, None,
+            None,
+            None,
+            None,
+            None,
+            None,
             error_msg,
             [],
             "No events detected.",
@@ -1455,25 +1417,21 @@ Your ROBOFLOW_API_KEY appears to be invalid or you've hit usage limits.
 # GRADIO INTERFACE
 # ==============================================
 with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
-    gr.Markdown("""
+    gr.Markdown(
+        """
     # ⚽ Advanced Football Video Analyzer
-    ### Complete Pipeline with Accurate Distance & Speed Tracking
+    ### Complete Pipeline Implementation
 
     This application computes:
     - Player & team detection with Roboflow
     - Team classification using SigLIP
     - Persistent tracking with ByteTrack
-    - **Realistic distances and speeds** (proper pitch scaling)
+    - Distances, speeds, and zone activity
     - Ball possession (per team & per player)
     - Events: passes, tackles, interceptions, shots, clearances, possession changes
     - Heatmaps and tactical radar view
-    - **Validation warnings** for unrealistic statistics
-    
-    **Expected realistic values:**
-    - Distance covered: 800-1200m per 10 minutes
-    - Average speed: 5-8 km/h (during active play)
-    - Max speed: 20-35 km/h (sprinting)
-    """)
+    """
+    )
 
     with gr.Row():
         video_input = gr.Video(label="📤 Upload Football Video")
@@ -1505,7 +1463,9 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             radar_output = gr.Image(label="Tactical Radar View")
 
         with gr.Tab("📈 Player Stats & Events"):
-            gr.Markdown("### Per-player stats (distance, speed, zones, possession time)")
+            gr.Markdown(
+                "### Per-player stats (distance, speed, zones, possession time)"
+            )
             player_stats_df = gr.Dataframe(
                 headers=[
                     "player_id",
@@ -1547,4 +1507,5 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
     )
 
 if __name__ == "__main__":
-    iface.launch()
+    # `share=True` is not supported on HF Spaces.
+    iface.launch()