Player Heatmaps: Footprints in the Snow

positions (lesson 33) -> grid of cells -> seconds per cell -> smooth -> colours on the pitch

"""Pretend positions in METRES (the lesson 33 format), so heatmaps can be practised before you have real data.
Eight players, each with a favourite area, wandering for 10 minutes at 5 frames per second."""
import json
 
import numpy as np
 
rng = np.random.default_rng(3)
FPS, MINUTES = 5, 10
W, H = 105.0, 68.0
roles = {1: (10, 34, "keeper"), 2: (30, 20, "defender"), 3: (30, 48, "defender"), 4: (55, 34, "midfielder"),
         5: (60, 15, "winger"), 6: (60, 53, "winger"), 7: (80, 30, "striker"), 8: (85, 40, "striker")}
n = FPS * 60 * MINUTES
pos = {pid: np.array([ax, ay], float) for pid, (ax, ay, _) in roles.items()}
frames = []
for i in range(n):
    players = []
    for pid, (ax, ay, _) in roles.items():
        step = rng.normal(0, 0.9, 2)
        pull = (np.array([ax, ay]) - pos[pid]) * 0.03            # drift back towards the favourite area
        pos[pid] = pos[pid] + step + pull
        x, y = pos[pid]
        players.append({"id": pid, "x": round(float(x), 2), "y": round(float(y), 2)})
    frames.append({"frame": i, "t": round(i / FPS, 2), "players": players, "ball": None})
json.dump({"units": "metres", "fps": FPS, "frames": frames}, open("positions_pitch.json", "w"))
print("frames:", len(frames), "| roles:", {k: v[2] for k, v in roles.items()})

"""Heatmaps: where did the players spend their time? Input: positions in metres (lesson 33)."""
import json
 
import cv2
import numpy as np
 
PITCH_W, PITCH_H = 105.0, 68.0
 
 
def load_positions(path="positions_pitch.json"):
    d = json.load(open(path))
    return d["fps"], d["frames"]
 
 
def collect(frames, player_id=None):
    """All (x, y) points for one player, or for everyone. Returns (points, how many were off the pitch)."""
    pts = [(p["x"], p["y"]) for fr in frames for p in fr["players"] if player_id is None or p["id"] == player_id]
    pts = np.array(pts, float).reshape(-1, 2)
    on = (pts[:, 0] >= 0) & (pts[:, 0] <= PITCH_W) & (pts[:, 1] >= 0) & (pts[:, 1] <= PITCH_H)
    return pts[on], int((~on).sum())
 
 
def seconds_grid(points, fps, cell=5.0):
    """Count the time spent in each cell of a grid (5 m by 5 m). Result is in SECONDS."""
    nx, ny = int(np.ceil(PITCH_W / cell)), int(np.ceil(PITCH_H / cell))
    counts, _, _ = np.histogram2d(points[:, 0], points[:, 1], bins=[nx, ny], range=[[0, nx * cell], [0, ny * cell]])
    return counts.T / fps                                     # rows = y, columns = x
 
 
def smooth(grid, sigma=1.0):
    """Blur so the picture looks like a smooth glow, not boxes. Blurring keeps the total (almost) the same."""
    return cv2.GaussianBlur(grid.astype(np.float32), (0, 0), sigma, borderType=cv2.BORDER_CONSTANT)
 
 
def thirds(points):
    """Share of time in the defensive, middle and attacking third (attacking left to right)."""
    if len(points) == 0:
        return (0.0, 0.0, 0.0)
    x = points[:, 0]
    d = float((x < PITCH_W / 3).mean())
    a = float((x >= 2 * PITCH_W / 3).mean())
    return (d, 1.0 - d - a, a)
 
 
def render(grid, scale=8, margin=20, vmax=None, title=None):
    """Draw the grid on a green pitch. Pass the same vmax to compare two players fairly."""
    w, h = int(PITCH_W * scale) + 2 * margin, int(PITCH_H * scale) + 2 * margin
    base = np.full((h, w, 3), (50, 120, 50), np.uint8)
    vmax = vmax or float(grid.max()) or 1.0
    norm = np.clip(grid / vmax, 0, 1)
    heat = cv2.resize((norm * 255).astype(np.uint8), (int(PITCH_W * scale), int(PITCH_H * scale)), interpolation=cv2.INTER_CUBIC)
    colour = cv2.applyColorMap(heat, cv2.COLORMAP_JET)
    alpha = (heat.astype(np.float32) / 255.0)[..., None] * 0.8        # cold cells stay see-through
    roi = base[margin:margin + heat.shape[0], margin:margin + heat.shape[1]].astype(np.float32)
    base[margin:margin + heat.shape[0], margin:margin + heat.shape[1]] = (roi * (1 - alpha) + colour * alpha).astype(np.uint8)
    cv2.rectangle(base, (margin, margin), (w - margin, h - margin), (255, 255, 255), 2)
    cv2.line(base, (w // 2, margin), (w // 2, h - margin), (255, 255, 255), 2)
    cv2.circle(base, (w // 2, h // 2), int(9.15 * scale), (255, 255, 255), 2)
    if title:
        cv2.putText(base, title, (margin, 14), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
    return base

import cv2
from heatmap import load_positions, collect, seconds_grid, smooth, render, thirds
 
fps, frames = load_positions("positions_pitch.json")
points, dropped = collect(frames, player_id=7)
print("points off the pitch:", dropped)
 
grid = seconds_grid(points, fps, cell=5.0)         # seconds per 5 m by 5 m cell
cv2.imwrite("heat_player7.png", render(smooth(grid), title="player 7"))
 
d, m, a = thirds(points)
print(f"defensive {d:.0%}   middle {m:.0%}   attacking {a:.0%}")

k, _ = collect(frames, 1)
s, _ = collect(frames, 7)
vmax = max(seconds_grid(k, fps).max(), seconds_grid(s, fps).max())
cv2.imwrite("heat_1.png", render(smooth(seconds_grid(k, fps)), vmax=vmax, title="player 1"))
cv2.imwrite("heat_7.png", render(smooth(seconds_grid(s, fps)), vmax=vmax, title="player 7"))

import numpy as np
from heatmap import *
 
bad = 0
def check(name, ok, extra=""):
    global bad; bad += not ok; print("PASS" if ok else "FAIL", name, extra)
 
fps = 5
# a player who stands in one spot for 10 seconds
frames = [{"players": [{"id": 1, "x": 12.0, "y": 8.0}]} for _ in range(10 * fps)]
pts, off = collect(frames, 1)
g = seconds_grid(pts, fps)
check("10 s in one place gives 10 s in that cell", abs(g.sum() - 10) < 1e-9 and abs(g[1, 2] - 10) < 1e-9, (g.sum(), g[1, 2]))
check("grid shape is 14 rows by 21 columns", g.shape == (14, 21), g.shape)
 
# off-pitch points are dropped and counted
frames = [{"players": [{"id": 1, "x": -5.0, "y": 10.0}, {"id": 1, "x": 50.0, "y": 70.0}, {"id": 1, "x": 50.0, "y": 30.0}]}]
pts, off = collect(frames, 1)
check("two off-pitch points dropped and counted", len(pts) == 1 and off == 2, (len(pts), off))
 
# smoothing keeps the total
fps, fr = load_positions("positions_pitch.json")
pts, off = collect(fr)
g = seconds_grid(pts, fps)
s = smooth(g, 1.0)
check("total time = players x minutes x 60 (8 x 600 s) minus off-pitch", abs(g.sum() - (len(pts) / fps)) < 1e-6, g.sum())
print(f"   total on-pitch time {g.sum():.0f} s, dropped {off} points")
check("smoothing keeps most of the total (edges lose a little)", 0.9 * g.sum() < s.sum() <= g.sum() + 1e-3, (s.sum(), g.sum()))
 
# roles show up
k, _ = collect(fr, 1); st, _ = collect(fr, 7)
dk, mk, ak = thirds(k); ds, ms, as_ = thirds(st)
check("keeper spends most time in the defensive third", dk > 0.8, f"{dk:.0%}")
check("striker spends most time in the attacking third", as_ > 0.5, f"{as_:.0%}")
check("thirds add to 1", abs(sum(thirds(st)) - 1) < 1e-9)
check("empty input does not crash", thirds(np.zeros((0, 2))) == (0.0, 0.0, 0.0))
 
img = render(smooth(seconds_grid(st, fps)), title="player 7")
check("render gives a picture", img.shape == (584, 880, 3) and img.std() > 5, img.shape)
cv2.imwrite("heat7.png", img)
# fair comparison: same scale
vmax = max(seconds_grid(k, fps).max(), seconds_grid(st, fps).max())
cv2.imwrite("heat1_shared.png", render(smooth(seconds_grid(k, fps)), vmax=vmax, title="player 1 (shared scale)"))
print("failures:", bad)