Empezar

Cálculo de distancias con Ultralytics YOLO26

¿Qué es el cálculo de distancias?#

El cálculo de distancias consiste en medir el espacio entre dos objetos detectados dentro de una imagen o un fotograma de vídeo. Con Ultralytics YOLO26, la solución mide la distancia entre los centroides de dos cuadros delimitadores seleccionados por el usuario.



Ver: Cómo calcular en píxeles la distancia entre objetos detectados con Ultralytics YOLO 🚀

Elementos visuales#

Cálculo de distancias con Ultralytics YOLO26
Cálculo de distancias con Ultralytics YOLO26

Ventajas del cálculo de distancias#

  • Precisión de localización: Mejora la precisión del posicionamiento espacial en tareas de visión artificial.
  • Estimación del tamaño: Permite estimar el tamaño de los objetos para comprender mejor el contexto.
  • Comprensión de la escena: Mejora la comprensión de escenas 3D para tomar mejores decisiones en aplicaciones como los vehículos autónomos y los sistemas de vigilancia.
  • Prevención de colisiones: Permite a los sistemas detectar posibles colisiones mediante la supervisión de las distancias entre objetos en movimiento.
  • Análisis espacial: Facilita el análisis de las relaciones e interacciones entre objetos en el entorno supervisado.
Cálculo de distancias
  • Haz clic con el botón izquierdo del ratón en dos cajas delimitadoras cualesquiera para calcular la distancia.
  • Haz clic con el botón derecho del ratón para eliminar todos los puntos dibujados.
La distancia es una estimación

La distancia es una estimación y puede no ser del todo precisa, ya que se calcula con datos 2D, que no contienen información de profundidad. Para obtener la profundidad de cada píxel, utiliza un modelo de estimación de profundidad.

Calcula distancias con YOLO26#

La solución DistanceCalculation sigue objetos a lo largo de los fotogramas y mide en píxeles la distancia euclídea entre los centroides de dos cajas delimitadoras cualesquiera que selecciones con el ratón. Ejecuta el ejemplo siguiente y, a continuación, haz clic con el botón izquierdo en dos objetos para dibujar la línea que los une y ver la distancia; haz clic con el botón derecho para borrar la selección.

Cálculo de distancias con Ultralytics YOLO
import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"

# Escritor de vídeo
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
video_writer = cv2.VideoWriter("distance_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Inicializa el objeto de cálculo de distancias
distancecalculator = solutions.DistanceCalculation(
    model="yolo26n.pt",  # ruta al archivo del modelo YOLO26.
    show=True,  # mostrar el resultado
)

# Procesar el vídeo
while cap.isOpened():
    success, im0 = cap.read()

    if not success:
        print("Video frame is empty or processing is complete.")
        break

    results = distancecalculator(im0)

    print(results)  # accede a la salida

    video_writer.write(results.plot_im)  # escribe el fotograma procesado.

cap.release()
video_writer.release()
cv2.destroyAllWindows()  # cerrar todas las ventanas abiertas

Argumentos de DistanceCalculation()#

Aquí tienes una tabla con los argumentos de DistanceCalculation:

ArgumentoTipoPredeterminadoDescripción
modelstrNoneRuta a un archivo de modelo Ultralytics YOLO.
line_widthint2Grosor de línea de los cuadros, puntos clave y recuentos que dibuja la solución.
verboseboolTrueActiva el registro por fotograma de la forma de entrada, los recuentos por clase y la velocidad de procesamiento de la solución. La llamada de seguimiento en sí siempre es silenciosa.

También puedes utilizar los argumentos track en la solución DistanceCalculation.

ArgumentoTipoPredeterminadoDescripción
trackerstr'tracktrack.yaml'Especifica el algoritmo de seguimiento que se va a usar. Opciones integradas: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml.
conffloat0.25Establece el umbral de confianza de las detecciones; los valores más bajos permiten seguir más objetos, pero pueden incluir falsos positivos.
ioufloat0.5Establece el umbral de intersección sobre unión (IoU) para filtrar las detecciones solapadas.
classeslistNoneFiltra los resultados por índice de clase. Por ejemplo, classes=[0, 2, 3] solo sigue las clases especificadas.
devicestrNoneEspecifica el dispositivo para la inferencia (p. ej., cpu, cuda:0 o 0). Permite elegir entre CPU, una GPU concreta u otros dispositivos de cálculo para ejecutar el modelo.
imgszint or tuple640Tamaño de imagen de destino para la inferencia: un entero para una imagen cuadrada o una pareja (height, width). Las dimensiones se ajustan al stride del modelo.
max_detint300Número máximo de detecciones que se conservan por fotograma antes del seguimiento, lo que limita los objetos que procesa una solución en escenas densas.
quantizeint or strNonePrecisión de inferencia: 16 (FP16) o 32/unset (FP32) para los modelos PyTorch y TorchScript fuera de CPU; los demás formatos usan la precisión que seleccionen el artefacto y el entorno de ejecución. Sustituye al argumento obsoleto half.

Además, están disponibles los siguientes argumentos de visualización:

ArgumentoTipoPredeterminadoDescripción
showboolFalseSi True, muestra las imágenes o los vídeos anotados en una ventana. Es útil para obtener información visual inmediata durante el desarrollo o las pruebas.
show_confboolTrueMuestra la puntuación de confianza de cada detección junto a su etiqueta. Permite conocer el grado de certeza del modelo para cada detección.
show_labelsboolTrueMuestra etiquetas para cada detección en la salida visual. Facilita la identificación inmediata de los objetos detectados.

Detalles de implementación#

La clase DistanceCalculation funciona siguiendo objetos a lo largo de los fotogramas de vídeo y calculando la distancia euclídea entre los centroides de las cajas delimitadoras seleccionadas. Cuando haces clic en dos objetos, la solución:

  1. Extrae los centroides (puntos centrales) de las cajas delimitadoras seleccionadas
  2. Calcula en píxeles la distancia euclídea entre estos centroides
  3. Muestra la distancia en el fotograma con una línea que une los objetos

La implementación utiliza el método mouse_event_for_distance para gestionar las interacciones con el ratón, lo que permite a los usuarios seleccionar objetos y borrar las selecciones cuando sea necesario. El método process se encarga del procesamiento fotograma a fotograma, del seguimiento de objetos y del cálculo de distancias.

Aplicaciones#

El cálculo de distancias con YOLO26 tiene numerosas aplicaciones prácticas:

  • Analítica del comercio minorista: Mide la proximidad de los clientes a los productos y analiza la eficacia de la distribución de la tienda
  • Seguridad industrial: Supervisa las distancias de seguridad entre los trabajadores y la maquinaria
  • Gestión del tráfico: Analiza la separación entre vehículos y detecta cuándo circulan demasiado cerca unos de otros
  • Análisis deportivo: Calcula las distancias entre los jugadores, el balón y las posiciones clave del campo
  • Sanidad: Garantiza que se mantengan las distancias adecuadas en las salas de espera y supervisa los movimientos de los pacientes
  • Robótica: Permite que los robots mantengan distancias adecuadas con respecto a los obstáculos y las personas

Preguntas frecuentes#

  • Para calcular las distancias entre objetos con Ultralytics YOLO26, tienes que identificar los centroides de las cajas delimitadoras de los objetos detectados. Este proceso consiste en inicializar la clase DistanceCalculation del módulo solutions de Ultralytics y utilizar las salidas de seguimiento del modelo para calcular las distancias.

  • Calcular distancias con Ultralytics YOLO26 ofrece varias ventajas:

    • Precisión de localización: Proporciona un posicionamiento espacial preciso de los objetos.
    • Estimación del tamaño: Ayuda a estimar los tamaños físicos y contribuye a comprender mejor el contexto.
    • Comprensión de la escena: Mejora la comprensión de escenas 3D y ayuda a tomar mejores decisiones en aplicaciones como la conducción autónoma y la vigilancia.
    • Procesamiento en tiempo real: Realiza cálculos sobre la marcha, por lo que resulta adecuado para analizar vídeo en directo.
    • Capacidades de integración: Funciona con otras soluciones de YOLO26, como el seguimiento de objetos y la estimación de velocidad.
  • Sí, puedes calcular distancias en secuencias de vídeo en tiempo real con Ultralytics YOLO26. El proceso consiste en capturar fotogramas de vídeo con OpenCV, ejecutar la detección de objetos de YOLO26 y utilizar la clase DistanceCalculation para calcular las distancias entre objetos en fotogramas consecutivos. Para ver una implementación detallada, consulta el ejemplo de secuencia de vídeo.

  • Para eliminar los puntos dibujados durante el cálculo de distancias con Ultralytics YOLO26, puedes hacer clic con el botón derecho del ratón. Esta acción borrará todos los puntos que hayas dibujado. Para obtener más detalles, consulta la sección de notas del ejemplo de cálculo de distancias.

  • Los argumentos clave para inicializar la clase DistanceCalculation en Ultralytics YOLO26 son:

    • model: Ruta al archivo del modelo YOLO26.
    • tracker: Algoritmo de seguimiento que se utilizará (las soluciones usan tracktrack.yaml de forma predeterminada).
    • conf: Umbral de confianza para las detecciones.
    • show: Indicador para mostrar la salida.

    Para consultar la lista completa y los valores predeterminados, ve los argumentos de DistanceCalculation.

Comentarios195

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. muhammadwildangoniGitHub

    hallo, I am processing a men's 100 meter sprint video using YOLO and SpeedEstimator (Ultralytics) to detect runners, estimate their speed, and track their progress. However, the output statistics are incorrect. My code detects 16 runners, while there should only be 8 (those on the track), and the maximum speed reported is 0.00 m/s, which is clearly not correct for a sprint race. The furthest distance covered is about 96.7 meters, which seems off.

    1646ed86-3d5e-4074-b5cf-71bbd4da30c4

    import cv2 import math import numpy as np from ultralytics import YOLO from ultralytics.solutions import speed_estimation

    --- SETTINGS ---

    video_path = "WHAT A RACE! _ Men s 100m Final! _ #Paris2024 highlights (online-video-cutter.com).mp4" # Change to your video path model_path = "yolo11n.pt" # Path to your YOLO model (could be yolov11n.pt if available) output_path = "output_sprint.avi" # Output video file name

    meter_per_pixel = 0.05 # Calibration result for track (e.g., 0.05 for a 100m lane) center_point = (0, 720) # Track start point (adjust to your video height)

    --- INITIALIZATION ---

    cap = cv2.VideoCapture(video_path) assert cap.isOpened(), "Error reading video file"

    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)) out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

    model = YOLO(model_path) names = model.model.names if hasattr(model.model, "names") else ["person"]

    speed_obj = speed_estimation.SpeedEstimator( names=names, reg_pts=[(0, int(h/2)), (w, int(h/2))], # Speed estimation line (across track, adjust as needed) view_img=False, meter_per_pixel=meter_per_pixel # Convert pixel to meters )

    frame_count = 0 speed_over_time, distance_over_time = {}, {}

    while cap.isOpened(): success, frame = cap.read() if not success: break frame_count += 1

    # Detect and track runners on each frame
    tracks = model.track(frame, persist=True, show=False)
    
    # Estimate runners' speed and update visualization on frame
    frame = speed_obj.estimate_speed(frame)
    
    # Extract runner IDs, position, speed, and distance
    # Make sure .boxes.id/cls property exists:
    if tracks and hasattr(tracks[0], "boxes") and tracks[0].boxes.id is not None:
        boxes = tracks[0].boxes.xyxy.cpu()
        track_ids = tracks[0].boxes.id.int().cpu().tolist()
        clss = tracks[0].boxes.cls.cpu().tolist()
        for box, track_id, cls in zip(boxes, track_ids, clss):
            if cls == 0:  # 'person' class (runners)
                # Calculate runner's distance from start
                x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2)
                distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2)) * meter_per_pixel
    
                # Store statistics in dictionary
                if track_id not in distance_over_time:
                    distance_over_time[track_id] = [0] * (frame_count - 1)
                distance_over_time[track_id].append(distance)
    
                speed = speed_obj.speeds.get(track_id, 0) if hasattr(speed_obj, "speeds") else 0
                if track_id not in speed_over_time:
                    speed_over_time[track_id] = [0] * (frame_count - 1)
                speed_over_time[track_id].append(speed)
    
                # Overlay runner's speed and distance information directly on video frame
                text_speed = f"Speed: {speed:.2f} m/s"
                text_dist = f"Distance: {distance:.2f} m"
                cv2.putText(frame, f"ID:{track_id} {text_speed}, {text_dist}", (x1, y1 - 10),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,255,0), 2)
    
    # Save frame to output video
    out.write(frame)
    
    # Display real-time video preview
    cv2.imshow("Sprint Runner Detection Preview", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

    cap.release() out.release() cv2.destroyAllWindows()

    --- Final statistics: print results to terminal ---

    best_speed = max((max(speeds) for speeds in speed_over_time.values()), default=0) best_distance = max((max(distances) for distances in distance_over_time.values()), default=0) total_runners = len(distance_over_time)

    print(f"Total runners detected: {total_runners}") print(f"Highest speed: {best_speed:.2f} m/s") print(f"Furthest distance covered: {best_distance:.2f} meters")

  2. maribalkeGitHub(editado)

    Hi! I have tried to do a test on the distance calculation on a single image, but I keep getting the attribute error: 'DistanceCalculation' object has no attribute 'start_process'. I have basis in the YOLO11n-model, further trained on images from a different dataset.

    model_path = "../runs/detect/train2/weights/best.pt"
    model = YOLO(model_path)
    
    dist_obj = distance_calculation.DistanceCalculation() 
    
    frame = cv2.imread("../images/s73/raw_images/10.jpg")
    
    # Detect objects
    results = model(frame)
    
    # Run object tracking
    tracks = model.track(frame, persist=True, show = False)
    
    # process the image
    image_with_distances = dist_obj.start_process(frame, tracks)
    
    # Display the frame
    cv2.imshow('Distance Calculation', image_with_distances)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    1. Glenn JocherUltralytics(editado)

      @maribalke thanks for reaching out! start_process() has been removed. DistanceCalculation is now called directly on the frame and returns a results object with the annotated image in plot_im. It also runs tracking itself, so no separate model.track() call is needed. Here's the minimal fix for your single-image case:

      dist_obj = solutions.DistanceCalculation(model=model_path, show=False)
      results = dist_obj(frame)
      cv2.imshow("Distance Calculation", results.plot_im)

      Note that the distance is measured between two objects you select by clicking them in a display window, so a single static image only shows a distance once two boxes have been selected. For full implementation details, see our Distance Calculation Guide. Let us know if you encounter any other issues!

  3. dgnovoGitHub

    Is it possible to know the distance from an object and another object without using mouse?

  4. Muhammad-237GitHub

    How can we find the distance of in the bounding box like from one point to another point in the bounding box to measure the size of object

    1. Glenn JocherUltralytics

      @Muhammad-237 to measure the size of an object within a bounding box using Ultralytics YOLO11, you can calculate the distance between two points (e.g., edges or centroid) within that bounding box. This can be achieved using the DistanceCalculation class, which allows you to click on specific points to measure distances. Keep in mind, these calculations are approximations as they rely on 2D data without depth information. For more details, refer to the Distance Calculation Docs.

  5. gg120wolfGitHub

    Hi, I am using the example code of Distance Calculation using YOLO11 Example, but there is a problem of File "f:\fyp yolo\ultralytics-main\distance test1.py", line 13, in distance = solutions.DistanceCalculation() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: DistanceCalculation.init() missing 1 required positional argument: 'names' So what is this names should i set?

    1. RizwanMunawarGitHub

      @gg120wolf Hi, the correct way to use the Ultralytics distance calculation module is mentioned below.

      import cv2
      
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("Path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
      
      # Video writer
      video_writer = cv2.VideoWriter("distance_calculation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
      
      # Init distance-calculation obj
      distance = solutions.DistanceCalculation(model="yolo11n.pt", show=True)
      
      # Process video
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              print("Video frame is empty or video processing has been successfully completed.")
              break
          im0 = distance.calculate(im0)
          video_writer.write(im0)
      
      cap.release()
      video_writer.release()
      cv2.destroyAllWindows()

      Thanks :) The Ultralytics Team!

  6. tylerfrisinger01GitHub

    Hey there, I have a model that is trained for object detection not tracking. We are detecting two animals that are inside a cage. What we want to do is import a mp4 video then calculate the distance between the two objects while also showing the bounding boxes. However when i use the VideoStream code snippet from above, the popup window is larger then my screen. How could i adjust that code to make it a different window size so that I am able to track them in real time.

    Also after this is done and the distances are calculated is there anyway to save the whole video with the bounding boxes and the distance calculations that were done in real time? Or would I have to save the video by doing the results = model.predict(save=true) and also do the VideoStream code snippet from above at the same time? and not have the distances shown in the saved video?

    Get back to me as soon as possible as this is for a project for school! Thank You!!

    1. tylerfrisinger01GitHub

      I am also using YOLOv11, i'm not sure if that will change anything or not. And i have tried creating my own window using cv2 but that didnt work when i attempted it.

    2. Glenn JocherUltralytics

      @tylerfrisinger01 to adjust the window size in OpenCV, you can use cv2.namedWindow() and cv2.resizeWindow() to set a custom size. For saving the video with bounding boxes and distances, you can modify the code to include distance annotations and use cv2.VideoWriter to save the processed frames. Here's a quick example on resizing the window:

      cv2.namedWindow('Video', cv2.WINDOW_NORMAL)
      cv2.resizeWindow('Video', 800, 600)  # Adjust the dimensions as needed

      Regarding saving the video with distances, you can overlay the distance on the frames before writing them out with cv2.VideoWriter. If you need further assistance, feel free to ask!

    3. tylerfrisinger01GitHub

      @glenn-jocher when I do this, it still pops open its own window that I am assuming is built into the solutions.DistanceCalculator function (since that is the name of the window) So then it does not work. Any workaround for this?

    4. Glenn JocherUltralytics(editado)

      @tylerfrisinger01 to prevent the DistanceCalculation function from opening its own window, you can set the show parameter to False when initializing it, like so: distance = solutions.DistanceCalculation(model="yolo26n.pt", show=False). This should stop the automatic display window. For saving the video, continue using cv2.VideoWriter. Let me know if you need further assistance!

  7. AbtinzGitHub

    Hello everyone, I want to deploy an yolov8-application on the edge device and estimate the distance through the user's camera without having to click on the detected object, how can I find the distance of the objects to the camera without need to click?

    1. Glenn JocherUltralytics

      @Abtinz to estimate object distances without clicking, you'll need to use depth estimation techniques, as YOLOv8 primarily provides 2D bounding boxes. Consider integrating depth sensors or stereo cameras to obtain depth information. For more details, you can refer to the distance calculation guide.

    1. Glenn JocherUltralytics(editado)

      @gaodaren47297 the DistanceCalculation solution measures the pixel distance between the centroids of two objects you select in the frame; it does not estimate the distance between the camera and an object. A 2D bounding box has no depth information, so camera-to-object distance needs extra information such as a depth sensor or stereo camera, or a calibration using an object of known size. For measuring between objects, see the distance calculation documentation on our website. If you have further questions, feel free to ask here.

  8. Dmitrii-SmirnovGitHub

    Hi Guys, Guys, I have a video with multiple objects(people) on the video. I need to calculate distance between each detected person on the each frame and to save results to csv file. Can you help me with that task? It will be really cool if you will share documentation=) As I understood relevant method for my task is DistanceCalculation(names=names[0], view_img=True).calculate_distance(obj1, obj2), am I correct?

    1. Glenn JocherUltralytics(editado)

      @Dmitrii-Smirnov there is no calculate_distance(obj1, obj2) method on DistanceCalculation in current versions. The solution is called on each frame (results = dist_obj(im0)), you left-click two tracked objects, and it reports the pixel distance in results.pixels_distance. For distances between every pair of people on each frame and a CSV export, compute the centroid distances from the tracking boxes yourself. For details, see our documentation: https://docs.ultralytics.com/guides/distance-calculation/.

    2. Glenn JocherUltralytics(editado)

      @Dmitrii-Smirnov to calculate distances between all detected people in each frame and save the results to a CSV file, compute the centroid distances from the tracking results. The DistanceCalculation solution only measures between two objects you click, so for all pairs here's a basic implementation:

      import csv
      import math
      from itertools import combinations
      
      import cv2
      
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      with open("distances.csv", mode="w", newline="") as file:
          writer = csv.writer(file)
          writer.writerow(["Frame", "Object1", "Object2", "Distance"])
      
          frame_count = 0
          while cap.isOpened():
              success, im0 = cap.read()
              if not success:
                  break
      
              results = model.track(im0, persist=True, show=False, classes=[0])  # class 0 = person
              boxes = results[0].boxes
              if boxes.id is not None:
                  centroids = dict(zip(boxes.id.int().tolist(), boxes.xywh[:, :2].tolist()))
                  for (id1, c1), (id2, c2) in combinations(centroids.items(), 2):
                      writer.writerow([frame_count, id1, id2, math.dist(c1, c2)])
      
              frame_count += 1
      
      cap.release()

      This script captures video frames, calculates pixel distances between detected people, and writes the results to a CSV file. For more details, refer to our documentation: https://docs.ultralytics.com/guides/distance-calculation/.

  9. zgr1446741194GitHub

    Hello author, I would like to propose a scenario similar to this: using monocular distance measurement to calculate the distance from the distant water level line (similar to the shoreline) in the video stream obtained by the camera to my camera (a kind of early warning of the water level), how can I use the solution? At present, the difficulty can be determined that we need to complete distance conversion similar to 3D to 2D, because of perspective space, instead of using fixed linear distance conversion similar to visionEye (from pixels to realistic distance). Another difficulty is that we do not know the true physical properties of the observed water line, which means that we cannot use the traditional method of monocular distance measurement to deduce the distance from the true length or height of the observed object. If you have any viable solutions, thank you very much for adding the code demo in your reply.

    1. Glenn JocherUltralytics

      For calculating distances to a waterline using monocular vision, consider using depth estimation techniques or stereo vision for more accurate results. YOLO models can assist in object detection, but for precise distance measurement, integrating additional sensors or methods might be necessary. For more details, please refer to our distance calculation guide.