Update app.py

app.py

@@ -1,6 +1,6 @@
 import os
 from collections import deque, defaultdict
-from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Optional, Union
 from io import BytesIO
 import base64
 
@@ -62,6 +62,35 @@ EMBEDDINGS_PROCESSOR = AutoProcessor.from_pretrained(SIGLIP_MODEL_PATH, token=HF
 # ==============================================
 CONFIG = SoccerPitchConfiguration()
 
+# ==============================================
+# BALL PATH OUTLIER REMOVAL
+# ==============================================
+def replace_outliers_based_on_distance(
+    positions: List[np.ndarray],
+    distance_threshold: float
+) -> List[np.ndarray]:
+    """Remove outlier positions based on distance threshold"""
+    last_valid_position: Union[np.ndarray, None] = None
+    cleaned_positions: List[np.ndarray] = []
+
+    for position in positions:
+        if len(position) == 0:
+            cleaned_positions.append(position)
+        else:
+            if last_valid_position is None:
+                cleaned_positions.append(position)
+                last_valid_position = position
+            else:
+                distance = np.linalg.norm(position - last_valid_position)
+                if distance > distance_threshold:
+                    cleaned_positions.append(np.array([], dtype=np.float64))
+                else:
+                    cleaned_positions.append(position)
+                    last_valid_position = position
+
+    return cleaned_positions
+
+
 # ==============================================
 # PLAYER PERFORMANCE TRACKING
 # ==============================================
@@ -70,10 +99,10 @@ class PlayerPerformanceTracker:
     
     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_positions = defaultdict(list)
+        self.player_velocities = defaultdict(list)
+        self.player_distances = defaultdict(float)
+        self.player_team = {}
         self.player_stats = defaultdict(lambda: {
             'frames_visible': 0,
             'avg_velocity': 0,
@@ -92,22 +121,18 @@ class PlayerPerformanceTracker:
         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
+            velocity = distance * 30  # cm/s assuming 30fps
             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
@@ -124,7 +149,7 @@ class PlayerPerformanceTracker:
             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['total_distance_meters'] = self.player_distances[tracker_id] / 100
         stats['team_id'] = self.player_team.get(tracker_id, -1)
         
         return stats
@@ -136,7 +161,6 @@ class PlayerPerformanceTracker:
         
         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
         
@@ -146,10 +170,9 @@ class PlayerPerformanceTracker:
             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
+        return heatmap.T
     
     def get_all_players_by_team(self) -> Dict[int, List[int]]:
         """Get all player IDs grouped by team"""
@@ -210,28 +233,22 @@ def create_player_heatmap_visualization(performance_tracker: PlayerPerformanceTr
     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
+    scale = 0.1
     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"
     
@@ -284,28 +301,24 @@ def create_team_comparison_plot(performance_tracker: PlayerPerformanceTracker) -
         
         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),
@@ -336,7 +349,6 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> n
         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)
@@ -345,7 +357,6 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> n
         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]
@@ -377,6 +388,7 @@ def create_combined_heatmaps(performance_tracker: PlayerPerformanceTracker) -> n
 # HELPER FUNCTIONS
 # ==============================================
 def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detections) -> np.ndarray:
+    """Assign goalkeepers to the nearest team centroid"""
     if len(goalkeepers) == 0 or len(players) == 0:
         return np.array([])
     goalkeepers_xy = goalkeepers.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
@@ -389,18 +401,12 @@ def resolve_goalkeepers_team_id(players: sv.Detections, goalkeepers: sv.Detectio
     ])
 
 
-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_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)
     
+    # Draw ball trail with fading effect
     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:
@@ -417,6 +423,7 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
                     pitch=annotated_frame
                 )
     
+    # Draw current ball position
     if len(pitch_ball_xy) > 0:
         annotated_frame = draw_points_on_pitch(
             CONFIG, pitch_ball_xy, 
@@ -426,6 +433,7 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
             pitch=annotated_frame
         )
     
+    # Draw players
     for team_id, color_hex in zip([0, 1], ["00BFFF", "FF1493"]):
         mask = players_class_id == team_id
         if np.any(mask):
@@ -437,6 +445,7 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
                 pitch=annotated_frame
             )
     
+    # Draw referees
     if len(pitch_referees_xy) > 0:
         annotated_frame = draw_points_on_pitch(
             CONFIG, pitch_referees_xy, 
@@ -454,7 +463,7 @@ def create_game_style_radar(pitch_ball_xy, pitch_players_xy, players_class_id,
 # ==============================================
 def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     """
-    Complete football analysis with performance tracking and heatmaps
+    Complete football analysis pipeline following Colab notebook steps
     """
     if not video_path:
         return None, None, None, None, None, "❌ Please upload a video file."
@@ -462,13 +471,17 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     try:
         progress(0, desc="🔧 Initializing...")
 
+        # IDs from Roboflow model
         BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
-        STRIDE = 30
-        MAXLEN = 5
+        STRIDE = 30  # Frame sampling for training
+        MAXLEN = 5   # Transformation matrix smoothing
+        MAX_DISTANCE_THRESHOLD = 500  # Ball path outlier threshold
 
+        # Initialize managers
         tracking_manager = PlayerTrackingManager(max_history=10)
         performance_tracker = PlayerPerformanceTracker(CONFIG)
 
+        # Annotators with exact colors from notebook
         ellipse_annotator = sv.EllipseAnnotator(
             color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']), 
             thickness=2
@@ -476,7 +489,8 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         label_annotator = sv.LabelAnnotator(
             color=sv.ColorPalette.from_hex(['#00BFFF', '#FF1493', '#FFD700']),
             text_color=sv.Color.from_hex('#FFFFFF'), 
-            text_thickness=2
+            text_thickness=2,
+            text_position=sv.Position.BOTTOM_CENTER
         )
         triangle_annotator = sv.TriangleAnnotator(
             color=sv.Color.from_hex('#FFD700'), 
@@ -484,6 +498,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             height=17
         )
 
+        # ByteTrack tracker with optimized settings
         tracker = sv.ByteTrack(
             track_activation_threshold=0.4,
             lost_track_buffer=60,
@@ -492,6 +507,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         )
         tracker.reset()
 
+        # Video setup
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
             return None, None, None, None, None, f"❌ Failed to open video: {video_path}"
@@ -506,10 +522,13 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         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...")
+        # ========================================
+        # STEP 1: Collect Player Crops for Team Classifier
+        # ========================================
+        progress(0.05, desc="🏃 Collecting player samples (Step 1/6)...")
         player_crops = []
         frame_count = 0
+        
         while frame_count < min(total_frames, 300):
             ret, frame = cap.read()
             if not ret:
@@ -518,6 +537,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             if frame_count % STRIDE == 0:
                 result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID)
                 detections = sv.Detections.from_inference(result)
+                detections = detections.with_nms(threshold=0.5, class_agnostic=True)
                 players_detections = detections[detections.class_id == PLAYER_ID]
 
                 if len(players_detections.xyxy) > 0:
@@ -531,19 +551,29 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 
         print(f"✅ Collected {len(player_crops)} player samples")
 
-        # Train classifier
-        progress(0.15, desc="🎯 Training team classifier...")
+        # ========================================
+        # STEP 2: Train Team Classifier
+        # ========================================
+        progress(0.15, desc="🎯 Training team classifier (Step 2/6)...")
         team_classifier = TeamClassifier(device=DEVICE)
         team_classifier.fit(player_crops)
         print("✅ Team classifier trained")
 
-        # Process video
+        # ========================================
+        # STEP 3: Process Full Video with Tracking
+        # ========================================
         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
         frame_count = 0
-        M = deque(maxlen=MAXLEN)
+        M = deque(maxlen=MAXLEN)  # Transformation matrix smoothing
         ball_path_raw = []
+        
+        # Store last frame data for radar
+        last_pitch_players_xy = None
+        last_players_class_id = None
+        last_pitch_referees_xy = None
 
-        progress(0.2, desc="🎬 Processing video frames...")
+        progress(0.2, desc="🎬 Processing video frames (Step 3/6)...")
+        
         while True:
             ret, frame = cap.read()
             if not ret:
@@ -553,29 +583,39 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             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.4 * (frame_count / total_frames), 
+                        desc=f"🎬 Processing frame {frame_count}/{total_frames}")
 
-            result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID)
+            # Player and ball detection
+            result = CLIENT.infer(frame, model_id=PLAYER_DETECTION_MODEL_ID, confidence=0.3)
             detections = sv.Detections.from_inference(result)
 
             if len(detections.xyxy) == 0:
                 out.write(frame)
+                ball_path_raw.append(np.empty((0, 2)))
                 continue
 
+            # Separate ball from other detections
             ball_detections = detections[detections.class_id == BALL_ID]
+            ball_detections.xyxy = sv.pad_boxes(xyxy=ball_detections.xyxy, px=10)
+            
             all_detections = detections[detections.class_id != BALL_ID]
             all_detections = all_detections.with_nms(threshold=0.5, class_agnostic=True)
+            
+            # Track detections
             all_detections = tracker.update_with_detections(detections=all_detections)
 
+            # Separate by type
             goalkeepers_detections = all_detections[all_detections.class_id == GOALKEEPER_ID]
             players_detections = all_detections[all_detections.class_id == PLAYER_ID]
             referees_detections = all_detections[all_detections.class_id == REFEREE_ID]
 
+            # Team prediction with stability
             if len(players_detections.xyxy) > 0:
                 crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
                 predicted_teams = team_classifier.predict(crops)
                 
+                # Apply stable team assignment
                 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(
@@ -584,63 +624,117 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                 
                 players_detections.class_id = predicted_teams
 
+            # Assign goalkeeper teams
             goalkeepers_detections.class_id = resolve_goalkeepers_team_id(
                 players_detections, goalkeepers_detections
             )
+
+            # Adjust referee class_id
             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)
 
+            # Create labels
             labels = [f"#{tid}" for tid in all_detections.tracker_id]
 
+            # Annotate frame
             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
+            # ========================================
+            # STEP 4: Field Detection & Transformation
+            # ========================================
             try:
-                result_field = CLIENT.infer(frame, model_id=FIELD_DETECTION_MODEL_ID)
+                result_field = CLIENT.infer(frame, model_id=FIELD_DETECTION_MODEL_ID, confidence=0.3)
                 key_points = sv.KeyPoints.from_inference(result_field)
+                
+                # Filter confident keypoints
                 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:
+                if len(frame_ref_pts) >= 4:  # Need at least 4 points for homography
+                    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
+                    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 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)
+                    
+                    # Transform referees
+                    referees_xy = referees_detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+                    pitch_referees_xy = transformer.transform_points(referees_xy)
+                    
+                    # Store for radar view
+                    last_pitch_players_xy = pitch_players_xy
+                    last_players_class_id = all_players.class_id
+                    last_pitch_referees_xy = pitch_referees_xy
+                    
+                    # Update performance tracker
+                    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
+                            )
+                else:
+                    ball_path_raw.append(np.empty((0, 2)))
+            except Exception as e:
                 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...")
+        # ========================================
+        # STEP 5: Clean Ball Path (Remove Outliers)
+        # ========================================
+        progress(0.65, desc="🧹 Cleaning ball trajectory (Step 4/6)...")
+        
+        # Convert to proper format for cleaning
+        path_for_cleaning = []
+        for coords in ball_path_raw:
+            if len(coords) == 0:
+                path_for_cleaning.append(np.empty((0, 2), dtype=np.float32))
+            elif coords.shape[0] >= 2:
+                path_for_cleaning.append(np.empty((0, 2), dtype=np.float32))
+            else:
+                path_for_cleaning.append(coords)
+        
+        # Flatten coordinates
+        path_flattened = [coords.flatten() for coords in path_for_cleaning]
+        
+        # Remove outliers
+        cleaned_path = replace_outliers_based_on_distance(
+            [np.array(p).reshape(-1, 2) if len(p) > 0 else np.empty((0, 2)) for p in path_for_cleaning],
+            MAX_DISTANCE_THRESHOLD
+        )
+        
+        print(f"✅ Ball path cleaned: {len([p for p in cleaned_path if len(p) > 0])} valid points")
+
+        # ========================================
+        # STEP 6: Generate Performance Analytics
+        # ========================================
+        progress(0.75, desc="📊 Generating performance analytics (Step 5/6)...")
         
-        # Team comparison
+        # Team comparison charts
         comparison_fig = create_team_comparison_plot(performance_tracker)
         
         # Combined team heatmaps
@@ -648,10 +742,11 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         team_heatmaps = create_combined_heatmaps(performance_tracker)
         cv2.imwrite(team_heatmaps_path, team_heatmaps)
         
-        # Individual player heatmaps (top 6 players by distance)
+        # Individual player heatmaps (top 6 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]
@@ -665,7 +760,7 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
             heatmap = create_player_heatmap_visualization(performance_tracker, pid)
             individual_heatmaps.append(heatmap)
         
-        # Arrange individual heatmaps in grid
+        # Arrange individual heatmaps in grid (3 columns)
         if len(individual_heatmaps) > 0:
             rows = []
             for i in range(0, len(individual_heatmaps), 3):
@@ -683,29 +778,39 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
         else:
             individual_heatmaps_path = None
 
-        # Radar view
-        progress(0.9, desc="🗺️ Creating game-style radar view...")
+        # ========================================
+        # STEP 7: Create Game-Style Radar View
+        # ========================================
+        progress(0.9, desc="🗺️ Creating game-style radar view (Step 6/6)...")
         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)
+            if last_pitch_players_xy is not None:
+                radar_frame = create_game_style_radar(
+                    pitch_ball_xy=cleaned_path[-1] if cleaned_path else np.empty((0, 2)),
+                    pitch_players_xy=last_pitch_players_xy,
+                    players_class_id=last_players_class_id,
+                    pitch_referees_xy=last_pitch_referees_xy,
+                    ball_path=cleaned_path
+                )
+                cv2.imwrite(radar_path, radar_frame)
+            else:
+                radar_path = None
         except Exception as e:
             print(f"⚠️ Radar view creation failed: {e}")
             radar_path = None
 
-        # Generate summary stats
+        # ========================================
+        # Generate Summary Report
+        # ========================================
         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")
+        summary_lines.append(f"**Video Statistics:**")
+        summary_lines.append(f"- Total Frames Processed: {frame_count}")
+        summary_lines.append(f"- Video Resolution: {width}x{height}")
+        summary_lines.append(f"- Frame Rate: {fps:.2f} fps")
+        summary_lines.append(f"- Ball Trajectory Points: {len([p for p in cleaned_path if len(p) > 0])}\n")
         
         for team_id in [0, 1]:
             if team_id not in teams:
@@ -726,17 +831,26 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
                               for pid in teams[team_id]]
             player_distances.sort(key=lambda x: x[1], reverse=True)
             
-            summary_lines.append(f"\n  **Top Performers:**")
+            summary_lines.append(f"\n  **Top 3 Performers:**")
             for i, (pid, dist) in enumerate(player_distances[:3], 1):
                 stats = performance_tracker.get_player_stats(pid)
                 summary_lines.append(
                     f"  {i}. Player #{pid}: {dist:.1f}m, "
-                    f"Avg Speed: {stats['avg_velocity']/100:.2f}m/s"
+                    f"Avg: {stats['avg_velocity']/100:.2f}m/s, "
+                    f"Max: {stats['max_velocity']/100:.2f}m/s"
                 )
         
+        summary_lines.append("\n**Pipeline Steps Completed:**")
+        summary_lines.append("✅ 1. Player crop collection")
+        summary_lines.append("✅ 2. Team classifier training")
+        summary_lines.append("✅ 3. Video processing with tracking")
+        summary_lines.append("✅ 4. Ball trajectory cleaning")
+        summary_lines.append("✅ 5. Performance analytics generation")
+        summary_lines.append("✅ 6. Visualization creation")
+        
         summary_msg = "\n".join(summary_lines)
 
-        progress(1.0, desc="✅ Complete!")
+        progress(1.0, desc="✅ Analysis Complete!")
 
         return (output_path, comparison_fig, team_heatmaps_path, 
                 individual_heatmaps_path, radar_path, summary_msg)
@@ -752,39 +866,50 @@ def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
 # ==============================================
 # GRADIO INTERFACE
 # ==============================================
-with gr.Blocks(title="⚽ Football Performance Analyzer") as iface:
+with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) 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
+    ### Complete Pipeline Implementation
+    
+    This application follows the exact pipeline from the Colab notebook:
+    1. **Player Detection** - Collect player crops using Roboflow
+    2. **Team Classification** - Train SigLIP-based team classifier  
+    3. **Persistent Tracking** - ByteTrack with stable ID assignment
+    4. **Field Transformation** - Project players onto pitch coordinates
+    5. **Ball Trajectory** - Track and clean ball path with outlier removal
+    6. **Performance Analytics** - Generate heatmaps and statistics
+    
+    Upload a football match video to get comprehensive performance analytics!
     """)
     
     with gr.Row():
-        video_input = gr.Video(label="Upload Football Video")
+        video_input = gr.Video(label="📤 Upload Football Video")
     
-    analyze_btn = gr.Button("🚀 Analyze Video", variant="primary", size="lg")
+    analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary", size="lg")
     
     with gr.Row():
-        status_output = gr.Textbox(label="Analysis Status & Summary", lines=20)
+        status_output = gr.Textbox(label="📊 Analysis Summary & Statistics", lines=25)
     
     with gr.Tabs():
         with gr.Tab("📹 Annotated Video"):
-            video_output = gr.Video(label="Annotated Video with Player Tracking")
+            gr.Markdown("### Full video with player tracking, team colors, and ball detection")
+            video_output = gr.Video(label="Processed Video")
         
         with gr.Tab("📊 Performance Comparison"):
+            gr.Markdown("### Interactive charts comparing player performance metrics")
             comparison_output = gr.Plot(label="Team Performance Metrics")
         
         with gr.Tab("🗺️ Team Heatmaps"):
-            team_heatmaps_output = gr.Image(label="Combined Team Activity Heatmaps")
+            gr.Markdown("### Combined activity heatmaps showing team positioning")
+            team_heatmaps_output = gr.Image(label="Team Activity Heatmaps")
         
         with gr.Tab("👤 Individual Heatmaps"):
-            individual_heatmaps_output = gr.Image(label="Top Players Individual Heatmaps")
+            gr.Markdown("### Top 6 players with detailed activity analysis")
+            individual_heatmaps_output = gr.Image(label="Top Players Heatmaps")
         
         with gr.Tab("🎮 Game Radar View"):
-            radar_output = gr.Image(label="Game-Style Radar with Ball Trail")
+            gr.Markdown("### Game-style tactical view with ball trail")
+            radar_output = gr.Image(label="Tactical Radar View")
     
     analyze_btn.click(
         fn=analyze_football_video,
@@ -801,19 +926,34 @@ with gr.Blocks(title="⚽ Football Performance Analyzer") as iface:
     
     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
+    ### 🔧 Technical Details:
+    
+    **Detection Models:**
+    - Player/Ball/Referee Detection: `football-players-detection-3zvbc/11`
+    - Field Keypoint Detection: `football-field-detection-f07vi/14`
+    
+    **Tracking & Classification:**
+    - ByteTrack for persistent player IDs (60-frame buffer)
+    - SigLIP embeddings for team classification
+    - Majority voting for stable team assignments
+    
+    **Performance Metrics:**
+    - Distance covered (meters)
+    - Average & maximum speed (m/s)
+    - Zone activity (defensive/middle/attacking thirds)
+    - Position heatmaps with Gaussian smoothing
+    
+    **Ball Tracking:**
+    - Field homography transformation
+    - Outlier removal (500cm threshold)
+    - Transformation matrix smoothing (5-frame window)
+    
+    ### 📈 Output Files:
+    - Annotated video: `/tmp/annotated_football.mp4`
+    - Team heatmaps: `/tmp/team_heatmaps.png`
+    - Individual heatmaps: `/tmp/individual_heatmaps.png`
+    - Radar view: `/tmp/radar_view_enhanced.png`
     """)
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch(share=True)