Zone Detection & Spatial Logic

"""Zones as polygons, and the question 'is this point inside?'"""
 
 
def point_in_polygon(x, y, poly):
    """Ray casting: shoot a ray to the right and count edge crossings.
    Odd number of crossings = inside."""
    inside = False
    n = len(poly)
    for i in range(n):
        x1, y1 = poly[i]
        x2, y2 = poly[(i + 1) % n]
        if (y1 > y) != (y2 > y):                       # the edge straddles our horizontal line
            x_cross = x1 + (y - y1) * (x2 - x1) / (y2 - y1)
            if x < x_cross:
                inside = not inside
    return inside
 
 
class Zone:
    def __init__(self, name, points):
        self.name = name
        self.points = [tuple(p) for p in points]
 
    def contains(self, x, y):
        return point_in_polygon(x, y, self.points)
 
    def __repr__(self):
        return f"Zone({self.name!r}, {len(self.points)} points)"
 
 
def zones_containing(x, y, zones):
    """Every zone that holds the point. Zones may overlap."""
    return [z.name for z in zones if z.contains(x, y)]
 
 
def offside_line_x(defenders_x, attacking_right=True):
    """The line is set by the second-last defender (the keeper counts as one).
    Pass the x of every defending outfield player AND the keeper."""
    xs = sorted(defenders_x, reverse=attacking_right)
    return xs[1] if len(xs) > 1 else None
 
 
def is_offside(attacker_x, ball_x, line_x, attacking_right=True):
    """Simplified: ahead of both the ball and the line, in the attacking direction."""
    if line_x is None:
        return False
    if attacking_right:
        return attacker_x > line_x and attacker_x > ball_x
    return attacker_x < line_x and attacker_x < ball_x

from zones import Zone, point_in_polygon, zones_containing, offside_line_x, is_offside
 
square = [(0, 0), (10, 0), (10, 10), (0, 10)]
L = [(0, 0), (10, 0), (10, 4), (4, 4), (4, 10), (0, 10)]          # an L shape (concave)
tri = [(0, 0), (10, 0), (5, 8)]
tests = [
    ("square centre", point_in_polygon(5, 5, square), True),
    ("square outside", point_in_polygon(15, 5, square), False),
    ("L inside the long arm", point_in_polygon(2, 8, L), True),
    ("L in the notch (outside)", point_in_polygon(8, 8, L), False),
    ("triangle inside", point_in_polygon(5, 3, tri), True),
    ("triangle outside corner", point_in_polygon(1, 6, tri), False),
]
z = [Zone("box", square), Zone("small", [(4, 4), (6, 4), (6, 6), (4, 6)])]
tests += [
    ("overlap reports both", zones_containing(5, 5, z), ["box", "small"]),
    ("only big one", zones_containing(1, 1, z), ["box"]),
    ("none", zones_containing(50, 50, z), []),
]
line = offside_line_x([30, 55, 70, 90, 100], attacking_right=True)   # keeper at 100
tests += [
    ("offside line is second-last", line, 90),
    ("attacker 95, ball 60 -> offside", is_offside(95, 60, line), True),
    ("attacker 95, ball 98 -> onside", is_offside(95, 98, line), False),
    ("attacker 85 -> onside", is_offside(85, 60, line), False),
]
bad = 0
for name, got, want in tests:
    ok = got == want
    bad += not ok
    print("PASS" if ok else "FAIL", name, got)
print("failures:", bad)

"""Click to draw zones on a frame, save them to zones.json, and draw them back.
Keys: click = add a corner, n = finish this zone and name it, u = undo corner, s = save, q = quit."""
import json
import sys
 
import cv2
import numpy as np
 
 
def save_zones(zones, path="zones.json"):
    with open(path, "w") as f:
        json.dump({z["name"]: z["points"] for z in zones}, f, indent=2)
 
 
def load_zones(path="zones.json"):
    with open(path) as f:
        return [{"name": k, "points": [list(map(float, p)) for p in v]} for k, v in json.load(f).items()]
 
 
def draw_zones(frame, zones, colour=(0, 255, 255)):
    out = frame.copy()
    overlay = out.copy()
    for z in zones:
        pts = np.array(z["points"], np.int32)
        cv2.fillPoly(overlay, [pts], colour)
        cv2.polylines(out, [pts], True, colour, 2)
        cv2.putText(out, z["name"], tuple(pts[0]), cv2.FONT_HERSHEY_SIMPLEX, 0.6, colour, 2)
    return cv2.addWeighted(overlay, 0.25, out, 0.75, 0)
 
 
def main(image_path):
    frame = cv2.imread(image_path)
    zones, current = [], []
 
    def on_mouse(event, x, y, flags, param):
        if event == cv2.EVENT_LBUTTONDOWN:
            current.append([x, y])
 
    cv2.namedWindow("zones")
    cv2.setMouseCallback("zones", on_mouse)
    while True:
        view = draw_zones(frame, zones)
        for p in current:
            cv2.circle(view, tuple(p), 4, (0, 0, 255), -1)
        if len(current) > 1:
            cv2.polylines(view, [np.array(current, np.int32)], False, (0, 0, 255), 1)
        cv2.imshow("zones", view)
        k = cv2.waitKey(30) & 0xFF
        if k == ord("u") and current:
            current.pop()
        elif k == ord("n") and len(current) >= 3:
            name = input("name for this zone: ").strip() or f"zone{len(zones) + 1}"
            zones.append({"name": name, "points": current.copy()})
            current.clear()
        elif k == ord("s"):
            save_zones(zones)
            print("saved zones.json")
        elif k == ord("q"):
            break
    cv2.destroyAllWindows()
 
 
if __name__ == "__main__":
    main(sys.argv[1])

"""Time spent in each zone, from detections.json (lesson 30). Player x,y is the feet."""
import json
from collections import defaultdict
 
from zone_tool import load_zones
from zones import Zone, zones_containing
 
 
def zone_times(detections_path="detections.json", zones_path="zones.json"):
    data = json.load(open(detections_path))
    zones = [Zone(z["name"], z["points"]) for z in load_zones(zones_path)]
    dt = 1.0 / data["fps"]
    seconds = defaultdict(float)                        # (player id, zone name) -> seconds
    for fr in data["frames"]:
        for p in fr["players"]:
            for name in zones_containing(p["x"], p["y"], zones):
                seconds[(p["id"], name)] += dt
    return seconds
 
 
if __name__ == "__main__":
    for (pid, zone), s in sorted(zone_times().items()):
        print(f"player {pid:>2} in {zone:<12} {s:5.1f} s")

from goal_detector import GoalDetector
from zones import Zone
 
 
class PolygonGoalDetector(GoalDetector):
    """lesson 31's detector, with a polygon goal instead of a rectangle. Only 'inside' changes."""
 
    def __init__(self, polygon_zone, bus, **kw):
        super().__init__({"x": 0, "y": 0, "w": 0, "h": 0}, bus, **kw)
        self.polygon = polygon_zone
 
    def inside(self, ball):
        return ball is not None and self.polygon.contains(ball["x"], ball["y"])