Capstone - Complete Analytics System

# Python: Basic image processing with OpenCV
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load a football frame
img = cv2.imread("match_frame.jpg")
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

print(f"Dimensions: {img.shape[1]} x {img.shape[0]}")

# Basic preprocessing
# Resize to standard dimensions
resized = cv2.resize(img, (1280, 720))

# Adjust brightness and contrast
alpha = 1.2  # Contrast
beta = 10    # Brightness
adjusted = cv2.convertScaleAbs(resized, alpha=alpha, beta=beta)

# Edge detection for pitch lines
gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 150)

# Hough line detection for pitch lines
lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=100,
                        minLineLength=100, maxLineGap=10)

# Draw detected lines
line_img = resized.copy()
if lines is not None:
    for line in lines:
        x1, y1, x2, y2 = line[0]
        cv2.line(line_img, (x1, y1), (x2, y2), (0, 255, 0), 2)

# Display results
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
axes[0].imshow(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
axes[0].set_title("Original")
axes[1].imshow(edges, cmap="gray")
axes[1].set_title("Edge Detection")
axes[2].imshow(cv2.cvtColor(line_img, cv2.COLOR_BGR2RGB))
axes[2].set_title("Pitch Lines")
plt.tight_layout()
plt.show()

# Python: Player detection with YOLOv8
from ultralytics import YOLO
import cv2
import numpy as np

# Load pre-trained YOLO model
model = YOLO("yolov8n.pt")  # Nano model for speed

# Run detection
results = model("match_frame.jpg")

# Process results
for result in results:
    boxes = result.boxes

    # Filter for person class (0) and sports ball (32)
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

        if cls == 0:  # Person
            print(f"Player: ({x1:.0f}, {y1:.0f}) to ({x2:.0f}, {y2:.0f}), conf: {conf:.2f}")
        elif cls == 32:  # Sports ball
            print(f"Ball: ({x1:.0f}, {y1:.0f}) to ({x2:.0f}, {y2:.0f}), conf: {conf:.2f}")

# Visualize detections
annotated_frame = results[0].plot()
cv2.imwrite("detections.jpg", annotated_frame)

print(f"\nTotal people detected: {len([b for b in boxes if int(b.cls[0]) == 0])}")

# Python: Team classification by jersey color
import cv2
import numpy as np
from sklearn.cluster import KMeans

def extract_jersey_color(img, bbox):
    """Extract dominant jersey color from player bounding box."""
    x1, y1, x2, y2 = map(int, bbox)
    height = y2 - y1

    # Focus on torso region (upper-middle of bounding box)
    torso_y1 = int(y1 + height * 0.2)
    torso_y2 = int(y1 + height * 0.5)

    # Crop jersey region
    jersey_region = img[torso_y1:torso_y2, x1:x2]

    if jersey_region.size == 0:
        return None

    # Reshape to list of pixels
    pixels = jersey_region.reshape(-1, 3)

    # K-means to find dominant color
    kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
    kmeans.fit(pixels)

    # Get most common cluster center
    labels, counts = np.unique(kmeans.labels_, return_counts=True)
    dominant_idx = labels[np.argmax(counts)]
    dominant_color = kmeans.cluster_centers_[dominant_idx]

    return dominant_color

def classify_teams(player_colors):
    """Classify players into teams based on jersey colors."""
    colors = np.array([c for c in player_colors if c is not None])

    if len(colors) < 3:
        return None

    # Cluster into 3 groups (2 teams + refs/others)
    kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
    labels = kmeans.fit_predict(colors)

    return labels, kmeans.cluster_centers_

# Example usage
img = cv2.imread("match_frame.jpg")

# Assume we have detections from YOLO
player_bboxes = [
    [234, 156, 289, 298],
    [567, 189, 612, 334],
    # ... more players
]

# Extract colors for all players
colors = [extract_jersey_color(img, bbox) for bbox in player_bboxes]

# Classify teams
team_labels, team_colors = classify_teams(colors)
print(f"Team 1 color (BGR): {team_colors[0]}")
print(f"Team 2 color (BGR): {team_colors[1]}")

# Python: Homography transformation
import cv2
import numpy as np

# Define corresponding points
# Source: pixel coordinates from video frame (detected pitch markings)
src_points = np.array([
    [324, 189],   # Corner flag
    [856, 201],   # Penalty area corner
    [1234, 312],  # Center circle point
    [567, 445],   # 6-yard box corner
], dtype=np.float32)

# Destination: pitch coordinates (in meters, standard 105x68 pitch)
dst_points = np.array([
    [0, 0],       # Corner
    [16.5, 0],    # Penalty area corner
    [52.5, 34],   # Center
    [5.5, 13.84]  # 6-yard box corner
], dtype=np.float32)

# Scale for visualization (pixels per meter)
scale = 10
dst_points = dst_points * scale

# Calculate homography matrix
H, mask = cv2.findHomography(src_points, dst_points)

print("Homography Matrix:")
print(H)

# Function to transform points
def transform_to_pitch(pixel_coords, H):
    """Transform pixel coordinates to pitch coordinates."""
    pts = np.array([[pixel_coords]], dtype=np.float32)
    transformed = cv2.perspectiveTransform(pts, H)
    return transformed[0][0] / scale  # Unscale to meters

# Transform player positions
player_pixels = [
    [500, 300],
    [750, 250],
    [1000, 400]
]

for px in player_pixels:
    pitch_pos = transform_to_pitch(px, H)
    print(f"Pixel {px} -> Pitch ({pitch_pos[0]:.1f}, {pitch_pos[1]:.1f}) meters")

# Create pitch visualization with transformed points
def create_pitch_overlay(H, detections, pitch_size=(1050, 680)):
    """Create top-down pitch view with player positions."""
    pitch = np.ones((pitch_size[1], pitch_size[0], 3), dtype=np.uint8) * 34

    # Draw pitch markings (simplified)
    cv2.rectangle(pitch, (0, 0), (pitch_size[0]-1, pitch_size[1]-1),
                 (255, 255, 255), 2)
    cv2.line(pitch, (pitch_size[0]//2, 0), (pitch_size[0]//2, pitch_size[1]),
            (255, 255, 255), 2)
    cv2.circle(pitch, (pitch_size[0]//2, pitch_size[1]//2), 91,
              (255, 255, 255), 2)

    # Transform and plot detections
    for det in detections:
        px = [(det[0] + det[2])/2, det[3]]  # Bottom center of bbox
        pitch_pos = transform_to_pitch(px, H)
        x = int(pitch_pos[0] * scale)
        y = int(pitch_pos[1] * scale)
        if 0 <= x < pitch_size[0] and 0 <= y < pitch_size[1]:
            cv2.circle(pitch, (x, y), 8, (0, 0, 255), -1)

    return pitch

# Python: Automatic pitch keypoint detection
import cv2
import numpy as np

def detect_pitch_keypoints(frame):
    """Detect pitch keypoints for homography estimation."""

    # Convert to HSV for grass detection
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # Mask for grass (green)
    lower_green = np.array([35, 50, 50])
    upper_green = np.array([85, 255, 255])
    grass_mask = cv2.inRange(hsv, lower_green, upper_green)

    # Detect white lines on grass
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    _, white_mask = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)

    # Combine masks - white on grass
    line_mask = cv2.bitwise_and(white_mask, grass_mask)

    # Clean up with morphology
    kernel = np.ones((3, 3), np.uint8)
    line_mask = cv2.morphologyEx(line_mask, cv2.MORPH_CLOSE, kernel)
    line_mask = cv2.morphologyEx(line_mask, cv2.MORPH_OPEN, kernel)

    # Detect lines with Hough transform
    lines = cv2.HoughLinesP(line_mask, 1, np.pi/180,
                           threshold=100, minLineLength=50, maxLineGap=20)

    # Find line intersections (potential keypoints)
    keypoints = []
    if lines is not None:
        for i in range(len(lines)):
            for j in range(i+1, len(lines)):
                pt = line_intersection(lines[i][0], lines[j][0])
                if pt is not None:
                    keypoints.append(pt)

    return lines, keypoints

def line_intersection(line1, line2):
    """Find intersection point of two lines."""
    x1, y1, x2, y2 = line1
    x3, y3, x4, y4 = line2

    denom = (x1-x2)*(y3-y4) - (y1-y2)*(x3-x4)
    if abs(denom) < 1e-10:
        return None

    t = ((x1-x3)*(y3-y4) - (y1-y3)*(x3-x4)) / denom

    px = x1 + t*(x2-x1)
    py = y1 + t*(y2-y1)

    # Check if intersection is within frame
    if 0 <= px <= 1920 and 0 <= py <= 1080:
        return (int(px), int(py))
    return None

# For production, use specialized models like:
# - SoccerNet Camera Calibration
# - Sports Camera Calibration networks
# - Keypoint detection CNNs

# Python: Multi-object tracking with SORT
import numpy as np
from scipy.optimize import linear_sum_assignment

class SimpleTracker:
    """Simple IoU-based multi-object tracker."""

    def __init__(self, max_age=5, min_hits=3, iou_threshold=0.3):
        self.max_age = max_age
        self.min_hits = min_hits
        self.iou_threshold = iou_threshold
        self.tracks = {}
        self.next_id = 0
        self.frame_count = 0

    def iou(self, box1, box2):
        """Calculate IoU between two boxes."""
        x1 = max(box1[0], box2[0])
        y1 = max(box1[1], box2[1])
        x2 = min(box1[2], box2[2])
        y2 = min(box1[3], box2[3])

        inter = max(0, x2-x1) * max(0, y2-y1)
        area1 = (box1[2]-box1[0]) * (box1[3]-box1[1])
        area2 = (box2[2]-box2[0]) * (box2[3]-box2[1])

        return inter / (area1 + area2 - inter + 1e-6)

    def update(self, detections):
        """Update tracks with new detections."""
        self.frame_count += 1

        if len(self.tracks) == 0:
            # Initialize tracks
            for det in detections:
                self.tracks[self.next_id] = {
                    "bbox": det,
                    "age": 0,
                    "hits": 1,
                    "history": [det.copy()]
                }
                self.next_id += 1
            return self.get_active_tracks()

        # Build cost matrix (negative IoU)
        track_ids = list(self.tracks.keys())
        cost_matrix = np.zeros((len(track_ids), len(detections)))

        for i, tid in enumerate(track_ids):
            for j, det in enumerate(detections):
                cost_matrix[i, j] = -self.iou(self.tracks[tid]["bbox"], det)

        # Hungarian algorithm for optimal assignment
        row_ind, col_ind = linear_sum_assignment(cost_matrix)

        # Update matched tracks
        matched_tracks = set()
        matched_dets = set()

        for i, j in zip(row_ind, col_ind):
            if -cost_matrix[i, j] >= self.iou_threshold:
                tid = track_ids[i]
                self.tracks[tid]["bbox"] = detections[j]
                self.tracks[tid]["age"] = 0
                self.tracks[tid]["hits"] += 1
                self.tracks[tid]["history"].append(detections[j].copy())
                matched_tracks.add(tid)
                matched_dets.add(j)

        # Age unmatched tracks
        for tid in track_ids:
            if tid not in matched_tracks:
                self.tracks[tid]["age"] += 1

        # Remove old tracks
        self.tracks = {k: v for k, v in self.tracks.items()
                      if v["age"] <= self.max_age}

        # Create new tracks for unmatched detections
        for j, det in enumerate(detections):
            if j not in matched_dets:
                self.tracks[self.next_id] = {
                    "bbox": det,
                    "age": 0,
                    "hits": 1,
                    "history": [det.copy()]
                }
                self.next_id += 1

        return self.get_active_tracks()

    def get_active_tracks(self):
        """Return tracks with enough hits."""
        return {k: v for k, v in self.tracks.items()
                if v["hits"] >= self.min_hits}

# Example usage
tracker = SimpleTracker()

# Process video frames
cap = cv2.VideoCapture("match_video.mp4")
model = YOLO("yolov8n.pt")

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Detect players
    results = model(frame)
    detections = []
    for box in results[0].boxes:
        if int(box.cls[0]) == 0:  # Person class
            detections.append(box.xyxy[0].cpu().numpy())

    # Update tracker
    if detections:
        active_tracks = tracker.update(np.array(detections))

        # Draw tracks
        for tid, track in active_tracks.items():
            x1, y1, x2, y2 = map(int, track["bbox"])
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(frame, f"ID:{tid}", (x1, y1-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cap.release()

# Python: ByteTrack for robust tracking
# pip install bytetracker

from bytetracker import BYTETracker
import numpy as np

# Initialize ByteTrack
tracker = BYTETracker(
    track_thresh=0.5,      # Detection confidence threshold
    track_buffer=30,       # Frames to keep lost tracks
    match_thresh=0.8,      # IoU threshold for matching
    frame_rate=25          # Video frame rate
)

# Process video with ByteTrack
def process_video_with_bytetrack(video_path, detector):
    """Process video and track all players."""

    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    all_tracks = []

    frame_idx = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        # Get detections [x1, y1, x2, y2, conf, class]
        results = detector(frame)
        dets = []
        for box in results[0].boxes:
            if int(box.cls[0]) == 0:  # Person
                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
                conf = float(box.conf[0])
                dets.append([x1, y1, x2, y2, conf])

        dets = np.array(dets) if dets else np.empty((0, 5))

        # Update tracker
        if len(dets) > 0:
            online_targets = tracker.update(
                dets,
                [frame.shape[0], frame.shape[1]],
                [frame.shape[0], frame.shape[1]]
            )

            # Store tracking results
            for t in online_targets:
                all_tracks.append({
                    "frame": frame_idx,
                    "track_id": t.track_id,
                    "bbox": t.tlbr,  # [x1, y1, x2, y2]
                    "score": t.score
                })

        frame_idx += 1

    cap.release()
    return pd.DataFrame(all_tracks)

# Run tracking
tracks_df = process_video_with_bytetrack("match.mp4", model)
print(f"Tracked {tracks_df['track_id'].nunique()} unique players")

# Python: Ball detection with specialized model
import cv2
import numpy as np
from ultralytics import YOLO

class BallDetector:
    """Specialized ball detection with tracking."""

    def __init__(self, model_path="yolov8n.pt"):
        self.model = YOLO(model_path)
        self.ball_history = []
        self.max_history = 10
        self.kalman = self._init_kalman()

    def _init_kalman(self):
        """Initialize Kalman filter for ball tracking."""
        kf = cv2.KalmanFilter(4, 2)  # 4 state vars, 2 measurements

        # State: [x, y, vx, vy]
        kf.measurementMatrix = np.array([
            [1, 0, 0, 0],
            [0, 1, 0, 0]
        ], dtype=np.float32)

        kf.transitionMatrix = np.array([
            [1, 0, 1, 0],
            [0, 1, 0, 1],
            [0, 0, 1, 0],
            [0, 0, 0, 1]
        ], dtype=np.float32)

        kf.processNoiseCov = np.eye(4, dtype=np.float32) * 0.03

        return kf

    def detect(self, frame):
        """Detect ball in frame."""
        # Run YOLO detection
        results = self.model(frame, classes=[32])  # Sports ball class

        best_detection = None
        best_confidence = 0

        for result in results:
            for box in result.boxes:
                conf = float(box.conf[0])
                if conf > best_confidence:
                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
                    center = ((x1 + x2) / 2, (y1 + y2) / 2)
                    size = ((x2 - x1) + (y2 - y1)) / 2

                    # Validate ball-like properties
                    if self._validate_ball(center, size):
                        best_detection = center
                        best_confidence = conf

        # If no detection, use Kalman prediction
        if best_detection is None and len(self.ball_history) > 0:
            prediction = self.kalman.predict()
            best_detection = (prediction[0, 0], prediction[1, 0])
            best_confidence = 0.3  # Lower confidence for predicted

        # Update tracker
        if best_detection is not None:
            measurement = np.array([[best_detection[0]], [best_detection[1]]], dtype=np.float32)
            self.kalman.correct(measurement)
            self.ball_history.append(best_detection)
            if len(self.ball_history) > self.max_history:
                self.ball_history.pop(0)

        return best_detection, best_confidence

    def _validate_ball(self, center, size):
        """Validate if detection is likely a ball."""
        # Size constraints (ball is small)
        if size < 10 or size > 100:
            return False

        # Trajectory consistency check
        if len(self.ball_history) >= 2:
            last_pos = self.ball_history[-1]
            dx = abs(center[0] - last_pos[0])
            dy = abs(center[1] - last_pos[1])
            # Ball cant move too far in one frame
            if dx > 200 or dy > 200:
                return False

        return True

    def get_velocity(self, fps=25):
        """Calculate ball velocity from history."""
        if len(self.ball_history) < 2:
            return None

        p1 = np.array(self.ball_history[-2])
        p2 = np.array(self.ball_history[-1])

        # Pixels per frame
        displacement = np.linalg.norm(p2 - p1)
        # Approximate: 1 pixel ≈ 0.1 meters (varies with camera)
        speed_mps = displacement * 0.1 * fps

        return speed_mps

# Usage
detector = BallDetector()
frame = cv2.imread("match_frame.jpg")
position, confidence = detector.detect(frame)

if position:
    print(f"Ball at ({position[0]:.0f}, {position[1]:.0f}), conf: {confidence:.2f}")
    velocity = detector.get_velocity()
    if velocity:
        print(f"Ball speed: {velocity:.1f} m/s ({velocity * 3.6:.1f} km/h)")

# Python: Physical metrics from tracking data
import numpy as np
import pandas as pd

def calculate_physical_metrics(tracks_df, H, fps=25, scale=10):
    """Calculate speed, distance, and acceleration from tracking data."""

    def transform_point(px, py, H):
        """Transform pixel to pitch coordinates."""
        pt = np.array([[[px, py]]], dtype=np.float32)
        transformed = cv2.perspectiveTransform(pt, H)
        return transformed[0, 0] / scale

    # Transform all positions
    tracks_df = tracks_df.copy()
    tracks_df["foot_x"] = (tracks_df["x1"] + tracks_df["x2"]) / 2
    tracks_df["foot_y"] = tracks_df["y2"]

    # Apply homography transformation
    pitch_coords = tracks_df.apply(
        lambda row: transform_point(row["foot_x"], row["foot_y"], H),
        axis=1
    )
    tracks_df["pitch_x"] = [c[0] for c in pitch_coords]
    tracks_df["pitch_y"] = [c[1] for c in pitch_coords]

    # Sort by track and frame
    tracks_df = tracks_df.sort_values(["track_id", "frame"])

    # Calculate displacement and speed per track
    dt = 1 / fps
    results = []

    for track_id, group in tracks_df.groupby("track_id"):
        group = group.reset_index(drop=True)

        # Frame-to-frame displacement
        dx = group["pitch_x"].diff()
        dy = group["pitch_y"].diff()
        displacement = np.sqrt(dx**2 + dy**2)

        # Speed (m/s)
        speed = displacement / dt

        # Smooth speed (rolling average)
        speed_smooth = speed.rolling(window=5, min_periods=1).mean()

        # Acceleration
        acceleration = speed.diff() / dt

        # Movement classification
        def classify_movement(s):
            if pd.isna(s):
                return "Unknown"
            if s < 2:
                return "Walking"
            if s < 4:
                return "Jogging"
            if s < 6:
                return "Running"
            if s < 7:
                return "High Speed"
            return "Sprinting"

        movement_type = speed_smooth.apply(classify_movement)

        group["displacement"] = displacement
        group["speed"] = speed
        group["speed_smooth"] = speed_smooth
        group["acceleration"] = acceleration
        group["movement_type"] = movement_type

        results.append(group)

    detailed = pd.concat(results, ignore_index=True)

    # Aggregate per player
    summary = detailed.groupby("track_id").agg(
        total_distance=("displacement", "sum"),
        max_speed=("speed_smooth", "max"),
        avg_speed=("speed_smooth", "mean"),
        time_walking=("movement_type", lambda x: (x == "Walking").sum() / fps),
        time_jogging=("movement_type", lambda x: (x == "Jogging").sum() / fps),
        time_running=("movement_type", lambda x: (x == "Running").sum() / fps),
        time_sprinting=("movement_type", lambda x: (x == "Sprinting").sum() / fps),
    ).reset_index()

    # Count sprints (transitions into sprinting)
    def count_sprints(group):
        is_sprint = group["movement_type"] == "Sprinting"
        return (is_sprint & ~is_sprint.shift(1, fill_value=False)).sum()

    sprint_counts = detailed.groupby("track_id").apply(count_sprints).reset_index()
    sprint_counts.columns = ["track_id", "sprints"]
    summary = summary.merge(sprint_counts, on="track_id")

    # Convert speed to km/h for display
    summary["max_speed_kmh"] = summary["max_speed"] * 3.6
    summary["avg_speed_kmh"] = summary["avg_speed"] * 3.6

    return detailed, summary

# Example usage
print("Player Physical Summary:")
print("Track  Distance  Max Speed   Sprints")
print("  1    10.2 km   32.4 km/h      24")
print("  2    11.8 km   28.7 km/h      18")
print("  3     9.8 km   31.1 km/h      22")

# Python: Action recognition with deep learning
import torch
import torch.nn as nn
from torchvision.models.video import r3d_18

class FootballActionRecognizer:
    """Recognize football actions from video clips."""

    def __init__(self, num_classes=10):
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

        # Use pre-trained 3D ResNet
        self.model = r3d_18(pretrained=True)
        # Replace final layer for our classes
        self.model.fc = nn.Linear(512, num_classes)
        self.model.to(self.device)
        self.model.eval()

        self.action_labels = [
            "pass", "shot", "dribble", "tackle", "header",
            "cross", "clearance", "save", "foul", "other"
        ]

    def preprocess_clip(self, frames, target_frames=16):
        """Preprocess video clip for model input."""
        import torchvision.transforms as T

        # Sample frames uniformly
        indices = np.linspace(0, len(frames)-1, target_frames, dtype=int)
        sampled = [frames[i] for i in indices]

        # Transform
        transform = T.Compose([
            T.ToPILImage(),
            T.Resize((112, 112)),
            T.ToTensor(),
            T.Normalize(mean=[0.485, 0.456, 0.406],
                       std=[0.229, 0.224, 0.225])
        ])

        tensors = [transform(f) for f in sampled]
        clip = torch.stack(tensors, dim=1)  # [C, T, H, W]
        return clip.unsqueeze(0).to(self.device)  # [1, C, T, H, W]

    def predict(self, frames):
        """Predict action from video frames."""
        clip = self.preprocess_clip(frames)

        with torch.no_grad():
            outputs = self.model(clip)
            probs = torch.softmax(outputs, dim=1)
            pred_idx = torch.argmax(probs, dim=1).item()
            confidence = probs[0, pred_idx].item()

        return self.action_labels[pred_idx], confidence

    def extract_action_clips(self, video_path, detections, window=32):
        """Extract clips around key events for classification."""
        cap = cv2.VideoCapture(video_path)
        fps = cap.get(cv2.CAP_PROP_FPS)

        clips = []
        for event in detections:
            center_frame = event["frame"]
            start = max(0, center_frame - window // 2)

            cap.set(cv2.CAP_PROP_POS_FRAMES, start)
            frames = []

            for _ in range(window):
                ret, frame = cap.read()
                if not ret:
                    break
                # Crop to player bounding box area
                if "bbox" in event:
                    x1, y1, x2, y2 = map(int, event["bbox"])
                    pad = 50  # Add padding
                    x1 = max(0, x1 - pad)
                    y1 = max(0, y1 - pad)
                    x2 = min(frame.shape[1], x2 + pad)
                    y2 = min(frame.shape[0], y2 + pad)
                    frame = frame[y1:y2, x1:x2]
                frames.append(frame)

            if len(frames) >= 16:
                clips.append({
                    "event": event,
                    "frames": frames
                })

        cap.release()
        return clips

# Example usage
recognizer = FootballActionRecognizer()
# frames = [...]  # List of video frames
# action, confidence = recognizer.predict(frames)
# print(f"Detected action: {action} ({confidence:.2f})")

# Python: SoccerNet action spotting
# pip install SoccerNet

from SoccerNet.Downloader import SoccerNetDownloader
from SoccerNet.Evaluation.ActionSpotting import evaluate

# Download action spotting data and models
mySoccerNetDownloader = SoccerNetDownloader(LocalDirectory="./SoccerNet")
mySoccerNetDownloader.downloadGames(files=["Labels-v2.json"], split=["train", "valid", "test"])

# Action classes in SoccerNet
SOCCERNET_ACTIONS = [
    "Ball out of play",
    "Clearance",
    "Corner",
    "Direct free-kick",
    "Foul",
    "Goal",
    "Indirect free-kick",
    "Kick-off",
    "Offside",
    "Penalty",
    "Red card",
    "Shots off target",
    "Shots on target",
    "Substitution",
    "Throw-in",
    "Yellow card",
    "Yellow->red card"
]

print(f"SoccerNet has {len(SOCCERNET_ACTIONS)} action classes")

# Python: Complete CV pipeline
import cv2
import numpy as np
import pandas as pd
from ultralytics import YOLO
from bytetracker import BYTETracker
from pathlib import Path

class FootballCVPipeline:
    """Complete computer vision pipeline for football analysis."""

    def __init__(self, output_dir="./output"):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)

        # Initialize components
        self.detector = YOLO("yolov8m.pt")
        self.tracker = BYTETracker(track_thresh=0.5, track_buffer=30, match_thresh=0.8)
        self.ball_detector = BallDetector()

        self.homography = None
        self.team_colors = None

    def process_video(self, video_path, max_frames=None):
        """Process video and extract all data."""
        print(f"Processing video: {video_path}")

        cap = cv2.VideoCapture(video_path)
        fps = cap.get(cv2.CAP_PROP_FPS)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if max_frames:
            total_frames = min(total_frames, max_frames)

        # Results storage
        all_tracks = []
        all_ball_positions = []
        sample_frames = []

        frame_idx = 0
        print(f"Processing {total_frames} frames at {fps} FPS...")

        while cap.isOpened() and frame_idx < total_frames:
            ret, frame = cap.read()
            if not ret:
                break

            # Save sample frames for homography estimation
            if frame_idx % 100 == 0:
                sample_frames.append((frame_idx, frame.copy()))
                print(f"  Frame {frame_idx}/{total_frames}")

            # Detect players
            results = self.detector(frame, classes=[0])  # Person class
            detections = []

            for box in results[0].boxes:
                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
                conf = float(box.conf[0])
                detections.append([x1, y1, x2, y2, conf])

            detections = np.array(detections) if detections else np.empty((0, 5))

            # Track players
            if len(detections) > 0:
                online_targets = self.tracker.update(
                    detections,
                    [frame.shape[0], frame.shape[1]],
                    [frame.shape[0], frame.shape[1]]
                )

                for t in online_targets:
                    all_tracks.append({
                        "frame": frame_idx,
                        "track_id": t.track_id,
                        "x1": t.tlbr[0],
                        "y1": t.tlbr[1],
                        "x2": t.tlbr[2],
                        "y2": t.tlbr[3],
                        "score": t.score
                    })

            # Detect ball
            ball_pos, ball_conf = self.ball_detector.detect(frame)
            if ball_pos:
                all_ball_positions.append({
                    "frame": frame_idx,
                    "x": ball_pos[0],
                    "y": ball_pos[1],
                    "confidence": ball_conf
                })

            frame_idx += 1

        cap.release()

        # Convert to DataFrames
        tracks_df = pd.DataFrame(all_tracks)
        ball_df = pd.DataFrame(all_ball_positions)

        print(f"\nTracked {tracks_df[\"track_id\"].nunique()} unique players")
        print(f"Ball detected in {len(ball_df)} frames")

        # Estimate homography from sample frames
        if sample_frames:
            self.homography = self._estimate_homography(sample_frames[0][1])

        # Classify teams
        if len(tracks_df) > 0 and len(sample_frames) > 0:
            tracks_df = self._classify_teams(tracks_df, sample_frames[0][1])

        # Calculate physical metrics
        if self.homography is not None and len(tracks_df) > 0:
            detailed, summary = calculate_physical_metrics(tracks_df, self.homography, fps)
            tracks_df = detailed
            summary.to_csv(self.output_dir / "physical_summary.csv", index=False)
            print(f"\nPhysical metrics saved to {self.output_dir / \"physical_summary.csv\"}")

        # Save results
        tracks_df.to_csv(self.output_dir / "tracks.csv", index=False)
        ball_df.to_csv(self.output_dir / "ball_positions.csv", index=False)

        return tracks_df, ball_df

    def _estimate_homography(self, frame):
        """Estimate homography from pitch lines."""
        # Simplified: would use keypoint detection in production
        # Return identity matrix as placeholder
        print("Estimating homography (placeholder)...")
        return np.eye(3, dtype=np.float32)

    def _classify_teams(self, tracks_df, frame):
        """Classify players into teams."""
        print("Classifying teams by jersey color...")

        # Get sample of player crops
        sample_tracks = tracks_df.drop_duplicates("track_id").head(22)

        colors = []
        for _, row in sample_tracks.iterrows():
            color = extract_jersey_color(frame, [row["x1"], row["y1"], row["x2"], row["y2"]])
            colors.append(color)

        if colors:
            team_labels, _ = classify_teams(colors)
            # Map back to all tracks
            label_map = dict(zip(sample_tracks["track_id"], team_labels))
            tracks_df["team"] = tracks_df["track_id"].map(label_map)

        return tracks_df

# Run pipeline
pipeline = FootballCVPipeline(output_dir="./match_analysis")
tracks, ball = pipeline.process_video("match_clip.mp4", max_frames=1000)

print("\n=== Pipeline Complete ===")
print(f"Output saved to: ./match_analysis/")

# Python: Pose estimation with MediaPipe
import mediapipe as mp
import cv2
import numpy as np

# Initialize MediaPipe Pose
mp_pose = mp.solutions.pose
mp_draw = mp.solutions.drawing_utils

pose = mp_pose.Pose(
    static_image_mode=False,
    model_complexity=1,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
)

def calculate_angle(p1, p2, p3):
    """Calculate angle at p2 between p1-p2-p3."""
    v1 = np.array(p1) - np.array(p2)
    v2 = np.array(p3) - np.array(p2)

    cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
    angle = np.arccos(np.clip(cos_angle, -1, 1))

    return np.degrees(angle)

def analyze_player_pose(frame, bbox):
    """Extract pose from player bounding box."""
    x1, y1, x2, y2 = map(int, bbox)
    player_crop = frame[y1:y2, x1:x2]

    if player_crop.size == 0:
        return None

    # Run pose estimation
    rgb_crop = cv2.cvtColor(player_crop, cv2.COLOR_BGR2RGB)
    results = pose.process(rgb_crop)

    if not results.pose_landmarks:
        return None

    # Extract keypoints
    landmarks = results.pose_landmarks.landmark
    h, w = player_crop.shape[:2]

    keypoints = {}
    for idx, name in enumerate(mp_pose.PoseLandmark):
        lm = landmarks[idx]
        keypoints[name.name] = {
            "x": lm.x * w + x1,  # Convert to frame coords
            "y": lm.y * h + y1,
            "visibility": lm.visibility
        }

    # Calculate useful metrics
    metrics = {}

    # Knee angles (running form)
    if all(keypoints[k]["visibility"] > 0.5 for k in
           ["LEFT_HIP", "LEFT_KNEE", "LEFT_ANKLE"]):
        metrics["left_knee_angle"] = calculate_angle(
            [keypoints["LEFT_HIP"]["x"], keypoints["LEFT_HIP"]["y"]],
            [keypoints["LEFT_KNEE"]["x"], keypoints["LEFT_KNEE"]["y"]],
            [keypoints["LEFT_ANKLE"]["x"], keypoints["LEFT_ANKLE"]["y"]]
        )

    # Body lean (acceleration indicator)
    if all(keypoints[k]["visibility"] > 0.5 for k in
           ["NOSE", "LEFT_HIP", "RIGHT_HIP"]):
        hip_center = [
            (keypoints["LEFT_HIP"]["x"] + keypoints["RIGHT_HIP"]["x"]) / 2,
            (keypoints["LEFT_HIP"]["y"] + keypoints["RIGHT_HIP"]["y"]) / 2
        ]
        nose = [keypoints["NOSE"]["x"], keypoints["NOSE"]["y"]]

        # Lean angle from vertical
        dx = nose[0] - hip_center[0]
        dy = hip_center[1] - nose[1]  # Inverted y
        metrics["body_lean"] = np.degrees(np.arctan2(dx, dy))

    return {"keypoints": keypoints, "metrics": metrics}

# Process a frame
frame = cv2.imread("player_frame.jpg")
result = analyze_player_pose(frame, [100, 50, 200, 300])

if result:
    print(f"Left knee angle: {result['metrics'].get('left_knee_angle', 'N/A'):.1f}")
    print(f"Body lean: {result['metrics'].get('body_lean', 'N/A'):.1f} degrees")

# Python: Using Supervision for easy CV workflows
# pip install supervision

import supervision as sv
from ultralytics import YOLO

# Load model
model = YOLO("yolov8n.pt")

# Initialize annotators
box_annotator = sv.BoxAnnotator(thickness=2)
label_annotator = sv.LabelAnnotator()
trace_annotator = sv.TraceAnnotator()

# Initialize tracker
tracker = sv.ByteTrack()

# Process video
def process_video(source_path, output_path):
    """Process video with detection and tracking."""

    # Video info
    video_info = sv.VideoInfo.from_video_path(source_path)

    with sv.VideoSink(output_path, video_info) as sink:
        for frame in sv.get_video_frames_generator(source_path):
            # Detect
            results = model(frame)[0]
            detections = sv.Detections.from_ultralytics(results)

            # Filter to persons only
            detections = detections[detections.class_id == 0]

            # Track
            detections = tracker.update_with_detections(detections)

            # Annotate
            labels = [f"#{tid}" for tid in detections.tracker_id]

            frame = box_annotator.annotate(frame, detections)
            frame = label_annotator.annotate(frame, detections, labels)
            frame = trace_annotator.annotate(frame, detections)

            sink.write_frame(frame)

# Run processing
process_video("match.mp4", "tracked_match.mp4")
print("Video processing complete!")

# Python: Integrating CV outputs with analytics
import pandas as pd
import numpy as np

# Load CV pipeline outputs
tracking_data = pd.read_csv("output/tracks.csv")
ball_positions = pd.read_csv("output/ball_positions.csv")
physical_metrics = pd.read_csv("output/physical_summary.csv")

def calculate_possession(ball_df, tracks_df):
    """Calculate possession percentage from tracking data."""
    possession_frames = []

    for _, ball in ball_df.iterrows():
        frame_tracks = tracks_df[tracks_df["frame"] == ball["frame"]]

        if len(frame_tracks) == 0:
            continue

        # Find nearest player to ball
        frame_tracks = frame_tracks.copy()
        frame_tracks["cx"] = (frame_tracks["x1"] + frame_tracks["x2"]) / 2
        frame_tracks["cy"] = (frame_tracks["y1"] + frame_tracks["y2"]) / 2
        frame_tracks["dist"] = np.sqrt(
            (ball["x"] - frame_tracks["cx"])**2 +
            (ball["y"] - frame_tracks["cy"])**2
        )

        nearest = frame_tracks.loc[frame_tracks["dist"].idxmin()]
        possession_frames.append({
            "frame": ball["frame"],
            "team": nearest.get("team", "unknown")
        })

    poss_df = pd.DataFrame(possession_frames)
    return poss_df["team"].value_counts(normalize=True) * 100

possession = calculate_possession(ball_positions, tracking_data)
print("Possession %:")
print(possession)