Seguimiento multiobjeto con Ultralytics YOLO#

El seguimiento de objetos en el ámbito de la analítica de vídeo es una tarea crítica que no solo identifica la ubicación y la clase de los objetos dentro del fotograma, sino que también mantiene un ID único para cada objeto detectado a medida que avanza el vídeo. Las aplicaciones son ilimitadas, desde vigilancia y seguridad hasta analítica deportiva en tiempo real.

¿Por qué elegir Ultralytics YOLO para el seguimiento de objetos?#

El resultado de los rastreadores de Ultralytics es coherente con la detección de objetos estándar, pero aporta el valor añadido de los ID de objetos. Esto facilita el seguimiento de objetos en transmisiones de vídeo y la realización de análisis posteriores. He aquí por qué deberías considerar usar Ultralytics YOLO para tus necesidades de seguimiento de objetos:

• Eficiencia: Procesa flujos de vídeo en tiempo real sin comprometer la precisión.
• Flexibilidad: Admite múltiples algoritmos y configuraciones de seguimiento.
• Facilidad de uso: API de Python y opciones de CLI sencillas para una integración y despliegue rápidos.
• Personalización: Fácil de usar con modelos YOLO personalizados, lo que permite la integración en aplicaciones específicas de cada dominio.

Aplicaciones en el mundo real#

Transporte	Comercio minorista	Acuicultura
Seguimiento de vehículos	Seguimiento de personas	Seguimiento de peces

Inicio rápido#

Ejecuta el seguimiento en un vídeo con el rastreador BoT-SORT predeterminado. Cambia a otro rastreador modificando el 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 ejecutar el rastreador en secuencias de vídeo, utiliza un modelo entrenado de tipo Detect, Segment, Pose u OBB como YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puedes entrenar modelos personalizados localmente o con el entrenamiento en la nube de 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 compatibles#

Ultralytics YOLO incluye seis rastreadores integrados. Activa uno pasando su archivo de configuración YAML al argumento tracker.

¿Qué rastreador debería usar?#

Utiliza este flujo para elegir un punto de partida:

1. ¿Necesitas la base más rápida y sencilla? → ByteTrack (sin ReID, sin compensación de movimiento de cámara, sobrecarga mínima).
2. ¿Tomas manuales, con drones o con cámara en movimiento? → BoT-SORT (predeterminado; añade compensación de movimiento de cámara y ReID opcional).
3. ¿Movimiento no lineal (deportes, baile, giros bruscos) y sin ReID? → OC-SORT (correcciones centradas en la observación sin coste de apariencia).
4. ¿Escenas concurridas con cámara en movimiento donde los intercambios de ID son el problema principal? → Deep OC-SORT o TrackTrack (ambos añaden fusión de apariencia adaptativa; TrackTrack también añade asociación multi-cue y supresión de ID duplicados).
5. ¿Solapamiento parcial frecuente en tiempo real, sin presupuesto para ReID? → FastTracker (variante de ByteTrack sensible a la oclusión con reversión de Kalman).

Cambio de rastreadores#

Pasa el nombre del archivo de configuración del rastreador a tracker=. Todo el demás 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")

Configuración#

Argumentos de seguimiento#

La configuración del seguimiento comparte propiedades con el modo Predict, tales como conf, iou y show. Para configuraciones adicionales, consulta la página del 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)

Configuración de rastreador personalizado#

Ultralytics también te permite utilizar un archivo de configuración de rastreador modificado. Para ello, simplemente haz una copia de un archivo de configuración de rastreador (por ejemplo, custom_tracker.yaml) desde ultralytics/cfg/trackers y modifica las configuraciones (excepto tracker_type) según tus necesidades.

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 de rastreador compartidos#

Los siguientes parámetros son comunes a la mayoría de los archivos YAML de rastreadores; no todos los parámetros aparecen en cada configuración:

Argumentos específicos del tracker#

Cada algoritmo expone parámetros adicionales además de los compartidos. Consulta las secciones de cada tracker a continuación para obtener descripciones y consejos de ajuste, o dirígete directamente a los archivos de configuración:

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

Habilitación de la Re-Identificación (ReID)#

ReID está desactivado por defecto para minimizar la sobrecarga. Habilítalo configurando with_reid: True en un archivo de configuración del rastreador.

Opciones de modelo ReID:

• model: auto — Utiliza las características nativas del detector YOLO, añadiendo una sobrecarga mínima. Es ideal cuando necesitas algo de ReID sin un impacto grande en el rendimiento. Vuelve a yolo26n-cls.pt si el detector no expone características compatibles.
• Modelo ReID exportado — Apunta model: a un archivo exportado (.torchscript, .onnx, .engine, .openvino, etc.) para obtener incrustaciones más discriminativas a costa de una pasada de avance adicional por recorte. El codificador se carga mediante AutoBackend, por lo que cualquier formato de exportación compatible con Ultralytics funciona sin cambios en el código.

Se publican codificadores ONNX listos para usar para cada tamaño de modelo. Establece model: en uno de estos nombres y el archivo se descargará automáticamente la primera vez que se ejecute el rastreador (del mismo modo que se obtienen los pesos de YOLO); no se requiere ningún paso manual de exportación o descarga:

# 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 un mejor rendimiento con un modelo de clasificación independiente, expórtalo a un backend más rápido como 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 vez exportado, señala la ruta del modelo TensorRT en tu configuración de tracker.

Detalles del tracker#

Expande las secciones a continuación para ver el diseño, los parámetros específicos y los consejos de ajuste de cada tracker.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) es el rastreador predeterminado. Amplía ByteTrack con compensación de movimiento de cámara y ReID opcional:

• Compensación de movimiento de cámara (CMC): se aplica una deformación afín estimada en cada fotograma (flujo óptico disperso por defecto; ORB / ECC también disponibles) a los estados de Kalman antes de la coincidencia por IoU.
• ReID opcional: las incrustaciones de apariencia se pueden fusionar en la matriz de costes. Desactivado por defecto; actívalo con with_reid: True.

Ideal para: seguimiento de propósito general, especialmente con cámaras en movimiento. Añade ReID solo cuando multitudes que se parecen causen intercambios de ID.

Argumentos específicos de BoT-SORT:

Consejos de ajuste:

• Cámara estática: configura gmc_method: none para ahorrar unos pocos ms/fotograma.
• Movimiento de cámara intenso: mantén sparseOptFlow; ecc es más preciso pero más lento.
• Multitudes con aspecto similar: activa with_reid: True y aumenta appearance_thresh (p. ej., 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) es la línea base ligera. Utiliza Kalman lineal + IoU con una asociación de dos etapas:

• Etapa 1: empareja detecciones de alta puntuación con tracks activos.
• Etapa 2: reintenta tracks no emparejados con detecciones de baja puntuación para recuperar a través de una breve oclusión parcial.

No hay modelo de apariencia ni compensación de movimiento de cámara.

Ideal para: cámaras estáticas o casi estáticas donde el coste del detector domina y quieres un impacto mínimo del tracker.

Argumentos específicos de ByteTrack: Ninguno más allá de los argumentos compartidos del rastreador.

Consejos de ajuste:

• Detector ruidoso: reduce track_low_thresh para que la segunda etapa tenga más candidatos.
• Detector de alta recuperación: aumenta track_high_thresh para reducir los ID fragmentados.
• Parpadeo frecuente de ID: aumenta track_buffer para que los seguimientos perdidos brevemente sobrevivan.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) es una extensión centrada en la observación de SORT. Mantiene el diseño ligero de SORT (sin características de apariencia) y añade tres correcciones:

• Re-actualización centrada en la observación (ORU): reproduce una trayectoria virtual entre la última observación y la detección actual, ejecutando de nuevo la actualización de Kalman para reparar la velocidad desviada.
• Momento centrado en la observación (OCM): penaliza las detecciones que se mueven en la dirección incorrecta mediante un término de consistencia de velocidad.
• Recuperación centrada en la observación (OCR): verifica de nuevo las detecciones no emparejadas con tracks perdidos recientemente usando su última observación en lugar del estado predicho.

Ideal para: movimiento no lineal sin el coste de un modelo ReID.

Argumentos específicos de OC-SORT:

Consejos de ajuste:

• Movimiento no lineal: aumenta inertia (p. ej., 0.3-0.4).
• Detecciones dispersas: habilita use_byte: True.
• Oclusiones largas: aumenta track_buffer para que OCR tenga más seguimientos perdidos que reasignar.

Deep OC-SORT#

Deep OC-SORT amplía OC-SORT con información de apariencia y compensación de movimiento de cámara:

• Fusión adaptativa de apariencia: los embeddings de detección se fusionan en la matriz de costes con un peso modulado por la confianza de la detección y el solapamiento.
• EMA de apariencia dinámica: los embeddings del track se actualizan con una EMA cuyo factor de suavizado se adapta a la confianza de la detección.
• Compensación de movimiento de cámara: los estados de Kalman se deforman de fotograma a fotograma mediante flujo óptico disperso, ORB o ECC.

Ideal para: escenas concurridas o con cámara en movimiento donde los intercambios de ID entre objetos visualmente diferentes pero espacialmente cercanos son comunes.

Argumentos específicos de Deep OC-SORT:

Consejos de ajuste:

• Intercambios de identidad en multitudes: aumenta appearance_thresh (p. ej., 0.92-0.95) y disminuye alpha_fixed_emb para que las incrustaciones se adapten más lentamente.
• Cámara en movimiento: configura gmc_method: sparseOptFlow (Deep OC-SORT usa por defecto none).
• Menor latencia: mantén with_reid: False (predeterminado) solo para movimiento + CMC; habilita ReID solo cuando los intercambios de ID dominen los errores.

FastTracker#

FastTracker es una variante de ByteTrack consciente de la oclusión sin modelo de apariencia:

• Detección de oclusión: marca los seguimientos como ocluidos cuando la cobertura por otros seguimientos activos supera occ_cover_thresh.
• Reversión de Kalman en oclusión: revierte el estado de Kalman a un fotograma previo a la oclusión usando un historial en búfer circular.
• Amortiguación de movimiento y expansión de búsqueda: la velocidad se amortigua y el bbox predicho se agranda mientras está ocluido.
• Supresión de Init-IoU: evita que se generen nuevos tracks sobre tracks activos.

Ideal para: pipelines en tiempo real solo de detección con frecuentes solapamientos entre objetivos (multitudes, colas, deportes).

Argumentos específicos de FastTracker:

Consejos de ajuste:

• Oclusiones parciales frecuentes: reduce occ_cover_thresh (p. ej., 0.5-0.6).
• ID duplicados alrededor del solapamiento: reduce init_iou_suppress (p. ej., 0.5).
• Oclusiones largas: aumenta occ_reappear_window y track_buffer conjuntamente.
• Objetivos de rápido movimiento: aumenta dampen_motion_occ (más cerca de 1.0) y reduce enlarge_bbox_occ.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) razona desde la perspectiva de cada seguimiento con asociación iterativa multi-señal:

• Asociación basada en la perspectiva de la trayectoria (TPA): combina HMIoU, distancia de ReID de coseno, distancia de proyección de confianza y distancia de ángulo de esquina. La asignación se resuelve de forma iterativa con un umbral de relajación.
• Inicialización consciente de la trayectoria (TAI): suprime la creación de duplicados antes de generar un nuevo ID.

Ideal para: escenas concurridas con oclusiones frecuentes donde los IDs duplicados suponen un problema.

Argumentos específicos de TrackTrack:

Consejos de ajuste:

• Peatones aglomerados: reduce tai_thr (p. ej., 0.45) para suprimir más desoves duplicados; aumenta track_buffer para oclusiones más largas.
• Movimiento rápido de la cámara: mantén gmc_method: sparseOptFlow habilitado.
• Objetivos pequeños/rápidos: aumenta ligeramente angle_weight y reduce min_track_len.
• Activa ReID solo cuando sea necesario: añade coste de inferencia; para oclusiones cortas, el coste multi-pista por defecto suele ser suficiente.

Ejemplos en Python#

Bucle de persistencia de trayectorias#

Aquí tienes un script de Python que utiliza OpenCV (cv2) y YOLO26 para realizar el seguimiento de objetos en fotogramas de vídeo. Este script asume que los paquetes necesarios (opencv-python y ultralytics) ya están instalados. El argumento persist=True le indica al rastreador que la imagen o fotograma actual es el siguiente en una secuencia y que debe esperar los seguimientos de la imagen anterior en la imagen actual.

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 el cambio de model(frame) a model.track(frame), que habilita el seguimiento de objetos en lugar de una simple detección. Este script modificado ejecutará el rastreador en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. Se puede salir del bucle pulsando 'q'.

Representación gráfica de trayectorias a lo largo del tiempo#

Visualizar las trayectorias de los objetos a lo largo de fotogramas consecutivos puede aportar información valiosa sobre los patrones de movimiento y el comportamiento de los objetos detectados en un vídeo. Con Ultralytics YOLO26, trazar estas trayectorias es un proceso fluido y eficiente.

En el siguiente ejemplo, demostramos cómo utilizar las capacidades de seguimiento de YOLO26 para representar el movimiento de los objetos detectados a través de múltiples fotogramas de vídeo. Este script implica abrir un archivo de vídeo, leerlo fotograma a fotograma y utilizar el modelo YOLO para identificar y rastrear varios objetos. Al conservar los puntos centrales de los cuadros delimitadores detectados y unirlos, podemos dibujar líneas que representen las rutas seguidas por los 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()

Seguimiento multihilo#

El seguimiento multihilo ofrece la capacidad de ejecutar el seguimiento de objetos en múltiples flujos de vídeo de forma simultánea. Esto es especialmente útil al gestionar múltiples entradas de vídeo, como desde cámaras de vigilancia, donde el procesamiento concurrente puede mejorar enormemente la eficiencia y el rendimiento.

En el script de Python proporcionado, utilizamos el módulo threading de Python para ejecutar múltiples instancias del rastreador simultáneamente. Cada hilo se encarga de ejecutar el rastreador en un archivo de vídeo, y todos los hilos se ejecutan simultáneamente en segundo plano.

Para garantizar que cada hilo reciba los parámetros correctos (el archivo de vídeo, el modelo que se va a usar y el índice de archivo), definimos una función run_tracker_in_thread que acepta estos parámetros y contiene el bucle principal de seguimiento. Esta función lee el vídeo fotograma a fotograma, ejecuta el rastreador y muestra los resultados.

En este ejemplo se utilizan dos modelos diferentes: yolo26n.pt y yolo26n-seg.pt, cada uno de los cuales rastrea objetos en un archivo de vídeo distinto. Los archivos de vídeo se especifican en SOURCES.

El parámetro daemon=True en threading.Thread significa que estos hilos se cerrarán en cuanto termine el programa principal. A continuación, iniciamos los hilos con start() y usamos join() para hacer que el hilo principal espere hasta que ambos hilos del rastreador hayan terminado.

Finalmente, una vez que todos los hilos han completado su tarea, las ventanas que muestran los resultados se cierran utilizando 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 ejemplo se puede ampliar fácilmente para manejar más archivos de vídeo y modelos creando más hilos y aplicando la misma metodología.

Contribuye con nuevos rastreadores#

¿Tienes experiencia en el seguimiento de múltiples objetos y has implementado o adaptado con éxito un algoritmo de seguimiento con Ultralytics YOLO? ¡Te invitamos a contribuir en nuestra sección de rastreadores en ultralytics/cfg/trackers! Tus aplicaciones y soluciones del mundo real pueden ser de un valor incalculable para los usuarios que trabajan en tareas de seguimiento.

Al contribuir a esta sección, ayudas a ampliar el alcance de las soluciones de seguimiento disponibles dentro del framework Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad.

Para iniciar tu contribución, consulta nuestra Guía de contribución para obtener instrucciones detalladas sobre cómo enviar una solicitud de extracción (PR) 🛠️. ¡Estamos deseando ver qué puedes aportar!

¡Juntos, mejoremos las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏!

FAQ#

¿Qué es el seguimiento multiobjeto y cómo lo soporta Ultralytics YOLO?#

El seguimiento de múltiples objetos en analítica de vídeo implica tanto identificar objetos como mantener un ID único para cada objeto detectado a lo largo de los fotogramas del vídeo. Ultralytics YOLO lo admite proporcionando seguimiento en tiempo real junto con ID de objetos, lo que facilita tareas como la videovigilancia de seguridad y la analítica deportiva. El sistema utiliza rastreadores como BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker y TrackTrack, que se pueden configurar mediante archivos YAML.

¿Puedo guardar el rastreador dentro de un archivo de modelo YOLO?#

No. Los archivos estándar .pt de Ultralytics almacenan los pesos del modelo YOLO, mientras que el rastreador se crea en el momento de la inferencia mediante model.track(). Los ID de seguimiento dependen del estado del rastreador en fotogramas consecutivos, por lo que una sola imagen independiente puede devolver detecciones como cajas, clases y confidences, pero por sí sola no puede producir ID de seguimiento persistentes significativos.

Para el despliegue, empaqueta el detector y el rastreador juntos en tu aplicación y llama a model.track() fotograma a fotograma con persist=True cuando los fotogramas provengan de la misma secuencia de vídeo. Utiliza instancias independientes del modelo o del rastreador para secuencias no relacionadas para que el estado no se arrastre entre vídeos.

¿Cómo configuro un rastreador personalizado para Ultralytics YOLO?#

Puedes configurar un rastreador personalizado copiando un archivo de configuración de rastreador existente (p. ej., custom_tracker.yaml) desde el directorio de configuración de rastreadores de Ultralytics y modificando los parámetros según sea necesario, excepto tracker_type. Utiliza este archivo en tu modelo de seguimiento de la siguiente manera:

from ultralytics import YOLO

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

¿Cómo puedo realizar el seguimiento de objetos en múltiples flujos de vídeo simultáneamente?#

Para ejecutar el seguimiento de objetos en múltiples transmisiones de vídeo simultáneamente, puedes utilizar el módulo threading de Python. Cada hilo manejará una transmisión de vídeo independiente. He aquí un ejemplo de cómo puedes 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()

¿Cuáles son las aplicaciones reales del seguimiento multiobjeto con Ultralytics YOLO?#

El seguimiento multiobjeto con Ultralytics YOLO tiene numerosas aplicaciones, incluyendo:

• Transporte: Seguimiento de vehículos para la gestión del tráfico y la conducción autónoma.
• Retail: seguimiento de personas para analítica en tienda y seguridad.
• Acuicultura: seguimiento de peces para el monitoreo de entornos acuáticos.
• Análisis deportivo: seguimiento de jugadores y equipamiento para análisis de rendimiento.
• Sistemas de seguridad: Monitoreo de actividades sospechosas y creación de alarmas de seguridad.

Estas aplicaciones se benefician de la capacidad de Ultralytics YOLO para procesar vídeos con alta tasa de fotogramas en tiempo real y con una precisión excepcional.

¿Cómo puedo visualizar las trayectorias de los objetos a lo largo de múltiples fotogramas de vídeo con Ultralytics YOLO?#

Para visualizar las trayectorias de los objetos a lo largo de varios fotogramas de vídeo, puedes usar las funciones de seguimiento del modelo YOLO junto con OpenCV para dibujar las rutas de los objetos detectados. Aquí tienes un script de ejemplo que lo demuestra:

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 trazará las líneas de seguimiento mostrando las rutas de movimiento de los objetos rastreados a lo largo del tiempo, proporcionando información valiosa sobre el comportamiento y los patrones de los objetos.