Update app.py

app.py

@@ -1,463 +1,819 @@
 import os
+from collections import deque, defaultdict
+from typing import List, Tuple, Dict
+from io import BytesIO
+import base64
 
-# Suppress inference model warnings (must be at the very top)
-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"
+import cv2
+import numpy as np
+from PIL import Image
+import torch
+from tqdm import tqdm
+from scipy.ndimage import gaussian_filter
+
+import supervision as sv
+from sports.common.team import TeamClassifier
+from sports.common.view import ViewTransformer
+from sports.annotators.soccer import draw_pitch, draw_points_on_pitch, draw_paths_on_pitch
+from sports.configs.soccer import SoccerPitchConfiguration
 
 import gradio as gr
-import uuid
-import shutil
-import json
-import time
-from pathlib import Path
-from PIL import Image
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from transformers import AutoProcessor, SiglipVisionModel
+from more_itertools import chunked
+from sklearn.cluster import KMeans
+import umap
 
-# Import your existing pipeline
-from pipeline_full import run_full_pipeline
+from inference_sdk import InferenceHTTPClient
 
-BASE_RESULTS_DIR = "jobs"
-Path(BASE_RESULTS_DIR).mkdir(exist_ok=True)
+# ==============================================
+# ENVIRONMENT VARIABLES
+# ==============================================
+HF_TOKEN = os.environ.get("HF_TOKEN")
+ROBOFLOW_API_KEY = os.environ.get("ROBOFLOW_API_KEY")
 
+if not HF_TOKEN or not ROBOFLOW_API_KEY:
+    raise ValueError("❌ HF_TOKEN and ROBOFLOW_API_KEY must be set as environment variables.")
 
-def monitor_progress(job_dir):
-    """
-    Monitor the status.json file and yield progress updates
-    """
-    status_file = os.path.join(job_dir, "status.json")
-    
-    last_progress = 0
-    last_stage = ""
-    
-    # Keep checking until done or error
-    max_wait = 300  # 5 minutes max
-    start_time = time.time()
-    
-    while (time.time() - start_time) < max_wait:
-        if os.path.exists(status_file):
-            try:
-                with open(status_file, 'r') as f:
-                    status = json.load(f)
-                
-                stage = status.get('stage', '')
-                progress = status.get('progress', 0)
-                message = status.get('message', '')
-                
-                # Only yield if something changed
-                if stage != last_stage or progress != last_progress:
-                    last_stage = stage
-                    last_progress = progress
-                    
-                    # Map stages to friendly names with emojis
-                    stage_map = {
-                        'initializing': '🚀 Initializing',
-                        'siglip': '🤖 SigLIP Clustering',
-                        'team_classifier': '👕 Team Classification',
-                        'basic_frames': '🎯 Basic Detection',
-                        'advanced_views': '🎨 Tactical Views',
-                        'ball_path': '⚽ Ball Tracking',
-                        'stats': '📊 Statistics',
-                        'done': '✅ Complete',
-                        'error': '❌ Error'
-                    }
-                    
-                    friendly_stage = stage_map.get(stage, stage)
-                    percentage = int(progress * 100)
-                    
-                    status_msg = f"**[{percentage}%]** {friendly_stage}"
-                    if message:
-                        status_msg += f"\n\n_{message}_"
-                    
-                    yield status_msg
-                    
-                    # Stop if done or error
-                    if stage in ['done', 'error']:
-                        break
-                        
-            except Exception as e:
-                print(f"Error reading status: {e}")
-        
-        time.sleep(1)  # Poll every second
-    
-    # Final status
-    yield "✅ **Processing complete!** Loading results..."
-
-
-def analyze_video(video_file):
-    """
-    Main analysis function with real-time progress monitoring
-    """
-    # Initial empty outputs
-    empty_outputs = (None, None, None, None, None, None, None, None)
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🖥️ Using device: {DEVICE}")
+
+# ==============================================
+# ROBOFLOW INFERENCE CLIENT
+# ==============================================
+CLIENT = InferenceHTTPClient(
+    api_url="https://detect.roboflow.com",
+    api_key=ROBOFLOW_API_KEY
+)
+
+PLAYER_DETECTION_MODEL_ID = "football-players-detection-3zvbc/11"
+FIELD_DETECTION_MODEL_ID = "football-field-detection-f07vi/14"
+
+# ==============================================
+# 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)
+
+# ==============================================
+# TEAM CLASSIFIER & CONFIG
+# ==============================================
+CONFIG = SoccerPitchConfiguration()
+
+# ==============================================
+# PLAYER PERFORMANCE TRACKING
+# ==============================================
+class PlayerPerformanceTracker:
+    """Track individual player performance metrics and generate heatmaps"""
     
-    if video_file is None:
-        yield (*empty_outputs, "❌ **Please upload a video file**")
-        return
+    def __init__(self, pitch_config):
+        self.config = pitch_config
+        self.player_positions = defaultdict(list)  # tracker_id -> list of (x, y, frame)
+        self.player_velocities = defaultdict(list)  # tracker_id -> list of velocities
+        self.player_distances = defaultdict(float)  # tracker_id -> total distance
+        self.player_team = {}  # tracker_id -> team_id
+        self.player_stats = defaultdict(lambda: {
+            'frames_visible': 0,
+            'avg_velocity': 0,
+            'max_velocity': 0,
+            'time_in_attacking_third': 0,
+            'time_in_defensive_third': 0,
+            'time_in_middle_third': 0
+        })
+        
+    def update(self, tracker_id: int, position: np.ndarray, team_id: int, frame: int):
+        """Update player position and calculate metrics"""
+        if len(position) != 2:
+            return
+            
+        self.player_team[tracker_id] = team_id
+        self.player_positions[tracker_id].append((position[0], position[1], frame))
+        self.player_stats[tracker_id]['frames_visible'] += 1
+        
+        # Calculate velocity if we have previous position
+        if len(self.player_positions[tracker_id]) > 1:
+            prev_pos = np.array(self.player_positions[tracker_id][-2][:2])
+            curr_pos = np.array(position)
+            distance = np.linalg.norm(curr_pos - prev_pos)
+            self.player_distances[tracker_id] += distance
+            
+            # Velocity (assuming 30 fps)
+            velocity = distance * 30  # cm/s
+            self.player_velocities[tracker_id].append(velocity)
+            
+            # Update velocity stats
+            if velocity > self.player_stats[tracker_id]['max_velocity']:
+                self.player_stats[tracker_id]['max_velocity'] = velocity
+        
+        # Track position zones (thirds of the pitch)
+        pitch_length = self.config.length
+        if position[0] < pitch_length / 3:
+            self.player_stats[tracker_id]['time_in_defensive_third'] += 1
+        elif position[0] < 2 * pitch_length / 3:
+            self.player_stats[tracker_id]['time_in_middle_third'] += 1
+        else:
+            self.player_stats[tracker_id]['time_in_attacking_third'] += 1
     
-    try:
-        # Create job directory
-        job_id = str(uuid.uuid4())
-        job_dir = os.path.join(BASE_RESULTS_DIR, job_id)
-        os.makedirs(job_dir, exist_ok=True)
-        
-        yield (*empty_outputs, f"🔧 **[0%]** Setting up job `{job_id[:8]}...`")
-        
-        # Copy video file
-        video_input_path = video_file
+    def get_player_stats(self, tracker_id: int) -> dict:
+        """Get comprehensive stats for a player"""
+        stats = self.player_stats[tracker_id].copy()
         
-        if not os.path.exists(video_input_path):
-            yield (*empty_outputs, f"❌ **Video file not found:** `{video_input_path}`")
-            return
+        if len(self.player_velocities[tracker_id]) > 0:
+            stats['avg_velocity'] = np.mean(self.player_velocities[tracker_id])
         
-        video_filename = f"input_{uuid.uuid4().hex[:8]}.mp4"
-        video_path = os.path.join(job_dir, video_filename)
-        shutil.copy2(video_input_path, video_path)
+        stats['total_distance'] = self.player_distances[tracker_id]
+        stats['total_distance_meters'] = self.player_distances[tracker_id] / 100  # Convert to meters
+        stats['team_id'] = self.player_team.get(tracker_id, -1)
         
-        yield (*empty_outputs, f"📁 **[5%]** Video copied successfully")
+        return stats
+    
+    def generate_heatmap(self, tracker_id: int, resolution: int = 100) -> np.ndarray:
+        """Generate heatmap for a specific player"""
+        if tracker_id not in self.player_positions or len(self.player_positions[tracker_id]) == 0:
+            return np.zeros((resolution, resolution))
         
-        # Start pipeline in separate thread
-        import threading
+        positions = np.array([(x, y) for x, y, _ in self.player_positions[tracker_id]])
         
-        pipeline_error = []
-        pipeline_complete = []
+        # Create 2D histogram
+        pitch_length = self.config.length
+        pitch_width = self.config.width
         
-        def run_pipeline_thread():
-            try:
-                result = run_full_pipeline(video_path, job_dir)
-                pipeline_complete.append(result)
-            except Exception as e:
-                pipeline_error.append(str(e))
-        
-        thread = threading.Thread(target=run_pipeline_thread, daemon=True)
-        thread.start()
-        
-        # Monitor progress while pipeline runs
-        for progress_msg in monitor_progress(job_dir):
-            yield (*empty_outputs, progress_msg)
-        
-        # Wait for thread to complete
-        thread.join(timeout=10)
-        
-        # Check for errors
-        if pipeline_error:
-            error_msg = f"""❌ **Error during analysis:**
-
-```
-{pipeline_error[0]}
-```
-
-**Troubleshooting:**
-- Ensure ROBOFLOW_API_KEY is set in Space secrets
-- Try a shorter video clip
-- Check container logs for details
-"""
-            yield (*empty_outputs, error_msg)
-            return
+        heatmap, xedges, yedges = np.histogram2d(
+            positions[:, 0], positions[:, 1],
+            bins=[resolution, resolution],
+            range=[[0, pitch_length], [0, pitch_width]]
+        )
         
-        # Load results
-        result_path = os.path.join(job_dir, "result.json")
+        # Apply Gaussian smoothing for better visualization
+        heatmap = gaussian_filter(heatmap, sigma=3)
         
-        if not os.path.exists(result_path):
-            yield (*empty_outputs, "⚠️ **Result file not found.** Pipeline may still be processing.")
-            return
+        return heatmap.T  # Transpose for correct orientation
+    
+    def get_all_players_by_team(self) -> Dict[int, List[int]]:
+        """Get all player IDs grouped by team"""
+        teams = defaultdict(list)
+        for tracker_id, team_id in self.player_team.items():
+            teams[team_id].append(tracker_id)
+        return teams
+
+
+# ==============================================
+# TRACKING MANAGER
+# ==============================================
+class PlayerTrackingManager:
+    """Manages persistent player tracking with team assignment stability"""
+    
+    def __init__(self, max_history=10):
+        self.tracker_team_history: Dict[int, List[int]] = defaultdict(list)
+        self.max_history = max_history
+        self.active_trackers = set()
+        
+    def update_team_assignment(self, tracker_id: int, team_id: int):
+        """Store team assignment history for each tracker"""
+        self.tracker_team_history[tracker_id].append(team_id)
+        if len(self.tracker_team_history[tracker_id]) > self.max_history:
+            self.tracker_team_history[tracker_id].pop(0)
+        self.active_trackers.add(tracker_id)
+    
+    def get_stable_team_id(self, tracker_id: int, current_team_id: int) -> int:
+        """Get stable team ID using majority voting from history"""
+        if tracker_id not in self.tracker_team_history or len(self.tracker_team_history[tracker_id]) < 3:
+            return current_team_id
+        
+        history = self.tracker_team_history[tracker_id]
+        team_counts = np.bincount(history)
+        stable_team = np.argmax(team_counts)
+        return stable_team
+    
+    def get_player_count_by_team(self) -> Dict[int, int]:
+        """Get current count of players per team"""
+        team_counts = defaultdict(int)
+        for tracker_id in self.active_trackers:
+            if tracker_id in self.tracker_team_history and len(self.tracker_team_history[tracker_id]) > 0:
+                stable_team = self.get_stable_team_id(tracker_id, self.tracker_team_history[tracker_id][-1])
+                team_counts[stable_team] += 1
+        return team_counts
+    
+    def reset_frame(self):
+        """Reset active trackers for new frame"""
+        self.active_trackers = set()
+
+
+# ==============================================
+# VISUALIZATION FUNCTIONS
+# ==============================================
+def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTracker, 
+                                       tracker_id: int) -> np.ndarray:
+    """Create a single player heatmap overlay on pitch"""
+    pitch = draw_pitch(CONFIG)
+    heatmap = performance_tracker.generate_heatmap(tracker_id, resolution=150)
+    
+    # Normalize heatmap
+    if heatmap.max() > 0:
+        heatmap = heatmap / heatmap.max()
+    
+    # Create colored heatmap
+    scale = 0.1  # Same scale as pitch
+    padding = 50
+    
+    pitch_height, pitch_width = pitch.shape[:2]
+    heatmap_resized = cv2.resize(heatmap, (pitch_width - 2*padding, pitch_height - 2*padding))
+    
+    # Apply colormap (red = high activity, blue = low activity)
+    heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), cv2.COLORMAP_JET)
+    
+    # Create overlay
+    overlay = pitch.copy()
+    overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
+    
+    # Blend with pitch
+    result = cv2.addWeighted(pitch, 0.6, overlay, 0.4, 0)
+    
+    # Add stats text
+    stats = performance_tracker.get_player_stats(tracker_id)
+    team_color = "Blue" if stats['team_id'] == 0 else "Pink"
+    
+    text_lines = [
+        f"Player #{tracker_id} ({team_color} Team)",
+        f"Distance: {stats['total_distance_meters']:.1f}m",
+        f"Avg Speed: {stats['avg_velocity']/100:.2f}m/s",
+        f"Max Speed: {stats['max_velocity']/100:.2f}m/s",
+        f"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)
+        y_offset += 25
+    
+    return result
+
+
+def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -> go.Figure:
+    """Create interactive performance comparison plots"""
+    teams = performance_tracker.get_all_players_by_team()
+    
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=('Distance Covered', 'Average Speed', 'Max Speed', 'Activity by Zone'),
+        specs=[[{'type': 'bar'}, {'type': 'bar'}],
+               [{'type': 'bar'}, {'type': 'bar'}]]
+    )
+    
+    colors = {0: '#00BFFF', 1: '#FF1493'}
+    team_names = {0: 'Team 0 (Blue)', 1: 'Team 1 (Pink)'}
+    
+    for team_id, player_ids in teams.items():
+        if team_id not in [0, 1]:
+            continue
+            
+        distances = []
+        avg_speeds = []
+        max_speeds = []
+        attacking_time = []
+        
+        for pid in player_ids:
+            stats = performance_tracker.get_player_stats(pid)
+            distances.append(stats['total_distance_meters'])
+            avg_speeds.append(stats['avg_velocity']/100)
+            max_speeds.append(stats['max_velocity']/100)
+            attacking_time.append(stats['time_in_attacking_third'])
+        
+        player_labels = [f"#{pid}" for pid in player_ids]
+        
+        # Distance covered
+        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
+        )
         
-        with open(result_path, 'r') as f:
-            result = json.load(f)
-        
-        # Extract results
-        basic = result["basic"]
-        adv = result["advanced"]
-        ball = result["ball"]
-        stats = result["stats"]
-        siglip_html = result["siglip_html"]
-        
-        # Load images
-        def load_image(path, name="image"):
-            if not path or not os.path.exists(path):
-                print(f"⚠️ {name} not found at {path}")
-                return None
-            try:
-                img = Image.open(path)
-                if img.mode != 'RGB':
-                    img = img.convert('RGB')
-                print(f"✅ Loaded {name}: {img.size}")
-                return img
-            except Exception as e:
-                print(f"❌ Error loading {name}: {e}")
-                return None
-        
-        print("=" * 60)
-        print("LOADING RESULT IMAGES...")
-        
-        raw_frame = load_image(basic["raw_frame"], "Raw frame")
-        boxes_labels = load_image(basic["boxes_labels"], "Boxes/labels")
-        ball_players = load_image(basic["ball_players"], "Ball/players")
-        
-        frame_advanced = load_image(adv["frame_advanced"], "Advanced frame")
-        radar = load_image(adv["radar"], "Radar")
-        voronoi = load_image(adv["voronoi"], "Voronoi")
-        voronoi_blended = load_image(adv["voronoi_blended"], "Voronoi blended")
-        
-        ball_path_cleaned = load_image(ball["ball_path_cleaned_img"], "Ball path")
-        
-        # Format stats
-        stats_text = json.dumps(stats, indent=2)
-        
-        # Count loaded images
-        images_loaded = sum([
-            raw_frame is not None,
-            boxes_labels is not None,
-            ball_players is not None,
-            frame_advanced is not None,
-            radar is not None,
-            voronoi_blended is not None,
-            ball_path_cleaned is not None
-        ])
-        
-        print(f"Images loaded: {images_loaded}/7")
-        print("=" * 60)
-        
-        # Create success message
-        clustering_link = ""
-        if siglip_html and os.path.exists(siglip_html):
-            rel_path = os.path.relpath(siglip_html, ".")
-            clustering_link = f'\n\n📊 <a href="file/{rel_path}" target="_blank">**View 3D Clustering Visualization**</a>'
-        
-        success_msg = f"""✅ **[100%] Analysis Complete!**
-
-**Job ID:** `{job_id}`
-
-**Results Generated:**
-- ✅ Player detections ({images_loaded}/7 images loaded)
-- ✅ Team classifications
-- ✅ Tactical visualizations
-- ✅ Ball trajectory analysis
-- ✅ Match statistics
-
-{clustering_link}
-
----
-*Scroll through the tabs above to see all visualizations*
-
-**Note:** If images appear dark, try uploading a brighter video with good lighting.
-"""
-        
-        # Final yield with all results
-        yield (
-            raw_frame,
-            boxes_labels,
-            ball_players,
-            frame_advanced,
-            radar,
-            voronoi_blended,
-            ball_path_cleaned,
-            stats_text,
-            success_msg
+        # Average speed
+        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
         )
         
-    except Exception as e:
-        import traceback
-        error_detail = traceback.format_exc()
+        # Max speed
+        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
+        )
         
-        error_msg = f"""❌ **Unexpected Error:**
+        # Attacking third time
+        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
+        )
+    
+    fig.update_xaxes(title_text="Players", row=1, col=1)
+    fig.update_xaxes(title_text="Players", row=1, col=2)
+    fig.update_xaxes(title_text="Players", row=2, col=1)
+    fig.update_xaxes(title_text="Players", row=2, col=2)
+    
+    fig.update_yaxes(title_text="Distance (m)", row=1, col=1)
+    fig.update_yaxes(title_text="Speed (m/s)", row=1, col=2)
+    fig.update_yaxes(title_text="Speed (m/s)", row=2, col=1)
+    fig.update_yaxes(title_text="Frames in Zone", row=2, col=2)
+    
+    fig.update_layout(height=800, title_text="Team Performance Comparison", barmode='group')
+    
+    return fig
 
-```python
-{str(e)}
-```
 
-**Debug Info:**
-- Video: `{video_file if video_file else 'None'}`
-- Job: `{job_dir if 'job_dir' in locals() else 'Not created'}`
+def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> np.ndarray:
+    """Create side-by-side team heatmaps"""
+    teams = performance_tracker.get_all_players_by_team()
+    
+    team_heatmaps = []
+    for team_id in [0, 1]:
+        if team_id not in teams:
+            continue
+            
+        # Combine all players from this team
+        combined_heatmap = np.zeros((150, 150))
+        for pid in teams[team_id]:
+            player_heatmap = performance_tracker.generate_heatmap(pid, resolution=150)
+            combined_heatmap += player_heatmap
+        
+        if combined_heatmap.max() > 0:
+            combined_heatmap = combined_heatmap / combined_heatmap.max()
+        
+        # Create visualization
+        pitch = draw_pitch(CONFIG)
+        padding = 50
+        pitch_height, pitch_width = pitch.shape[:2]
+        heatmap_resized = cv2.resize(combined_heatmap, 
+                                    (pitch_width - 2*padding, pitch_height - 2*padding))
+        
+        colormap = cv2.COLORMAP_JET if team_id == 0 else cv2.COLORMAP_HOT
+        heatmap_colored = cv2.applyColorMap((heatmap_resized * 255).astype(np.uint8), colormap)
+        
+        overlay = pitch.copy()
+        overlay[padding:pitch_height-padding, padding:pitch_width-padding] = heatmap_colored
+        result = cv2.addWeighted(pitch, 0.5, overlay, 0.5, 0)
+        
+        team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
+        cv2.putText(result, team_name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
+                   1, (255, 255, 255), 2, cv2.LINE_AA)
+        
+        team_heatmaps.append(result)
+    
+    if len(team_heatmaps) == 2:
+        return np.hstack(team_heatmaps)
+    elif len(team_heatmaps) == 1:
+        return team_heatmaps[0]
+    else:
+        return draw_pitch(CONFIG)
+
+
+# ==============================================
+# HELPER FUNCTIONS
+# ==============================================
+def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detections) -> np.ndarray:
+    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
+    ])
 
-**Full Traceback:**
-```
-{error_detail}
-```
-"""
-        print("=" * 60)
-        print("UNEXPECTED ERROR:")
-        print(error_detail)
-        print("=" * 60)
-        
-        yield (*empty_outputs, error_msg)
 
+def pil_image_to_data_uri(image: Image.Image) -> str:
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/png;base64,{img_str}"
 
-# Create Gradio interface
-with gr.Blocks(
-    title="⚽ Afrigoals - Football Analytics",
-    theme=gr.themes.Soft()
-) as demo:
+
+def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id, 
+                           pitch_referees_xy, ball_path=None):
+    """Create game-style radar view with ball trail effect"""
+    annotated_frame = draw_pitch(CONFIG)
     
-    gr.Markdown("""
-    # ⚽ Afrigoals - Football Analytics Platform
+    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:
+            for i, coords in enumerate(valid_path[-20:]):
+                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))
+                annotated_frame = draw_points_on_pitch(
+                    CONFIG, coords, 
+                    face_color=color, 
+                    edge_color=sv.Color.BLACK, 
+                    radius=int(6 + alpha * 4),
+                    pitch=annotated_frame
+                )
     
-    AI-powered match analysis using computer vision and machine learning.
+    if len(pitch_ball_xy) > 0:
+        annotated_frame = draw_points_on_pitch(
+            CONFIG, pitch_ball_xy, 
+            face_color=sv.Color.WHITE, 
+            edge_color=sv.Color.BLACK, 
+            radius=10, 
+            pitch=annotated_frame
+        )
     
-    **Features:**
-    - 🎯 Player detection and tracking
-    - 👕 Automatic team classification
-    - ⚽ Ball path tracking
-    - 🎨 Tactical visualizations (radar, Voronoi)
-    - 📊 3D clustering analysis
-    - 📈 Match statistics
+    for team_id, color_hex in zip([0, 1], ["00BFFF", "FF1493"]):
+        mask = players_class_id == team_id
+        if np.any(mask):
+            annotated_frame = draw_points_on_pitch(
+                CONFIG, pitch_players_xy[mask], 
+                face_color=sv.Color.from_hex(color_hex), 
+                edge_color=sv.Color.BLACK, 
+                radius=16, 
+                pitch=annotated_frame
+            )
     
-    ---
-    """)
+    if len(pitch_referees_xy) > 0:
+        annotated_frame = draw_points_on_pitch(
+            CONFIG, pitch_referees_xy, 
+            face_color=sv.Color.from_hex("FFD700"), 
+            edge_color=sv.Color.BLACK, 
+            radius=16, 
+            pitch=annotated_frame
+        )
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            video_input = gr.Video(
-                label="📹 Upload Match Video",
-                sources=["upload"],
+    return annotated_frame
+
+
+# ==============================================
+# MAIN ANALYSIS PIPELINE
+# ==============================================
+def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
+    """
+    Complete football analysis with performance tracking and heatmaps
+    """
+    if not video_path:
+        return None, None, None, None, None, "❌ Please upload a video file."
+
+    try:
+        progress(0, desc="🔧 Initializing...")
+
+        BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
+        STRIDE = 30
+        MAXLEN = 5
+
+        tracking_manager = PlayerTrackingManager(max_history=10)
+        performance_tracker = PlayerPerformanceTracker(CONFIG)
+
+        ellipse_annotator = sv.EllipseAnnotator(
+            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'), 
+            text_thickness=2
+        )
+        triangle_annotator = sv.TriangleAnnotator(
+            color=sv.Color.from_hex('#FFD700'), 
+            base=20, 
+            height=17
+        )
+
+        tracker = sv.ByteTrack(
+            track_activation_threshold=0.4,
+            lost_track_buffer=60,
+            minimum_matching_threshold=0.85,
+            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}"
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        print(f"📹 Video: {width}x{height}, {fps}fps, {total_frames} frames")
+
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        output_path = "/tmp/annotated_football.mp4"
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+        # Collect player crops
+        progress(0.05, desc="🏃 Collecting player samples...")
+        player_crops = []
+        frame_count = 0
+        while frame_count < min(total_frames, 300):
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            if frame_count % STRIDE == 0:
+                result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID)
+                detections = sv.Detections.from_inference(result)
+                players_detections = detections[detections.class_id == PLAYER_ID]
+
+                if len(players_detections.xyxy) > 0:
+                    crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
+                    player_crops.extend(crops)
+
+            frame_count += 1
+
+        if len(player_crops) == 0:
+            return None, None, None, None, None, "❌ No player crops collected."
+
+        print(f"✅ Collected {len(player_crops)} player samples")
+
+        # Train classifier
+        progress(0.15, desc="🎯 Training team classifier...")
+        team_classifier = TeamClassifier(device=DEVICE)
+        team_classifier.fit(player_crops)
+        print("✅ Team classifier trained")
+
+        # Process video
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        frame_count = 0
+        M = deque(maxlen=MAXLEN)
+        ball_path_raw = []
+
+        progress(0.2, desc="🎬 Processing video frames...")
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_count += 1
+            tracking_manager.reset_frame()
+            
+            if frame_count % 30 == 0:
+                progress(0.2 + 0.5 * (frame_count / total_frames), 
+                        desc=f"🎬 Frame {frame_count}/{total_frames}")
+
+            result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID)
+            detections = sv.Detections.from_inference(result)
+
+            if len(detections.xyxy) == 0:
+                out.write(frame)
+                continue
+
+            ball_detections = detections[detections.class_id == BALL_ID]
+            all_detections = detections[detections.class_id != BALL_ID]
+            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]
+
+            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])
+                    predicted_teams[idx] = tracking_manager.get_stable_team_id(
+                        tracker_id, predicted_teams[idx]
+                    )
+                
+                players_detections.class_id = predicted_teams
+
+            goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
+                players_detections, goalkeepers_detections
             )
+            referees_detections.class_id -= 1
+
+            all_detections = sv.Detections.merge([
+                players_detections, goalkeepers_detections, referees_detections
+            ])
+
+            labels = [f"#{tid}" for tid in all_detections.tracker_id]
+
+            annotated_frame = frame.copy()
+            annotated_frame = ellipse_annotator.annotate(annotated_frame, all_detections)
+            annotated_frame = label_annotator.annotate(annotated_frame, all_detections, labels=labels)
+            annotated_frame = triangle_annotator.annotate(annotated_frame, ball_detections)
+            out.write(annotated_frame)
+
+            # Performance tracking with field transformation
+            try:
+                result_field = CLIENT.infer(frame, model_id=FIELD_DETECTION_MODEL_ID)
+                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]
+                transformer = ViewTransformer(source=frame_ref_pts, target=pitch_ref_pts)
+                M.append(transformer.m)
+                transformer.m = np.mean(np.array(M), axis=0)
+
+                # Track ball
+                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)
+
+                # Track all players (including goalkeepers)
+                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)
+                
+                for idx, tracker_id in enumerate(all_players.tracker_id):
+                    if idx < len(pitch_players_xy):
+                        performance_tracker.update(
+                            tracker_id, 
+                            pitch_players_xy[idx], 
+                            all_players.class_id[idx],
+                            frame_count
+                        )
+            except:
+                ball_path_raw.append(np.empty((0, 2)))
+
+        cap.release()
+        out.release()
+        print(f"✅ Processed {frame_count} frames")
+
+        # Generate visualizations
+        progress(0.75, desc="📊 Generating performance analytics...")
+        
+        # Team comparison
+        comparison_fig = create_team_comparison_plot(performance_tracker)
+        
+        # Combined team heatmaps
+        team_heatmaps_path = "/tmp/team_heatmaps.png"
+        team_heatmaps = create_combined_heatmaps(performance_tracker)
+        cv2.imwrite(team_heatmaps_path, team_heatmaps)
+        
+        # Individual player heatmaps (top 6 players by distance)
+        progress(0.85, desc="🗺️ Creating individual heatmaps...")
+        teams = performance_tracker.get_all_players_by_team()
+        top_players = []
+        for team_id in [0, 1]:
+            if team_id in teams:
+                team_players = teams[team_id]
+                player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance']) 
+                                  for pid in team_players]
+                player_distances.sort(key=lambda x: x[1], reverse=True)
+                top_players.extend([pid for pid, _ in player_distances[:3]])
+        
+        individual_heatmaps = []
+        for pid in top_players[:6]:
+            heatmap = create_player_heatmap_visualization(performance_tracker, pid)
+            individual_heatmaps.append(heatmap)
+        
+        # Arrange individual heatmaps in grid
+        if len(individual_heatmaps) > 0:
+            rows = []
+            for i in range(0, len(individual_heatmaps), 3):
+                row_maps = individual_heatmaps[i:i+3]
+                if len(row_maps) == 3:
+                    rows.append(np.hstack(row_maps))
+                elif len(row_maps) == 2:
+                    rows.append(np.hstack([row_maps[0], row_maps[1]]))
+                else:
+                    rows.append(row_maps[0])
+            
+            individual_grid = np.vstack(rows) if len(rows) > 1 else rows[0]
+            individual_heatmaps_path = "/tmp/individual_heatmaps.png"
+            cv2.imwrite(individual_heatmaps_path, individual_grid)
+        else:
+            individual_heatmaps_path = None
+
+        # Radar view
+        progress(0.9, desc="🗺️ Creating game-style radar view...")
+        radar_path = "/tmp/radar_view_enhanced.png"
+        try:
+            radar_frame = create_game_style_radar(
+                pitch_ball_xy=ball_path_raw[-1] if ball_path_raw else np.empty((0, 2)),
+                pitch_players_xy=pitch_players_xy if 'pitch_players_xy' in locals() else np.empty((0, 2)),
+                players_class_id=all_players.class_id if 'all_players' in locals() else np.array([]),
+                pitch_referees_xy=np.empty((0, 2)),
+                ball_path=ball_path_raw
+            )
+            cv2.imwrite(radar_path, radar_frame)
+        except Exception as e:
+            print(f"⚠️ Radar view creation failed: {e}")
+            radar_path = None
+
+        # Generate summary stats
+        progress(0.95, desc="📝 Generating summary report...")
+        teams = performance_tracker.get_all_players_by_team()
+        
+        summary_lines = ["✅ **Analysis Complete!**\n"]
+        summary_lines.append(f"- Total Frames: {frame_count}")
+        summary_lines.append(f"- Ball Path Points: {len([p for p in ball_path_raw if len(p) > 0])}\n")
+        
+        for team_id in [0, 1]:
+            if team_id not in teams:
+                continue
             
-            gr.Markdown("""
-            **Supported formats:** MP4, AVI, MOV, MKV
+            team_name = "Team 0 (Blue)" if team_id == 0 else "Team 1 (Pink)"
+            summary_lines.append(f"\n**{team_name}:**")
+            summary_lines.append(f"- Players Tracked: {len(teams[team_id])}")
             
-            **Best results with:**
-            - 30-60 second clips
-            - Good lighting (daytime matches)
-            - Clear view of the pitch
-            - 720p or higher resolution
+            total_dist = sum(performance_tracker.get_player_stats(pid)['total_distance_meters'] 
+                           for pid in teams[team_id])
+            avg_dist = total_dist / len(teams[team_id]) if len(teams[team_id]) > 0 else 0
+            summary_lines.append(f"- Team Total Distance: {total_dist:.1f}m")
+            summary_lines.append(f"- Average Distance per Player: {avg_dist:.1f}m")
             
-            **Progress updates appear below** 👇
-            """)
+            # Top 3 performers
+            player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters']) 
+                              for pid in teams[team_id]]
+            player_distances.sort(key=lambda x: x[1], reverse=True)
             
-            analyze_btn = gr.Button(
-                "🔍 Analyze Video",
-                variant="primary",
-                size="lg"
-            )
+            summary_lines.append(f"\n  **Top Performers:**")
+            for i, (pid, dist) in enumerate(player_distances[:3], 1):
+                stats = performance_tracker.get_player_stats(pid)
+                summary_lines.append(
+                    f"  {i}. Player #{pid}: {dist:.1f}m, "
+                    f"Avg Speed: {stats['avg_velocity']/100:.2f}m/s"
+                )
+        
+        summary_msg = "\n".join(summary_lines)
+
+        progress(1.0, desc="✅ Complete!")
+
+        return (output_path, comparison_fig, team_heatmaps_path, 
+                individual_heatmaps_path, radar_path, summary_msg)
+
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        print(error_msg)
+        import traceback
+        traceback.print_exc()
+        return None, None, None, None, None, error_msg
+
+
+# ==============================================
+# GRADIO INTERFACE
+# ==============================================
+with gr.Blocks(title="⚽ Football Performance Analyzer") as iface:
+    gr.Markdown("""
+    # ⚽ Advanced Football Video Analyzer
+    Upload a football match video to get comprehensive performance analytics including:
+    - Player tracking with persistent IDs
+    - Individual and team heatmaps
+    - Distance covered and speed metrics
+    - Game-style radar view with ball tracking
+    """)
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 📊 Progress & Status")
-            status_output = gr.Markdown(
-                value="⏳ **Ready** - Upload a video and click Analyze to start"
-            )
+        video_input = gr.Video(label="Upload Football Video")
+    
+    analyze_btn = gr.Button("🚀 Analyze Video", variant="primary", size="lg")
     
-    gr.Markdown("---")
-    gr.Markdown("## 📊 Analysis Results")
-    gr.Markdown("*Results will appear here after analysis (typically 30-90 seconds)*")
+    with gr.Row():
+        status_output = gr.Textbox(label="Analysis Status & Summary", lines=20)
     
     with gr.Tabs():
-        with gr.Tab("🎯 Basic Detections"):
-            gr.Markdown("### Player and Ball Detection Results")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### Raw Frame")
-                    raw_frame_output = gr.Image(
-                        label="Original Frame",
-                        type="pil"
-                    )
-                with gr.Column():
-                    gr.Markdown("#### Detections with Boxes")
-                    boxes_output = gr.Image(
-                        label="Bounding Boxes + Labels",
-                        type="pil"
-                    )
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### Ball vs Players")
-                    ball_players_output = gr.Image(
-                        label="Ball & Players Markers",
-                        type="pil"
-                    )
+        with gr.Tab("📹 Annotated Video"):
+            video_output = gr.Video(label="Annotated Video with Player Tracking")
         
-        with gr.Tab("🎨 Advanced Views"):
-            gr.Markdown("### Tactical Analysis")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### Annotated Frame with Teams")
-                    advanced_output = gr.Image(
-                        label="Teams + Player IDs",
-                        type="pil"
-                    )
-                with gr.Column():
-                    gr.Markdown("#### Radar View")
-                    radar_output = gr.Image(
-                        label="Top-Down Tactical View",
-                        type="pil"
-                    )
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### Voronoi Diagram - Space Control")
-                    voronoi_output = gr.Image(
-                        label="Territory Control",
-                        type="pil"
-                    )
+        with gr.Tab("📊 Performance Comparison"):
+            comparison_output = gr.Plot(label="Team Performance Metrics")
         
-        with gr.Tab("⚽ Ball Analysis"):
-            gr.Markdown("### Ball Movement Tracking")
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### Ball Path (Cleaned)")
-                    ball_path_output = gr.Image(
-                        label="Ball Trajectory",
-                        type="pil"
-                    )
+        with gr.Tab("🗺️ Team Heatmaps"):
+            team_heatmaps_output = gr.Image(label="Combined Team Activity Heatmaps")
         
-        with gr.Tab("📈 Statistics"):
-            gr.Markdown("### Match Statistics")
-            stats_output = gr.Code(
-                label="JSON Data",
-                language="json",
-                lines=25
-            )
+        with gr.Tab("👤 Individual Heatmaps"):
+            individual_heatmaps_output = gr.Image(label="Top Players Individual Heatmaps")
+        
+        with gr.Tab("🎮 Game Radar View"):
+            radar_output = gr.Image(label="Game-Style Radar with Ball Trail")
     
-    # Wire up the button
     analyze_btn.click(
-        fn=analyze_video,
+        fn=analyze_football_video,
         inputs=[video_input],
         outputs=[
-            raw_frame_output,
-            boxes_output,
-            ball_players_output,
-            advanced_output,
+            video_output,
+            comparison_output,
+            team_heatmaps_output,
+            individual_heatmaps_output,
             radar_output,
-            voronoi_output,
-            ball_path_output,
-            stats_output,
             status_output
         ]
     )
     
     gr.Markdown("""
     ---
-    ## 📝 Information
-    
-    ### ⏱️ Processing Time
-    | Video Length | Est. Time |
-    |--------------|-----------|
-    | 30 seconds   | 30-60s    |
-    | 1 minute     | 60-120s   |
-    | 2 minutes    | 2-4 min   |
-    
-    ### 🔧 Technical Stack
-    - **Detection**: Roboflow YOLO models
-    - **Tracking**: ByteTrack algorithm
-    - **Embeddings**: SigLIP
-    - **Clustering**: UMAP + K-means
-    - **Visualization**: Supervision, Plotly, OpenCV
-    
-    ### ⚠️ Requirements
-    - ROBOFLOW_API_KEY must be set in Space secrets
-    - GPU recommended for faster processing
-    - Good lighting improves detection quality
+    ### 📋 Features:
+    - **Persistent Player Tracking**: IDs remain consistent throughout the video
+    - **Performance Metrics**: Distance covered, average/max speed, zone activity
+    - **Team Heatmaps**: Visualize team positioning and movement patterns
+    - **Individual Analysis**: Top 6 players by distance with detailed heatmaps
+    - **Professional Visualization**: Game-style radar view with ball trail effects
     
-    ---
-    **Built with ❤️ for African Football Analytics**
+    ### 🎯 Perfect for:
+    - Coaching staff analysis
+    - Player performance reports
+    - Tactical review sessions
+    - Scouting and recruitment
     """)
 
-
-# Launch
 if __name__ == "__main__":
-    demo.queue()  # Enable queuing for progress
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+    iface.launch()