Zählungen, Wärmekarten und Geschwindigkeitsschätzung

Tracking und Geometrie#

Jede Lösungsklasse in ultralytics.solutions führt intern den Tracking-Modus aus und wendet dann ihre eigene Geometrie auf den Track-Verlauf an. Installiere die Zusatzpakete einmalig mit pip install "ultralytics[solutions]".

Lösungen verwenden standardmäßig tracker="tracktrack.yaml"; übergib den Tracker, den du in der vorherigen Lektion validiert hast.

Linienüberquerungen zählen#

Eine Zähllinie ist ein Liniensegment. Ein Objekt wird einmal gezählt, wenn der Mittelpunkt seiner Box zwischen zwei Bildern die Linie überquert. Die Seite, von der es kommt, bestimmt IN oder OUT. Deshalb ist Tracking beim Förderband oben nötig: Ohne ID würde Box #015 in jedem Bild erneut gezählt, in dem sie die Linie berührt.

import cv2

from ultralytics import solutions
from ultralytics.utils.downloads import safe_download

video = safe_download("https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4")
cap = cv2.VideoCapture(str(video))  # 640x360, 30 FPS, 62 frames
w, h, fps = (int(cap.get(p)) for p in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
writer = cv2.VideoWriter("counted.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

counter = solutions.ObjectCounter(
    model="yolo26n.pt",
    region=[(0, 180), (640, 180)],  # two points: a horizontal line across the middle of the frame
    classes=[0],  # person
    tracker="bytetrack.yaml",
    verbose=False,
)

while True:
    ok, frame = cap.read()
    if not ok:
        break
    results = counter(frame)  # detect + track + count in one call
    writer.write(results.plot_im)

cap.release()
writer.release()
print(f"in={results.in_count} out={results.out_count} classwise={results.classwise_count}")

in=2 out=2 classwise={'person': {'IN': 2, 'OUT': 2}}

In den zwei Sekunden des Clips überquerten vier Menschen die Mitte des Platzes, zwei in jede Richtung. Mit der TrackTrack-Standardkonfiguration meldet dasselbe Skript in=0 out=1, denn weniger Tracks bedeuten weniger Überquerungen. Öffne counted.mp4 und überprüfe jede Überquerung mit eigenen Augen, bevor du einer Zahl vertraust.

Auf einer Straße teilt dieselbe Linie den Verkehr nach Fahrtrichtung auf: Aufwärts fahrende Fahrzeuge werden als IN gezählt, abwärts fahrende als OUT. Platziere die Linie dort, wo Objekte sie sauber und im rechten Winkel überqueren, weit entfernt von Bildrändern, Verdeckungen und dem hinteren Straßenabschnitt, wo die Boxen sehr klein sind.

Belegung einer Zone zählen#

Eine Polygonzone beantwortet die Frage: „Wie viele Objekte befinden sich gerade darin?“ Die Anleitung zur Bereichszählung enthält eine fertige RegionCounter; im Kern wird für jede verfolgte Box geprüft, ob ein Punkt innerhalb des Polygons liegt:

from shapely.geometry import Point, Polygon

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
zone = Polygon([(100, 100), (500, 100), (500, 300), (100, 300)])  # pixel coordinates

peak = 0
for r in model.track(video, stream=True, tracker="bytetrack.yaml", classes=[0], verbose=False):
    if not r.boxes.is_track:
        continue
    inside = sum(zone.contains(Point(cx, cy)) for cx, cy in r.boxes.xywh[:, :2].tolist())
    peak = max(peak, inside)
print(f"peak occupancy: {peak} people inside the zone")

peak occupancy: 10 people inside the zone

xywh[:, :2] ist der Mittelpunkt jeder Box. Für Warteschlangen und Verweildauer speicherst du pro ID einen Zeitstempel dafür, wann das Objekt die Zone betreten hat.

Geschwindigkeit schätzen#

Jede Beschriftung oben ergibt sich aus der Spur hinter dem Fahrzeug: der Pixelstrecke, die sein Track über eine bekannte Anzahl von Bildern zurückgelegt hat. Geschwindigkeit = Pixelstrecke × Meter pro Pixel ÷ verstrichene Zeit. Zwei Eingaben bestimmen, ob das Ergebnis stimmt:

1. Meter pro Pixel. Miss eine bekannte Länge in der Szene (eine Bodenfliese, eine Fahrbahnmarkierung, einen Parkplatz) in der Tiefe, in der sich die Objekte bewegen. Bei schräg ausgerichteten Kameras kannst du stattdessen die Bodenebene mit einer Homografie aus vier Punkten abbilden.
2. Die tatsächliche Aufnahmebildrate. Die Geschwindigkeit skaliert mit der FPS; neu kodiertes oder verlangsamtes Videomaterial skaliert jede Geschwindigkeit um denselben Faktor.

Diese Schleife misst den unteren Mittelpunkt jeder Box (dort, wo das Objekt den Boden berührt) und mittelt jede Spur über 10 Frames:

from collections import defaultdict, deque

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
fps = 30  # the real capture rate, not the playback rate
pixels_per_meter = 33  # example: a 1.2 m floor feature spans 40 px; measure your own scene

prev = {}  # track ID -> last bottom-center point
window = defaultdict(lambda: deque(maxlen=10))  # about 0.3 s of speeds per track at 30 FPS
for r in model.track(video, stream=True, tracker="bytetrack.yaml", classes=[0], verbose=False):
    if not r.boxes.is_track:
        continue
    for (x1, y1, x2, y2), tid in zip(r.boxes.xyxy.tolist(), r.boxes.id.int().tolist()):
        cx, cy = (x1 + x2) / 2, y2  # bottom-center sits on the ground plane
        if tid in prev:
            px, py = prev[tid]
            meters = ((cx - px) ** 2 + (cy - py) ** 2) ** 0.5 / pixels_per_meter
            window[tid].append(meters * fps * 3.6)  # km/h
        prev[tid] = (cx, cy)

smoothed = sorted(sum(s) / len(s) for s in window.values() if len(s) == s.maxlen)
print(f"{len(smoothed)} tracks; median {smoothed[len(smoothed) // 2]:.1f} km/h")

29 tracks; median 2.1 km/h

Menschen gehen mit 4–5 km/h. Die 2,1 km/h zeigen also, dass die beispielhafte Skalierung für diese Szene falsch ist: Der Wert pixels_per_meter wurde hier nicht gemessen. Genau diese Plausibilitätsprüfung ist entscheidend: den Median mit einer Geschwindigkeit vergleichen, die du kennst.

solutions.SpeedEstimator verpackt dieselbe Idee für den Produktionseinsatz: Es misst den Mittelpunkt der Box jeder Spur über max_hist Frames, rechnet mit meter_per_pixel um und legt pro ID eine Geschwindigkeit fest (begrenzt auf max_speed):

import cv2

from ultralytics import solutions
from ultralytics.utils.downloads import safe_download

video = safe_download("https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4")
cap = cv2.VideoCapture(str(video))
speed = solutions.SpeedEstimator(
    model="yolo26n.pt",
    classes=[0],
    tracker="bytetrack.yaml",
    fps=30,  # the real capture rate, not the playback rate
    meter_per_pixel=0.03,  # a guess: a ~0.45 m shoulder width spans ~15 px here
    max_hist=15,  # 0.5 s of history before a speed is locked
    verbose=False,
)

speeds = {}
while True:
    ok, frame = cap.read()
    if not ok:
        break
    speeds.update(speed(frame).speed_dict)  # {track_id: km/h} once locked
cap.release()

kmh = sorted(speeds.values())
print(f"{len(kmh)} tracks; median {kmh[len(kmh) // 2]} km/h, range {kmh[0]}-{kmh[-1]} km/h")

25 tracks; median 1 km/h, range 0-4 km/h

Wieder um etwa den Faktor 4 daneben, aus demselben Grund: Die Skalierung wurde anhand der Körpergröße geschätzt. Der Boxmittelpunkt eignet sich für Kameras mit Blick von oben wie diese; bei schräg ausgerichteten Kameras solltest du die Schleife mit dem unteren Mittelpunkt oder eine Homografie bevorzugen.

Eine Heatmap erstellen#

Eine Heatmap fügt in jedem Frame unter jeder verfolgten Box Wärme hinzu, sodass stark frequentierte Fahrspuren oder Gänge am hellsten leuchten. Gib ihr region, und sie zählt auch Objekte – wie oben auf der Autobahn:

import cv2

from ultralytics import solutions
from ultralytics.utils.downloads import safe_download

video = safe_download("https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4")
cap = cv2.VideoCapture(str(video))
heatmap = solutions.Heatmap(
    model="yolo26n.pt",
    classes=[0],
    tracker="bytetrack.yaml",
    colormap=cv2.COLORMAP_PARULA,
    verbose=False,
)

while True:
    ok, frame = cap.read()
    if not ok:
        break
    results = heatmap(frame)
cap.release()
cv2.imwrite("heatmap.jpg", results.plot_im)  # letzter Frame mit der akkumulierten Wärmeüberlagerung

Bei stundenlangem Videomaterial zeigt dieselbe Überlagerung überfüllte Gänge, ungenutzte Bereiche und die Wege, die Menschen tatsächlich nehmen. Trainingsüberwachung und eine Streamlit-Oberfläche für Live-Inferenz basieren auf denselben Bausteinen.

Stolperfallen#