Calcolo della distanza con Ultralytics YOLO26
Che cos'è il calcolo della distanza?#
Il calcolo della distanza consiste nel misurare lo spazio tra due oggetti rilevati in un'immagine o in un fotogramma video. Con Ultralytics YOLO26, la soluzione misura la distanza tra i centroidi di due bounding box selezionate dall'utente.
Guarda: Come stimare in pixel la distanza tra oggetti rilevati con Ultralytics YOLO 🚀
Elementi visivi#
| Calcolo della distanza con Ultralytics YOLO26 |
|---|
![]() |
Vantaggi del calcolo della distanza#
- Precisione di localizzazione: migliora la precisione del posizionamento spaziale nelle attività di visione artificiale.
- Stima delle dimensioni: consente di stimare le dimensioni degli oggetti per una migliore comprensione del contesto.
- Comprensione della scena: migliora la comprensione delle scene 3D per prendere decisioni più efficaci in applicazioni come i veicoli autonomi e i sistemi di sorveglianza.
- Prevenzione delle collisioni: consente ai sistemi di rilevare potenziali collisioni monitorando le distanze tra gli oggetti in movimento.
- Analisi spaziale: facilita l'analisi delle relazioni e delle interazioni tra gli oggetti nell'ambiente monitorato.
Calcolo della distanza
- Fai clic con il pulsante sinistro del mouse su due riquadri di delimitazione qualsiasi per calcolare la distanza.
- Usa il pulsante destro del mouse per eliminare tutti i punti disegnati.
La distanza è una stima
La distanza è una stima e potrebbe non essere del tutto precisa perché viene calcolata usando dati 2D, privi di informazioni sulla profondità. Per ottenere la profondità per pixel, usa un modello di stima della profondità.
Calcola le distanze con YOLO26#
La soluzione DistanceCalculation traccia gli oggetti tra i fotogrammi e misura in pixel la distanza euclidea tra i centroidi di due riquadri di delimitazione selezionati con il mouse. Esegui l'esempio qui sotto, poi fai clic con il pulsante sinistro su due oggetti per tracciare la linea che li collega e visualizzare la distanza; fai clic con il pulsante destro per cancellare la selezione.
import cv2
from ultralytics import solutions
cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"
# Scrittore video
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))
# Inizializza l'oggetto per il calcolo della distanza
distancecalculator = solutions.DistanceCalculation(
model="yolo26n.pt", # percorso del file del modello YOLO26.
show=True, # visualizza l'output
)
# Elabora il video
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) # accedi all'output
video_writer.write(results.plot_im) # scrivi il fotogramma elaborato.
cap.release()
video_writer.release()
cv2.destroyAllWindows() # chiudi tutte le finestre aperteArgomenti di DistanceCalculation()#
Ecco una tabella con gli argomenti di DistanceCalculation:
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
model | str | None | Percorso a un file modello Ultralytics YOLO. |
line_width | int | 2 | Spessore delle linee dei riquadri, dei punti chiave e dei conteggi disegnati dalla soluzione. |
verbose | bool | True | Abilita il log per frame della soluzione, con forma dell'input, conteggi per classe e velocità di elaborazione. La chiamata di tracking è sempre silenziosa. |
Puoi usare anche gli argomenti track nella soluzione DistanceCalculation.
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
tracker | str | 'tracktrack.yaml' | Specifica l'algoritmo di tracciamento da usare. Opzioni integrate: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml. |
conf | float | 0.25 | Imposta la soglia di confidenza per le rilevazioni; valori più bassi consentono di tracciare più oggetti, ma possono includere falsi positivi. |
iou | float | 0.5 | Imposta la soglia di Intersezione sull'unione (IoU) per filtrare le rilevazioni sovrapposte. |
classes | list | None | Filtra i risultati in base all'indice della classe. Ad esempio, classes=[0, 2, 3] traccia solo le classi specificate. |
device | str | None | Specifica il dispositivo per l'inferenza (ad es. cpu, cuda:0 o 0). Consente di scegliere tra CPU, una GPU specifica o altri dispositivi di calcolo per l'esecuzione del modello. |
imgsz | int or tuple | 640 | Dimensione dell'immagine di destinazione per l'inferenza: un intero per un'immagine quadrata o una coppia (height, width). Le forme vengono adattate allo stride del modello. |
max_det | int | 300 | Numero massimo di rilevazioni da mantenere per fotogramma prima del tracciamento, che limita gli oggetti elaborati da una soluzione nelle scene dense. |
quantize | int or str | None | Precisione dell’inferenza: 16 (FP16) oppure 32/unset (FP32) per i modelli PyTorch e TorchScript quando non si usa la CPU; gli altri formati usano la precisione selezionata dal rispettivo artefatto e ambiente di esecuzione. Sostituisce l’argomento deprecato half. |
Sono inoltre disponibili i seguenti argomenti di visualizzazione:
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
show | bool | False | Se True, mostra le immagini o i video annotati in una finestra. Utile per ottenere un riscontro visivo immediato durante lo sviluppo o i test. |
show_conf | bool | True | Mostra il punteggio di confidenza di ogni rilevamento accanto all'etichetta. Fornisce indicazioni sul grado di certezza del modello per ciascun rilevamento. |
show_labels | bool | True | Mostra le etichette di ogni rilevamento nell'output visivo. Permette di identificare immediatamente gli oggetti rilevati. |
Dettagli dell'implementazione#
La classe DistanceCalculation funziona tracciando gli oggetti tra i fotogrammi video e calcolando la distanza euclidea tra i centroidi dei riquadri di delimitazione selezionati. Quando fai clic su due oggetti, la soluzione:
- Estrae i centroidi (punti centrali) dei riquadri di delimitazione selezionati
- Calcola in pixel la distanza euclidea tra questi centroidi
- Visualizza la distanza sul fotogramma, con una linea che collega gli oggetti
L'implementazione usa il metodo mouse_event_for_distance per gestire le interazioni con il mouse, consentendo agli utenti di selezionare gli oggetti e cancellare le selezioni secondo necessità. Il metodo process gestisce l'elaborazione fotogramma per fotogramma, il tracciamento degli oggetti e il calcolo delle distanze.
Applicazioni#
Il calcolo della distanza con YOLO26 ha numerose applicazioni pratiche:
- Analisi della vendita al dettaglio: misura la vicinanza dei clienti ai prodotti e analizza l'efficacia della disposizione del negozio
- Sicurezza industriale: monitora le distanze di sicurezza tra lavoratori e macchinari
- Gestione del traffico: analizza la distanza tra i veicoli e rileva chi segue troppo da vicino
- Analisi sportiva: calcola le distanze tra i giocatori, la palla e i punti chiave del campo
- Assistenza sanitaria: garantisce il mantenimento di una distanza adeguata nelle sale d'attesa e monitora gli spostamenti dei pazienti
- Robotica: consente ai robot di mantenere distanze adeguate da ostacoli e persone
Domande frequenti#
Per calcolare le distanze tra oggetti usando Ultralytics YOLO26, devi individuare i centroidi dei riquadri di delimitazione degli oggetti rilevati. Il processo prevede l'inizializzazione della classe
DistanceCalculationdal modulosolutionsdi Ultralytics e l'uso degli output di tracciamento del modello per calcolare le distanze.Il calcolo della distanza con Ultralytics YOLO26 offre diversi vantaggi:
- Precisione della localizzazione: fornisce un posizionamento spaziale accurato degli oggetti.
- Stima delle dimensioni: aiuta a stimare le dimensioni fisiche, contribuendo a una migliore comprensione del contesto.
- Comprensione della scena: migliora la comprensione delle scene 3D e favorisce decisioni più efficaci in applicazioni come la guida autonoma e la sorveglianza.
- Elaborazione in tempo reale: esegue i calcoli al volo, risultando adatta all'analisi video in diretta.
- Capacità di integrazione: funziona con altre soluzioni YOLO26, come il tracciamento degli oggetti e la stima della velocità.
Sì, puoi calcolare le distanze nei flussi video in tempo reale con Ultralytics YOLO26. Il processo prevede l'acquisizione dei fotogrammi video con OpenCV, l'esecuzione del rilevamento degli oggetti con YOLO26 e l'uso della classe
DistanceCalculationper calcolare le distanze tra gli oggetti nei fotogrammi successivi. Per un'implementazione dettagliata, consulta l'esempio di flusso video.Per eliminare i punti disegnati durante il calcolo della distanza con Ultralytics YOLO26, puoi fare clic con il pulsante destro del mouse. Questa azione cancella tutti i punti che hai disegnato. Per ulteriori dettagli, consulta la sezione delle note nell'esempio di calcolo della distanza.
Gli argomenti principali per inizializzare la classe
DistanceCalculationin Ultralytics YOLO26 includono:model: percorso del file del modello YOLO26.tracker: algoritmo di tracciamento da usare (per impostazione predefinita, Solutions usatracktrack.yaml).conf: soglia di confidenza per i rilevamenti.show: flag per visualizzare l'output.
Per l'elenco completo e i valori predefiniti, consulta gli argomenti di DistanceCalculation.
Commenti195
Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.
muhammadwildangoni
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.
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"): breakcap.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")
maribalke(modificato)
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()
Glenn JocherUltralytics(modificato)@maribalke thanks for reaching out!
start_process()has been removed.DistanceCalculationis now called directly on the frame and returns a results object with the annotated image inplot_im. It also runs tracking itself, so no separatemodel.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!
dgnovo
Is it possible to know the distance from an object and another object without using mouse?
Glenn JocherUltralytics@dgnovo yes, it's possible. You can calculate distances programmatically by using bounding box centroids from YOLO11 detections and computing the Euclidean distance between them without relying on mouse clicks. Refer to the
DistanceCalculationimplementation to customize the process for your needs: https://docs.ultralytics.com/guides/distance-calculation/.1
Muhammad-237
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
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
DistanceCalculationclass, 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.
gg120wolf
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?
RizwanMunawar
@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!
tylerfrisinger01
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!!
tylerfrisinger01
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.
Glenn JocherUltralytics@tylerfrisinger01 to adjust the window size in OpenCV, you can use
cv2.namedWindow()andcv2.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 usecv2.VideoWriterto 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 neededRegarding 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!tylerfrisinger01
@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?
Glenn JocherUltralytics(modificato)@tylerfrisinger01 to prevent the
DistanceCalculationfunction from opening its own window, you can set theshowparameter toFalsewhen initializing it, like so:distance = solutions.DistanceCalculation(model="yolo26n.pt", show=False). This should stop the automatic display window. For saving the video, continue usingcv2.VideoWriter. Let me know if you need further assistance!
Abtinz
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?
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.
gaodaren47297
Hi,Is there a method to calculate the distance between the camera and the objects?
Glenn JocherUltralytics(modificato)@gaodaren47297 the
DistanceCalculationsolution 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.
Dmitrii-Smirnov
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?
Glenn JocherUltralytics(modificato)@Dmitrii-Smirnov there is no
calculate_distance(obj1, obj2)method onDistanceCalculationin 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 inresults.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/.Dmitrii-Smirnov
Thank you!
Glenn JocherUltralytics(modificato)@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
DistanceCalculationsolution 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/.
zgr1446741194
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.
Glenn JocherUltralyticsFor 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.
