SORT, DeepSORT and ByteTrack

pip install numpy scipy

import numpy as np


def to_cxcywh(b):
    return ((b[0] + b[2]) / 2, (b[1] + b[3]) / 2, b[2] - b[0], b[3] - b[1])


def to_xyxy(s):
    cx, cy, w, h = s
    return (cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2)


class BoxKalman:
    """Constant-velocity filter on (cx, cy, w, h). SORT uses (cx, cy, area, ratio)."""

    def __init__(self, box):
        cx, cy, w, h = to_cxcywh(box)
        self.x = np.array([cx, cy, w, h, 0., 0.])              # last two are velocities
        self.P = np.diag([10., 10., 10., 10., 1000., 1000.])   # we know position, not speed
        self.F = np.eye(6)
        self.F[0, 4] = self.F[1, 5] = 1.0                      # cx += vx, cy += vy
        self.H = np.eye(4, 6)                                  # we only ever measure a box
        self.Q = np.diag([1., 1., 1., 1., 0.01, 0.01])         # distrust in the model
        self.R = np.diag([1., 1., 10., 10.])                   # distrust in the detector

    def predict(self):
        self.x = self.F @ self.x
        self.P = self.F @ self.P @ self.F.T + self.Q
        return to_xyxy(self.x[:4])

    def update(self, box):
        z = np.array(to_cxcywh(box))
        y = z - self.H @ self.x                                # measured minus predicted
        S = self.H @ self.P @ self.H.T + self.R
        K = self.P @ self.H.T @ np.linalg.inv(S)               # the Kalman gain
        self.x = self.x + K @ y
        self.P = (np.eye(6) - K @ self.H) @ self.P


kf = BoxKalman((10., 10., 30., 50.))
truth = [(10. + 6 * t, 10., 30. + 6 * t, 50.) for t in range(9)]

print(f"{'frame':>5}{'detection':>16}{'prediction':>16}{'error':>8}")
for t in range(9):
    pred = kf.predict()
    seen = t not in (3, 4, 5)                  # the detector blinks for three frames
    shown = f"x={truth[t][0]:.0f}" if seen else "missing"
    print(f"{t:5d}{shown:>16}{'x=%.1f' % pred[0]:>16}{abs(pred[0] - truth[t][0]):8.2f}")
    if seen:
        kf.update(truth[t])

import numpy as np
from scipy.optimize import linear_sum_assignment


def iou(a, b):
    x1, y1 = max(a[0], b[0]), max(a[1], b[1])
    x2, y2 = min(a[2], b[2]), min(a[3], b[3])
    inter = max(0., x2 - x1) * max(0., y2 - y1)
    return inter / ((a[2]-a[0])*(a[3]-a[1]) + (b[2]-b[0])*(b[3]-b[1]) - inter)


def match(track_boxes, det_boxes, gate):
    """Returns matched pairs, unmatched track indices, unmatched detection indices."""
    if not track_boxes or not det_boxes:
        return [], list(range(len(track_boxes))), list(range(len(det_boxes)))
    M = np.array([[iou(t, d) for d in det_boxes] for t in track_boxes])
    r, c = linear_sum_assignment(-M)
    pairs = [(i, j) for i, j in zip(r, c) if M[i, j] >= gate]
    ut = [i for i in range(len(track_boxes)) if i not in {p[0] for p in pairs}]
    ud = [j for j in range(len(det_boxes)) if j not in {p[1] for p in pairs}]
    return pairs, ut, ud


def predict(t):
    b = t["box"]
    return (b[0] + t["vx"], b[1], b[2] + t["vx"], b[3])   # constant velocity, kept simple


def absorb(t, box):
    """Snap the track onto the detection and re-estimate how fast it is moving."""
    t["vx"] = 0.5 * t["vx"] + 0.5 * (box[0] - t["box"][0] + t["vx"])
    t["box"], t["age"] = box, 0


class Tracker:
    """SORT-style when second_round=False; ByteTrack's idea when True."""

    def __init__(self, second_round, high=0.5, low=0.1, gate=0.3, max_age=3):
        self.second_round, self.high, self.low = second_round, high, low
        self.gate, self.max_age = gate, max_age
        self.tracks, self.next_id = {}, 1

    def update(self, dets):
        for t in self.tracks.values():
            t["box"] = predict(t)                          # coast every track forward
        hi = [d for d in dets if d[1] >= self.high]
        lo = [d for d in dets if self.low <= d[1] < self.high]

        ids = list(self.tracks)
        pairs, ut, ud = match([self.tracks[i]["box"] for i in ids],
                              [d[0] for d in hi], self.gate)
        for i, j in pairs:
            absorb(self.tracks[ids[i]], hi[j][0])

        if self.second_round and lo:
            # Round two: leftover tracks get a chance against the low-confidence boxes.
            left = [ids[i] for i in ut]
            p2, ut2, _ = match([self.tracks[i]["box"] for i in left],
                               [d[0] for d in lo], self.gate)
            for i, j in p2:
                absorb(self.tracks[left[i]], lo[j][0])
            ut = [ids.index(left[i]) for i in ut2]

        for i in ut:
            self.tracks[ids[i]]["age"] += 1
        for j in ud:                                       # only high-score boxes are born
            self.tracks[self.next_id] = {"box": hi[j][0], "age": 0, "vx": 0.0}
            self.next_id += 1
        for i in [i for i, t in self.tracks.items() if t["age"] > self.max_age]:
            del self.tracks[i]
        return {i: t["box"] for i, t in self.tracks.items() if t["age"] == 0}


def scene(t):
    """Person 1 walks in the clear. Person 2 passes behind a pillar in frames 4-9."""
    p1 = ((10. + 6 * t, 10., 30. + 6 * t, 50.), 0.92)
    conf = 0.35 if 4 <= t <= 9 else 0.88               # occluded: the score collapses
    p2 = ((120. - 6 * t, 12., 138. - 6 * t, 50.), conf)
    return [p1, p2]


for name, second in (("high-score boxes only", False), ("ByteTrack second round", True)):
    tr = Tracker(second_round=second)
    print(f"\n--- {name} ---")
    for t in range(13):
        out = tr.update(scene(t))
        print(f"frame {t:2d}: live ids {sorted(out)}")

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
for result in model.track("video.mp4", persist=True, tracker="bytetrack.yaml", stream=True):
    if result.boxes.id is None:          # no confirmed tracks in this frame
        continue
    ids = result.boxes.id.int().cpu().tolist()
    boxes = result.boxes.xyxy.cpu().numpy()