Update app.py

app.py

@@ -9,6 +9,7 @@ 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
@@ -18,6 +19,7 @@ from sports.configs.soccer import SoccerPitchConfiguration
 
 import gradio as gr
 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
@@ -60,6 +62,317 @@ EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF
 # ==============================================
 CONFIG = SoccerPitchConfiguration()
 
+# ==============================================
+# PLAYER PERFORMANCE TRACKING
+# ==============================================
+class PlayerPerformanceTracker:
+    """Track individual player performance metrics and generate heatmaps"""
+    
+    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
+    
+    def get_player_stats(self, tracker_id: int) -> dict:
+        """Get comprehensive stats for a player"""
+        stats = self.player_stats[tracker_id].copy()
+        
+        if len(self.player_velocities[tracker_id]) > 0:
+            stats['avg_velocity'] = np.mean(self.player_velocities[tracker_id])
+        
+        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)
+        
+        return stats
+    
+    def generate_heatmap(self, tracker_id: int, resolution: int = 100) -> np.ndarray:
+        """Generate heatmap for a specific player"""
+        if tracker_id not in self.player_positions or len(self.player_positions[tracker_id]) == 0:
+            return np.zeros((resolution, resolution))
+        
+        positions = np.array([(x, y) for x, y, _ in self.player_positions[tracker_id]])
+        
+        # Create 2D histogram
+        pitch_length = self.config.length
+        pitch_width = self.config.width
+        
+        heatmap, xedges, yedges = np.histogram2d(
+            positions[:, 0], positions[:, 1],
+            bins=[resolution, resolution],
+            range=[[0, pitch_length], [0, pitch_width]]
+        )
+        
+        # Apply Gaussian smoothing for better visualization
+        heatmap = gaussian_filter(heatmap, sigma=3)
+        
+        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
+        )
+        
+        # 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
+        )
+        
+        # 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
+        )
+        
+        # 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
+
+
+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
 # ==============================================
@@ -75,129 +388,73 @@ def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detectio
         for gk in goalkeepers_xy
     ])
 
+
 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}"
 
-def create_umap_3d_plot(crops: List[np.ndarray]) -> Tuple[go.Figure, dict]:
-    if len(crops) == 0:
-        return go.Figure(), {}
-    BATCH_SIZE = 32
-    crops_pil = [sv.cv2_to_pillow(crop) for crop in crops]
-    batches = list(chunked(crops_pil, BATCH_SIZE))
-    data = []
-    with torch.no_grad():
-        for batch in tqdm(batches, desc="Extracting embeddings"):
-            inputs = EMBEDDINGS_PROCESSOR(images=batch, return_tensors="pt").to(DEVICE)
-            outputs = EMBEDDINGS_MODEL(**inputs)
-            embeddings = torch.mean(outputs.last_hidden_state, dim=1).cpu().numpy()
-            data.append(embeddings)
-    data = np.concatenate(data)
-    reducer = umap.UMAP(n_components=3, random_state=42)
-    projections = reducer.fit_transform(data)
-    clustering_model = KMeans(n_clusters=2, n_init=10, random_state=42)
-    clusters = clustering_model.fit_predict(projections)
-    
-    traces = []
-    for lbl in np.unique(clusters):
-        mask = clusters == lbl
-        trace = go.Scatter3d(
-            x=projections[mask][:, 0],
-            y=projections[mask][:, 1],
-            z=projections[mask][:, 2],
-            mode="markers",
-            name=f"Team {lbl}",
-            marker=dict(size=6, opacity=0.8),
-            hovertemplate="<b>Team %{text}</b><extra></extra>",
-            text=clusters[mask]
-        )
-        traces.append(trace)
-    fig = go.Figure(data=traces)
-    fig.update_layout(
-        width=800, height=800,
-        title="3D UMAP: Player Embeddings",
-        scene=dict(
-            xaxis_title="UMAP 1",
-            yaxis_title="UMAP 2",
-            zaxis_title="UMAP 3",
-            camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
-        )
-    )
-    return fig, {}
 
-def create_heatmap(positions: np.ndarray, config: SoccerPitchConfiguration, title: str = "Heatmap") -> np.ndarray:
-    """Create a heatmap visualization of player positions on the pitch."""
-    pitch = draw_pitch(config)
-    if len(positions) == 0:
-        return pitch
-    
-    # Create 2D histogram
-    h, w = pitch.shape[:2]
-    heatmap = np.zeros((h, w), dtype=np.float32)
-    
-    scale = 0.1  # Default scale from draw_pitch
-    padding = 50
-    
-    for pos in positions:
-        x = int(pos[0] * scale) + padding
-        y = int(pos[1] * scale) + padding
-        if 0 <= x < w and 0 <= y < h:
-            # Gaussian blur around position
-            cv2.circle(heatmap, (x, y), 30, 1.0, -1)
+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)
     
-    # Apply Gaussian blur
-    heatmap = cv2.GaussianBlur(heatmap, (51, 51), 0)
+    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
+                )
     
-    # Normalize
-    if heatmap.max() > 0:
-        heatmap = heatmap / heatmap.max()
+    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
+        )
     
-    # Apply colormap
-    heatmap_colored = cv2.applyColorMap((heatmap * 255).astype(np.uint8), cv2.COLORMAP_JET)
+    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
+            )
     
-    # Blend with pitch
-    result = cv2.addWeighted(pitch, 0.6, heatmap_colored, 0.4, 0)
+    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
+        )
     
-    return result
+    return annotated_frame
 
-def calculate_player_stats(tracker_positions: Dict[int, List[np.ndarray]]) -> Dict[int, Dict]:
-    """Calculate statistics for each tracked player."""
-    stats = {}
-    for tracker_id, positions in tracker_positions.items():
-        if len(positions) < 2:
-            continue
-        
-        positions_array = np.array(positions)
-        
-        # Calculate distance traveled
-        distances = np.sqrt(np.sum(np.diff(positions_array, axis=0)**2, axis=1))
-        total_distance = np.sum(distances)
-        
-        # Calculate average speed (assuming 30 fps)
-        avg_speed = np.mean(distances) * 30  # pixels per second
-        
-        # Calculate area covered (bounding box of positions)
-        min_x, min_y = positions_array.min(axis=0)
-        max_x, max_y = positions_array.max(axis=0)
-        area_covered = (max_x - min_x) * (max_y - min_y)
-        
-        stats[tracker_id] = {
-            'total_distance': total_distance,
-            'avg_speed': avg_speed,
-            'area_covered': area_covered,
-            'num_positions': len(positions)
-        }
-    
-    return stats
 
 # ==============================================
 # MAIN ANALYSIS PIPELINE
 # ==============================================
-def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str, go.Figure, str, str, str, str]:
+def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     """
-    Complete football video analysis pipeline with proper pitch transformation and performance tracking.
+    Complete football analysis with performance tracking and heatmaps
     """
     if not video_path:
         return None, None, None, None, None, "❌ Please upload a video file."
@@ -205,27 +462,36 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
     try:
         progress(0, desc="🔧 Initializing...")
 
-        # Detection IDs
         BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
         STRIDE = 30
         MAXLEN = 5
 
-        # Annotators
+        tracking_manager = PlayerTrackingManager(max_history=10)
+        performance_tracker = PlayerPerformanceTracker(CONFIG)
+
         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'), text_thickness=2
+            text_color=sv.Color.from_hex('#FFFFFF'), 
+            text_thickness=2
         )
         triangle_annotator = sv.TriangleAnnotator(
-            color=sv.Color.from_hex('#FFD700'), base=20, height=17
+            color=sv.Color.from_hex('#FFD700'), 
+            base=20, 
+            height=17
         )
 
-        tracker = sv.ByteTrack()
+        tracker = sv.ByteTrack(
+            track_activation_threshold=0.4,
+            lost_track_buffer=60,
+            minimum_matching_threshold=0.85,
+            frame_rate=30
+        )
         tracker.reset()
 
-        # Video setup
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
             return None, None, None, None, None, f"❌ Failed to open video: {video_path}"
@@ -240,16 +506,12 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
         output_path = "/tmp/annotated_football.mp4"
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
 
-        # --------------------------
-        # Step 1: Collect player crops for classifier
-        # --------------------------
+        # Collect player crops
         progress(0.05, desc="🏃 Collecting player samples...")
         player_crops = []
         frame_count = 0
-        cap_temp = cv2.VideoCapture(video_path)
-        
         while frame_count < min(total_frames, 300):
-            ret, frame = cap_temp.read()
+            ret, frame = cap.read()
             if not ret:
                 break
 
@@ -263,35 +525,23 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
                     player_crops.extend(crops)
 
             frame_count += 1
-        
-        cap_temp.release()
 
         if len(player_crops) == 0:
-            return None, None, None, None, None, "❌ No player crops collected. Check video or detection confidence."
+            return None, None, None, None, None, "❌ No player crops collected."
 
-        print(f"✅ Collected {len(player_crops)} player samples for team classifier")
+        print(f"✅ Collected {len(player_crops)} player samples")
 
-        # --------------------------
-        # Step 2: Fit TeamClassifier
-        # --------------------------
+        # Train classifier
         progress(0.15, desc="🎯 Training team classifier...")
         team_classifier = TeamClassifier(device=DEVICE)
         team_classifier.fit(player_crops)
         print("✅ Team classifier trained")
 
-        # --------------------------
-        # Step 3: Process entire video with tracking
-        # --------------------------
+        # Process video
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
         frame_count = 0
         M = deque(maxlen=MAXLEN)
-        
-        # Tracking data structures
         ball_path_raw = []
-        team_0_positions = []
-        team_1_positions = []
-        referee_positions = []
-        player_tracker_positions = defaultdict(list)  # tracker_id -> list of pitch positions
-        player_tracker_teams = {}  # tracker_id -> team_id
 
         progress(0.2, desc="🎬 Processing video frames...")
         while True:
@@ -300,10 +550,12 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
                 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}")
+                progress(0.2 + 0.5 * (frame_count / total_frames), 
+                        desc=f"🎬 Frame {frame_count}/{total_frames}")
 
-            # Player detection
             result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID)
             detections = sv.Detections.from_inference(result)
 
@@ -311,9 +563,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
                 out.write(frame)
                 continue
 
-            # Separate detections
             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)
@@ -322,201 +572,174 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
             players_detections = all_detections[all_detections.class_id == PLAYER_ID]
             referees_detections = all_detections[all_detections.class_id == REFEREE_ID]
 
-            # Predict team IDs
             if len(players_detections.xyxy) > 0:
                 crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
-                players_detections.class_id = team_classifier.predict(crops).astype(int)
-
-            # Assign goalkeeper teams
-            if len(goalkeepers_detections) > 0 and len(players_detections) > 0:
-                goalkeepers_detections.class_id = resolve_goalkeepers_team_id(players_detections, goalkeepers_detections).astype(int)
+                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
 
-            # Set referees to class 2
-            if len(referees_detections) > 0:
-                referees_detections.class_id = np.full(len(referees_detections), 2, dtype=int)
+            goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
+                players_detections, goalkeepers_detections
+            )
+            referees_detections.class_id -= 1
 
-            # Merge all detections
-            all_detections = sv.Detections.merge([players_detections, goalkeepers_detections, referees_detections])
-            all_detections.class_id = all_detections.class_id.astype(int)
+            all_detections = sv.Detections.merge([
+                players_detections, goalkeepers_detections, referees_detections
+            ])
 
-            # Field detection & 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
-                
-                if np.sum(filter_mask) >= 4:  # Need at least 4 points for transformation
-                    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)
-
-                    # Transform ball position
-                    if len(ball_detections) > 0:
-                        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)
-
-                    # Transform player positions
-                    if len(all_detections) > 0:
-                        frame_players_xy = all_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-                        pitch_players_xy = transformer.transform_points(frame_players_xy)
-                        
-                        # Store positions by team and tracker
-                        for i, (pitch_pos, class_id, tracker_id) in enumerate(
-                            zip(pitch_players_xy, all_detections.class_id, all_detections.tracker_id)
-                        ):
-                            if class_id == 0:
-                                team_0_positions.append(pitch_pos)
-                            elif class_id == 1:
-                                team_1_positions.append(pitch_pos)
-                            elif class_id == 2:
-                                referee_positions.append(pitch_pos)
-                            
-                            # Track individual players
-                            if class_id in [0, 1]:
-                                player_tracker_positions[tracker_id].append(pitch_pos)
-                                player_tracker_teams[tracker_id] = class_id
-                                
-            except Exception as e:
-                print(f"⚠️ Transformation failed at frame {frame_count}: {e}")
-
-            # Annotate frame
             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")
 
-        # --------------------------
-        # Step 4: UMAP Embeddings Visualization
-        # --------------------------
-        progress(0.75, desc="🎨 Creating player embeddings...")
-        umap_fig, _ = create_umap_3d_plot(player_crops[:500])
-
-        # --------------------------
-        # Step 5: Radar View with all positions
-        # --------------------------
-        progress(0.85, desc="🗺️ Creating radar view...")
-        radar_path = "/tmp/radar_view.png"
-        try:
-            annotated_frame = draw_pitch(CONFIG)
-            
-            # Draw ball path
-            if len(ball_path_raw) > 0:
-                ball_path = np.concatenate(ball_path_raw)
-                # Filter valid coordinates
-                ball_path = [coord.flatten() for coord in ball_path_raw if coord.shape[0] > 0]
-                if len(ball_path) > 0:
-                    annotated_frame = draw_paths_on_pitch(
-                        config=CONFIG,
-                        paths=[ball_path],
-                        color=sv.Color.WHITE,
-                        pitch=annotated_frame
-                    )
-            
-            # Draw team positions
-            if len(team_0_positions) > 0:
-                annotated_frame = draw_points_on_pitch(
-                    CONFIG, np.array(team_0_positions),
-                    face_color=sv.Color.from_hex("00BFFF"),
-                    edge_color=sv.Color.BLACK, radius=8, pitch=annotated_frame
-                )
-            
-            if len(team_1_positions) > 0:
-                annotated_frame = draw_points_on_pitch(
-                    CONFIG, np.array(team_1_positions),
-                    face_color=sv.Color.from_hex("FF1493"),
-                    edge_color=sv.Color.BLACK, radius=8, pitch=annotated_frame
-                )
-            
-            if len(referee_positions) > 0:
-                annotated_frame = draw_points_on_pitch(
-                    CONFIG, np.array(referee_positions),
-                    face_color=sv.Color.from_hex("FFD700"),
-                    edge_color=sv.Color.BLACK, radius=8, pitch=annotated_frame
-                )
+        # 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])
             
-            cv2.imwrite(radar_path, annotated_frame)
+            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
 
-        # --------------------------
-        # Step 6: Heatmaps
-        # --------------------------
-        progress(0.90, desc="🔥 Creating heatmaps...")
-        heatmap_team0_path = "/tmp/heatmap_team0.png"
-        heatmap_team1_path = "/tmp/heatmap_team1.png"
+        # Generate summary stats
+        progress(0.95, desc="📝 Generating summary report...")
+        teams = performance_tracker.get_all_players_by_team()
         
-        try:
-            if len(team_0_positions) > 0:
-                heatmap0 = create_heatmap(np.array(team_0_positions), CONFIG, "Team 0 Heatmap")
-                cv2.imwrite(heatmap_team0_path, heatmap0)
+        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
             
-            if len(team_1_positions) > 0:
-                heatmap1 = create_heatmap(np.array(team_1_positions), CONFIG, "Team 1 Heatmap")
-                cv2.imwrite(heatmap_team1_path, heatmap1)
-        except Exception as e:
-            print(f"⚠️ Heatmap creation failed: {e}")
-            heatmap_team0_path = None
-            heatmap_team1_path = None
-
-        # --------------------------
-        # Step 7: Player Statistics
-        # --------------------------
-        progress(0.95, desc="📊 Calculating statistics...")
-        player_stats = calculate_player_stats(player_tracker_positions)
-        
-        # Find top performers
-        if player_stats:
-            top_distance = max(player_stats.items(), key=lambda x: x[1]['total_distance'])
-            top_speed = max(player_stats.items(), key=lambda x: x[1]['avg_speed'])
-            top_area = max(player_stats.items(), key=lambda x: x[1]['area_covered'])
+            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])}")
             
-            # Team statistics
-            team_0_distances = sum(stats['total_distance'] for tid, stats in player_stats.items() 
-                                  if player_tracker_teams.get(tid) == 0)
-            team_1_distances = sum(stats['total_distance'] for tid, stats in player_stats.items() 
-                                  if player_tracker_teams.get(tid) == 1)
+            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")
             
-            stats_msg = f"""📊 **Performance Statistics**
-
-**Top Players:**
-- Most Distance: Player #{top_distance[0]} - {top_distance[1]['total_distance']:.0f} units
-- Fastest: Player #{top_speed[0]} - {top_speed[1]['avg_speed']:.2f} units/s
-- Most Area Covered: Player #{top_area[0]} - {top_area[1]['area_covered']:.0f} sq units
-
-**Team Statistics:**
-- Team 0 (Blue) Total Distance: {team_0_distances:.0f} units
-- Team 1 (Pink) Total Distance: {team_1_distances:.0f} units
-- Better Team: {"Team 0 (Blue)" if team_0_distances > team_1_distances else "Team 1 (Pink)"}
-
-**General:**
-- Total Tracked Players: {len(player_stats)}
-- Team 0 Players: {sum(1 for t in player_tracker_teams.values() if t == 0)}
-- Team 1 Players: {sum(1 for t in player_tracker_teams.values() if t == 1)}
-"""
-        else:
-            stats_msg = "⚠️ Insufficient tracking data for statistics"
+            # Top 3 performers
+            player_distances = [(pid, performance_tracker.get_player_stats(pid)['total_distance_meters']) 
+                              for pid in teams[team_id]]
+            player_distances.sort(key=lambda x: x[1], reverse=True)
+            
+            summary_lines.append(f"\n  **Top 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="✅ Analysis Complete!")
+        progress(1.0, desc="✅ Complete!")
 
-        success_msg = f"""✅ **Analysis Complete!**
-- Total Frames: {frame_count}
-- Player Samples: {len(player_crops)}
-- Ball Path Points: {len(ball_path_raw)}
-- Team 0 Positions: {len(team_0_positions)}
-- Team 1 Positions: {len(team_1_positions)}
-"""
-        return output_path, umap_fig, radar_path, heatmap_team0_path, heatmap_team1_path, success_msg + "\n" + stats_msg
+        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)}"
@@ -525,30 +748,72 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple[str
         traceback.print_exc()
         return None, None, None, None, None, error_msg
 
+
 # ==============================================
 # GRADIO INTERFACE
 # ==============================================
-iface = gr.Interface(
-    fn=analyze_football_video,
-    inputs=gr.Video(label="Upload Football Video"),
-    outputs=[
-        gr.Video(label="Annotated Video"),
-        gr.Plot(label="3D Player Embeddings (UMAP)"),
-        gr.Image(label="Radar View (All Positions)"),
-        gr.Image(label="Team 0 Heatmap"),
-        gr.Image(label="Team 1 Heatmap"),
-        gr.Textbox(label="Statistics & Status", lines=20)
-    ],
-    title="⚽ Football Video Analyzer - Complete Pipeline",
-    description="""
-    Upload a football video for comprehensive analysis:
-    - Player detection and team classification
-    - Ball tracking with trajectory visualization
-    - Player movement heatmaps
-    - Performance statistics and rankings
-    - 3D embeddings visualization
-    """
-)
+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():
+        video_input = gr.Video(label="Upload Football Video")
+    
+    analyze_btn = gr.Button("🚀 Analyze Video", variant="primary", size="lg")
+    
+    with gr.Row():
+        status_output = gr.Textbox(label="Analysis Status & Summary", lines=20)
+    
+    with gr.Tabs():
+        with gr.Tab("📹 Annotated Video"):
+            video_output = gr.Video(label="Annotated Video with Player Tracking")
+        
+        with gr.Tab("📊 Performance Comparison"):
+            comparison_output = gr.Plot(label="Team Performance Metrics")
+        
+        with gr.Tab("🗺️ Team Heatmaps"):
+            team_heatmaps_output = gr.Image(label="Combined Team Activity Heatmaps")
+        
+        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")
+    
+    analyze_btn.click(
+        fn=analyze_football_video,
+        inputs=[video_input],
+        outputs=[
+            video_output,
+            comparison_output,
+            team_heatmaps_output,
+            individual_heatmaps_output,
+            radar_output,
+            status_output
+        ]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📋 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
+    
+    ### 🎯 Perfect for:
+    - Coaching staff analysis
+    - Player performance reports
+    - Tactical review sessions
+    - Scouting and recruitment
+    """)
 
 if __name__ == "__main__":
     iface.launch()