Seguimento de vários objectos com Ultralytics YOLO

O rastreio de objectos no domínio da análise de vídeo é uma tarefa crítica que não só identifica a localização e a classe dos objectos dentro da imagem, como também mantém uma ID única para cada objeto detectado à medida que o vídeo avança. As aplicações são ilimitadas - desde a vigilância e segurança até à análise desportiva em tempo real.

Porquê escolher Ultralytics YOLO para o seguimento de objectos?

A saída dos rastreadores Ultralytics é consistente com a deteção de objetos padrão, mas tem o valor agregado de IDs de objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Eis porque deves considerar a utilização do Ultralytics YOLO para as tuas necessidades de seguimento de objectos:

• Eficiência: Processa fluxos de vídeo em tempo real sem comprometer a precisão.
• Flexibilidade: Suporta vários algoritmos e configurações de rastreio.
• Facilidade de utilização: API Python simples e opções CLI para uma integração e implementação rápidas.
• Personalização: Fácil de utilizar com modelos YOLO personalizados e treinados, permitindo a integração em aplicações específicas do domínio.

Observa: Deteção e seguimento de objectos com Ultralytics YOLOv8 .

Aplicações no mundo real

Transporte	Retalho	Aquacultura
Seguimento de veículos	Seguimento de pessoas	Seguimento de peixes

Visão geral das características

Ultralytics YOLO alarga as suas funcionalidades de deteção de objectos para proporcionar um seguimento de objectos robusto e versátil:

• Rastreamento em tempo real: Localiza objectos sem problemas em vídeos de alta taxa de fotogramas.
• Suporte a vários rastreadores: Escolhe entre uma variedade de algoritmos de rastreamento estabelecidos.
• Configurações personalizáveis do rastreador: Adapta o algoritmo de rastreamento para atender a requisitos específicos, ajustando vários parâmetros.

Rastreadores disponíveis

Ultralytics YOLO suporta os seguintes algoritmos de rastreamento. Eles podem ser ativados passando o arquivo de configuração YAML relevante, como tracker=tracker_type.yaml:

• BoT-SORT - Utiliza botsort.yaml para ativar este localizador.
• ByteTrack - Utiliza bytetrack.yaml para ativar este localizador.

O localizador predefinido é o BoT-SORT.

Seguimento

Para executar o rastreador em fluxos de vídeo, usa um modelo treinado de Detetar, Segmentar ou Pose, como 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"

Como pode ser visto na utilização acima, o rastreio está disponível para todos os modelos Detect, Segment e Pose executados em vídeos ou fontes de streaming.

Configuração

Argumentos de rastreio

A configuração de rastreio partilha propriedades com o modo Prever, tais como conf, ioue show. Para mais configurações, consulta a Prevê página do modelo.

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

Seleção do Tracker

Ultralytics também permite que uses um ficheiro de configuração do tracker modificado. Para fazer isso, basta fazer uma cópia de um arquivo de configuração do rastreador (por exemplo, custom_tracker.yaml) de ultralytics/cfg/trackers e modifica todas as configurações (exceto a tracker_type) de acordo com as tuas necessidades.

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'

Para uma lista completa de argumentos de rastreamento, consulta a página ultralytics/cfg/trackers.

Python Exemplos

Loop de pistas persistentes

Aqui tens um script Python que utiliza o OpenCV (cv2) e YOLOv8 para executar o rastreio de objectos em fotogramas de vídeo. Este script ainda assume que já instalaste os pacotes necessários (opencv-python e ultralytics). O persist=True diz ao localizador que a imagem ou fotograma atual é o seguinte numa sequência e que deve esperar pistas da imagem anterior na imagem atual.

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

Nota a mudança de model(frame) para model.track(frame)que permite o rastreamento de objetos em vez da simples deteção. Este script modificado executa o rastreador em cada frame do vídeo, visualiza os resultados e apresenta-os numa janela. O ciclo pode ser encerrado premindo 'q'.

Traçar traços ao longo do tempo

A visualização de trajectos de objectos em fotogramas consecutivos pode fornecer informações valiosas sobre os padrões de movimento e o comportamento dos objectos detectados num vídeo. Com o Ultralytics YOLOv8 , traçar estes trajectos é um processo simples e eficiente.

No exemplo a seguir, demonstramos como utilizar os recursos de rastreamento do YOLOv8 para traçar o movimento de objetos detectados em vários quadros de vídeo. Este script envolve a abertura de um arquivo de vídeo, a leitura quadro a quadro e a utilização do modelo YOLO para identificar e rastrear vários objetos. Mantendo os pontos centrais das caixas delimitadoras detectadas e conectando-os, podemos desenhar linhas que representam os caminhos seguidos pelos objetos rastreados.

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

Rastreio multithreaded

O rastreamento multithread oferece a capacidade de executar o rastreamento de objetos em vários fluxos de vídeo simultaneamente. Isso é particularmente útil ao lidar com várias entradas de vídeo, como de várias câmeras de vigilância, onde o processamento simultâneo pode aumentar muito a eficiência e o desempenho.

No script Python fornecido, utilizamos o Python's threading para executar várias instâncias do rastreador ao mesmo tempo. Cada thread é responsável por executar o rastreador em um arquivo de vídeo, e todos os threads são executados simultaneamente em segundo plano.

Para garantir que cada thread recebe os parâmetros correctos (o ficheiro de vídeo, o modelo a utilizar e o índice do ficheiro), definimos uma função run_tracker_in_thread que aceita esses parâmetros e contém o loop de rastreamento principal. Esta função lê o vídeo quadro a quadro, executa o rastreador e exibe os resultados.

Neste exemplo, são utilizados dois modelos diferentes: yolov8n.pt e yolov8n-seg.ptCada um deles segue os objectos de um ficheiro de vídeo diferente. Os ficheiros de vídeo são especificados em video_file1 e video_file2.

O daemon=True parâmetro em threading.Thread significa que estas threads serão fechadas assim que o programa principal terminar. Em seguida, iniciamos as threads com start() e utiliza join() para que a thread principal espere até que ambas as threads do rastreador tenham terminado.

Finalmente, depois de todas as threads terem concluído a sua tarefa, as janelas que apresentam os resultados são fechadas utilizando 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()

Este exemplo pode ser facilmente alargado para lidar com mais ficheiros e modelos de vídeo, criando mais threads e aplicando a mesma metodologia.

Contribui com novos rastreadores

És especialista em rastreio de múltiplos objectos e implementaste ou adaptaste com sucesso um algoritmo de rastreio com Ultralytics YOLO ? Convidamos-te a contribuir para a nossa secção Trackers em ultralytics/cfg/trackers! As tuas aplicações e soluções do mundo real podem ser valiosas para os utilizadores que trabalham em tarefas de localização.

Ao contribuíres para esta secção, ajudas a expandir o âmbito das soluções de rastreio disponíveis na estrutura Ultralytics YOLO , adicionando outra camada de funcionalidade e utilidade para a comunidade.

Para iniciar a tua contribuição, consulta o nosso Guia de Contribuição para obteres instruções completas sobre como submeter um Pull Request (PR) 🛠️. Estamos entusiasmados por ver o que trazes para a mesa!

Juntos, vamos melhorar as capacidades de rastreio do ecossistema Ultralytics YOLO 🙏!

Comentários