Update app.py

app.py

@@ -593,184 +593,911 @@ def create_game_style_radar(
 # ==============================================
 def analyze_football_video(video_path: str, progress=gr.Progress()) -> Tuple:
     """
-    Complete football analysis pipeline - FULL IMPLEMENTATION
-    (This is your existing function - keeping it exactly as is)
+    Complete football analysis pipeline:
+    - Player & ball detection (Roboflow)
+    - Team classification (SigLIP-based)
+    - Tracking (ByteTrack) with stable team assignments
+    - Field homography -> pitch coordinates
+    - Ball trajectory cleaning
+    - Performance analytics
+    - Simple events + possession + per-player stats
     """
-    # ... [Keep your entire existing analyze_football_video function here]
-    # I'm not repeating it to save space, but include ALL the code from your original function
-    pass  # Replace this with your full function
-
-
-# ==============================================
-# API WRAPPER FOR REMOTE ACCESS
-# ==============================================
-def process_video_api(video_file):
-    """
-    API endpoint for processing videos from remote clients.
-    
-    This wrapper:
-    1. Accepts video file from gradio_client
-    2. Runs the full analysis pipeline
-    3. Returns results in a format suitable for JSON serialization
-    
-    Parameters:
-    ----------
-    video_file : str or dict
-        Path to uploaded video file (from gr.Video component)
-        
-    Returns:
-    -------
-    tuple: (
-        annotated_video_path: str,
-        stats_json: str,
-        events_json: str,
-        artifacts_json: str
-    )
-    """
-    print("=" * 80)
-    print("🎬 API Request Received")
-    print("=" * 80)
-    
-    if video_file is None:
-        error_result = {
-            "error": "No video file provided",
-            "success": False
-        }
-        return None, json.dumps(error_result), json.dumps([]), json.dumps({})
-    
-    # Handle video path extraction
-    if isinstance(video_file, dict):
-        video_path = video_file.get("path") or video_file.get("name") or video_file.get("filename")
-    else:
-        video_path = str(video_file)
-    
     if not video_path:
-        error_result = {
-            "error": "Could not resolve video file path",
-            "success": False
-        }
-        return None, json.dumps(error_result), json.dumps([]), json.dumps({})
-    
-    print(f"📁 Video path: {video_path}")
-    
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Please upload a video file.",
+            [],
+            [],
+            None,
+        )
+
     try:
-        # Run the full analysis pipeline
-        print("⚙️  Running analysis pipeline...")
-        results = analyze_football_video(video_path)
-        
-        # Unpack results (9 outputs from analyze_football_video)
-        (
-            annotated_video,
-            comparison_fig,
-            team_heatmaps_path,
-            individual_heatmaps_path,
-            radar_path,
-            summary_msg,
-            player_stats_table,
-            events_table,
-            events_json_path,
-        ) = results
-        
-        # Build stats dictionary
-        stats = {
-            "success": True,
-            "summary": summary_msg,
-            "player_stats": player_stats_table,
-            "comparison_plot_available": comparison_fig is not None,
-        }
-        
-        # Build artifacts dictionary with all generated file paths
-        artifacts = {
-            "team_heatmaps": team_heatmaps_path,
-            "individual_heatmaps": individual_heatmaps_path,
-            "radar_view": radar_path,
-            "events_json": events_json_path,
+        progress(0, desc="🔧 Initializing...")
+
+        # IDs from Roboflow model
+        BALL_ID, GOALKEEPER_ID, PLAYER_ID, REFEREE_ID = 0, 1, 2, 3
+        STRIDE = 30  # Frame sampling for training
+        MAXLEN = 5  # Transformation matrix smoothing
+        MAX_DISTANCE_THRESHOLD = 500  # Ball path outlier threshold
+
+        # Video setup
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return (
+                None,
+                None,
+                None,
+                None,
+                None,
+                f"❌ Failed to open video: {video_path}",
+                [],
+                [],
+                None,
+            )
+
+        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)
+        if fps <= 0:
+            fps = 30.0
+        dt = 1.0 / 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))
+
+        # Initialize managers
+        tracking_manager = PlayerTrackingManager(max_history=10)
+        performance_tracker = PlayerPerformanceTracker(CONFIG, fps=fps)
+
+        # Simple possession / events stats
+        distance_covered_m = defaultdict(float)  # tid -> meters
+        possession_time_player = defaultdict(float)  # tid -> seconds
+        possession_time_team = defaultdict(float)  # team_id -> seconds
+        team_of_player = {}  # tid -> team_id
+        events: List[Dict] = []
+
+        prev_owner_tid: Optional[int] = None
+        prev_ball_pos_pitch: Optional[np.ndarray] = None
+
+        # Annotators
+        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,
+            text_position=sv.Position.BOTTOM_CENTER,
+        )
+        triangle_annotator = sv.TriangleAnnotator(
+            color=sv.Color.from_hex("#FFD700"),
+            base=20,
+            height=17,
+        )
+
+        # ByteTrack tracker with optimized settings
+        tracker = sv.ByteTrack(
+            track_activation_threshold=0.4,
+            lost_track_buffer=60,
+            minimum_matching_threshold=0.85,
+            frame_rate=fps,
+        )
+        tracker.reset()
+
+        # For field transform smoothing + ball path
+        M = deque(maxlen=MAXLEN)  # Transformation matrix smoothing
+        ball_path_raw = []
+
+        # Last pitch positions (for speed/distance overlay, events)
+        last_pitch_players_xy = None
+        last_players_class_id = None
+        last_pitch_referees_xy = None
+        last_pitch_pos_by_tid: Dict[int, np.ndarray] = {}
+
+        # Simple goal centers (for shot/clearance direction)
+        goal_centers = {
+            0: np.array([0.0, CONFIG.width / 2.0]),
+            1: np.array([CONFIG.length, CONFIG.width / 2.0]),
         }
-        
-        # Convert to JSON strings
-        stats_json = json.dumps(stats, indent=2)
-        events_json = json.dumps(events_table, indent=2)
-        artifacts_json = json.dumps(artifacts, indent=2)
-        
-        print("✅ Analysis complete!")
-        print(f"📊 Stats: {len(player_stats_table)} players tracked")
-        print(f"⚡ Events: {len(events_table)} events detected")
-        print(f"🎬 Annotated video: {annotated_video}")
-        print("=" * 80)
-        
-        return annotated_video, stats_json, events_json, artifacts_json
-        
+
+        # Event banner overlay
+        current_event_text = ""
+        event_text_frames_left = 0
+        EVENT_TEXT_DURATION_S = 2.0
+        EVENT_TEXT_DURATION_FRAMES = int(EVENT_TEXT_DURATION_S * fps)
+
+        # ========================================
+        # 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:
+                break
+
+            if frame_count % STRIDE == 0:
+                _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
+                detections = detections.with_nms(threshold=0.5, class_agnostic=True)
+                players_detections = detections[detections.class_id == PLAYER_ID]
+
+                if len(players_detections.xyxy) > 0:
+                    crops = [sv.crop_image(frame, xyxy) for xyxy in players_detections.xyxy]
+                    player_crops.extend(crops)
+
+            frame_count += 1
+
+        if len(player_crops) == 0:
+            cap.release()
+            out.release()
+            return (
+                None,
+                None,
+                None,
+                None,
+                None,
+                "❌ No player crops collected.",
+                [],
+                [],
+                None,
+            )
+
+        print(f"✅ Collected {len(player_crops)} player samples")
+
+        # ========================================
+        # 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")
+
+        # ========================================
+        # STEP 3: Process Full Video with Tracking + Events
+        # ========================================
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        frame_count = 0
+
+        progress(0.2, desc="🎬 Processing video frames (Step 3/6)...")
+
+        frame_idx = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_idx += 1
+            t = frame_idx * dt
+            frame_count += 1
+            tracking_manager.reset_frame()
+
+            if frame_count % 30 == 0:
+                progress(
+                    0.2 + 0.4 * (frame_count / max(total_frames, 1)),
+                    desc=f"🎬 Processing frame {frame_count}/{total_frames}",
+                )
+
+            # Player and ball detection
+            _, detections = infer_with_confidence(PLAYER_DETECTION_MODEL_ID, frame, 0.3)
+
+            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(int(tracker_id), int(predicted_teams[idx]))
+                    predicted_teams[idx] = tracking_manager.get_stable_team_id(
+                        int(tracker_id),
+                        int(predicted_teams[idx]),
+                    )
+
+                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)
+
+            # ========================================
+            # STEP 4: Field Detection & Transformation
+            # ========================================
+            pitch_players_xy = None
+            pitch_referees_xy = None
+            pitch_ball_xy = np.empty((0, 2), dtype=np.float32)
+            frame_ball_pos_pitch = None
+
+            try:
+                result_field, _ = infer_with_confidence(FIELD_DETECTION_MODEL_ID, frame, 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]
+
+                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)
+                        if len(frame_ball_xy) > 0
+                        else np.empty((0, 2))
+                    )
+                    if len(pitch_ball_xy) > 0:
+                        frame_ball_pos_pitch = pitch_ball_xy[0]
+                    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)
+                        if len(players_xy) > 0
+                        else np.empty((0, 2))
+                    )
+
+                    # Transform referees
+                    referees_xy = referees_detections.get_anchors_coordinates(
+                        sv.Position.BOTTOM_CENTER
+                    )
+                    pitch_referees_xy = (
+                        transformer.transform_points(referees_xy)
+                        if len(referees_xy) > 0
+                        else np.empty((0, 2))
+                    )
+
+                    # 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 + distance per player (meters)
+                    for idx, tracker_id in enumerate(all_players.tracker_id):
+                        tid_int = int(tracker_id)
+                        if idx < len(pitch_players_xy):
+                            pos_pitch = pitch_players_xy[idx]
+                            performance_tracker.update(
+                                tid_int,
+                                pos_pitch,
+                                int(all_players.class_id[idx]),
+                                frame_count,
+                            )
+                            team_of_player[tid_int] = int(all_players.class_id[idx])
+
+                            prev_pos = last_pitch_pos_by_tid.get(tid_int)
+                            if prev_pos is not None:
+                                dist_m = pitch_distance_m(prev_pos, pos_pitch)
+                                distance_covered_m[tid_int] += dist_m
+                            last_pitch_pos_by_tid[tid_int] = pos_pitch
+                else:
+                    ball_path_raw.append(np.empty((0, 2)))
+            except Exception:
+                ball_path_raw.append(np.empty((0, 2)))
+
+            # ========================================
+            # POSSESSION + EVENTS (simple heuristics)
+            # ========================================
+            owner_tid: Optional[int] = None
+            POSSESSION_RADIUS_M = 5.0
+
+            if frame_ball_pos_pitch is not None and pitch_players_xy is not None and len(pitch_players_xy) > 0:
+                dists = np.linalg.norm(pitch_players_xy - frame_ball_pos_pitch, axis=1)
+                j = int(np.argmin(dists))
+                nearest_dist_m = pitch_distance_m(pitch_players_xy[j], frame_ball_pos_pitch)
+                if nearest_dist_m < POSSESSION_RADIUS_M:
+                    owner_tid = int(all_players.tracker_id[j])
+
+            # accumulate possession time
+            if owner_tid is not None:
+                possession_time_player[owner_tid] += dt
+                owner_team = team_of_player.get(owner_tid)
+                if owner_team is not None:
+                    possession_time_team[owner_team] += dt
+
+            def register_event(ev: Dict, text: str):
+                nonlocal current_event_text, event_text_frames_left
+                events.append(ev)
+                if text:
+                    current_event_text = text
+                    event_text_frames_left = EVENT_TEXT_DURATION_FRAMES
+
+            # possession change events, passes, tackles, interceptions
+            if owner_tid != prev_owner_tid:
+                if owner_tid is not None and prev_owner_tid is not None:
+                    prev_team = team_of_player.get(prev_owner_tid)
+                    cur_team = team_of_player.get(owner_tid)
+
+                    travel_m = 0.0
+                    if prev_ball_pos_pitch is not None and frame_ball_pos_pitch is not None:
+                        travel_m = pitch_distance_m(prev_ball_pos_pitch, frame_ball_pos_pitch)
+
+                    MIN_PASS_TRAVEL_M = 3.0
+
+                    if prev_team is not None and cur_team is not None:
+                        if prev_team == cur_team and travel_m > MIN_PASS_TRAVEL_M:
+                            # pass
+                            register_event(
+                                {
+                                    "type": "pass",
+                                    "t": float(t),
+                                    "from_tid": int(prev_owner_tid),
+                                    "to_tid": int(owner_tid),
+                                    "team_id": int(cur_team),
+                                    "extra": {"distance_m": travel_m},
+                                },
+                                f"Pass: #{prev_owner_tid} → #{owner_tid} (Team {cur_team})",
+                            )
+                        elif prev_team != cur_team:
+                            # tackle vs interception
+                            d_pp = 999.0
+                            if pitch_players_xy is not None:
+                                pos_prev = last_pitch_pos_by_tid.get(int(prev_owner_tid))
+                                pos_cur = last_pitch_pos_by_tid.get(int(owner_tid))
+                                if pos_prev is not None and pos_cur is not None:
+                                    d_pp = pitch_distance_m(pos_prev, pos_cur)
+                            ev_type = "tackle" if d_pp < 3.0 else "interception"
+                            label = "Tackle" if ev_type == "tackle" else "Interception"
+                            register_event(
+                                {
+                                    "type": ev_type,
+                                    "t": float(t),
+                                    "from_tid": int(prev_owner_tid),
+                                    "to_tid": int(owner_tid),
+                                    "team_id": int(cur_team),
+                                    "extra": {
+                                        "player_distance_m": d_pp,
+                                        "ball_travel_m": travel_m,
+                                    },
+                                },
+                                f"{label}: #{owner_tid} wins ball from #{prev_owner_tid}",
+                            )
+
+                # generic possession-change event (optional text)
+                if owner_tid is not None:
+                    team_id = team_of_player.get(owner_tid)
+                    register_event(
+                        {
+                            "type": "possession_change",
+                            "t": float(t),
+                            "from_tid": int(prev_owner_tid)
+                            if prev_owner_tid is not None
+                            else None,
+                            "to_tid": int(owner_tid),
+                            "team_id": int(team_id) if team_id is not None else None,
+                            "extra": {},
+                        },
+                        "",
+                    )
+
+            # shot / clearance based on ball speed & direction
+            if (
+                prev_ball_pos_pitch is not None
+                and frame_ball_pos_pitch is not None
+                and owner_tid is not None
+            ):
+                v_vec = frame_ball_pos_pitch - prev_ball_pos_pitch  # pitch units
+                # convert to meters per second
+                dist_m = pitch_distance_m(prev_ball_pos_pitch, frame_ball_pos_pitch)
+                speed_mps = dist_m / dt
+                speed_kmh = speed_mps * 3.6
+                HIGH_SPEED_KMH = 18.0
+
+                if speed_kmh > HIGH_SPEED_KMH:
+                    shooter_team = team_of_player.get(owner_tid)
+                    if shooter_team is not None:
+                        target_goal = goal_centers[1 - shooter_team]
+                        direction = target_goal - frame_ball_pos_pitch
+                        v_norm = np.linalg.norm(v_vec)
+                        d_norm = np.linalg.norm(direction)
+                        cos_angle = 0.0
+                        if v_norm > 1e-6 and d_norm > 1e-6:
+                            cos_angle = float(np.dot(v_vec, direction) / (v_norm * d_norm))
+
+                        if cos_angle > 0.8:
+                            register_event(
+                                {
+                                    "type": "shot",
+                                    "t": float(t),
+                                    "from_tid": int(owner_tid),
+                                    "to_tid": None,
+                                    "team_id": int(shooter_team),
+                                    "extra": {"speed_kmh": speed_kmh},
+                                },
+                                f"Shot by #{owner_tid} (Team {shooter_team}) – {speed_kmh:.1f} km/h",
+                            )
+                        else:
+                            register_event(
+                                {
+                                    "type": "clearance",
+                                    "t": float(t),
+                                    "from_tid": int(owner_tid),
+                                    "to_tid": None,
+                                    "team_id": int(shooter_team),
+                                    "extra": {"speed_kmh": speed_kmh},
+                                },
+                                f"Clearance by #{owner_tid} (Team {shooter_team})",
+                            )
+
+            prev_owner_tid = owner_tid
+            prev_ball_pos_pitch = frame_ball_pos_pitch
+
+            # ========================================
+            # FRAME ANNOTATION (video overlay)
+            # ========================================
+            annotated_frame = frame.copy()
+
+            # Basic labels: only player ID + team
+            labels = []
+            for tid, cid in zip(all_detections.tracker_id, all_detections.class_id):
+                labels.append(f"#{int(tid)} T{int(cid)}")
+
+            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)
+
+            # HUD: possession per team
+            total_poss = sum(possession_time_team.values()) + 1e-6
+            team0_pct = 100.0 * possession_time_team.get(0, 0.0) / total_poss
+            team1_pct = 100.0 * possession_time_team.get(1, 0.0) / total_poss
+
+            hud_text = (
+                f"Team 0 Ball Control: {team0_pct:5.2f}%   "
+                f"Team 1 Ball Control: {team1_pct:5.2f}%"
+            )
+            cv2.rectangle(
+                annotated_frame,
+                (20, annotated_frame.shape[0] - 60),
+                (annotated_frame.shape[1] - 20, annotated_frame.shape[0] - 20),
+                (255, 255, 255),
+                -1,
+            )
+            cv2.putText(
+                annotated_frame,
+                hud_text,
+                (30, annotated_frame.shape[0] - 30),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.8,
+                (0, 0, 0),
+                2,
+                cv2.LINE_AA,
+            )
+
+            # Event banner
+            if event_text_frames_left > 0 and current_event_text:
+                cv2.rectangle(
+                    annotated_frame,
+                    (20, 20),
+                    (annotated_frame.shape[1] - 20, 90),
+                    (255, 255, 255),
+                    -1,
+                )
+                cv2.putText(
+                    annotated_frame,
+                    current_event_text,
+                    (30, 70),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    1.0,
+                    (0, 0, 0),
+                    2,
+                    cv2.LINE_AA,
+                )
+                event_text_frames_left -= 1
+
+            out.write(annotated_frame)
+
+        cap.release()
+        out.release()
+        print(f"✅ Processed {frame_count} frames")
+
+        # ========================================
+        # 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:
+                # If multiple points (rare for ball), ignore to avoid ambiguity
+                path_for_cleaning.append(np.empty((0, 2), dtype=np.float32))
+            else:
+                path_for_cleaning.append(coords)
+
+        # 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: "
+            f"{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 charts
+        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 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_meters"])
+                    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 (3 columns)
+        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
+
+        # ========================================
+        # 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:
+            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
+
+        # ========================================
+        # BUILD PLAYER STATS TABLE & EVENTS TABLE
+        # ========================================
+        total_poss = sum(possession_time_team.values()) + 1e-6
+
+        player_stats_table = []
+        for team_id, player_ids in teams.items():
+            for pid in player_ids:
+                stats = performance_tracker.get_player_stats(pid)
+                poss_s = float(possession_time_player.get(pid, 0.0))
+                poss_pct = 100.0 * poss_s / total_poss if total_poss > 0 else 0.0
+
+                row = [
+                    int(pid),
+                    int(stats["team_id"]),
+                    float(stats["total_distance_meters"]),
+                    float(stats["avg_velocity"]),
+                    float(stats["max_velocity"]),
+                    int(stats["frames_visible"]),
+                    int(stats["time_in_defensive_third"]),
+                    int(stats["time_in_middle_third"]),
+                    int(stats["time_in_attacking_third"]),
+                    poss_s,
+                    poss_pct,
+                ]
+                player_stats_table.append(row)
+
+        events_table = []
+        for ev in events:
+            ev_type = ev.get("type", "")
+            t_ev = float(ev.get("t", 0.0))
+            team_id = ev.get("team_id", None)
+            from_tid = ev.get("from_tid", None)
+            to_tid = ev.get("to_tid", None)
+            extra = ev.get("extra", {}) or {}
+
+            speed_kmh = float(extra.get("speed_kmh", 0.0))
+            ball_dist_m = float(extra.get("distance_m", extra.get("ball_travel_m", 0.0)))
+            player_dist_m = float(extra.get("player_distance_m", 0.0))
+
+            if ev_type == "pass":
+                desc = f"Pass #{from_tid} → #{to_tid} (Team {team_id})"
+            elif ev_type == "tackle":
+                desc = (
+                    f"Tackle: #{to_tid} wins ball from #{from_tid} "
+                    f"(Team {team_id})"
+                )
+            elif ev_type == "interception":
+                desc = (
+                    f"Interception: #{to_tid} intercepts #{from_tid} "
+                    f"(Team {team_id})"
+                )
+            elif ev_type == "shot":
+                desc = (
+                    f"Shot by #{from_tid} (Team {team_id}) at {speed_kmh:.1f} km/h"
+                )
+            elif ev_type == "clearance":
+                desc = f"Clearance by #{from_tid} (Team {team_id})"
+            else:
+                desc = ev_type
+
+            row = [
+                t_ev,
+                ev_type,
+                team_id,
+                from_tid,
+                to_tid,
+                speed_kmh,
+                ball_dist_m,
+                player_dist_m,
+                desc,
+            ]
+            events_table.append(row)
+
+        events_json_path = "/tmp/events.json"
+        with open(events_json_path, "w", encoding="utf-8") as f:
+            json.dump(events, f, indent=2)
+
+        # ========================================
+        # Generate Summary Report
+        # ========================================
+        progress(0.95, desc="📝 Generating summary report...")
+
+        summary_lines = ["✅ **Analysis Complete!**\n"]
+        summary_lines.append("**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: "
+            f"{len([p for p in cleaned_path if len(p) > 0])}\n"
+        )
+
+        for team_id in [0, 1]:
+            if team_id not in teams:
+                continue
+
+            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])}")
+
+            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"
+            )
+
+            # Top 3 performers (by distance)
+            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("\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: {stats['avg_velocity']:.2f} km/h, "
+                    f"Max: {stats['max_velocity']:.2f} km/h"
+                )
+
+        # Team possession in summary
+        summary_lines.append("\n**Team Possession:**")
+        for team_id in sorted(possession_time_team.keys()):
+            t_sec = possession_time_team[team_id]
+            pct = 100.0 * t_sec / total_poss if total_poss > 0 else 0.0
+            summary_lines.append(f"- Team {team_id}: {t_sec:.1f} s ({pct:.1f}%)")
+
+        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 & events")
+        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="✅ Analysis Complete!")
+
+        # IMPORTANT: must return 9 outputs in the same order as Gradio wiring
+        return (
+            output_path,  # video_output
+            comparison_fig,  # comparison_output
+            team_heatmaps_path,  # team_heatmaps_output
+            individual_heatmaps_path,  # individual_heatmaps_output
+            radar_path,  # radar_output
+            summary_msg,  # status_output
+            player_stats_table,  # player_stats_output (Dataframe)
+            events_table,  # events_output (Dataframe)
+            events_json_path,  # events_json_output (File download)
+        )
+
     except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        print(error_msg)
         import traceback
-        error_details = traceback.format_exc()
-        
-        print(f"❌ Error during analysis: {e}")
-        print(f"📋 Traceback:\n{error_details}")
-        print("=" * 80)
-        
-        error_result = {
-            "error": str(e),
-            "traceback": error_details,
-            "success": False
-        }
-        
-        return None, json.dumps(error_result), json.dumps([]), json.dumps({})
+
+        traceback.print_exc()
+        # Match the 9 outputs (fill with Nones/empties)
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            error_msg,
+            [],
+            [],
+            None,
+        )
 
 
 # ==============================================
-# GRADIO INTERFACE - MAIN WEB UI
+# GRADIO INTERFACE
 # ==============================================
+
 def run_pipeline(video) -> Tuple:
     """
-    Gradio wrapper for web UI: accept the raw video object from gr.Video
+    Gradio wrapper: accept the raw video object from gr.Video and
+    convert it to a filesystem path for analyze_football_video().
     """
     if video is None:
         return (
-            None, None, None, None, None,
+            None,
+            None,
+            None,
+            None,
+            None,
             "❌ Please upload a video file.",
-            [], [], None,
+            [],
+            [],
+            None,
         )
 
+    # On Spaces, Video input is usually a dict with at least a "path" key.
     if isinstance(video, dict):
-        video_path = video.get("path") or video.get("name") or video.get("filename")
+        video_path = (
+            video.get("path")
+            or video.get("name")
+            or video.get("filename")
+        )
     else:
+        # Fallback: if it's already a string/path-like
         video_path = str(video)
 
     if not video_path:
         return (
-            None, None, None, None, None,
+            None,
+            None,
+            None,
+            None,
+            None,
             "❌ Could not resolve video file path from upload.",
-            [], [], None,
+            [],
+            [],
+            None,
         )
 
     return analyze_football_video(video_path)
 
 
-# ==============================================
-# CREATE GRADIO INTERFACES
-# ==============================================
-
-# Main web interface (for direct Space access)
-with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as web_interface:
+with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()) as iface:
     gr.Markdown(
         """
     # ⚽ Advanced Football Video Analyzer
     ### Complete Pipeline Implementation
     
-    This application provides:
-    1. **Player Detection** - Roboflow models for player, ball, and referee detection
-    2. **Team Classification** - SigLIP-based team classifier with stable assignments
-    3. **Persistent Tracking** - ByteTrack with ID stability
-    4. **Field Transformation** - Homography projection to pitch coordinates
-    5. **Ball Trajectory** - Path tracking with outlier removal
-    6. **Performance Analytics** - Heatmaps, stats, possession, events
+    This application:
+    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** - Heatmaps, stats, possession, and event detection  
     
     Upload a football match video to get comprehensive performance analytics!
     """
     )
 
     with gr.Row():
-        video_input = gr.File(label="Upload Football Video", file_types=["video"])
+        # No "type" argument – your Gradio version does not support it
+        video_input = gr.Video(label="📤 Upload Football Video")
 
     analyze_btn = gr.Button("🚀 Start Analysis Pipeline", variant="primary", size="lg")
 
@@ -779,11 +1506,13 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
 
     with gr.Tabs():
         with gr.Tab("📹 Annotated Video"):
-            gr.Markdown("### Full video with tracking, teams, ball detection, and events")
+            gr.Markdown(
+                "### Full video with player tracking, team colors, ball detection, and events overlay"
+            )
             video_output = gr.Video(label="Processed Video")
 
         with gr.Tab("📊 Performance Comparison"):
-            gr.Markdown("### Interactive charts comparing player performance")
+            gr.Markdown("### Interactive charts comparing player performance metrics")
             comparison_output = gr.Plot(label="Team Performance Metrics")
 
         with gr.Tab("🗺️ Team Heatmaps"):
@@ -799,7 +1528,7 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             radar_output = gr.Image(label="Tactical Radar View")
 
         with gr.Tab("📋 Player Stats"):
-            gr.Markdown("### Per-player: distance, speeds, zones, possession")
+            gr.Markdown("### Per-player totals: distance, speeds, zones, possession")
             player_stats_output = gr.Dataframe(
                 headers=PLAYER_STATS_HEADERS,
                 col_count=len(PLAYER_STATS_HEADERS),
@@ -808,72 +1537,69 @@ with gr.Blocks(title="⚽ Football Performance Analyzer", theme=gr.themes.Soft()
             )
 
         with gr.Tab("⏱️ Event Timeline"):
-            gr.Markdown("### Passes, tackles, interceptions, shots, clearances")
+            gr.Markdown(
+                "### Detected passes, tackles, interceptions, shots, clearances"
+            )
             events_output = gr.Dataframe(
                 headers=EVENT_HEADERS,
                 col_count=len(EVENT_HEADERS),
                 row_count=0,
                 interactive=False,
             )
-            events_json_output = gr.File(label="Download events JSON", file_types=[".json"])
+            events_json_output = gr.File(
+                label="Download events JSON",
+                file_types=[".json"],
+            )
 
     analyze_btn.click(
         fn=run_pipeline,
         inputs=[video_input],
         outputs=[
-            video_output,
-            comparison_output,
-            team_heatmaps_output,
-            individual_heatmaps_output,
-            radar_output,
-            status_output,
-            player_stats_output,
-            events_output,
-            events_json_output,
+            video_output,  # 1
+            comparison_output,  # 2
+            team_heatmaps_output,  # 3
+            individual_heatmaps_output,  # 4
+            radar_output,  # 5
+            status_output,  # 6
+            player_stats_output,  # 7
+            events_output,  # 8
+            events_json_output,  # 9
         ],
     )
 
-# API interface (for programmatic access via gradio_client)
-with gr.Blocks(title="⚽ AfriGoals API") as api_interface:
-    gr.Markdown("# ⚽ AfriGoals - Football Video Analysis API")
-    gr.Markdown("This interface is for programmatic access via `gradio_client`.")
+    gr.Markdown(
+        """
+    ---
+    ### 🔧 Technical Details:
     
-    with gr.Row():
-        api_video_input = gr.Video(label="Upload Match Video")
+    **Detection Models:**
+    - Player/Ball/Referee Detection: `football-players-detection-3zvbc/11`
+    - Field Keypoint Detection: `football-field-detection-f07vi/14`
     
-    with gr.Row():
-        api_process_btn = gr.Button("Process Video", variant="primary")
+    **Tracking & Classification:**
+    - ByteTrack for persistent player IDs  
+    - SigLIP embeddings for team classification  
+    - Majority voting for stable team assignments  
     
-    with gr.Tabs():
-        with gr.Tab("📹 Results"):
-            api_video_output = gr.Video(label="Annotated Video")
-            api_stats_output = gr.JSON(label="Match Statistics")
-            api_events_output = gr.JSON(label="Detected Events")
-            api_artifacts_output = gr.JSON(label="Generated Artifacts")
+    **Performance Metrics:**
+    - Distance covered (meters)  
+    - Average & maximum speed (km/h)  
+    - Zone activity (defensive/middle/attacking thirds)  
+    - Position heatmaps with Gaussian smoothing  
+    - Possession per player & per team  
     
-    api_process_btn.click(
-        fn=process_video_api,
-        inputs=[api_video_input],
-        outputs=[
-            api_video_output,
-            api_stats_output,
-            api_events_output,
-            api_artifacts_output,
-        ],
+    **Ball Tracking:**
+    - Field homography transformation  
+    - Outlier removal (500 cm threshold)  
+    - Transformation matrix smoothing (5-frame window)  
+    
+    **Events:**
+    - Passes, tackles, interceptions, shots, clearances  
+    - Event banner overlay in video  
+    - Full event list downloadable as JSON  
+    """
     )
 
-# ==============================================
-# LAUNCH BOTH INTERFACES
-# ==============================================
+
 if __name__ == "__main__":
-    # Create tabbed interface with both UIs
-    demo = gr.TabbedInterface(
-        [web_interface, api_interface],
-        ["🌐 Web Interface", "🔌 API Access"],
-        title="⚽ AfriGoals - Football Video Analyzer"
-    )
-    
-    demo.launch(
-        show_error=True,
-        share=False,
-    )
+    iface.launch()