Suivi multi-objets avec Ultralytics YOLO#

Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui non seulement identifie l'emplacement et la classe des objets dans l'image, mais maintient également un identifiant unique pour chaque objet détecté au fur et à mesure que la vidéo progresse. Les applications sont illimitées, allant de la surveillance et de la sécurité à l'analyse sportive en temps réel.

Pourquoi choisir Ultralytics YOLO pour le suivi d'objets ?#

Le résultat des traqueurs Ultralytics est cohérent avec la détection d'objets standard, mais offre la valeur ajoutée des ID d'objets. Cela facilite le suivi d'objets dans les flux vidéo et l'exécution d'analyses ultérieures. Voici pourquoi tu devrais envisager d'utiliser Ultralytics YOLO pour tes besoins de suivi d'objets :

• Efficacité : Traite les flux vidéo en temps réel sans compromettre la précision.
• Flexibilité : Prend en charge plusieurs algorithmes et configurations de suivi.
• Facilité d'utilisation : API Python simple et options CLI pour une intégration et un déploiement rapides.
• Personnalisation : Facile à utiliser avec des modèles YOLO entraînés sur mesure, permettant une intégration dans des applications spécifiques à un domaine.

Applications concrètes#

Transports	Commerce de détail	Aquaculture
Suivi de véhicules	Suivi de personnes	Suivi de poissons

Démarrage rapide#

Exécute le suivi sur une vidéo avec le traqueur BoT-SORT par défaut. Passe à un autre traqueur en modifiant l'argument tracker.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (BoT-SORT)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

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

Pour exécuter le traqueur sur des flux vidéo, utilise un modèle entraîné Detect, Segment, Pose ou OBB tel que YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Tu peux entraîner des modèles personnalisés localement ou avec l'entraînement cloud d'Ultralytics Platform.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo26n.pt")  # Load an official Detect model
model = YOLO("yolo26n-seg.pt")  # Load an official Segment model
model = YOLO("yolo26n-pose.pt")  # Load an official Pose model
model = YOLO("path/to/best.pt")  # Load a custom-trained model

# Perform tracking with the model
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # with ByteTrack

Trackers pris en charge#

Ultralytics YOLO est fourni avec six traqueurs intégrés. Active-le en passant son fichier de configuration YAML à l'argument tracker.

Quel tracker utiliser ?#

Utilise ce flux pour choisir un point de départ :

1. Besoin de la base de référence la plus rapide et la plus simple ? → ByteTrack (pas de ReID, pas de compensation de mouvement de caméra, surcharge minimale).
2. Images portatives, par drone ou caméra mobile ? → BoT-SORT (par défaut ; ajoute la compensation de mouvement de caméra et ReID en option).
3. Mouvement non linéaire (sport, danse, virages brusques) et pas de ReID ? → OC-SORT (corrections centrées sur l'observation sans coût d'apparence).
4. Scènes encombrées avec caméra mobile où les échanges d'ID sont le problème principal ? → Deep OC-SORT ou TrackTrack (tous deux ajoutent une fusion d'apparence adaptative ; TrackTrack ajoute également une association multi-indices et une suppression des ID en double).
5. Chevauchement partiel fréquent en temps réel, pas de budget ReID ? → FastTracker (variante ByteTrack sensible aux occlusions avec retour en arrière Kalman).

Changement de tracker#

Passe le nom du fichier de configuration du traqueur à tracker=. Tout le reste du code reste inchangé.

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")

Configuration#

Arguments de suivi#

La configuration du suivi partage des propriétés avec le mode Predict, telles que conf, iou et show. Pour d'autres configurations, consulte la page du modèle Predict.

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)

Configuration personnalisée du tracker#

Ultralytics te permet également d'utiliser un fichier de configuration de traqueur modifié. Pour ce faire, fais simplement une copie d'un fichier de configuration de traqueur (par exemple, custom_tracker.yaml) depuis ultralytics/cfg/trackers et modifie les configurations (sauf le tracker_type) selon tes besoins.

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Arguments de suivi partagés#

Les paramètres suivants sont communs à la plupart des fichiers YAML de suivi ; tous les paramètres ne figurent pas dans chaque configuration :

Arguments spécifiques au tracker#

Chaque algorithme expose des options supplémentaires en plus des paramètres partagés. Consulte les sections dédiées à chaque tracker ci-dessous pour obtenir des descriptions et des conseils de réglage, ou reporte-toi directement aux fichiers de configuration :

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

Activer la ré-identification (ReID)#

Le ReID est désactivé par défaut pour minimiser la surcharge. Active-le en définissant with_reid: True dans un fichier de configuration de traqueur.

Options du modèle ReID :

• model: auto — Utilise les caractéristiques natives du détecteur YOLO, ajoutant une surcharge minime. Idéal lorsque tu as besoin d'un certain ReID sans baisse importante des performances. Revient à yolo26n-cls.pt si le détecteur n'expose pas de caractéristiques compatibles.
• Modèle ReID exporté — Pointe model: vers un fichier exporté (.torchscript, .onnx, .engine, .openvino, etc.) pour des embeddings plus discriminants au prix d'une passe avant supplémentaire par recadrage. L'encodeur est chargé via AutoBackend, de sorte que tout format d'exportation pris en charge par Ultralytics fonctionne sans modification du code.

Des encodeurs ONNX prêts à l'emploi sont publiés pour chaque taille de modèle. Définis model: sur l'un de ces noms et le fichier sera téléchargé automatiquement lors de la première exécution du traqueur (de la même manière que les poids YOLO sont récupérés) — aucune étape d'exportation ou de téléchargement manuel requise :

# 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

Pour de meilleures performances avec un modèle de classification séparé, exporte-le vers un backend plus rapide comme TensorRT :

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo26n-cls.pt")

# Add average pooling layer
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

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

Une fois exporté, indique le chemin du modèle TensorRT dans ta configuration de tracker.

Détails sur les trackers#

Développe les sections ci-dessous pour découvrir la conception, les paramètres spécifiques et les conseils de réglage de chaque tracker.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) est le traqueur par défaut. Il étend ByteTrack avec une compensation du mouvement de la caméra et un ReID facultatif :

• Compensation du mouvement de la caméra (CMC) : une déformation affine estimée à chaque image (flux optique épars par défaut ; ORB / ECC également disponibles) est appliquée aux états de Kalman avant la mise en correspondance IoU.
• ReID facultatif : les embeddings d'apparence peuvent être fusionnés dans la matrice des coûts. Désactivé par défaut ; active-le avec with_reid: True.

Idéal pour : le suivi à usage général, surtout avec des caméras mobiles. N'ajoute la ReID que lorsque des foules aux apparences similaires provoquent des échanges d'ID.

Arguments spécifiques à BoT-SORT :

Conseils de réglage :

• Caméra fixe : définis gmc_method: none pour économiser quelques ms/image.
• Mouvement important de la caméra : conserve sparseOptFlow ; ecc est plus précis mais plus lent.
• Foules similaires : active with_reid: True et augmente appearance_thresh (par exemple, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) est la ligne de base légère. Il utilise Kalman linéaire + IoU avec une association en deux étapes :

• Étape 1 : fait correspondre les détections à score élevé avec les pistes actives.
• Étape 2 : réessaye avec les pistes non appariées contre les détections à faible score pour récupérer après une brève occlusion partielle.

Il n'y a pas de modèle d'apparence ni de compensation de mouvement de la caméra.

Idéal pour : les caméras statiques ou quasi statiques où le coût du détecteur prédomine et où tu souhaites une surcharge de suivi minimale.

Arguments spécifiques à ByteTrack : Aucun en dehors des arguments de traqueur partagés.

Conseils de réglage :

• Détecteur bruyant : diminue track_low_thresh pour que la deuxième étape ait plus de candidats.
• Détecteur à haut rappel : augmente track_high_thresh pour réduire les identifiants fragmentés.
• Scintillement fréquent des identifiants : augmente track_buffer pour que les pistes brièvement manquées survivent.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) est une extension axée sur l'observation de SORT. Il conserve la conception légère de SORT (pas de caractéristiques d'apparence) et ajoute trois corrections :

• Ré-actualisation centrée sur l'observation (ORU) : rejoue une trajectoire virtuelle entre la dernière observation et la détection actuelle, en relançant la mise à jour de Kalman pour corriger la dérive de vitesse.
• Momentum centré sur l'observation (OCM) : pénalise les détections se déplaçant dans la mauvaise direction via un terme de cohérence de vitesse.
• Récupération centrée sur l'observation (OCR) : revérifie les détections non appariées par rapport aux pistes récemment perdues en utilisant leur dernière observation plutôt que l'état prédit.

Idéal pour : le mouvement non linéaire sans le coût d'un modèle ReID.

Arguments spécifiques à OC-SORT :

Conseils de réglage :

• Mouvement non linéaire : augmente inertia (par exemple, 0.3-0.4).
• Détections éparses : active use_byte: True.
• Occlusions longues : augmente track_buffer pour que l'OCR ait plus de pistes perdues à réassocier.

Deep OC-SORT#

Deep OC-SORT complète OC-SORT avec des informations d'apparence et une compensation du mouvement de la caméra :

• Fusion d'apparence adaptative : les embeddings de détection sont fusionnés dans la matrice de coût avec un poids modulé par la confiance de détection et le chevauchement.
• EMA d'apparence dynamique : les embeddings de piste se mettent à jour avec une EMA dont le facteur de lissage s'adapte à la confiance de détection.
• Compensation du mouvement de la caméra : les états de Kalman sont déformés image par image via un flux optique épars, ORB ou ECC.

Idéal pour : les scènes bondées ou à caméra mobile où les échanges d'ID entre des objets visuellement différents mais spatialement proches sont courants.

Arguments spécifiques à Deep OC-SORT :

Conseils de réglage :

• Échanges d'identifiants dans les foules : augmente appearance_thresh (par exemple, 0.92-0.95) et diminue alpha_fixed_emb pour que les embeddings s'adaptent plus lentement.
• Caméra en mouvement : définis gmc_method: sparseOptFlow (Deep OC-SORT utilise none par défaut).
• Faible latence : conserve with_reid: False (par défaut) pour le mouvement + CMC uniquement ; n'active le ReID que lorsque les échanges d'identifiants dominent les erreurs.

FastTracker#

FastTracker est une variante de ByteTrack consciente des occlusions sans modèle d'apparence :

• Détection d'occlusion : marque les pistes comme occluses lorsque la couverture par d'autres pistes actives dépasse occ_cover_thresh.
• Retour en arrière de Kalman lors d'une occlusion : ramène l'état de Kalman à une image pré-occlusion en utilisant un historique en anneau.
• Atténuation du mouvement et expansion de la recherche : la vitesse est amortie et la bbox prédite est agrandie pendant l'occlusion.
• Suppression Init-IoU : empêche les nouvelles pistes de se créer au-dessus des pistes actives.

Idéal pour : les pipelines en temps réel dédiés à la détection avec des chevauchements fréquents de cibles (foules, files d'attente, sports).

Arguments spécifiques à FastTracker :

Conseils de réglage :

• Occlusions partielles fréquentes : diminue occ_cover_thresh (par exemple, 0.5-0.6).
• Identifiants en double autour du chevauchement : diminue init_iou_suppress (par exemple, 0.5).
• Occlusions longues : augmente occ_reappear_window et track_buffer ensemble.
• Cibles en mouvement rapide : augmente dampen_motion_occ (plus près de 1.0) et diminue enlarge_bbox_occ.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) raisonne du point de vue de chaque piste avec une association itérative à indices multiples :

• Association basée sur la perspective de trace (TPA) : combine HMIoU, distance ReID cosinus, distance de projection de confiance, et distance d'angle de coin. L'assignation est résolue de manière itérative avec un seuil relaxant.
• Initialisation consciente des traces (TAI) : supprime les apparitions en double avant la création d'un nouvel identifiant.

Idéal pour : les scènes bondées avec des occlusions fréquentes où les identifiants en double posent problème.

Arguments spécifiques à TrackTrack :

Conseils de réglage :

• Piétons en foule : diminue tai_thr (par exemple, 0.45) pour supprimer davantage de duplications ; augmente track_buffer pour des occlusions plus longues.
• Mouvement rapide de la caméra : garde gmc_method: sparseOptFlow activé.
• Petits objets / objets rapides : augmente légèrement angle_weight et diminue min_track_len.
• Active ReID uniquement si nécessaire : cela ajoute un coût d'inférence ; pour les occlusions courtes, le coût multi-indices par défaut est généralement suffisant.

Exemples Python#

Boucle de persistance des traces#

Voici un script Python utilisant OpenCV (cv2) et YOLO26 pour exécuter le suivi d'objets sur des images vidéo. Ce script suppose que les paquets nécessaires (opencv-python et ultralytics) sont déjà installés. L'argument persist=True indique au traqueur que l'image ou la trame actuelle est la suivante dans une séquence et qu'il doit s'attendre à retrouver les pistes de l'image précédente dans l'image actuelle.

import cv2

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Veuillez noter le passage de model(frame) à model.track(frame), qui permet le suivi d'objets au lieu d'une simple détection. Ce script modifié exécutera le traqueur sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.

Tracer les trajectoires dans le temps#

Visualiser les traces d'objets sur des frames consécutives peut fournir des informations précieuses sur les modèles de mouvement et le comportement des objets détectés au sein d'une vidéo. Avec Ultralytics YOLO26, tracer ces trajectoires est un processus fluide et efficace.

Dans l'exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLO26 pour tracer le mouvement des objets détectés à travers plusieurs frames vidéo. Ce script implique l'ouverture d'un fichier vidéo, sa lecture frame par frame, et l'utilisation du modèle YOLO pour identifier et suivre divers objets. En conservant les points centraux des boîtes englobantes détectées et en les connectant, nous pouvons dessiner des lignes qui représentent les chemins suivis par les objets suivis.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Store the track history
track_history = defaultdict(list)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        result = model.track(frame, persist=True)[0]

        # Get the boxes and track IDs
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualize the result on the frame
            frame = result.plot()

            # Plot the tracks
            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)))  # x, y center point
                if len(track) > 30:  # retain 30 tracks for 30 frames
                    track.pop(0)

                # Draw the tracking lines
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Suivi multi-thread#

Le suivi multi-thread offre la capacité d'exécuter le suivi d'objets sur plusieurs flux vidéo simultanément. Ceci est particulièrement utile lors du traitement de multiples entrées vidéo, comme depuis plusieurs caméras de surveillance, où le traitement simultané peut grandement améliorer l'efficacité et la performance.

Dans le script Python fourni, nous utilisons le module Python threading pour exécuter plusieurs instances du traqueur simultanément. Chaque thread est responsable de l'exécution du traqueur sur un fichier vidéo, et tous les threads s'exécutent en même temps en arrière-plan.

Pour s'assurer que chaque thread reçoit les bons paramètres (le fichier vidéo, le modèle à utiliser et l'indice du fichier), nous définissons une fonction run_tracker_in_thread qui accepte ces paramètres et contient la boucle de suivi principale. Cette fonction lit la vidéo image par image, exécute le traqueur et affiche les résultats.

Deux modèles différents sont utilisés dans cet exemple : yolo26n.pt et yolo26n-seg.pt, chacun suivant des objets dans un fichier vidéo différent. Les fichiers vidéo sont spécifiés dans SOURCES.

Le paramètre daemon=True dans threading.Thread signifie que ces threads seront fermés dès que le programme principal se terminera. Nous démarrons ensuite les threads avec start() et utilisons join() pour faire attendre le thread principal jusqu'à ce que les deux threads du traqueur aient terminé.

Enfin, une fois que tous les threads ont terminé leur tâche, les fenêtres affichant les résultats sont fermées à l'aide de cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

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

    Args:
        model_name (str): The YOLO26 model object.
        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

# Create and start tracker threads using a for loop
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()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Cet exemple peut être facilement étendu pour gérer davantage de fichiers vidéo et de modèles en créant plus de threads et en appliquant la même méthodologie.

Contribuer à de nouveaux trackers#

Tu maîtrises le suivi multi-objets et tu as réussi à mettre en œuvre ou à adapter un algorithme de suivi avec Ultralytics YOLO ? Nous t'invitons à contribuer à notre section Trackers dans ultralytics/cfg/trackers ! Tes applications et solutions du monde réel pourraient s'avérer inestimables pour les utilisateurs travaillant sur des tâches de suivi.

En contribuant à cette section, tu aides à élargir la portée des solutions de suivi disponibles au sein du framework Ultralytics YOLO, ajoutant une couche supplémentaire de fonctionnalité et d'utilité pour la communauté.

Pour initier ta contribution, consulte notre Guide de contribution pour obtenir des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous avons hâte de voir ce que tu as à offrir !

Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 !

FAQ#

Qu'est-ce que le suivi multi-objets et comment Ultralytics YOLO le prend-il en charge ?#

Le suivi multi-objets dans l'analyse vidéo implique à la fois l'identification des objets et le maintien d'un identifiant unique pour chaque objet détecté à travers les images vidéo. Ultralytics YOLO prend en charge cela en fournissant un suivi en temps réel ainsi que des identifiants d'objets, facilitant des tâches telles que la surveillance de sécurité et l'analyse sportive. Le système utilise des traqueurs tels que BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker et TrackTrack, qui peuvent être configurés via des fichiers YAML.

Puis-je stocker le tracker dans un fichier de modèle YOLO ?#

Non. Les fichiers .pt standard d'Ultralytics stockent les poids du modèle YOLO, tandis que le traqueur est créé au moment de l'inférence par model.track(). Les identifiants de suivi dépendent de l'état du traqueur sur des images consécutives, de sorte qu'une seule image isolée peut renvoyer des détections telles que des boîtes, des classes et des confidences, mais elle ne peut pas produire par elle-même des identifiants de suivi persistants significatifs.

Pour le déploiement, regroupe le détecteur et le traqueur dans ton application et appelle model.track() image par image avec persist=True lorsque les images proviennent du même flux vidéo. Utilise des instances de modèle ou de traqueur distinctes pour les flux non apparentés afin que l'état ne soit pas reporté d'une vidéo à l'autre.

Comment configurer un tracker personnalisé pour Ultralytics YOLO ?#

Tu peux configurer un traqueur personnalisé en copiant un fichier de configuration de traqueur existant (par exemple, custom_tracker.yaml) du répertoire de configuration des traqueurs Ultralytics et en modifiant les paramètres selon tes besoins, à l'exception de tracker_type. Utilise ce fichier dans ton modèle de suivi comme ceci :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Comment exécuter le suivi d'objets sur plusieurs flux vidéo simultanément ?#

Pour exécuter le suivi d'objets sur plusieurs flux vidéo simultanément, tu peux utiliser le module Python threading. Chaque thread gérera un flux vidéo distinct. Voici un exemple de la façon dont tu peux configurer cela :

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

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

    Args:
        model_name (str): The YOLO26 model object.
        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

# Create and start tracker threads using a for loop
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()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Quelles sont les applications réelles du suivi multi-objets avec Ultralytics YOLO ?#

Le suivi multi-objets avec Ultralytics YOLO a de nombreuses applications, notamment :

• Transport : Suivi de véhicules pour la gestion du trafic et la conduite autonome.
• Commerce de détail : Suivi de personnes pour l'analyse en magasin et la sécurité.
• Aquaculture : Suivi de poissons pour la surveillance d'environnements aquatiques.
• Analyse sportive : Suivi des joueurs et de l'équipement pour l'analyse de performance.
• Systèmes de sécurité : Surveillance d'activités suspectes et création d'alarmes de sécurité.

Ces applications bénéficient de la capacité d'Ultralytics YOLO à traiter des vidéos à haut taux de rafraîchissement en temps réel avec une précision exceptionnelle.

Comment visualiser les trajectoires d'objets sur plusieurs frames vidéo avec Ultralytics YOLO ?#

Pour visualiser les trajectoires d'objets sur plusieurs frames vidéo, tu peux utiliser les fonctionnalités de suivi du modèle YOLO avec OpenCV pour dessiner les chemins des objets détectés. Voici un exemple de script qui démontre cela :

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
track_history = defaultdict(list)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()
        annotated_frame = results[0].plot()
        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)))
            if len(track) > 30:
                track.pop(0)
            points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
            cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
        cv2.imshow("YOLO26 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Ce script tracera les lignes de suivi montrant les chemins de mouvement des objets suivis au fil du temps, fournissant des informations précieuses sur le comportement et les modèles des objets.