Multi-Objekt-Tracking mit Ultralytics YOLO#

Das Objekt-Tracking in der Videoanalyse ist eine wichtige Aufgabe: Dabei werden nicht nur Position und Klasse von Objekten im Bildausschnitt ermittelt, sondern auch jedem erkannten Objekt eine eindeutige ID zugewiesen, die während des Videos erhalten bleibt. Die Einsatzmöglichkeiten sind vielfältig und reichen von Überwachung und Sicherheit bis hin zur Sportanalyse in Echtzeit.

Sieh dir die Vorschau des noch nicht veröffentlichten YOLO27 an, um mehr über die geplante Tracking-Unterstützung zu erfahren.

Warum solltest du Ultralytics YOLO für Objekt-Tracking verwenden?#

Die Ausgaben der Ultralytics-Tracker entsprechen dem Standard der Objekterkennung, bieten aber zusätzlich Objekt-IDs. Dadurch lassen sich Objekte in Videostreams leicht verfolgen und anschließend analysieren. Darum solltest du Ultralytics YOLO für deine Tracking-Anwendungen in Betracht ziehen:

• Effizienz: Verarbeite Videostreams in Echtzeit, ohne die Genauigkeit zu beeinträchtigen.
• Flexibilität: Unterstützt mehrere Tracking-Algorithmen und Konfigurationen.
• Einfache Bedienung: Eine einfache Python-API und CLI-Optionen ermöglichen die schnelle Integration und Bereitstellung.
• Anpassbarkeit: Lässt sich leicht mit eigenen trainierten YOLO-Modellen verwenden und in anwendungsspezifische Lösungen integrieren.

Anwendungen in der Praxis#

Schnellstart#

Führe das Tracking in einem Video mit dem standardmäßigen TrackTrack-Tracker aus. Wechsle zu einem anderen Tracker, indem du das Argument tracker änderst.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Standard-Tracker (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# Zu ByteTrack wechseln
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Um den Tracker auf Videostreams auszuführen, verwende ein trainiertes Detect-, Segment-, Pose- oder OBB-Modell, etwa YOLO26n, YOLO26n-seg, YOLO26n-pose oder YOLO26n-obb. Du kannst eigene Modelle lokal oder mit dem Cloud-Training der Ultralytics Platform trainieren.

from ultralytics import YOLO

# Ein offizielles oder eigenes Modell laden
model = YOLO("yolo26n.pt")  # Ein offizielles Detect-Modell laden
model = YOLO("yolo26n-seg.pt")  # Ein offizielles Segment-Modell laden
model = YOLO("yolo26n-pose.pt")  # Ein offizielles Pose-Modell laden
model = YOLO("path/to/best.pt")  # Ein eigenes trainiertes Modell laden

# Mit dem Modell Tracking ausführen
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking mit dem Standard-Tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # mit ByteTrack

Unterstützte Tracker#

Ultralytics YOLO enthält sechs integrierte Tracker. Aktiviere einen davon, indem du seine YAML-Konfigurationsdatei an das Argument tracker übergibst.

Welchen Tracker solltest du verwenden?#

Nutze diesen Ablauf als Ausgangspunkt. Wenn du kein tracker übergibst, wird tracktrack.yaml verwendet:

1. Du brauchst eine möglichst schnelle und einfache Basis? → ByteTrack (kein ReID, keine Kompensation von Kamerabewegungen, minimaler Zusatzaufwand).
2. Aufnahmen mit Handkamera, Drohne oder bewegter Kamera? → BoT-SORT (bietet Kompensation von Kamerabewegungen und optionales ReID).
3. Nichtlineare Bewegungen (Sport, Tanzen, abrupte Richtungswechsel) und kein ReID? → OC-SORT (beobachtungszentrierte Korrekturen ohne Aufwand für den Abgleich des Erscheinungsbilds).
4. Dicht gedrängte Szenen mit bewegter Kamera, in denen ID-Wechsel das Hauptproblem sind? → Deep OC-SORT oder TrackTrack (beide unterstützen den optionalen Abgleich des Erscheinungsbilds; TrackTrack bietet zusätzlich eine Zuordnung anhand mehrerer Merkmale und unterdrückt doppelte IDs).
5. Häufige teilweise Überlappungen in Echtzeit, aber kein Budget für ReID? → FastTracker (eine für Verdeckungen ausgelegte ByteTrack-Variante mit Kalman-Zurücksetzen).

Tracker wechseln#

Übergib den Dateinamen der Tracker-Konfiguration an tracker=. Der übrige Code bleibt unverändert.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.track(source="path/to/video.mp4", tracker="bytetrack.yaml")
results = model.track(source="path/to/video.mp4", tracker="ocsort.yaml")
results = model.track(source="path/to/video.mp4", tracker="tracktrack.yaml")

Konfiguration#

Tracking-Argumente#

Die Tracking-Konfiguration verwendet einige Eigenschaften gemeinsam mit dem Predict-Modus, etwa conf, iou und show. Weitere Konfigurationsoptionen findest du auf der Modellseite Predict.

from ultralytics import YOLO

# Tracking-Parameter konfigurieren und Tracker ausführen
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)

Eigene Tracker-Konfiguration#

Ultralytics ermöglicht dir auch, eine geänderte Tracker-Konfigurationsdatei zu verwenden. Erstelle dazu einfach eine Kopie einer Tracker-Konfigurationsdatei (zum Beispiel custom_tracker.yaml) aus ultralytics/cfg/trackers und passe die Konfigurationen nach Bedarf an (mit Ausnahme von tracker_type).

from ultralytics import YOLO

# Modell laden und Tracker mit einer eigenen Konfigurationsdatei ausführen
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Gemeinsame Tracker-Argumente#

Die folgenden Parameter kommen in den meisten Tracker-YAML-Dateien vor; nicht jeder Parameter ist in jeder Konfiguration enthalten:

Trackerspezifische Argumente#

Jeder Algorithmus bietet zusätzlich zu den gemeinsamen Parametern weitere Einstellmöglichkeiten. Beschreibungen und Hinweise zur Abstimmung findest du in den folgenden Abschnitten zu den einzelnen Trackern oder direkt in den Konfigurationsdateien:

• botsort.yaml
• bytetrack.yaml
• ocsort.yaml
• deepocsort.yaml
• fasttrack.yaml
• tracktrack.yaml

Re-Identifikation (ReID) aktivieren#

ReID ist standardmäßig deaktiviert, um den zusätzlichen Aufwand zu minimieren. Aktiviere die Funktion, indem du in einer Tracker-Konfigurationsdatei with_reid: True festlegst.

ReID-Modelloptionen:

• model: auto — Verwendet native Merkmale des YOLO-Detektors und verursacht nur minimalen Mehraufwand. Ideal, wenn du ReID nutzen möchtest, ohne die Leistung stark zu beeinträchtigen. Wird auf yolo26n-cls.pt zurückgegriffen, wenn der Detektor keine kompatiblen Merkmale bereitstellt.
• Benutzerdefiniertes ReID-Modell — Verweise mit model: auf einen .pt-Checkpoint oder ein kompatibles exportiertes Einbettungsmodell, z. B. .torchscript, .onnx, .engine oder ein OpenVINO-Modellverzeichnis. Exportierte Modelle werden über AutoBackend geladen und müssen direkt einen Einbettungstensor ausgeben.

Für jede Modellgröße werden sofort einsetzbare ONNX-Encoder veröffentlicht. Setze model: auf einen dieser Namen. Die Datei wird dann beim ersten Start des Trackers automatisch heruntergeladen (genauso wie YOLO-Gewichte) — ein manueller Export oder Download ist nicht erforderlich:

# In your tracker config (e.g. tracktrack.yaml)
with_reid: True
model: yolo26n-reid.onnx # downloaded on first use; swap n→s/m/l/x for a larger encoder

Für eine bessere Leistung mit einem separaten Klassifizierungsmodell kannst du es in ein schnelleres Backend wie TensorRT exportieren:

from torch import nn

from ultralytics import YOLO

# Das Klassifizierungsmodell laden
model = YOLO("yolo26n-cls.pt")

# Eine Average-Pooling-Schicht hinzufügen
head = model.model.model[-1]
pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(start_dim=1))
pool.f, pool.i = head.f, head.i
model.model.model[-1] = pool

# Nach TensorRT exportieren
model.export(format="engine", quantize=16, dynamic=True, batch=32)

Verweise nach dem Export in deiner Tracker-Konfiguration auf den Pfad zum TensorRT-Modell.

Details zu den Trackern#

In den folgenden Abschnitten werden das Design, die spezifischen Parameter und Hinweise zur Abstimmung der einzelnen Tracker beschrieben.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) erweitert ByteTrack um den Ausgleich von Kamerabewegungen und optionales ReID:

• Ausgleich von Kamerabewegungen (CMC): Auf die Kalman-Zustände vor dem IoU-Abgleich wird in jedem Frame eine geschätzte affine Transformation angewendet (standardmäßig mit spärlichem optischem Fluss; ORB / ECC sind ebenfalls verfügbar).
• Optionales ReID: Einbettungen des Erscheinungsbilds können in die Kostenmatrix einfließen. Standardmäßig deaktiviert; aktiviere die Funktion mit with_reid: True.

Am besten geeignet für: allgemeines Tracking, insbesondere bei bewegten Kameras. Füge ReID nur hinzu, wenn Verwechslungen ähnlicher Objekte zu ID-Wechseln führen.

BoT-SORT-spezifische Argumente:

Hinweise zur Abstimmung:

• Statische Kamera: Setze gmc_method: none, um einige ms/Frame einzusparen.
• Starke Kamerabewegungen: Behalte sparseOptFlow bei; ecc ist genauer, aber langsamer.
• Menschenmengen mit ähnlichem Erscheinungsbild: Aktiviere with_reid: True und erhöhe appearance_thresh (z. B. 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) ist die ressourcenschonende Baseline. Der Tracker kombiniert einen linearen Kalman-Filter mit IoU und verwendet eine zweistufige Zuordnung:

• Stufe 1: Ordnet Erkennungen mit hohen Konfidenzwerten aktiven Tracks zu.
• Stufe 2: Gleicht nicht zugeordnete Tracks erneut mit Erkennungen mit niedrigen Konfidenzwerten ab, um sie nach kurzen teilweisen Verdeckungen wiederzufinden.

Es gibt weder ein Modell für das Erscheinungsbild noch einen Ausgleich von Kamerabewegungen.

Am besten geeignet für: statische oder nahezu statische Kameras, bei denen der Aufwand des Detektors ausschlaggebend ist und der Tracker möglichst wenig zusätzliche Ressourcen beanspruchen soll.

ByteTrack-spezifische Argumente: Keine über die gemeinsamen Tracker-Argumente hinaus.

Hinweise zur Abstimmung:

• Rauschen im Detektor: Senke track_low_thresh, damit in der zweiten Stufe mehr Kandidaten zur Verfügung stehen.
• Detektor mit hoher Trefferquote: Erhöhe track_high_thresh, um fragmentierte IDs zu reduzieren.
• Häufiges Flackern von IDs: Erhöhe track_buffer, damit kurzzeitig übersehene Tracks erhalten bleiben.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) ist eine beobachtungszentrierte Erweiterung von SORT. Sie behält das ressourcenschonende Design von SORT bei (ohne Merkmale des Erscheinungsbilds) und ergänzt drei Korrekturen:

• Beobachtungszentrierte Aktualisierung (ORU): Berechnet eine virtuelle Trajektorie zwischen der letzten Beobachtung und der aktuellen Erkennung erneut und führt die Kalman-Aktualisierung nochmals aus, um abgedriftete Geschwindigkeiten zu korrigieren.
• Beobachtungszentrierter Impuls (OCM): Bestraft Erkennungen, die sich in die falsche Richtung bewegen, mithilfe eines Terms für die Geschwindigkeitskonsistenz.
• Beobachtungszentrierte Wiederherstellung (OCR): Prüft nicht zugeordnete Erkennungen erneut anhand kürzlich verlorener Tracks. Dabei wird deren letzte Beobachtung statt des vorhergesagten Zustands verwendet.

Am besten geeignet für: nichtlineare Bewegungen ohne den zusätzlichen Aufwand eines ReID-Modells.

OC-SORT-spezifische Argumente:

Hinweise zur Abstimmung:

• Nichtlineare Bewegungen: Erhöhe inertia (z. B. 0.3-0.4).
• Spärliche Erkennungen: Aktiviere use_byte: True.
• Lange Verdeckungen: Erhöhe track_buffer, damit OCR mehr verlorene Tracks erneut zuordnen kann.

Bei OBB-Modellen verwendet OCR die vom Kalman-Filter vorhergesagte orientierte Box, da der Verlauf der letzten orientierten Beobachtung nicht gespeichert wird.

Deep OC-SORT#

Deep OC-SORT ergänzt OC-SORT um Informationen zum Erscheinungsbild und den Ausgleich von Kamerabewegungen:

• Zuordnung anhand des Erscheinungsbilds: Der Kosinusabstand zwischen Einbettungen wird durch die Überlappung begrenzt und mit den Bewegungskosten zusammengeführt.
• Dynamische EMA für das Erscheinungsbild: Einbettungen der Tracks werden mit einer EMA aktualisiert, deren Glättungsfaktor sich an die Konfidenz der Erkennung anpasst.
• Ausgleich von Kamerabewegungen: Kalman-Zustände werden zwischen Frames mithilfe von spärlichem optischem Fluss, ORB oder ECC transformiert.

Am besten geeignet für: überfüllte Szenen oder Szenen mit bewegter Kamera, in denen IDs häufig zwischen visuell unterschiedlichen, aber räumlich nahen Objekten wechseln.

Deep-OC-SORT-spezifische Argumente:

Hinweise zur Abstimmung:

• ID-Wechsel in Menschenmengen: Erhöhe appearance_thresh (z. B. 0.92-0.95) und erhöhe alpha_fixed_emb, damit sich Einbettungen langsamer anpassen.
• Bewegte Kamera: Setze gmc_method: sparseOptFlow (Deep OC-SORT verwendet standardmäßig none).
• Geringere Latenz: Behalte with_reid: False (Standard) bei, um nur Bewegung und CMC zu berücksichtigen; aktiviere ReID nur, wenn ID-Wechsel die Fehlerursache Nummer eins sind.

FastTracker#

FastTracker ist eine verdeckungsbewusste Variante von ByteTrack ohne Modell für das Erscheinungsbild:

• Verdeckungserkennung: Kennzeichnet Tracks als verdeckt, wenn ihre Abdeckung durch andere aktive Tracks den Wert occ_cover_thresh überschreitet.
• Kalman-Rücksetzung bei Verdeckung: Setzt den Kalman-Zustand mithilfe eines im Ringpuffer gespeicherten Verlaufs auf einen Frame vor der Verdeckung zurück.
• Dämpfung der Bewegung und Erweiterung des Suchbereichs: Die Geschwindigkeit wird gedämpft und die vorhergesagte BBox während der Verdeckung vergrößert.
• Unterdrückung bei der Initialisierung anhand von IoU: Verhindert, dass neue Tracks direkt auf aktiven Tracks beginnen.

Am besten geeignet für: Echtzeit-Pipelines, die nur Erkennungen verwenden und bei denen Ziele häufig einander überdecken (Menschenmengen, Warteschlangen, Sport).

FastTracker-spezifische Argumente:

Hinweise zur Abstimmung:

• Häufige teilweise Verdeckungen: occ_cover_thresh senken (z. B. auf 0.5-0.6).
• Doppelte IDs bei Überschneidungen: init_iou_suppress senken (z. B. auf 0.5).
• Lange Verdeckungen: occ_reappear_window und track_buffer gemeinsam erhöhen.
• Sich schnell bewegende Ziele: dampen_motion_occ erhöhen (näher an 1.0); enlarge_bbox_occ nur erhöhen, wenn ein größerer Suchbereich die Wiedererkennung verbessert.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) ist der Standard-Tracker. Er bewertet Zuordnungen aus der Perspektive jeder einzelnen Spur anhand mehrerer Kriterien und iterativer Zuordnung:

• Zuordnung aus der Spurperspektive (TPA): kombiniert HMIoU, optional den Kosinusabstand für ReID, den Konfidenzprojektionsabstand und den Eckwinkelabstand. Die Zuordnung wird iterativ mit einem schrittweise gelockerten Schwellenwert berechnet.
• Spurbewusste Initialisierung (TAI): unterdrückt doppelte neue Spuren, bevor eine neue ID erstellt wird.

Am besten geeignet für: überfüllte Szenen mit häufigen Verdeckungen, in denen doppelte IDs ein Problem darstellen.

TrackTrack-spezifische Argumente:

Hinweise zur Abstimmung:

• Viele Fußgänger: tai_thr senken (z. B. auf 0.45), um mehr doppelte neue Spuren zu unterdrücken; track_buffer für längere Verdeckungen erhöhen.
• Schnelle Kamerabewegungen: gmc_method: sparseOptFlow aktiviert lassen.
• Kleine/schnelle Objekte: angle_weight leicht erhöhen und min_track_len senken.
• ReID nur bei Bedarf aktivieren: Es erhöht den Inferenzaufwand; bei kurzen Verdeckungen reichen die standardmäßigen Kosten für mehrere Kriterien normalerweise aus.

Bei Segmentierungs- und Pose-Modellen überspringt TrackTrack die Erkennungswiederherstellung mit gelockertem NMS, damit Masken und Schlüsselpunkte weiterhin zu den Erkennungen passen.

Python-Beispiele#

Schleife mit persistenten Spuren#

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO26 verwendet, um Objekte in Videobildern zu verfolgen. Das Skript setzt voraus, dass die erforderlichen Pakete (opencv-python und ultralytics) bereits installiert sind. Mit dem Argument persist=True wird dem Tracker mitgeteilt, dass das aktuelle Bild bzw. Videobild das nächste in einer Sequenz ist und dass im aktuellen Bild Spuren aus dem vorherigen Bild erwartet werden sollen.

import cv2

from ultralytics import YOLO

# YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Videodatei öffnen
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Videobilder durchlaufen
while cap.isOpened():
    # Ein Videobild einlesen
    success, frame = cap.read()

    if success:
        # YOLO26-Tracking auf dem Bild ausführen und Spuren zwischen Bildern beibehalten
        # und das BoT-SORT-Tracker-Backend verwenden
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Ergebnisse auf dem Bild visualisieren
        annotated_frame = results[0].plot()

        # Annotiertes Bild anzeigen
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Schleife beenden, wenn „q“ gedrückt wird
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Schleife beenden, wenn das Video zu Ende ist
        break

# Videoaufnahmeobjekt freigeben und Anzeigefenster schließen
cap.release()
cv2.destroyAllWindows()

Beachte die Änderung von model(frame) zu model.track(frame), durch die Objektverfolgung statt einfacher Erkennung aktiviert wird. Dieses angepasste Skript führt den Tracker auf jedem Videobild aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife lässt sich durch Drücken von „q“ beenden.

Spuren im Zeitverlauf darstellen#

Die Visualisierung von Objektspuren über aufeinanderfolgende Bilder kann wertvolle Einblicke in Bewegungsmuster und Verhalten erkannter Objekte in einem Video liefern. Mit Ultralytics YOLO26 lassen sich diese Spuren einfach und effizient darstellen.

Im folgenden Beispiel zeigen wir, wie du mit den Tracking-Funktionen von YOLO26 die Bewegung erkannter Objekte über mehrere Videobilder hinweg darstellen kannst. Das Skript öffnet eine Videodatei, liest sie Bild für Bild aus und verwendet das YOLO-Modell, um verschiedene Objekte zu erkennen und zu verfolgen. Indem wir die Mittelpunkte der erkannten Begrenzungsrahmen speichern und miteinander verbinden, können wir Linien zeichnen, die die von den verfolgten Objekten zurückgelegten Wege darstellen.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# Videodatei öffnen
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Spurenverlauf speichern
track_history = defaultdict(list)

# Videobilder durchlaufen
while cap.isOpened():
    # Ein Videobild einlesen
    success, frame = cap.read()

    if success:
        # YOLO26-Tracking auf dem Bild ausführen und Spuren zwischen Bildern beibehalten
        result = model.track(frame, persist=True)[0]

        # Begrenzungsrahmen und Spuren-IDs abrufen
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Ergebnis auf dem Bild visualisieren
            frame = result.plot()

            # Spuren darstellen
            for box, track_id in zip(boxes, track_ids):
                x, y, w, h = box
                track = track_history[track_id]
                track.append((float(x), float(y)))  # Mittelpunkt x, y
                if len(track) > 30:  # 30 Spuren für 30 Bilder beibehalten
                    track.pop(0)

                # Tracking-Linien zeichnen
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Annotiertes Bild anzeigen
        cv2.imshow("YOLO26 Tracking", frame)

        # Schleife beenden, wenn „q“ gedrückt wird
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Schleife beenden, wenn das Video zu Ende ist
        break

# Videoaufnahmeobjekt freigeben und Anzeigefenster schließen
cap.release()
cv2.destroyAllWindows()

Mehrthreadiges Tracking#

Mehrthreadiges Tracking ermöglicht die gleichzeitige Verfolgung von Objekten in mehreren Videostreams. Das ist besonders nützlich, wenn mehrere Videoeingaben verarbeitet werden, etwa von mehreren Überwachungskameras, da die gleichzeitige Verarbeitung Effizienz und Leistung erheblich steigern kann.

Im bereitgestellten Python-Skript verwenden wir das Modul threading von Python, um mehrere Tracker-Instanzen gleichzeitig auszuführen. Jeder Thread ist für die Ausführung des Trackers auf einer Videodatei zuständig, und alle Threads laufen gleichzeitig im Hintergrund.

Damit jeder Thread die richtigen Parameter erhält (Videodatei, zu verwendendes Modell und Dateiindex), definieren wir eine Funktion run_tracker_in_thread, die diese Parameter entgegennimmt und die Haupt-Tracking-Schleife enthält. Diese Funktion liest das Video Bild für Bild aus, führt den Tracker aus und speichert die annotierten Ergebnisse.

In diesem Beispiel kommen zwei verschiedene Modelle zum Einsatz: yolo26n.pt und yolo26n-seg.pt; jedes verfolgt Objekte in einer anderen Videodatei. Die Videodateien sind in SOURCES angegeben.

Der Parameter daemon=True in threading.Thread bedeutet, dass diese Threads geschlossen werden, sobald das Hauptprogramm beendet ist. Anschließend starten wir die Threads mit start() und verwenden join(), damit der Hauptthread wartet, bis beide Tracker-Threads abgeschlossen sind.

Sobald alle Threads ihre Aufgabe abgeschlossen haben, werden die Fenster mit den Ergebnissen mithilfe von cv2.destroyAllWindows() geschlossen.

import threading

import cv2

from ultralytics import YOLO

# Modellnamen und Videoquellen festlegen
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # lokales Video, 0 für Webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): Model checkpoint name or path loaded inside the thread.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Tracker-Threads mit einer for-Schleife erstellen und starten
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Warten, bis alle Tracker-Threads abgeschlossen sind
for thread in tracker_threads:
    thread.join()

# Aufräumen und Fenster schließen
cv2.destroyAllWindows()

Dieses Beispiel lässt sich leicht auf weitere Videodateien und Modelle erweitern, indem du zusätzliche Threads erstellst und dieselbe Methode anwendest.

Neue Tracker beitragen#

Kennst du dich mit Multi-Objekt-Tracking aus und hast einen Tracking-Algorithmus mit Ultralytics YOLO erfolgreich implementiert oder angepasst? Wir laden dich ein, zum Abschnitt „Tracker“ unter ultralytics/cfg/trackers beizutragen! Deine Lösungen und Anwendungen aus der Praxis können für Nutzerinnen und Nutzer, die an Tracking-Aufgaben arbeiten, von großem Wert sein.

Mit deinem Beitrag zu diesem Abschnitt hilfst du dabei, das Angebot an Tracking-Lösungen im Ultralytics-YOLO-Framework zu erweitern und der Community zusätzliche Funktionen und Einsatzmöglichkeiten bereitzustellen.

Eine umfassende Anleitung zur Einreichung eines Pull Requests (PR) findest du in unserem Leitfaden für Beiträge 🛠️. Wir sind gespannt auf deinen Beitrag!

Lass uns gemeinsam die Tracking-Funktionen des Ultralytics-YOLO-Ökosystems verbessern 🙏!

Häufig gestellte Fragen#