Rastreamento de Múltiplos Objetos com Ultralytics YOLO#

O rastreamento de objetos no domínio da análise de vídeo é uma tarefa crítica que não apenas identifica a localização e a classe dos objetos dentro do quadro, mas também mantém um ID único para cada objeto detectado à medida que o vídeo progride. As aplicações são ilimitadas — variando de vigilância e segurança a análises esportivas em tempo real.

Por que escolher o Ultralytics YOLO para Rastreamento de Objetos?#

A saída dos rastreadores do Ultralytics é consistente com a detecção de objetos padrão, mas traz o valor adicional de IDs de objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Eis por que deves considerar usar o Ultralytics YOLO para as tuas necessidades de rastreamento de objetos:

• Eficiência: Processa fluxos de vídeo em tempo real sem comprometer a precisão.
• Flexibilidade: Suporta múltiplos algoritmos e configurações de rastreamento.
• Facilidade de Uso: API Python simples e opções de CLI para integração e implantação rápidas.
• Customização: Fácil de usar com modelos YOLO treinados de forma personalizada, permitindo a integração em aplicações de domínio específico.

Aplicações do mundo real#

Transporte	Varejo	Aquicultura
Rastreamento de Veículos	Rastreamento de Pessoas	Rastreamento de Peixes

Início Rápido#

Executa o rastreamento em um vídeo com o rastreador BoT-SORT padrão. Muda para outro rastreador alterando o argumento 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")

Para executar o rastreador em fluxos de vídeo, usa um modelo treinado de Detect, Segment, Pose ou OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Podes treinar modelos personalizados localmente ou com o treinamento na nuvem do 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

Rastreadores Suportados#

O Ultralytics YOLO vem com seis rastreadores integrados. Ativa um deles passando o seu arquivo de configuração YAML para o argumento tracker.

Qual Rastreador Devo Usar?#

Use este fluxo para escolher um ponto de partida:

1. Precisa da base mais rápida e simples? → ByteTrack (sem ReID, sem compensação de movimento de câmera, sobrecarga mínima).
2. Filmagem portátil, de drone ou com câmera em movimento? → BoT-SORT (padrão; adiciona compensação de movimento de câmera e ReID opcional).
3. Movimento não linear (esportes, dança, curvas bruscas) e sem ReID? → OC-SORT (correções centradas na observação sem custo de aparência).
4. Cenas movimentadas com câmera em movimento onde as trocas de ID são o problema principal? → Deep OC-SORT ou TrackTrack (ambos adicionam fusão de aparência adaptativa; TrackTrack também adiciona associação de múltiplas pistas e supressão de ID duplicado).
5. Sobreposição parcial frequente em tempo real, sem orçamento de ReID? → FastTracker (variante do ByteTrack consciente de oclusão com reversão Kalman).

Alternando Rastreadores#

Passa o nome do arquivo de configuração do rastreador para tracker=. Todo o restante código permanece igual.

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

Configuração#

Argumentos de Rastreamento#

A configuração de rastreamento partilha propriedades com o modo Predict, tais como conf, iou e show. Para mais configurações, consulta a página do modelo 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)

Configuração de Rastreador Personalizado#

O Ultralytics também permite usar um arquivo de configuração de rastreador modificado. Para isso, basta fazeres uma cópia de um arquivo de configuração de rastreador (por exemplo, custom_tracker.yaml) em ultralytics/cfg/trackers e modificar quaisquer configurações (exceto o 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("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Argumentos Compartilhados do Rastreador#

Os seguintes parâmetros são comuns à maioria dos arquivos YAML de rastreador; nem todo parâmetro aparece em todas as configurações:

Argumentos específicos do rastreador#

Cada algoritmo expõe botões adicionais além dos parâmetros compartilhados. Consulte as seções por rastreador abaixo para obter descrições e dicas de ajuste, ou consulte diretamente os arquivos de configuração:

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

Habilitando a Reidentificação (ReID)#

O ReID é desativado por padrão para minimizar a sobrecarga. Ativa-o definindo with_reid: True em um arquivo de configuração do rastreador.

Opções de modelo de ReID:

• model: auto — Usa recursos nativos do detector YOLO, adicionando sobrecarga mínima. Ideal quando precisas de algum ReID sem um grande impacto no desempenho. Recorre a yolo26n-cls.pt se o detector não expuser recursos compatíveis.
• Modelo ReID exportado — Aponta model: para um arquivo exportado (.torchscript, .onnx, .engine, .openvino, etc.) para obter embeddings mais discriminativos ao custo de uma passada para a frente (forward pass) extra por recorte. O codificador é carregado via AutoBackend, de modo que qualquer formato de exportação compatível com o Ultralytics funciona sem alterações de código.

Codificadores ONNX prontos a usar são publicados para cada tamanho de modelo. Define model: para um destes nomes e o arquivo é baixado automaticamente na primeira vez que o rastreador é executado (da mesma forma que os pesos do YOLO são obtidos) — sem necessidade de etapas manuais de exportação ou 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

Para um melhor desempenho com um modelo de classificação separado, exporte-o para um backend mais rápido como o 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)

Uma vez exportado, aponte para o caminho do modelo TensorRT na sua configuração de rastreador.

Detalhes do rastreador#

Expanda as seções abaixo para ver o design, os parâmetros específicos e as dicas de ajuste de cada rastreador.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) é o rastreador padrão. Ele estende o ByteTrack com compensação de movimento de câmara e ReID opcional:

• Compensação de Movimento da Câmera (CMC): uma transformação afim estimada a cada quadro (fluxo óptico esparso por padrão; ORB / ECC também estão disponíveis) é aplicada aos estados de Kalman antes da correspondência de IoU.
• ReID Opcional: os embeddings de aparência podem ser fundidos na matriz de custos. Desativado por padrão; ativa com with_reid: True.

Melhor para: rastreamento de propósito geral, especialmente com câmeras em movimento. Adicione ReID apenas quando multidões semelhantes causarem trocas de ID.

Argumentos específicos do BoT-SORT:

Dicas de ajuste:

• Câmara estática: define gmc_method: none para poupar alguns ms/quadro.
• Movimento intenso da câmara: mantém sparseOptFlow; ecc é mais preciso, mas mais lento.
• Multidões semelhantes: ativa with_reid: True e aumenta appearance_thresh (por exemplo, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) é a linha de base leve. Ele usa Kalman linear + IoU com uma associação em duas etapas:

• Estágio 1: faz a correspondência de detecções de alta pontuação com trilhas ativas.
• Estágio 2: tenta novamente a correspondência de trilhas não correspondidas com detecções de baixa pontuação para recuperar através de uma breve oclusão parcial.

Não há modelo de aparência nem compensação de movimento da câmera.

Melhor para: câmeras estáticas ou quase estáticas onde o custo do detector domina e você deseja o mínimo de sobrecarga de rastreador.

Argumentos específicos do ByteTrack: Nenhum além dos argumentos de rastreador partilhados.

Dicas de ajuste:

• Detector ruidoso: reduz track_low_thresh para que a segunda etapa tenha mais candidatos.
• Detector de alta recuperação (high-recall): aumenta track_high_thresh para reduzir IDs fragmentados.
• Frequente oscilação de ID: aumenta track_buffer para que os rastreamentos perdidos brevemente sobrevivam.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) é uma extensão centrada na observação do SORT. Mantém o design leve do SORT (sem recursos de aparência) e adiciona três correções:

• Reatualização Centrada na Observação (ORU): reproduz uma trajetória virtual entre a última observação e a detecção atual, executando novamente a atualização de Kalman para reparar a velocidade com desvio.
• Momento Centrado na Observação (OCM): penaliza detecções que se movem na direção errada através de um termo de consistência de velocidade.
• Recuperação Centrada na Observação (OCR): verifica novamente detecções não correspondidas contra trilhas perdidas recentemente usando sua última observação em vez do estado previsto.

Melhor para: movimento não linear sem o custo de um modelo de ReID.

Argumentos específicos do OC-SORT:

Dicas de ajuste:

• Movimento não linear: aumenta inertia (por exemplo, 0.3-0.4).
• Detecções esparsas: ativa use_byte: True.
• Oclusões longas: aumenta track_buffer para que o OCR tenha mais rastreamentos perdidos para reassociar.

Deep OC-SORT#

Deep OC-SORT complementa o OC-SORT com informações de aparência e compensação de movimento de câmara:

• Fusão adaptativa de aparência: embeddings de detecção são fundidos na matriz de custo com peso modulado pela confiança da detecção e sobreposição.
• EMA de aparência dinâmica: embeddings de trilha são atualizados com um EMA cujo fator de suavização se adapta à confiança da detecção.
• Compensação de Movimento da Câmera: estados de Kalman são deformados quadro a quadro via fluxo óptico esparso, ORB ou ECC.

Melhor para: cenas lotadas ou com câmera em movimento onde trocas de ID entre objetos visualmente diferentes mas espacialmente próximos são comuns.

Argumentos específicos do Deep OC-SORT:

Dicas de ajuste:

• Trocas de identidade em multidões: aumenta appearance_thresh (por exemplo, 0.92-0.95) e reduz alpha_fixed_emb para que os embeddings se adaptem mais lentamente.
• Câmara em movimento: define gmc_method: sparseOptFlow (o Deep OC-SORT assume none por padrão).
• Menor latência: mantém with_reid: False (padrão) apenas para movimento + CMC; ativa o ReID apenas quando as trocas de ID dominam os erros.

FastTracker#

FastTracker é uma variante do ByteTrack ciente de oclusão, sem modelo de aparência:

• Detecção de oclusão: sinaliza rastreamentos como ocluídos quando a cobertura por outros rastreamentos ativos excede occ_cover_thresh.
• Rollback de Kalman na oclusão: reverte o estado de Kalman para um quadro pré-oclusão usando histórico de buffer circular.
• Amortecimento de movimento e expansão de busca: a velocidade é amortecida e a bbox prevista é ampliada enquanto ocluída.
• Supressão de Init-IoU: evita que novas trilhas surjam sobre trilhas ativas.

Melhor para: pipelines de detecção em tempo real com sobreposição frequente de alvo-em-alvo (multidões, filas, esportes).

Argumentos específicos do FastTracker:

Dicas de ajuste:

• Oclusões parciais frequentes: reduz occ_cover_thresh (por exemplo, 0.5-0.6).
• IDs duplicados em torno de sobreposições: reduz init_iou_suppress (por exemplo, 0.5).
• Oclusões longas: aumenta occ_reappear_window e track_buffer em conjunto.
• Alvos de movimento rápido: aumenta dampen_motion_occ (mais perto de 1.0) e reduz enlarge_bbox_occ.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) raciocina a partir da perspectiva de cada rastreamento com associação iterativa de múltiplos indícios (multi-cue):

• Associação baseada na perspectiva do rastreamento (TPA): combina HMIoU, distância de ReID de cosseno, distância de projeção de confiança e distância de ângulo de canto. A atribuição é resolvida iterativamente com um limite de relaxamento.
• Inicialização com reconhecimento de rastreamento (TAI): suprime gerações duplicadas antes que um novo ID seja criado.

Melhor para: cenas lotadas com oclusão frequente onde IDs duplicados são um problema.

Argumentos específicos do TrackTrack:

Dicas de ajuste:

• Pedestres aglomerados: reduz tai_thr (por exemplo, 0.45) para suprimir mais gerações duplicadas; aumenta track_buffer para oclusões mais longas.
• Movimento rápido da câmara: mantém gmc_method: sparseOptFlow ativado.
• Objetos pequenos/rápidos: aumenta ligeiramente angle_weight e reduz min_track_len.
• Ative o ReID apenas quando necessário: ele aumenta o custo de inferência; para oclusões curtas, o custo multicanal padrão geralmente é suficiente.

Exemplos em Python#

Loop de persistência de rastreamentos#

Aqui está um script em Python que usa o OpenCV (cv2) e o YOLO26 para executar o rastreamento de objetos em quadros de vídeo. Este script assume que os pacotes necessários (opencv-python e ultralytics) já estão instalados. O argumento persist=True diz ao rastreador que a imagem ou quadro atual é o seguinte em uma sequência e para esperar rastreamentos da imagem anterior na imagem atual.

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

Observa a mudança de model(frame) para model.track(frame), que ativa o rastreamento de objetos em vez de uma simples detecção. Este script modificado executará o rastreador em cada quadro do vídeo, visualizará os resultados e os exibirá em uma janela. O loop pode ser fechado pressionando 'q'.

Plotando rastreamentos ao longo do tempo#

Visualizar rastreamentos de objetos ao longo de quadros consecutivos pode fornecer insights valiosos sobre os padrões de movimento e o comportamento dos objetos detectados dentro de um vídeo. Com o Ultralytics YOLO26, plotar esses rastreamentos é um processo contínuo e eficiente.

No exemplo a seguir, demonstramos como utilizar os recursos de rastreamento do YOLO26 para plotar o movimento de objetos detectados em vários quadros de vídeo. Este script envolve abrir um arquivo de vídeo, lê-lo quadro a quadro e utilizar o modelo YOLO para identificar e rastrear vários objetos. Ao reter os pontos centrais das caixas delimitadoras detectadas e conectá-los, 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 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()

Rastreamento multithread#

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 múltiplas entradas de vídeo, como de várias câmeras de vigilância, onde o processamento simultâneo pode melhorar muito a eficiência e o desempenho.

No script Python fornecido, utilizamos o módulo threading do Python para executar várias instâncias do rastreador simultaneamente. Cada thread é responsável por executar o rastreador em um arquivo de vídeo, e todas as threads são executadas em simultâneo em segundo plano.

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

Dois modelos diferentes são usados neste exemplo: yolo26n.pt e yolo26n-seg.pt, cada um rastreando objetos em um arquivo de vídeo diferente. Os arquivos de vídeo são especificados em SOURCES.

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

Finalmente, após todas as threads concluírem a sua tarefa, as janelas que exibem os resultados são fechadas 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()

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

Contribua com novos rastreadores#

Tens experiência em rastreamento de múltiplos objetos e implementaste ou adaptaste com sucesso um algoritmo de rastreamento com o Ultralytics YOLO? Convidamos-te a contribuir para a nossa seção Trackers em ultralytics/cfg/trackers! As tuas aplicações e soluções do mundo real podem ser inestimáveis para utilizadores que trabalham em tarefas de rastreamento.

Ao contribuir para esta seção, você ajuda a expandir o escopo de soluções de rastreamento disponíveis na estrutura do 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 obter instruções abrangentes sobre como enviar um Pull Request (PR) 🛠️. Estamos entusiasmados para ver o que tens para oferecer!

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

FAQ#

O que é rastreamento de múltiplos objetos e como o Ultralytics YOLO o suporta?#

O rastreamento de múltiplos objetos em análise de vídeo envolve tanto a identificação de objetos quanto a manutenção de um ID exclusivo para cada objeto detectado ao longo dos quadros de vídeo. O Ultralytics YOLO suporta isto fornecendo rastreamento em tempo real juntamente com IDs de objetos, facilitando tarefas como vigilância de segurança e análise desportiva. O sistema usa rastreadores como BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack, que podem ser configurados através de arquivos YAML.

Posso armazenar o rastreador dentro de um arquivo de modelo YOLO?#

Não. Os arquivos padrão .pt do Ultralytics armazenam os pesos do modelo YOLO, enquanto o rastreador é criado no momento da inferência por model.track(). Os IDs de rastreamento dependem do estado do rastreador em quadros consecutivos, de modo que uma única imagem isolada pode retornar detecções como caixas, classes e confianças, mas não consegue produzir IDs de rastreamento persistentes e significativos por si só.

Para a implantação, empacota o detector e o rastreador juntos na tua aplicação e chama model.track() quadro a quadro com persist=True quando os quadros vierem do mesmo fluxo de vídeo. Usa instâncias separadas de modelo ou rastreador para fluxos não relacionados, para que o estado não seja propagado entre vídeos.

Como configuro um rastreador personalizado para o Ultralytics YOLO?#

Podes configurar um rastreador personalizado copiando um arquivo de configuração de rastreador existente (por exemplo, custom_tracker.yaml) do diretório de configuração de rastreadores do Ultralytics e modificando os parâmetros conforme necessário, exceto o tracker_type. Usa este arquivo no teu modelo de rastreamento da seguinte forma:

from ultralytics import YOLO

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

Como posso executar o rastreamento de objetos em vários fluxos de vídeo simultaneamente?#

Para executar o rastreamento de objetos em múltiplos fluxos de vídeo simultaneamente, podes usar o módulo threading do Python. Cada thread lidará com um fluxo de vídeo separado. Aqui está um exemplo de como podes configurar isto:

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

Quais são as aplicações do mundo real do rastreamento de múltiplos objetos com o Ultralytics YOLO?#

O rastreamento de múltiplos objetos com o Ultralytics YOLO tem inúmeras aplicações, incluindo:

• Transportes: Rastreamento de veículos para gestão de tráfego e condução autônoma.
• Varejo: Rastreamento de pessoas para análises em loja e segurança.
• Aquicultura: Rastreamento de peixes para monitoramento de ambientes aquáticos.
• Análise Esportiva: Rastreamento de jogadores e equipamentos para análise de desempenho.
• Sistemas de Segurança: Monitorização de atividades suspeitas e criação de alarmes de segurança.

Essas aplicações se beneficiam da capacidade do Ultralytics YOLO de processar vídeos com alta taxa de quadros em tempo real com precisão excepcional.

Como posso visualizar rastreamentos de objetos em vários quadros de vídeo com o Ultralytics YOLO?#

Para visualizar rastreamentos de objetos em vários quadros de vídeo, você pode usar os recursos de rastreamento do modelo YOLO junto com o OpenCV para desenhar os caminhos dos objetos detectados. Aqui está um exemplo de script que demonstra isso:

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

Este script plotará as linhas de rastreamento mostrando os caminhos de movimento dos objetos rastreados ao longo do tempo, fornecendo insights valiosos sobre o comportamento e padrões dos objetos.