Update app.py

app.py

@@ -4,6 +4,7 @@ from collections import deque, defaultdict
 from typing import List, Tuple, Dict, Optional, Union, Any
 from io import BytesIO
 import base64
+import time
 
 import cv2
 import numpy as np
@@ -26,7 +27,8 @@ from more_itertools import chunked
 from sklearn.cluster import KMeans
 import umap
 
-from inference_sdk import InferenceHTTPClient
+from inference import get_model
+from inference_sdk.http.errors import HTTPCallErrorError
 
 # ==============================================
 # ENVIRONMENT VARIABLES
@@ -40,29 +42,93 @@ 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
+# ==============================================
+# REAL-WORLD PITCH DIMENSIONS
+# ==============================================
+CONFIG = SoccerPitchConfiguration()
+
+# 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
+# MODEL INITIALIZATION
 # ==============================================
-CLIENT = InferenceHTTPClient(
-    api_url="https://detect.roboflow.com",
-    api_key=ROBOFLOW_API_KEY
-)
+PLAYER_DETECTION_MODEL = None
+FIELD_DETECTION_MODEL = None
 
 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 initialize_models():
+    """Initialize detection models with local inference (more reliable than HTTP API)"""
+    global PLAYER_DETECTION_MODEL, FIELD_DETECTION_MODEL
+    
+    try:
+        print("📦 Loading detection models locally...")
+        PLAYER_DETECTION_MODEL = get_model(
+            model_id=PLAYER_DETECTION_MODEL_ID,
+            api_key=ROBOFLOW_API_KEY
+        )
+        FIELD_DETECTION_MODEL = get_model(
+            model_id=FIELD_DETECTION_MODEL_ID,
+            api_key=ROBOFLOW_API_KEY
+        )
+        print("✅ Models loaded successfully")
+    except Exception as e:
+        print(f"❌ Failed to load models: {e}")
+        raise
+
+
+def infer_with_confidence(
+    model,
+    frame: np.ndarray,
+    confidence_threshold: float = 0.3,
+    max_retries: int = 3
+):
+    """
+    Run inference with retry logic for transient errors.
+    
+    Args:
+        model: The detection model to use
+        frame: Input frame
+        confidence_threshold: Confidence threshold for detections
+        max_retries: Maximum number of retry attempts
+    
+    Returns:
+        Tuple of (result, detections)
+    """
+    for attempt in range(max_retries):
+        try:
+            result = model.infer(frame, confidence=confidence_threshold)[0]
+            detections = sv.Detections.from_inference(result)
+            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)
+            else:
+                print(f"❌ All inference attempts failed: {e}")
+                # Return empty detections to continue processing
+                return None, sv.Detections.empty()
 
-def infer_with_confidence(model_id: str, frame: np.ndarray, confidence_threshold: float = 0.3):
-    """Run inference and filter by confidence threshold"""
-    result = CLIENT.infer(frame, model_id=model_id)
-    detections = sv.Detections.from_inference(result)
-    if len(detections) > 0:
-        detections = detections[detections.confidence > confidence_threshold]
-    return result, detections
 
+# Initialize models at startup
+initialize_models()
 
 # ==============================================
 # SIGLIP MODEL (Embeddings)
@@ -72,9 +138,22 @@ EMBEDDINGS_MODEL = SiglipVisionModel.from_pretrained(SIGLIP_MODEL_PATH, token=HF
 EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF_TOKEN)
 
 # ==============================================
-# TEAM CONFIG
+# DISTANCE CALCULATION UTILITIES
 # ==============================================
-CONFIG = SoccerPitchConfiguration()
+def calculate_real_distance(pos1: np.ndarray, pos2: np.ndarray) -> float:
+    """
+    Calculate real-world distance in meters between two pitch positions.
+    
+    Args:
+        pos1, pos2: positions in pitch coordinate units [x, y]
+    
+    Returns:
+        distance in meters
+    """
+    dx = (pos2[0] - pos1[0]) * SCALE_X
+    dy = (pos2[1] - pos1[1]) * SCALE_Y
+    distance_m = np.sqrt(dx**2 + dy**2)
+    return float(distance_m)
 
 
 # ==============================================
@@ -82,9 +161,12 @@ CONFIG = SoccerPitchConfiguration()
 # ==============================================
 def replace_outliers_based_on_distance(
     positions: List[np.ndarray],
-    distance_threshold: float
+    distance_threshold_m: float = 50.0  # 50 meters is realistic max between frames
 ) -> List[np.ndarray]:
-    """Remove outlier positions based on distance threshold (in same units as positions)"""
+    """
+    Remove outlier positions based on real-world distance threshold in meters.
+    Ball can't travel more than ~50m between frames at normal frame rates.
+    """
     last_valid_position: Union[np.ndarray, None] = None
     cleaned_positions: List[np.ndarray] = []
 
@@ -96,8 +178,11 @@ def replace_outliers_based_on_distance(
                 cleaned_positions.append(position)
                 last_valid_position = position
             else:
-                distance = np.linalg.norm(position - last_valid_position)
-                if distance > distance_threshold:
+                # Calculate real distance in meters
+                distance_m = calculate_real_distance(last_valid_position, position)
+                
+                if distance_m > distance_threshold_m:
+                    # Outlier detected - mark as invalid
                     cleaned_positions.append(np.array([], dtype=np.float64))
                 else:
                     cleaned_positions.append(position)
@@ -110,85 +195,77 @@ def replace_outliers_based_on_distance(
 # PLAYER PERFORMANCE TRACKING
 # ==============================================
 class PlayerPerformanceTracker:
-    """Track individual player performance metrics and generate heatmaps"""
+    """Track individual player performance metrics with correct real-world scaling"""
 
     def __init__(self, pitch_config):
         self.config = pitch_config
-        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_positions = defaultdict(list)  # (x, y, frame) in config units
+        self.player_velocities = defaultdict(list)  # m/s
+        self.player_distances_m = defaultdict(float)
         self.player_team = {}
         self.player_stats = defaultdict(lambda: {
             'frames_visible': 0,
-            'avg_velocity_cm_s': 0.0,
-            'max_velocity_cm_s': 0.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_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:
+    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:
             return
 
         self.player_team[tracker_id] = team_id
-        self.player_positions[tracker_id].append((position_cm[0], position_cm[1], frame))
+        self.player_positions[tracker_id].append((position[0], position[1], frame))
         self.player_stats[tracker_id]['frames_visible'] += 1
 
         if len(self.player_positions[tracker_id]) > 1:
             prev_pos = np.array(self.player_positions[tracker_id][-2][:2])
-            curr_pos = np.array(position_cm)
-            distance_cm = np.linalg.norm(curr_pos - prev_pos)
-            self.player_distances_cm[tracker_id] += distance_cm
+            curr_pos = np.array(position)
+            
+            # Calculate REAL distance in meters
+            distance_m = calculate_real_distance(prev_pos, curr_pos)
+            self.player_distances_m[tracker_id] += distance_m
 
+            # Calculate velocity in m/s
             dt = 1.0 / fps
-            velocity_cm_s = distance_cm / dt
-            self.player_velocities[tracker_id].append(velocity_cm_s)
+            velocity_m_s = distance_m / dt
+            self.player_velocities[tracker_id].append(velocity_m_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
+            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
 
-        pitch_length_cm = self.config.length  # same units as transform
-        x = position_cm[0]
-        if x < pitch_length_cm / 3:
+        # 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_cm / 3:
+        elif x < 2 * pitch_length / 3:
             self.player_stats[tracker_id]['time_in_middle_third_frames'] += 1
         else:
             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 (distances in m, speed in m/s and km/h)."""
+        """Get comprehensive stats for a player in real-world units."""
         stats = self.player_stats[tracker_id].copy()
 
         if len(self.player_velocities[tracker_id]) > 0:
-            stats['avg_velocity_cm_s'] = float(np.mean(self.player_velocities[tracker_id]))
+            stats['avg_velocity_m_s'] = float(np.mean(self.player_velocities[tracker_id]))
 
-        # 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
+        # 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)
 
-        # 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 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
 
-        # 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
+        # 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
 
         return stats
 
@@ -264,6 +341,53 @@ class PlayerTrackingManager:
         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
 # ==============================================
@@ -527,12 +651,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                                Optional[str]
                            ]:
     """
-    Complete football analysis pipeline:
-      * team classification
-      * tracking + speeds/distances
-      * possession per team & per player
-      * events: passes, tackles, interceptions, shots, clearances, possession changes
-      * heatmaps + radar
+    Complete football analysis pipeline with proper distance/speed calculations
     """
     if not video_path:
         return (None, None, None, None, None,
@@ -542,11 +661,9 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
     try:
         progress(0, desc="🔧 Initializing...")
 
-        # IDs from Roboflow model
-        BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
         STRIDE = 30
         MAXLEN = 5
-        MAX_DISTANCE_THRESHOLD = 500.0  # in 'cm' units of pitch
+        MAX_DISTANCE_THRESHOLD_M = 50.0  # realistic max ball travel between frames
 
         # Managers
         tracking_manager = PlayerTrackingManager(max_history=10)
@@ -608,7 +725,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
             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, 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:
@@ -645,7 +762,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
 
         # stats for events / possession
         dt = 1.0 / fps
-        distance_covered_per_player_m = defaultdict(float)  # using correct meters
+        distance_covered_per_player_m = defaultdict(float)
         possession_time_player_s = defaultdict(float)
         possession_time_team_s = defaultdict(float)
         team_of_player: Dict[int, int] = {}
@@ -657,19 +774,17 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
         EVENT_TEXT_DURATION_FRAMES = int(2.0 * fps)
 
         prev_owner_tid: Optional[int] = None
-        prev_ball_pos_pitch_cm: Optional[np.ndarray] = None
+        prev_ball_pos_pitch: Optional[np.ndarray] = None
 
-        # approximate goal centers in pitch coords (same units)
+        # 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 in cm units
+        # thresholds
         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):
@@ -693,7 +808,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                          desc=f"🎬 Processing frame {frame_idx}/{total_frames}")
 
             # --- detections ---
-            _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
+            _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL, frame, 0.3)
             if len(detections.xyxy) == 0:
                 out.write(frame)
                 ball_path_raw.append(np.empty((0, 2)))
@@ -738,27 +853,27 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
 
             # --- field homography ---
             try:
-                result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 0.3)
+                result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL, frame, 0.3)
                 key_points = sv.KeyPoints.from_inference(result_field)
 
                 filter_mask = key_points.confidence[0] > 0.5
                 frame_ref_pts = key_points.xy[0][filter_mask]
                 pitch_ref_pts = np.array(CONFIG.vertices)[filter_mask]
 
-                frame_ball_pos_pitch_cm = None
-                frame_players_xy_pitch_cm = None
+                frame_ball_pos_pitch = None
+                frame_players_xy_pitch = 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 position in pitch coords (cm)
+                    # ball position in pitch coords
                     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_cm = 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])
@@ -773,44 +888,47 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                     last_players_class_id = all_players.class_id
                     last_pitch_referees_xy = pitch_referees_xy
 
-                    frame_players_xy_pitch_cm = pitch_players_xy
+                    frame_players_xy_pitch = pitch_players_xy
 
-                    # update performance tracker + distance/speed stats
+                    # update performance tracker with REAL distance calculations
                     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]
+                        pos = pitch_players_xy[idx]
                         performance_tracker.update(
-                            tid_int, pos_cm, team_id, frame_idx, fps
+                            tid_int, pos, team_id, frame_idx, fps
                         )
 
-                        # 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 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)
                             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)))
-                    frame_ball_pos_pitch_cm = None
-                    frame_players_xy_pitch_cm = None
+                    frame_ball_pos_pitch = None
+                    frame_players_xy_pitch = None
             except Exception:
                 ball_path_raw.append(np.empty((0, 2)))
-                frame_ball_pos_pitch_cm = None
-                frame_players_xy_pitch_cm = None
+                frame_ball_pos_pitch = None
+                frame_players_xy_pitch = None
 
             # --- possession owner ---
             owner_tid: Optional[int] = None
-            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:
+            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:
                     owner_tid = int(all_players.tracker_id[j])
 
             # accumulate possession time
@@ -825,18 +943,16 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
 
             if owner_tid != prev_owner_tid:
                 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)
-                    )
+                        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)
+                    
                     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_cm > MIN_PASS_TRAVEL_CM:
+                        if prev_team == cur_team and travel_m > MIN_PASS_TRAVEL_M:
                             # pass
-                            dist_m = travel_cm / CM_PER_METER
                             register_event(
                                 {
                                     "type": "pass",
@@ -845,23 +961,20 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                                     "from_player_id": int(prev_owner_tid),
                                     "to_player_id": int(owner_tid),
                                     "team_id": int(cur_team),
-                                    "distance_m": dist_m,
+                                    "distance_m": travel_m,
                                 },
-                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team}, {dist_m:.1f} m)"
+                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team}, {travel_m:.1f} m)"
                             )
                         elif prev_team != cur_team:
                             # 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
+                            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)
 
                             ev_type = "tackle"
                             label = "Tackle"
@@ -881,7 +994,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                                 f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}"
                             )
 
-                # explicit possession change event (only when someone gains it)
+                # explicit possession change event
                 if owner_tid is not None:
                     register_event(
                         {
@@ -896,20 +1009,24 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                     )
 
             # shot / clearance
-            if prev_ball_pos_pitch_cm is not None and frame_ball_pos_pitch_cm is not None \
+            if prev_ball_pos_pitch is not None and frame_ball_pos_pitch 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
+                # 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
                 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_cm
+                        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_cm, direction) /
-                            (np.linalg.norm(v_cm) * np.linalg.norm(direction) + 1e-6)
+                            np.dot(v_scaled, direction_scaled) /
+                            (np.linalg.norm(v_scaled) * np.linalg.norm(direction_scaled) + 1e-6)
                         )
                         if cos_angle > 0.8:
                             register_event(
@@ -937,7 +1054,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
                             )
 
             prev_owner_tid = owner_tid
-            prev_ball_pos_pitch_cm = frame_ball_pos_pitch_cm
+            prev_ball_pos_pitch = frame_ball_pos_pitch
 
             # --- draw frame ---
             annotated_frame = frame.copy()
@@ -947,14 +1064,13 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
             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
+                    # 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_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
+                        prev = np.array(pos_list[-2][:2])
+                        curr = np.array(pos_list[-1][:2])
+                        dist_m = calculate_real_distance(prev, curr)
                         speed_km_h = (dist_m / dt) * 3.6
 
                     d_total_m = distance_covered_per_player_m[tid_int]
@@ -1043,12 +1159,21 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
         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
+            MAX_DISTANCE_THRESHOLD_M
         )
         print(f"✅ Ball path cleaned: {len([p for p in cleaned_path if len(p) > 0])} valid points")
 
         # -----------------------------------
-        # STEP 4: performance analytics
+        # 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
         # -----------------------------------
         progress(0.70, desc="📊 Generating performance analytics (Step 5/7)...")
 
@@ -1093,7 +1218,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
             individual_heatmaps_path = None
 
         # -----------------------------------
-        # STEP 5: radar view
+        # STEP 6: radar view
         # -----------------------------------
         progress(0.85, desc="🗺️ Creating game-style radar view (Step 6/7)...")
         radar_path = "/tmp/radar_view_enhanced.png"
@@ -1114,7 +1239,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
             radar_path = None
 
         # -----------------------------------
-        # STEP 6: summary + tabular stats + events
+        # STEP 7: summary + tabular stats + events
         # -----------------------------------
         progress(0.92, desc="📝 Building summary & tables (Step 7/7)...")
 
@@ -1123,6 +1248,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
         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"
         )
@@ -1147,8 +1273,14 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
         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_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_msg = "\n".join(summary_lines)
 
@@ -1246,16 +1378,22 @@ def analyze_football_video(video_path: str, progress=gr.Progress()
 with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
     # ⚽ Advanced Football Video Analyzer
-    ### Complete Pipeline Implementation
+    ### Complete Pipeline with Accurate Distance & Speed Tracking
 
     This application computes:
     - Player & team detection with Roboflow
     - Team classification using SigLIP
     - Persistent tracking with ByteTrack
-    - Distances, speeds, and zone activity
+    - **Realistic distances and speeds** (proper pitch scaling)
     - 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():
@@ -1330,5 +1468,4 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
     )
 
 if __name__ == "__main__":
-    # `share=True` is not supported on HF Spaces, so keep default.
-    iface.launch()
+    iface.launch()