Tracciamento multi-oggetto con Ultralytics YOLO#

Il tracciamento degli oggetti nell'ambito della video analisi è un compito critico che non solo identifica la posizione e la classe degli oggetti all'interno del fotogramma, ma mantiene anche un ID univoco per ogni oggetto rilevato man mano che il video procede. Le applicazioni sono illimitate: dalla sorveglianza e sicurezza all'analisi sportiva in tempo reale.

Perché scegliere Ultralytics YOLO per il tracciamento degli oggetti?#

L'output dei tracker di Ultralytics è coerente con il rilevamento di oggetti standard, ma offre in più il valore degli ID di oggetto. Questo rende semplice tracciare oggetti nei flussi video ed eseguire analisi successive. Ecco perché dovresti prendere in considerazione l'uso di Ultralytics YOLO per le tue esigenze di object tracking:

• Efficienza: elabora flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: supporta molteplici algoritmi di tracciamento e configurazioni.
• Facilità d'uso: semplici opzioni API Python e CLI per una rapida integrazione e distribuzione.
• Personalizzabilità: facile da usare con modelli YOLO addestrati su misura, consentendo l'integrazione in applicazioni specifiche per il dominio.

Applicazioni nel mondo reale#

Trasporti	Vendita al dettaglio	Acquacoltura
Tracciamento veicoli	Tracciamento persone	Tracciamento pesci

Avvio rapido#

Esegui il tracciamento su un video con il tracker BoT-SORT predefinito. Passa a un altro tracker modificando l'argomento 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")

Per eseguire il tracker su flussi video, usa un modello addestrato Detect, Segment, Pose o OBB come YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puoi addestrare modelli personalizzati localmente o con l'addestramento cloud di 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

Tracker supportati#

Ultralytics YOLO include sei tracker integrati. Abiltane uno passando il suo file di configurazione YAML all'argomento tracker.

Quale tracker dovrei usare?#

Segui questo flusso per scegliere un punto di partenza:

1. Hai bisogno della baseline più veloce e semplice? → ByteTrack (niente ReID, niente compensazione del movimento della telecamera, overhead minimo).
2. Riprese portatili, da drone o con telecamera in movimento? → BoT-SORT (predefinito; aggiunge la compensazione del movimento della telecamera e ReID opzionale).
3. Movimento non lineare (sport, danza, curve brusche) e niente ReID? → OC-SORT (correzioni basate sull'osservazione senza costo di apparenza).
4. Scene affollate con telecamera in movimento dove gli scambi di ID sono il problema principale? → Deep OC-SORT o TrackTrack (entrambi aggiungono la fusione dell'aspetto adattivo; TrackTrack aggiunge anche l'associazione multi-cue e la soppressione degli ID duplicati).
5. Frequente sovrapposizione parziale in tempo reale, nessun budget ReID? → FastTracker (variante di ByteTrack consapevole dell'occlusione con rollback di Kalman).

Cambio dei tracker#

Passa il nome del file di configurazione del tracker a tracker=. Tutto il resto del codice rimane invariato.

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

Configurazione#

Argomenti di tracciamento#

La configurazione del tracciamento condivide proprietà con la modalità Predict, come conf, iou e show. Per ulteriori configurazioni, fai riferimento alla pagina del modello 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)

Configurazione personalizzata del tracker#

Ultralytics ti consente anche di usare un file di configurazione del tracker modificato. Per farlo, crea semplicemente una copia di un file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/trackers e modifica qualsiasi configurazione (tranne tracker_type) in base alle tue esigenze.

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

Argomenti condivisi del tracker#

I seguenti parametri sono comuni alla maggior parte dei file YAML del tracker; non tutti i parametri appaiono in ogni configurazione:

Argomenti specifici del tracker#

Ogni algoritmo espone manopole aggiuntive oltre ai parametri condivisi. Consulta le sezioni relative a ciascun tracker qui sotto per descrizioni e suggerimenti di ottimizzazione, oppure fai riferimento direttamente ai file di configurazione:

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

Abilitazione della Re-Identificazione (ReID)#

ReID è disabilitato per impostazione predefinita per ridurre al minimo l'overhead. Abilitalo impostando with_reid: True in un file di configurazione del tracker.

Opzioni del modello ReID:

• model: auto — Utilizza le funzionalità native del rilevatore YOLO, aggiungendo un overhead minimo. Ideale quando hai bisogno di un po' di ReID senza un calo drastico delle prestazioni. Passa a yolo26n-cls.pt se il rilevatore non espone funzionalità compatibili.
• Modello ReID esportato — Punta model: a un file esportato (.torchscript, .onnx, .engine, .openvino, ecc.) per embedding più discriminanti al costo di un passaggio in avanti (forward pass) extra per ritaglio (crop). Il codificatore viene caricato tramite AutoBackend, quindi qualsiasi formato di esportazione supportato da Ultralytics funziona senza modifiche al codice.

I codificatori ONNX pronti all'uso sono pubblicati per ogni dimensione del modello. Imposta model: su uno di questi nomi e il file verrà scaricato automaticamente la prima volta che il tracker viene eseguito (nello stesso modo in cui vengono recuperati i pesi di YOLO), senza passaggi manuali di esportazione o download:

# 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

Per prestazioni migliori con un modello di classificazione separato, esportalo verso un backend più veloce come 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)

Una volta esportato, punta al percorso del modello TensorRT nella configurazione del tuo tracker.

Dettagli del tracker#

Espandi le sezioni sottostanti per il design, i parametri specifici e i suggerimenti di ottimizzazione per ogni tracker.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) è il tracker predefinito. Estende ByteTrack con la compensazione del movimento della telecamera e ReID opzionale:

• Compensazione del movimento della fotocamera (CMC): una deformazione affine stimata per ogni frame (flusso ottico sparso per impostazione predefinita; ORB / ECC sono anche disponibili) viene applicata agli stati di Kalman prima della corrispondenza IoU.
• ReID opzionale: gli embedding dell'aspetto possono essere fusi nella matrice dei costi. Disabilitato per impostazione predefinita; abilitalo con with_reid: True.

Ideale per: tracciamento generico, specialmente con fotocamere in movimento. Aggiungi la ReID solo quando folle simili causano scambi di ID.

Argomenti specifici di BoT-SORT:

Suggerimenti di ottimizzazione:

• Telecamera statica: imposta gmc_method: none per risparmiare qualche ms/fotogramma.
• Movimento pesante della telecamera: mantieni sparseOptFlow; ecc è più preciso ma più lento.
• Folla simile: attiva with_reid: True e aumenta appearance_thresh (ad es. 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) è la base leggera. Usa Kalman lineare + IoU con un'associazione in due fasi:

• Stadio 1: abbina le rilevazioni con punteggio alto alle tracce attive.
• Stadio 2: riprova ad abbinare le tracce non accoppiate con rilevazioni a punteggio basso per recuperarle durante una breve occlusione parziale.

Non esiste un modello di aspetto né compensazione del movimento della fotocamera.

Ideale per: fotocamere statiche o quasi statiche in cui il costo del rilevatore domina e desideri il minimo overhead del tracker.

Argomenti specifici di ByteTrack: nessuno oltre agli argomenti di tracciamento condivisi.

Suggerimenti di ottimizzazione:

• Rilevatore rumoroso: abbassa track_low_thresh affinché la seconda fase abbia più candidati.
• Rilevatore ad alto richiamo: aumenta track_high_thresh per ridurre gli ID frammentati.
• Frequente sfarfallio degli ID: aumenta track_buffer in modo che i tracciamenti mancati brevemente sopravvivano.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) è un'estensione incentrata sull'osservazione di SORT. Mantiene il design leggero di SORT (senza caratteristiche di aspetto) e aggiunge tre correzioni:

• Riapprovvigionamento incentrato sull'osservazione (ORU): riproduce una traiettoria virtuale tra l'ultima osservazione e la rilevazione corrente, rieseguendo l'aggiornamento di Kalman per riparare la velocità alla deriva.
• Momento incentrato sull'osservazione (OCM): penalizza le rilevazioni che si muovono nella direzione sbagliata tramite un termine di coerenza della velocità.
• Recupero incentrato sull'osservazione (OCR): ricontrolla le rilevazioni non abbinate rispetto alle tracce perse di recente utilizzando la loro ultima osservazione anziché lo stato predetto.

Ideale per: movimento non lineare senza il costo di un modello ReID.

Argomenti specifici di OC-SORT:

Suggerimenti di ottimizzazione:

• Movimento non lineare: aumenta inertia (ad es. 0.3-0.4).
• Rilevamenti sparsi: abilita use_byte: True.
• Occlusioni lunghe: aumenta track_buffer affinché OCR abbia più tracce perse da ricollegare.

Deep OC-SORT#

Deep OC-SORT arricchisce OC-SORT con informazioni sull'aspetto e compensazione del movimento della telecamera:

• Fusione adattiva dell'aspetto: gli embedding di rilevazione sono fusi nella matrice dei costi con un peso modulato dalla confidenza di rilevazione e dalla sovrapposizione.
• EMA dell'aspetto dinamico: gli embedding delle tracce si aggiornano con un EMA il cui fattore di smoothing si adatta alla confidenza di rilevazione.
• Compensazione del movimento della fotocamera: gli stati di Kalman vengono deformati frame-per-frame tramite flusso ottico sparso, ORB o ECC.

Ideale per: scene affollate o con fotocamera in movimento dove gli scambi di ID tra oggetti visivamente diversi ma spazialmente vicini sono comuni.

Argomenti specifici di Deep OC-SORT:

Suggerimenti di ottimizzazione:

• Scambi di identità nella folla: aumenta appearance_thresh (ad es. 0.92-0.95) e abbassa alpha_fixed_emb affinché gli embedding si adattino più lentamente.
• Telecamera in movimento: imposta gmc_method: sparseOptFlow (Deep OC-SORT usa per impostazione predefinita none).
• Latenza inferiore: mantieni with_reid: False (predefinito) solo per movimento + CMC; abilita ReID solo quando gli scambi di ID dominano gli errori.

FastTracker#

FastTracker è una variante di ByteTrack consapevole delle occlusioni senza alcun modello di aspetto:

• Rilevamento delle occlusioni: contrassegna le tracce come occluse quando la copertura da parte di altre tracce attive supera occ_cover_thresh.
• Rollback di Kalman sull'occlusione: riporta lo stato di Kalman a un frame pre-occlusione utilizzando la cronologia del ring-buffer.
• Smorzamento del movimento ed espansione della ricerca: la velocità viene smorzata e la bbox predetta viene ingrandita mentre è occlusa.
• Soppressione Init-IoU: impedisce alle nuove tracce di generarsi sopra le tracce attive.

Ideale per: pipeline in tempo reale solo di rilevamento con frequente sovrapposizione target-su-target (folle, code, sport).

Argomenti specifici di FastTracker:

Suggerimenti di ottimizzazione:

• Occlusioni parziali frequenti: abbassa occ_cover_thresh (ad es. 0.5-0.6).
• ID duplicati attorno alla sovrapposizione: abbassa init_iou_suppress (ad es. 0.5).
• Occlusioni lunghe: aumenta occ_reappear_window e track_buffer insieme.
• Bersagli in movimento rapido: aumenta dampen_motion_occ (più vicino a 1.0) e abbassa enlarge_bbox_occ.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) ragiona dalla prospettiva di ciascuna traccia con un'associazione iterativa a più segnali:

• Associazione basata sulla prospettiva della traccia (TPA): combina HMIoU, distanza ReID coseno, distanza di proiezione della confidenza e distanza dell'angolo d'angolo. L'assegnazione viene risolta iterativamente con una soglia di rilassamento.
• Inizializzazione consapevole della traccia (TAI): sopprime le creazioni duplicate prima che venga generato un nuovo ID.

Ideale per: scene affollate con occlusioni frequenti dove gli ID duplicati sono un problema.

Argomenti specifici di TrackTrack:

Suggerimenti di ottimizzazione:

• Pedoni affollati: abbassa tai_thr (ad es. 0.45) per sopprimere più spawn duplicati; aumenta track_buffer per occlusioni più lunghe.
• Movimento rapido della telecamera: mantieni gmc_method: sparseOptFlow abilitato.
• Oggetti piccoli/veloci: aumenta leggermente angle_weight e abbassa min_track_len.
• Abilita ReID solo quando necessario: aggiunge un costo di inferenza; per brevi occlusioni, il costo multi-cue predefinito è solitamente sufficiente.

Esempi in Python#

Loop di persistenza delle tracce#

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO26 per eseguire il tracciamento degli oggetti sui fotogrammi video. Questo script presuppone che i pacchetti necessari (opencv-python e ultralytics) siano già installati. L'argomento persist=True indica al tracker che l'immagine o il fotogramma corrente è il successivo in una sequenza e di attendere le tracce dell'immagine precedente nell'immagine corrente.

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

Si prega di notare il passaggio da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti anziché il semplice rilevamento. Questo script modificato eseguirà il tracker su ogni fotogramma del video, ne visualizzerà i risultati e li mostrerà in una finestra. È possibile uscire dal ciclo premendo 'q'.

Tracciamento delle tracce nel tempo#

Visualizzare le tracce degli oggetti su frame consecutivi può fornire intuizioni preziose sui modelli di movimento e sul comportamento degli oggetti rilevati all'interno di un video. Con Ultralytics YOLO26, tracciare questi percorsi è un processo fluido ed efficiente.

Nell'esempio seguente, dimostriamo come utilizzare le capacità di tracciamento di YOLO26 per tracciare il movimento degli oggetti rilevati attraverso più frame video. Questo script prevede l'apertura di un file video, la sua lettura frame per frame e l'utilizzo del modello YOLO per identificare e tracciare vari oggetti. Mantenendo i punti centrali dei bounding box rilevati e collegandoli, possiamo disegnare linee che rappresentano i percorsi seguiti dagli oggetti tracciati.

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

Tracciamento multithread#

Il tracciamento multithread offre la possibilità di eseguire il tracciamento degli oggetti su più flussi video simultaneamente. Ciò è particolarmente utile quando si gestiscono più ingressi video, come da diverse telecamere di sorveglianza, dove l'elaborazione simultanea può migliorare notevolmente l'efficienza e le prestazioni.

nello script Python fornito, utilizziamo il modulo threading di Python per eseguire più istanze del tracker contemporaneamente. Ciascun thread è responsabile dell'esecuzione del tracker su un file video e tutti i thread vengono eseguiti simultaneamente in background.

Per assicurarsi che ciascun thread riceva i parametri corretti (il file video, il modello da utilizzare e l'indice del file), definiamo una funzione run_tracker_in_thread che accetta questi parametri e contiene il ciclo di tracciamento principale. Questa funzione legge il video fotogramma per fotogramma, esegue il tracker e visualizza i risultati.

In questo esempio vengono utilizzati due modelli differenti: yolo26n.pt e yolo26n-seg.pt, ognuno dei quali traccia oggetti in un file video diverso. I file video sono specificati in SOURCES.

Il parametro daemon=True in threading.Thread indica che questi thread verranno chiusi non appena il programma principale termina. Avviamo quindi i thread con start() e utilizziamo join() per fare in modo che il thread principale attende fino al completamento di entrambi i thread del tracker.

Infine, dopo che tutti i thread avranno completato il loro compito, le finestre che visualizzano i risultati verranno chiuse usando 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()

Questo esempio può essere facilmente esteso per gestire più file video e modelli creando più thread e applicando la stessa metodologia.

Contribuisci con nuovi tracker#

Hai esperienza nel multi-object tracking e hai implementato o adattato con successo un algoritmo di tracciamento con Ultralytics YOLO? Ti invitiamo a contribuire alla nostra sezione Trackers in ultralytics/cfg/trackers! Le tue applicazioni e soluzioni del mondo reale potrebbero rivelarsi preziose per gli utenti che lavorano su attività di tracciamento.

Contribuendo a questa sezione, aiuti ad espandere l'ambito delle soluzioni di tracciamento disponibili all'interno del framework Ultralytics YOLO, aggiungendo un ulteriore livello di funzionalità e utilità per la community.

Per iniziare a contribuire, fai riferimento alla nostra Guida ai contributi per istruzioni dettagliate su come inviare una Pull Request (PR) 🛠️. Siamo impazienti di scoprire cosa porterai in tavola!

Insieme, miglioriamo le capacità di tracciamento dell'ecosistema Ultralytics YOLO 🙏!

FAQ#

Cos'è il tracciamento multi-oggetto e come lo supporta Ultralytics YOLO?#

Il multi-object tracking nell'analisi video comporta sia l'identificazione degli oggetti sia il mantenimento di un ID univoco per ciascun oggetto rilevato attraverso i fotogrammi video. Ultralytics YOLO supporta questa funzionalità fornendo il tracciamento in tempo reale insieme agli ID degli oggetti, facilitando attività come la sorveglianza di sicurezza e l'analisi sportiva. Il sistema utilizza tracker quali BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack, configurabili tramite file YAML.

Posso salvare il tracker all'interno di un file del modello YOLO?#

No. I file standard .pt di Ultralytics memorizzano i pesi del modello YOLO, mentre il tracker viene creato al momento dell'inferenza da model.track(). Gli ID di tracciamento dipendono dallo stato del tracker su fotogrammi consecutivi, quindi una singola immagine autonoma può restituire rilevamenti come riquadri, classi e confidenze, ma non può produrre autonomamente ID di tracciamento persistenti significativi.

Per il deployment, raggruppa il rilevatore e il tracker insieme nella tua applicazione e chiama model.track() fotogramma per fotogramma con persist=True quando i fotogrammi provengono dallo stesso flusso video. Utilizza istanze di modello o tracker separate per flussi non correlati in modo che lo stato non si propaghi tra i video.

Come configuro un tracker personalizzato per Ultralytics YOLO?#

Puoi configurare un tracker personalizzato copiando un file di configurazione del tracker esistente (ad esempio, custom_tracker.yaml) dalla directory di configurazione del tracker di Ultralytics e modificando i parametri necessari, ad eccezione di tracker_type. Usa questo file nel tuo modello di tracciamento in questo modo:

from ultralytics import YOLO

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

Come posso eseguire il tracciamento degli oggetti su più flussi video simultaneamente?#

Per eseguire il tracciamento degli oggetti su più flussi video contemporaneamente, puoi usare il modulo threading di Python. Ciascun thread gestirà un flusso video separato. Ecco un esempio di come impostarlo:

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

Quali sono le applicazioni reali del tracciamento multi-oggetto con Ultralytics YOLO?#

Il tracciamento multi-oggetto con Ultralytics YOLO ha numerose applicazioni, tra cui:

• Trasporti: tracciamento dei veicoli per la gestione del traffico e guida autonoma.
• Retail: Tracciamento delle persone per analisi in negozio e sicurezza.
• Acquacoltura: Tracciamento dei pesci per il monitoraggio degli ambienti acquatici.
• Analisi Sportiva: Tracciamento di giocatori e attrezzature per l'analisi delle prestazioni.
• Sistemi di sicurezza: monitoraggio di attività sospette e creazione di allarmi di sicurezza.

Queste applicazioni beneficiano della capacità di Ultralytics YOLO di elaborare video ad alto frame rate in tempo reale con una precisione eccezionale.

Come posso visualizzare le tracce degli oggetti su più frame video con Ultralytics YOLO?#

Per visualizzare le tracce degli oggetti su più frame video, puoi usare le funzionalità di tracciamento del modello YOLO insieme a OpenCV per disegnare i percorsi degli oggetti rilevati. Ecco uno script di esempio che lo dimostra:

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

Questo script traccerà le linee di monitoraggio che mostrano i percorsi di movimento degli oggetti seguiti nel tempo, fornendo intuizioni preziose sul comportamento e sui modelli degli oggetti.