Link to this sectionTracciamento 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.

Link to this sectionPerché scegliere Ultralytics YOLO per il tracciamento degli oggetti?#

L'output dei tracker Ultralytics è coerente con il normale object detection, ma ha il valore aggiunto degli ID oggetto. Questo semplifica il tracciamento degli oggetti nei flussi video e l'esecuzione di analisi successive. Ecco perché dovresti considerare l'utilizzo di Ultralytics YOLO per le tue esigenze di tracciamento oggetti:

• Efficienza: elabora i flussi video in tempo reale senza compromettere l'accuratezza.
• 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.

Link to this sectionApplicazioni nel mondo reale#

Trasporti	Vendita al dettaglio	Acquacoltura
Tracciamento veicoli	Tracciamento persone	Tracciamento pesci

Link to this sectionAvvio rapido#

Esegui il tracciamento su un video con il tracker predefinito BoT-SORT. 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, utilizza un modello Detect, Segment, Pose o OBB addestrato come YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puoi addestrare modelli personalizzati localmente o su GPU in cloud tramite 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

Come si può vedere nell'utilizzo sopra indicato, il tracciamento è disponibile per tutti i modelli Detect, Segment e Pose eseguiti su video o sorgenti in streaming.

Link to this sectionTracker supportati#

Ultralytics YOLO viene fornito con sei tracker integrati. Abilitane uno passando il suo file di configurazione YAML all'argomento tracker.

Link to this sectionQuale 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).

Link to this sectionCambio 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")

Link to this sectionConfigurazione#

Link to this sectionArgomenti di tracciamento#

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

Link to this sectionConfigurazione personalizzata del tracker#

Ultralytics ti consente anche di utilizzare un file di configurazione del tracker modificato. Per fare ciò, crea semplicemente una copia di un file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/trackers e modifica qualsiasi configurazione (eccetto il tracker_type) secondo le 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")

Link to this sectionArgomenti condivisi del tracker#

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

Link to this sectionArgomenti 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

Link to this sectionAbilitazione della Re-Identificazione (ReID)#

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

Opzioni del modello ReID:

• model: auto — Utilizza le caratteristiche native del rilevatore YOLO, aggiungendo un overhead minimo. Ideale quando ti serve un po' di ReID senza un forte impatto sulle prestazioni. Torna a yolo26n-cls.pt se il rilevatore non espone caratteristiche compatibili.
• Modello ReID esportato — Punta model: verso un file esportato (.torchscript, .onnx, .engine, .openvino, ecc.) per embedding più discriminativi a costo di un passaggio in avanti extra per ritaglio. L'encoder viene caricato tramite AutoBackend, quindi qualsiasi formato di esportazione supportato da Ultralytics funziona senza modifiche al codice.

Encoder ONNX pronti all'uso sono pubblicati per ogni dimensione di modello. Imposta model: su uno di questi nomi e il file verrà scaricato automaticamente la prima volta che il tracker viene eseguito (allo stesso modo in cui vengono recuperati i pesi YOLO) — non è richiesto alcun passaggio manuale 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.

Link to this sectionDettagli del tracker#

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

Link to this sectionBoT-SORT#

BoT-SORT (Aharon et al., 2022) è il tracker predefinito. Estende ByteTrack con la compensazione del movimento della fotocamera e la 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:

• Fotocamera statica: imposta gmc_method: none per risparmiare alcuni ms/frame.
• Forte movimento della fotocamera: mantieni sparseOptFlow; ecc è più accurato ma più lento.
• Folle simili: attiva with_reid: True e aumenta appearance_thresh (es. 0.85+).

Link to this sectionByteTrack#

ByteTrack (Zhang et al., ECCV 2022) è la baseline leggera. Utilizza Kalman lineare + IoU con un'associazione a due stadi:

• 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 condivisi del tracker.

Suggerimenti di ottimizzazione:

• Rilevatore rumoroso: abbassa track_low_thresh in modo che il secondo stadio abbia più candidati.
• Rilevatore ad alto recall: aumenta track_high_thresh per ridurre gli ID frammentati.
• Frequente sfarfallio dell'ID: aumenta track_buffer in modo che le tracce brevemente perse sopravvivano.

Link to this sectionOC-SORT#

OC-SORT (Cao et al., CVPR 2023) è un'estensione di SORT incentrata sull'osservazione. 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 (es. 0.3-0.4).
• Rilevazioni sparse: abilita use_byte: True.
• Occlusioni lunghe: aumenta track_buffer in modo che OCR abbia più tracce perse da riassociare.

Link to this sectionDeep OC-SORT#

Deep OC-SORT potenzia OC-SORT con informazioni sull'aspetto e compensazione del movimento della fotocamera:

• 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à in folle: aumenta appearance_thresh (es. 0.92-0.95) e abbassa alpha_fixed_emb in modo che gli embedding si adattino più lentamente.
• Fotocamera in movimento: imposta gmc_method: sparseOptFlow (Deep OC-SORT è preimpostato su none).
• Latenza inferiore: mantieni with_reid: False (predefinito) solo per movimento + CMC; abilita la ReID solo quando gli scambi di ID dominano gli errori.

Link to this sectionFastTracker#

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

• Rilevamento occlusione: 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 (es. 0.5-0.6).
• ID duplicati durante la sovrapposizione: abbassa init_iou_suppress (es. 0.5).
• Occlusioni lunghe: aumenta occ_reappear_window e track_buffer insieme.
• Target in rapido movimento: aumenta dampen_motion_occ (più vicino a 1.0) e abbassa enlarge_bbox_occ.

Link to this sectionTrackTrack#

TrackTrack (Shim et al., CVPR 2025) analizza dalla prospettiva di ogni traccia con un'associazione iterativa multi-cue:

• 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 in ambienti affollati: abbassa tai_thr (es. 0.45) per sopprimere più creazioni duplicate; 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.

Link to this sectionEsempi in Python#

Link to this sectionLoop di persistenza delle tracce#

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO26 per eseguire il tracciamento degli oggetti sui frame 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 frame corrente è il successivo in una sequenza e di aspettarsi tracce dall'immagine precedente nell'immagine attuale.

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

Nota la modifica da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti invece del semplice rilevamento. Questo script modificato eseguirà il tracker su ogni frame del video, visualizzerà i risultati e li mostrerà in una finestra. Il loop può essere terminato premendo 'q'.

Link to this sectionTracciamento 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(lambda: [])

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

Link to this sectionTracciamento 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 simultaneamente. Ogni thread è responsabile dell'esecuzione del tracker su un file video e tutti i thread vengono eseguiti contemporaneamente in background.

Per garantire che ogni 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 loop di tracciamento principale. Questa funzione legge il video frame per frame, esegue il tracker e visualizza i risultati.

In questo esempio vengono utilizzati due modelli diversi: 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 significa che questi thread verranno chiusi non appena il programma principale termina. Avviamo quindi i thread con start() e usiamo join() per far sì che il thread principale attenda il completamento di entrambi i thread del tracker.

Infine, dopo che tutti i thread hanno completato il loro compito, le finestre che visualizzano i risultati vengono 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.

Link to this sectionContribuisci con nuovi tracker#

Sei esperto di tracciamento multi-oggetto 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 reali potrebbero essere inestimabili 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 il tuo contributo, consulta la nostra Guida al Contributo per istruzioni complete sull'invio di una Pull Request (PR) 🛠️. Siamo entusiasti di vedere cosa porterai al tavolo!

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

Link to this sectionFAQ#

Link to this sectionCos'è il tracciamento multi-oggetto e come lo supporta Ultralytics YOLO?#

Il tracciamento multi-oggetto nell'analisi video comporta sia l'identificazione degli oggetti che il mantenimento di un ID univoco per ogni oggetto rilevato tra i frame video. Ultralytics YOLO supporta questo fornendo tracciamento in tempo reale insieme agli ID degli oggetti, facilitando attività come la sorveglianza di sicurezza e l'analisi sportiva. Il sistema utilizza tracker come BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack, che possono essere configurati tramite file YAML.

Link to this sectionCome configuro un tracker personalizzato per Ultralytics YOLO?#

Puoi configurare un tracker personalizzato copiando un file di configurazione del tracker esistente (es. custom_tracker.yaml) dalla directory di configurazione dei tracker di Ultralytics e modificando i parametri come necessario, tranne per il 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")

Link to this sectionCome posso eseguire il tracciamento degli oggetti su più flussi video simultaneamente?#

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

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

Link to this sectionQuali 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.

Link to this sectionCome 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(lambda: [])

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.