Case Study 6.2: Building a Defensive Shape Analyzer Using Coordinate Data

Background

A team's "defensive shape" refers to the spatial arrangement of its players when out of possession. A compact, well-organized shape forces opponents into low-value areas and limits passing lanes. A stretched, disorganized shape exposes gaps that skilled attackers exploit.

Quantifying defensive shape requires treating each player's position as a point in a coordinate system and computing spatial summary statistics: spread, compactness, width, depth, and centroid. In this case study, we build a defensive shape analyzer that takes a snapshot of player positions and returns a comprehensive spatial report.

Objectives

1. Define and compute key defensive shape metrics from coordinate data.
2. Visualize defensive formations with player positions, convex hulls, and team centroids.
3. Analyze how defensive shape changes across match phases (in possession, out of possession, transition).
4. Compare the defensive compactness of two teams using Voronoi-based area metrics.

Metrics Definitions

Given a set of outfield player positions $\{(x_i, y_i)\}_{i=1}^{10}$ (excluding the goalkeeper) for one team, we define:

Team Centroid: $$\bar{x} = \frac{1}{10}\sum_{i=1}^{10} x_i, \qquad \bar{y} = \frac{1}{10}\sum_{i=1}^{10} y_i$$

Team Length (Depth): The difference between the most advanced and deepest outfield player: $$\text{Length} = \max(x_i) - \min(x_i)$$

Team Width: The difference between the widest players: $$\text{Width} = \max(y_i) - \min(y_i)$$

Spread (Standard Deviation): $$\sigma_x = \sqrt{\frac{1}{10}\sum_{i=1}^{10}(x_i - \bar{x})^2}, \qquad \sigma_y = \sqrt{\frac{1}{10}\sum_{i=1}^{10}(y_i - \bar{y})^2}$$

Convex Hull Area: The area of the smallest convex polygon enclosing all outfield players. A smaller hull area indicates a more compact shape.

Stretch Index: The mean distance of each player from the centroid: $$\text{SI} = \frac{1}{10}\sum_{i=1}^{10}\sqrt{(x_i - \bar{x})^2 + (y_i - \bar{y})^2}$$

Step 1: Computing Defensive Shape Metrics

import numpy as np
from scipy.spatial import ConvexHull

def compute_defensive_shape(
    x: np.ndarray,
    y: np.ndarray,
) -> dict:
    """Compute defensive shape metrics for a set of outfield player positions.

    Args:
        x: x-coordinates of outfield players (excluding GK).
        y: y-coordinates of outfield players (excluding GK).

    Returns:
        Dictionary of shape metrics.
    """
    centroid_x = np.mean(x)
    centroid_y = np.mean(y)

    team_length = np.max(x) - np.min(x)
    team_width = np.max(y) - np.min(y)

    spread_x = np.std(x)
    spread_y = np.std(y)

    distances = np.sqrt((x - centroid_x) ** 2 + (y - centroid_y) ** 2)
    stretch_index = np.mean(distances)

    points = np.column_stack([x, y])
    hull = ConvexHull(points)
    hull_area = hull.volume  # In 2D, 'volume' is the area

    return {
        "centroid_x": centroid_x,
        "centroid_y": centroid_y,
        "team_length": team_length,
        "team_width": team_width,
        "spread_x": spread_x,
        "spread_y": spread_y,
        "stretch_index": stretch_index,
        "hull_area": hull_area,
    }

Step 2: Visualizing the Defensive Shape

import matplotlib.pyplot as plt
from mplsoccer import Pitch
from scipy.spatial import ConvexHull

def plot_defensive_shape(
    x: np.ndarray,
    y: np.ndarray,
    gk_x: float,
    gk_y: float,
    team_name: str = "Team",
    pitch_length: float = 105.0,
    pitch_width: float = 68.0,
) -> None:
    """Visualize defensive shape with convex hull and centroid."""
    pitch = Pitch(pitch_type="custom", pitch_length=pitch_length,
                  pitch_width=pitch_width, pitch_color="#1a1a2e", line_color="#c7d5cc")
    fig, ax = pitch.draw(figsize=(12, 8))

    # Compute convex hull
    points = np.column_stack([x, y])
    hull = ConvexHull(points)

    # Draw hull
    hull_vertices = np.append(hull.vertices, hull.vertices[0])  # Close polygon
    ax.fill(points[hull_vertices, 0], points[hull_vertices, 1],
            alpha=0.2, color="#3498db", zorder=2)
    ax.plot(points[hull_vertices, 0], points[hull_vertices, 1],
            color="#3498db", linewidth=2, zorder=2)

    # Plot players
    ax.scatter(x, y, c="#3498db", s=150, edgecolors="white",
               linewidth=2, zorder=5)
    ax.scatter(gk_x, gk_y, c="#f39c12", s=200, edgecolors="white",
               linewidth=2, zorder=5, marker="D", label="GK")

    # Plot centroid
    centroid_x, centroid_y = np.mean(x), np.mean(y)
    ax.scatter(centroid_x, centroid_y, c="white", s=100, marker="x",
               linewidth=3, zorder=6, label="Centroid")

    # Annotate metrics
    metrics = compute_defensive_shape(x, y)
    info_text = (
        f"Length: {metrics['team_length']:.1f} m\n"
        f"Width: {metrics['team_width']:.1f} m\n"
        f"Hull Area: {metrics['hull_area']:.0f} m$^2$\n"
        f"Stretch Index: {metrics['stretch_index']:.1f} m"
    )
    ax.text(2, pitch_width - 2, info_text, fontsize=11, color="white",
            verticalalignment="top", family="monospace",
            bbox=dict(boxstyle="round,pad=0.5", facecolor="#2c3e50", alpha=0.8))

    ax.set_title(f"{team_name} Defensive Shape", fontsize=16, color="white", pad=10)
    ax.legend(loc="upper right", fontsize=10)
    fig.set_facecolor("#1a1a2e")
    return fig, ax

Step 3: Simulating Match Scenarios

To demonstrate the analyzer, we simulate three defensive configurations:

Scenario A: Compact Low Block (4-4-2)

# Compact low block: all players within 30m of own goal
x_low = np.array([20, 22, 18, 24,   30, 35, 28, 33,   38, 40])
y_low = np.array([15, 28, 40, 55,   12, 25, 42, 58,   30, 38])
gk_x_low, gk_y_low = 5.0, 34.0

Scenario B: High Press (4-3-3)

# High press: players pushed up, tight shape near halfway line
x_high = np.array([45, 48, 44, 50,   55, 60, 58,   68, 72, 65])
y_high = np.array([15, 28, 42, 58,   20, 34, 50,   18, 34, 52])
gk_x_high, gk_y_high = 30.0, 34.0

Scenario C: Stretched / Disorganized

# Stretched shape: players spread across the pitch
x_stretched = np.array([15, 25, 30, 20,   45, 50, 55, 40,   70, 80])
y_stretched = np.array([10, 60, 30, 45,   8, 62, 34, 50,    20, 55])
gk_x_str, gk_y_str = 5.0, 34.0

Results Comparison

Interpretation:

• The low block has the smallest hull area and stretch index, reflecting extreme compactness. The centroid is deep (28.8 m), indicating the team is defending close to their own goal.
• The high press has a similar compactness but the centroid is pushed forward to 56.5 m -- past the halfway line. This is a team pressing aggressively in the opponent's half.
• The stretched shape has nearly four times the hull area and a stretch index 77% larger than the low block. This team is vulnerable to through-balls and diagonal passes that exploit the gaps.

Step 4: Temporal Analysis

In a real match, defensive shape evolves continuously. Using tracking data (sampled at 25 Hz), we can compute shape metrics at each frame and track their evolution:

def compute_shape_timeseries(
    frames: list[dict],
) -> pd.DataFrame:
    """Compute defensive shape metrics for each frame.

    Args:
        frames: List of dicts, each with 'time', 'x', 'y' keys.
                'x' and 'y' are arrays of outfield player positions.

    Returns:
        DataFrame with one row per frame and columns for each metric.
    """
    records = []
    for frame in frames:
        metrics = compute_defensive_shape(frame["x"], frame["y"])
        metrics["time"] = frame["time"]
        records.append(metrics)
    return pd.DataFrame(records)

Typical findings from temporal analysis:

• Hull area spikes during transitions. When a team loses possession, there is a brief period (2-5 seconds) where players are spread across the pitch before they reorganize.
• Compactness recovers faster in well-coached teams. Elite teams reduce their hull area back to baseline within 3-4 seconds; weaker teams may take 6-8 seconds.
• Width is more stable than length. Teams maintain lateral compactness more consistently than longitudinal compactness, because depth is more affected by the offside line and pressing triggers.

Step 5: Voronoi-Based Defensive Territory

We can also quantify defensive coverage using Voronoi tessellation. For each defending player, the Voronoi cell area represents the space they are "responsible" for. Large cells indicate isolation; small, uniform cells indicate balanced coverage.

from scipy.spatial import Voronoi

def compute_defensive_voronoi_areas(
    x: np.ndarray,
    y: np.ndarray,
    pitch_length: float = 105.0,
    pitch_width: float = 68.0,
) -> np.ndarray:
    """Compute approximate Voronoi cell areas for defending players.

    Uses a grid-counting approach for simplicity and pitch-boundary clipping.
    """
    grid_res = 200
    x_grid = np.linspace(0, pitch_length, grid_res)
    y_grid = np.linspace(0, pitch_width, grid_res)
    X, Y = np.meshgrid(x_grid, y_grid)

    cell_area = (pitch_length / grid_res) * (pitch_width / grid_res)
    areas = np.zeros(len(x))

    for i in range(grid_res):
        for j in range(grid_res):
            dists = np.sqrt((x - X[i, j]) ** 2 + (y - Y[i, j]) ** 2)
            nearest = np.argmin(dists)
            areas[nearest] += cell_area

    return areas

A balanced defensive shape will have roughly equal Voronoi areas across players. The coefficient of variation (CV) of the Voronoi areas is a useful summary:

$$\text{CV} = \frac{\sigma_{\text{areas}}}{\mu_{\text{areas}}}$$

A low CV (< 0.3) indicates even coverage; a high CV (> 0.5) suggests some players are covering disproportionately large areas.

Discussion

This case study shows how coordinate geometry transforms abstract notions of "defensive shape" into quantifiable metrics. The convex hull area, stretch index, and Voronoi area distribution together give a comprehensive picture of a team's spatial organization.

Practical Applications:

• Match preparation: Analysts can compute the opponent's typical defensive shape to identify areas of weakness (e.g., if the CV of Voronoi areas is high, there are exploitable gaps).
• In-game adjustments: Real-time tracking data enables live monitoring of defensive compactness, triggering alerts when the shape exceeds a threshold.
• Player evaluation: Defenders who consistently maintain compact positioning relative to teammates contribute more to team shape than those who frequently break formation.

Limitations:

• These metrics capture positional snapshots but not orientation or body angle. A player facing the wrong direction is poorly positioned even if their coordinates are ideal.
• The goalkeeper is excluded from shape calculations, but their positioning affects the defensive line's height (the offside trap depends on the GK as a sweeper).
• Voronoi areas assume equal player capability; in practice, a player's effective coverage depends on speed, agility, and awareness.

Key Takeaways

1. Defensive shape is fundamentally a coordinate-geometry problem: given player positions, compute spatial statistics.
2. The convex hull area and stretch index are robust, interpretable measures of compactness.
3. Temporal analysis of shape metrics reveals tactical patterns (pressing recovery time, transition vulnerability).
4. Voronoi-based area analysis adds a player-level dimension, identifying which defenders cover disproportionate space.
5. These tools generalize beyond defence -- the same metrics can characterize attacking shape, pressing structure, or build-up play configurations.