Tracciamento di più oggetti con Ultralytics YOLO

Il tracciamento degli oggetti nel campo dell'analisi video è un compito fondamentale che non solo identifica la posizione e la classe degli oggetti all'interno dell'inquadratura, ma mantiene anche un ID univoco per ogni oggetto rilevato durante l'avanzamento del video. Le applicazioni sono illimitate e spaziano dalla sorveglianza e dalla sicurezza all'analisi degli sport in tempo reale.

Perché scegliere Ultralytics YOLO per il tracciamento degli oggetti?

Il risultato dei tracker di Ultralytics è coerente con il rilevamento standard degli oggetti, ma ha il valore aggiunto degli ID degli oggetti. In questo modo è facile tracciare gli oggetti nei flussi video ed eseguire analisi successive. Ecco perché dovresti considerare l'uso di Ultralytics YOLO per le tue esigenze di tracciamento degli oggetti:

• Efficienza: Elabora i flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: Supporta diversi algoritmi e configurazioni di tracciamento.
• Facilità d'uso: semplici API Python e opzioni CLI per un'integrazione e una distribuzione rapida.
• Personalizzabilità: Facile da usare con i modelli YOLO addestrati in modo personalizzato, consentendo l'integrazione in applicazioni specifiche del settore.

Guarda: Rilevamento e tracciamento di oggetti con Ultralytics YOLOv8 .

Applicazioni del mondo reale

Trasporto	Vendita al dettaglio	Acquacoltura
Tracciamento del veicolo	Tracciamento delle persone	Tracciamento dei pesci

Caratteristiche in sintesi

Ultralytics YOLO estende le sue funzioni di rilevamento degli oggetti per offrire un tracciamento degli oggetti robusto e versatile:

• Tracciamento in tempo reale: Traccia senza problemi gli oggetti nei video ad alta velocità.
• Supporto per Tracker multipli: Scegli tra una serie di algoritmi di tracciamento consolidati.
• Configurazioni personalizzabili del tracker: Adatta l'algoritmo di tracciamento per soddisfare requisiti specifici regolando vari parametri.

Tracker disponibili

Ultralytics YOLO supporta i seguenti algoritmi di tracciamento. Possono essere abilitati passando il relativo file di configurazione YAML, come ad esempio tracker=tracker_type.yaml:

• Sorta di BoT - Utilizza botsort.yaml per abilitare questo tracker.
• ByteTrack - Utilizza bytetrack.yaml per abilitare questo tracker.

Il tracker predefinito è BoT-SORT.

Tracciamento

Per eseguire il tracker sui flussi video, utilizza un modello addestrato di Detect, Segment o Pose come YOLOv8n, YOLOv8n-seg e YOLOv8n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO('yolov8n.pt')  # Load an official Detect model
model = YOLO('yolov8n-seg.pt')  # Load an official Segment model
model = YOLO('yolov8n-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(source="https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker

# Perform tracking with various models using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4"  # Official Detect model
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4"  # Official Pose model
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4"  # Custom trained model

# Track using ByteTrack tracker
yolo track model=path/to/best.pt tracker="bytetrack.yaml"

Come si può notare dall'utilizzo sopra descritto, il tracciamento è disponibile per tutti i modelli Detect, Segment e Pose eseguiti su video o fonti di streaming.

Configurazione

Tracciamento degli argomenti

La configurazione del tracciamento condivide le proprietà della modalità Predict, come ad esempio conf, iou, e show. Per ulteriori configurazioni, consulta la sezione Prevedere pagina del modello.

from ultralytics import YOLO

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

# Configure tracking parameters and run the tracker using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Selezione del tracker

Ultralytics ti permette anche di utilizzare un file di configurazione del tracker modificato. Per farlo, basta fare una copia del file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/tracker e modificare tutte le configurazioni (ad eccezione di quella 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('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')

# Load the model and run the tracker with a custom configuration file using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Per un elenco completo degli argomenti di tracciamento, consulta la pagina ultralytics/cfg/trackers.

Python Esempi

Loop delle tracce persistenti

Ecco uno script di Python che utilizza OpenCV (cv2) e YOLOv8 per eseguire il tracciamento degli oggetti sui fotogrammi video. Questo script presuppone che tu abbia già installato i pacchetti necessari (opencv-python e ultralytics). Il persist=True indica al tracker che l'immagine o il fotogramma corrente è il successivo di una sequenza e che deve aspettarsi le tracce dell'immagine precedente nell'immagine corrente.

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

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

        # Display the annotated frame
        cv2.imshow("YOLOv8 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 noti il cambiamento da model(frame) a model.track(frame)che consente il tracciamento degli oggetti invece del semplice rilevamento. Questo script modificato eseguirà il tracker su ogni fotogramma del video, visualizzerà i risultati e li mostrerà in una finestra. Il ciclo può essere interrotto premendo 'q'.

Tracciare tracce nel tempo

La visualizzazione delle tracce degli oggetti su fotogrammi consecutivi può fornire preziose informazioni sui modelli di movimento e sul comportamento degli oggetti rilevati in un video. Con Ultralytics YOLOv8 , tracciare queste tracce è un processo semplice ed efficiente.

Nel seguente esempio, dimostriamo come utilizzare le capacità di tracciamento di YOLOv8 per tracciare il movimento degli oggetti rilevati su più fotogrammi video. Questo script prevede l'apertura di un file video, la lettura fotogramma per fotogramma e l'utilizzo del modello YOLO per identificare e tracciare vari oggetti. Mantenendo i punti centrali delle bounding box rilevate e collegandoli tra loro, possiamo tracciare delle 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 YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Get the boxes and track IDs
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()

        # Visualize the results on the frame
        annotated_frame = results[0].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 90 tracks for 90 frames
                track.pop(0)

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

        # Display the annotated frame
        cv2.imshow("YOLOv8 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()

Tracciamento multithread

Il tracciamento multithreading consente di eseguire il tracciamento degli oggetti su più flussi video contemporaneamente. Questo è particolarmente utile quando si gestiscono più ingressi video, ad esempio da più telecamere di sorveglianza, dove l'elaborazione simultanea può migliorare notevolmente l'efficienza e le prestazioni.

Nello script Python fornito, utilizziamo lo script Python's threading per eseguire più istanze del tracker in contemporanea. 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 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 diversi: yolov8n.pt e yolov8n-seg.pt, ognuno dei quali traccia gli oggetti in un file video diverso. I file video sono specificati in video_file1 e video_file2.

Il daemon=True parametro in threading.Thread significa che questi thread verranno chiusi non appena il programma principale terminerà. Avviamo quindi i thread con start() e utilizzare join() per far sì che il thread principale attenda che entrambi i thread del tracker abbiano terminato.

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


def run_tracker_in_thread(filename, model, file_index):
    """
    Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.

    This function captures video frames from a given file or camera source and utilizes the YOLOv8 model for object
    tracking. The function runs in its own thread for concurrent processing.

    Args:
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
        model (obj): The YOLOv8 model object.
        file_index (int): An index to uniquely identify the file being processed, used for display purposes.

    Note:
        Press 'q' to quit the video display window.
    """
    video = cv2.VideoCapture(filename)  # Read the video file

    while True:
        ret, frame = video.read()  # Read the video frames

        # Exit the loop if no more frames in either video
        if not ret:
            break

        # Track objects in frames if available
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)

        key = cv2.waitKey(1)
        if key == ord('q'):
            break

    # Release video sources
    video.release()


# Load the models
model1 = YOLO('yolov8n.pt')
model2 = YOLO('yolov8n-seg.pt')

# Define the video files for the trackers
video_file1 = "path/to/video1.mp4"  # Path to video file, 0 for webcam
video_file2 = 0  # Path to video file, 0 for webcam, 1 for external camera

# Create the tracker threads
tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

# Start the tracker threads
tracker_thread1.start()
tracker_thread2.start()

# Wait for the tracker threads to finish
tracker_thread1.join()
tracker_thread2.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

Sei esperto di tracking di oggetti multipli e hai implementato o adattato con successo un algoritmo di tracking con Ultralytics YOLO ? Ti invitiamo a contribuire alla nostra sezione Trackers in ultralytics/cfg/trackers! Le tue applicazioni e soluzioni reali potrebbero essere preziose per gli utenti che lavorano al tracciamento.

Contribuendo a questa sezione, contribuisci ad ampliare la portata delle soluzioni di tracciamento disponibili all'interno del framework Ultralytics YOLO , aggiungendo un ulteriore livello di funzionalità e utilità per la comunità.

Per iniziare a dare il tuo contributo, consulta la nostra Guida alla contribuzione per avere istruzioni complete sull'invio di una richiesta di modifica (PR) 🛠️. Non vediamo l'ora di vedere cosa porterai in tavola!

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

Commenti