guides/distance-calculation/

[giscus[bot]]

guides/distance-calculation/

Distance Calculation Using Ultralytics YOLOv8

Python Usage

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

Documentation

For more information, you can explore: https://docs.ultralytics.com/guides/distance-calculation/

[AdadAlShabab]

Hi, I'm clicking on the objects to track distance. But it's not working. Why?

[RizwanMunawar]

@AdadAlShabab which platform you are using? Also, make sure to follow the mentioned guidelines.

- Mouse Right Click will delete all drawn points
- Mouse Left Click can be used to draw points

[AdadAlShabab]

@RizwanMunawar I'm using Windows 11. Please help.

[SaiBhujbal]

Hi, I am actually using mss to detect objs from my screen so how can i implement the distance caluclations as there are about 10 objects and their distance must be mapped for every obj with every other obj ?

[SaiBhujbal]

Thanks a lot, for more detailed info I have a model trained using instance segmentation also now as you showed mss , is the model .predict() function useful or model .track as the objects on the screen will have continuous random mouse over a selected area of the screen and I want to continuously detect the distances and with shortest distance between two objects automatically keys should be pressed.

Can you give a code for that as I am new to the output of YOLOv8 model

Also consider the labels are equal to number on keyboard so also class IDs must be extracted

and can you help get output in json from my custom .pt YOLOV8 model

[pderrenger]

@SaiBhujbal certainly! To continuously detect objects and calculate distances between them while pressing keys corresponding to the shortest distance between two objects, you can use the .predict() function for instance segmentation and .track() for object tracking. Since you're using instance segmentation, you'll have access to masks that can help with more precise centroid calculations.

Here's a code snippet that demonstrates how you might set this up with YOLOv8:

import mss
import numpy as np
import cv2
from ultralytics import YOLO
import json
from pynput.keyboard import Key, Controller

# Initialize keyboard controller
keyboard = Controller()

# Function to calculate Euclidean distance between two points
def euclidean_distance(point1, point2):
    return np.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)

# Load your custom trained YOLOv8 model
model = YOLO('path/to/your/custom_model.pt')

# Set up mss for screen capture
with mss.mss() as sct:
    monitor = {"top": 160, "left": 160, "width": 640, "height": 480}  # Define your monitor region to capture

    while True:  # Continuous loop for real-time processing
        sct_img = sct.grab(monitor)
        frame = np.array(sct_img)

        # Convert from BGR to RGB (mss captures in BGR format)
        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

        # Run prediction
        results = model.predict(frame_rgb)

        # Extract centroids and class IDs
        centroids = []
        class_ids = []
        for det in results[0].boxes:
            x1, y1, x2, y2 = det.xyxy
            centroid = ((x1 + x2) / 2, (y1 + y2) / 2)
            centroids.append(centroid)
            class_ids.append(det.cls)

        # Calculate distances
        distances = np.full((len(centroids), len(centroids)), np.inf)
        for i, point1 in enumerate(centroids):
            for j, point2 in enumerate(centroids):
                if i != j:
                    distances[i][j] = euclidean_distance(point1, point2)

        # Find the pair with the shortest distance
        i, j = np.unravel_index(distances.argmin(), distances.shape)
        shortest_distance = distances[i][j]

        # Press keys corresponding to the shortest distance pair
        if shortest_distance < threshold_distance:  # Define a threshold distance
            keyboard.press(str(class_ids[i]))  # Press key for object i
            keyboard.release(str(class_ids[i]))
            keyboard.press(str(class_ids[j]))  # Press key for object j
            keyboard.release(str(class_ids[j]))

        # Optionally, save results to JSON
        json_results = results[0].tojson()
        with open('results.json', 'w') as f:
            json.dump(json_results, f)

        # Display the frame with annotations
        annotated_frame = results[0].plot()
        cv2.imshow('YOLOv8 Inference', annotated_frame)
        if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
            break

cv2.destroyAllWindows()

In this code:

• We're using mss to capture a specific region of the screen.
• The YOLOv8 model is loaded and used to predict objects in the captured frame.
• We calculate the centroids of the bounding boxes and their class IDs.
• We calculate pairwise distances between centroids and find the shortest distance.
• If the shortest distance is below a certain threshold, we simulate key presses corresponding to the class IDs of the closest objects.
• We save the results to a JSON file.
• We display the annotated frame and allow the user to quit by pressing 'q'.

Please adjust threshold_distance to a value that makes sense for your application. Also, ensure that the class IDs correspond to keys that can be pressed on the keyboard. If the class IDs are not directly mappable to keyboard keys, you'll need to create a mapping dictionary.

Remember to replace 'path/to/your/custom_model.pt' with the actual path to your custom trained model. The monitor dictionary should also be adjusted to capture the desired area of your screen.

This script assumes that the class IDs are single characters that can be pressed on the keyboard. If your class IDs are not directly mappable to keyboard keys, you'll need to create a mapping from class IDs to keyboard keys.

Lastly, the results[0].tojson() function call will convert the first result in the list to JSON format, which you can then save to a file or use as needed.

[SaiBhujbal]

File "c:\Study\Coding\Spectator Automation\test_custommodel.py", line 47, in detect_objects
x1, y1, x2, y2 = det.xyxy
^^^^^^^^^^^^^^

ValueError: not enough values to unpack (expected 4, got 1)

this is the error for some reason can you help me out with that please

[AdadAlShabab]

Traceback (most recent call last):
File "e:\Ultralytics\distance_2.py", line 49, in
i, j = np.unravel_index(distances.argmin(), distances.shape)
^^^^^^^^^^^^^^^^^^
ValueError: attempt to get argmin of an empty sequence

[pderrenger]

@AdadAlShabab the first error you're encountering, ValueError: not enough values to unpack (expected 4, got 1), suggests that the det.xyxy is not returning a tuple of four values as expected. This could be due to an incorrect format of the detection results.

The second error, ValueError: attempt to get argmin of an empty sequence, indicates that the distances array is empty, which means no distances were calculated, likely because no centroids were found or there was only one detection, making the distance calculation irrelevant.

Let's address these issues with an updated code snippet:

import mss
import numpy as np
import cv2
from ultralytics import YOLO
import json
from pynput.keyboard import Key, Controller

# Initialize keyboard controller
keyboard = Controller()

# Function to calculate Euclidean distance between two points
def euclidean_distance(point1, point2):
    return np.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)

# Load your custom trained YOLOv8 model
model = YOLO('path/to/your/custom_model.pt')

# Set up mss for screen capture
with mss.mss() as sct:
    monitor = {"top": 160, "left": 160, "width": 640, "height": 480}  # Define your monitor region to capture

    while True:  # Continuous loop for real-time processing
        sct_img = sct.grab(monitor)
        frame = np.array(sct_img)

        # Convert from BGR to RGB (mss captures in BGR format)
        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

        # Run prediction
        results = model.predict(frame_rgb)

        # Extract centroids and class IDs
        centroids = []
        class_ids = []
        for det in results[0].boxes.xyxy:
            if len(det) == 4:  # Ensure that the detection has 4 values
                x1, y1, x2, y2 = det
                centroid = ((x1 + x2) / 2, (y1 + y2) / 2)
                centroids.append(centroid)
                class_ids.append(int(results[0].boxes.cls))  # Convert class tensor to int

        # Calculate distances if there are at least 2 detections
        if len(centroids) > 1:
            distances = np.full((len(centroids), len(centroids)), np.inf)
            for i, point1 in enumerate(centroids):
                for j, point2 in enumerate(centroids):
                    if i != j:
                        distances[i][j] = euclidean_distance(point1, point2)

            # Find the pair with the shortest distance
            i, j = np.unravel_index(distances.argmin(), distances.shape)
            shortest_distance = distances[i][j]

            # Press keys corresponding to the shortest distance pair
            if shortest_distance < threshold_distance:  # Define a threshold distance
                keyboard.press(str(class_ids[i]))  # Press key for object i
                keyboard.release(str(class_ids[i]))
                keyboard.press(str(class_ids[j]))  # Press key for object j
                keyboard.release(str(class_ids[j]))

        # Optionally, save results to JSON
        json_results = results[0].tojson()
        with open('results.json', 'w') as f:
            json.dump(json_results, f)

        # Display the frame with annotations
        annotated_frame = results[0].plot()
        cv2.imshow('YOLOv8 Inference', annotated_frame)
        if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
            break

cv2.destroyAllWindows()

Please ensure that threshold_distance is defined and that the class IDs are correctly mapped to keyboard keys. Also, replace 'path/to/your/custom_model.pt' with the actual path to your custom trained model. Adjust the monitor dictionary to capture the desired area of your screen.

This updated code checks that each detection has four values before unpacking and only calculates distances if there are at least two detections. It also ensures that class IDs are integers before using them to press keys.

[AdadAlShabab]

Hi @pderrenger. The mouse clicking feature distance calculation ain't working for me. I'm clicking the mouse but no response. I'm using windows 11.

Code:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8n.pt")
names = model.model.names

cap = cv2.VideoCapture("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("MyFile.avi",
cv2.VideoWriter_fourcc(*'mp4v'),
fps,
(w, h))

Init distance-calculation obj

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

while cap.isOpened():
success, im0 = cap.read()
if not success:
print("Video frame is empty or video processing has been successfully completed.")
break

tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)
video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

Please help.

[pderrenger]

@AdadAlShabab hi there! It seems like you're having trouble with the distance calculation feature in YOLOv8. Let's try to troubleshoot this issue together. 😊

First, ensure that the cv2.imshow() function is being called within your loop to display the video frames. This is necessary for capturing mouse events. If view_img is set to True, the start_process() function should display the image. However, if it's not displaying, you might need to manually add cv2.imshow() after start_process().

Here's a modified snippet of your loop with cv2.imshow() added:

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = dist_obj.start_process(im0, tracks)
    video_writer.write(im0)
    
    # Display the frame
    cv2.imshow('YOLOv8 Distance Calculation', im0)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

Make sure you have the latest version of the Ultralytics YOLOv8 repository and all dependencies installed. If the issue persists, it could be a bug, and I would recommend opening an issue on the Ultralytics YOLOv8 GitHub repository to get further assistance from the development team.

Remember to include details about your environment, such as the version of OpenCV and the exact steps to reproduce the issue. This will help the team diagnose and resolve your problem more efficiently. 🛠️

[Rafi0198]

How to find the distance of the objects from the camera? For example, in your test video, how to calculate the distance of each person from the camera? Would be glad to have a solution. TIA.

[glenn-jocher]

Hey there! 👋 To calculate the distance of objects from the camera using YOLOv8, you can utilize the centroid of the bounding boxes detected by the model. Here's a simple example using the distance_calculation solution provided by Ultralytics:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

# Load the model
model = YOLO("yolov8n.pt")

# Initialize the video capture
cap = cv2.VideoCapture("path/to/your/video.mp4")
assert cap.isOpened(), "Error opening video file"

# Initialize distance calculation object
dist_obj = distance_calculation.DistanceCalculation()

# Process video frames
while True:
    success, frame = cap.read()
    if not success:
        break

    # Run object tracking
    tracks = model.track(frame, persist=True)

    # Calculate distances and update the frame
    frame = dist_obj.start_process(frame, tracks)

    # Display the frame
    cv2.imshow('Distance Calculation', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

Make sure to click on the bounding boxes in the displayed video window to calculate the distance between them. If you need to clear the points, right-click anywhere in the window. Hope this helps! 😊 Let us know if you have any more questions.

[sauravdasmg]

#I am trying to find the distance between the object and camera in real-time object detection using my webcam on yolov8n.pt model. but I am getting this error:

Traceback (most recent call last):
File "C:/Users/SAURAV/scrapy_projects/yolo/test.py", line 40, in
frame = dist_obj.start_process(frame, tracks)
File "C:\Users\SAURAV\scrapy_projects\yolo\venv\lib\site-packages\ultralytics\solutions\distance_calculation.py", line 146, in start_process
self.annotator.box_label(box, color=colors(int(cls), True), label=self.names[int(cls)])
TypeError: 'NoneType' object is not subscriptable
0: 384x640 1 person, 113.1ms
Speed: 15.3ms preprocess, 113.1ms inference, 15.7ms postprocess per image at shape (1, 3, 384, 640)

Process finished with exit code 1

#Would be glad to have a solution. TIA.
#Here is my code:

from ultralytics.solutions import distance_calculation
import cv2
import argparse

from ultralytics import YOLO

def parse_arguments() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="YOLOv8 live")
    parser.add_argument(
        "--webcam-resolution",
        default=[1280, 720],
        nargs=2,
        type=int
    )
    args = parser.parse_args()
    return args
# Load the model
model = YOLO("yolov8n.pt")

# Initialize the video capture
args = parse_arguments()
frame_width, frame_height = args.webcam_resolution
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, frame_width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, frame_height)
assert cap.isOpened(), "Error opening video file"

# Initialize distance calculation object
dist_obj = distance_calculation.DistanceCalculation()

# Process video frames
while True:
    success, frame = cap.read()
    if not success:
        break

    # Run object tracking
    tracks = model.track(frame, persist=True)
    # Calculate distances and update the frame
    frame = dist_obj.start_process(frame, tracks)
    print(frame.shape)
    # Display the frame
    cv2.imshow('Distance Calculation', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

[pderrenger]

@sauravdasmg hey there! It looks like you're encountering a TypeError when trying to label the boxes during distance calculation. This error suggests that the label argument passed to cv2.getTextSize() is not a string, as expected.

The issue might be related to how the names are being passed to the DistanceCalculation object. You're using a dictionary with integer keys, which should be fine, but let's make sure the labels are indeed strings. Try explicitly converting cls to an integer and then to a string when accessing self.names:

label = str(self.names[int(cls)])

Regarding your parse_arguments() method and video capture initialization, they seem correct. The error is likely not related to these parts of your code.

If the problem persists, you might want to check the ultralytics documentation or reach out to their support for more tailored assistance. Good luck! 🚀

[sauravdasmg]

Thank you for solving the error problem. Program run properly but it does not print the distance.

And program open two window of webcam one named Distance Calculation and another is Ultralytics Distance Estimation.

How to solve this problem?
Code:

from ultralytics.solutions import distance_calculation
import cv2
import argparse

from ultralytics import YOLO


def parse_arguments() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="YOLOv8 live")
    parser.add_argument(
        "--webcam-resolution",
        default=[1280, 720],
        nargs=2,
        type=str
    )
    arg = parser.parse_args()
    return arg


# Load the model
model = YOLO("yolov8n.pt")

# Initialize the video capture
args = parse_arguments()
frame_width, frame_height = args.webcam_resolution
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, frame_width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, frame_height)
assert cap.isOpened(), "Error opening video file"

# Initialize distance calculation object
dist_obj = distance_calculation.DistanceCalculation()
names_dict = {i: name for i, name in enumerate(model.names)}
dist_obj.set_args(names=names_dict, view_img=True)

# dist_obj.set_args(names=model.names, view_img=True)
# Process video frames
while True:
    success, frame = cap.read()
    if not success:
        break
    # Run object tracking
    tracks = model.track(frame, persist=True)
    # Calculate distances and update the frame
    processed_frame = dist_obj.start_process(frame, tracks)
    # print('####', type(processed_frame), '####')
    # Check if the processed frame is valid
    if processed_frame is not None and processed_frame.size != 0:
        # Display the frame
        cv2.imshow('Distance Calculation', processed_frame)
    else:
        print("Received an empty frame from distance calculation.")
    # Display the frame
    # Calculate distances and update the frame
    # cv2.imshow('Distance Calculation', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

[pderrenger]

@sauravdasmg hey there! Thanks for reaching out. 😊 It looks like the distance isn't printing because we need to ensure the view_img flag is set to True when initializing the DistanceCalculation object. This flag enables the display of frames with distance annotations.

Regarding the two windows issue, it seems like the view_img flag might be causing the DistanceCalculation object to create its own window. To fix this, you can try setting view_img=False and manage the display within your main loop.

Here's a snippet to update your code:

# Initialize distance calculation object
dist_obj = distance_calculation.DistanceCalculation()
names_dict = {i: name for i, name in enumerate(model.names)}
dist_obj.set_args(names=names_dict, view_img=False)  # Set view_img to False

And then in your loop, just use one cv2.imshow to display processed_frame. This should solve the double window issue and allow the distance to print on the frame.

Give this a try, and let's see how it goes! If you need more help, the Ultralytics docs are a great resource. 📚✨

[sauravdasmg]

Your code has worked properly. But it does not print the distance of cell phone from my webcam.

[pderrenger]

Hey there! Glad to hear the code is working for you. 🎉 If the distance isn't printing, it might be due to the view_img flag being set to False. Try setting view_img=True when initializing the DistanceCalculation object to enable on-screen distance annotations. Here's a quick example:

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=model.names, view_img=True)

Also, ensure you're clicking on the bounding boxes in your video feed to trigger the distance calculation as mentioned in the docs. If you're still having trouble, let's troubleshoot together! 😊

[pesal174]

Hi, I wanted to measure distance of vehicles using a camera, but the camera's POV is inside the car (example: dashcam). So, I wanna ask if we are able to measure distance automatically without needing to click on the bounding boxes. Thanks .

[rajuu0]

hi glennn can u please provide me the full code to find distance of the objects from the camera of the car

[glenn-jocher]

Hi there! 🚀 Sure, I'd be happy to help. Below is a concise example of code to calculate the distance of objects detected by a car's camera using Ultralytics YOLOv8. This leverages the distance calculation feature to measure the gap between objects detected in video frames. Make sure to adjust the video path to your needs.

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

# Load YOLO model
model = YOLO("yolov8n.pt")

# Capture video
cap = cv2.VideoCapture("path/to/your/video.mp4")
assert cap.isOpened(), "Error opening video stream or file"

# Initialize Distance Calculation
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=model.model.names, view_img=True)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Track objects
    tracks = model.track(frame, persist=True, show=False)
    
    # Calculate and visualize distances
    frame = dist_obj.start_process(frame, tracks)
    
    # Optionally display the frame
    cv2.imshow('Distance Visualization', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # press 'q' to quit
        break

cap.release()
cv2.destroyAllWindows()

This script does automatic tracking and displays the calculated distances on each frame. Adjust the path/to/your/video.mp4 to the actual path of your video file.

Note: Right-click to clear points, and left-click to draw if needed for custom measurements beyond automatic tracking.

Hope this helps you measure those distances effectively! Let me know if you have any questions. 😊

[rajuu0]

thank u but iam geting this error i also want the model to track distance of the cars without click :the error i am getting Traceback (most recent call last):
File "C:/Users/rajuboii/AppData/Local/Programs/Python/Python310/distancecalculation.py", line 29, in
cv2.imshow('Distance Visualization', frame)
File "C:\Users\rajuboii\AppData\Local\Programs\Python\Python310\lib\site-packages\ultralytics\utils\patches.py", line 56, in imshow
_imshow(winname.encode("unicode_escape").decode(), mat)
cv2.error: OpenCV(4.9.0) D:\a\opencv-python\opencv-python\opencv\modules\highgui\src\window.cpp:971: error: (-215:Assertion failed) size.width>0 && size.height>0 in function 'cv::imshow'

[rajuu0]

let me clarify my request . i want to measure distance of mutiple objects from the camera not distance between object but distance fro, the car camera and other objects please do help me on this one . and i dont want to click my mouse to measure i want it to measure automatically

[glenn-jocher]

Hey there! It looks like you're looking to automatically measure the distance from your car's camera to multiple objects around it without manual interaction. 😊 YOLOv8 can indeed help you detect objects automatically, but the direct distance calculation feature from the camera to an object involves a bit more setup, as the current implementation mainly focuses on the distance between objects.

For a camera-based setup, you generally need to calibrate your camera to understand its field of view and possibly leverage depth sensing if available. After detecting objects with YOLO, you could integrate with depth estimation techniques or use sensor data (if available) to calculate distances.

Here's a conceptual snippet on how you might approach object detection with YOLOv8:

from ultralytics import YOLO
import cv2

# Load the YOLO model
model = YOLO("yolov8n.pt")

# Assuming cap is your camera feed
while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Detect objects in the frame
    results = model(frame)

    # Here, you'd integrate a method to estimate distances
    # This could be a depth sensor reading, another ML model, or geometric calculations
    # based on camera calibration.
    
    # Show results
    cv2.imshow('Frame', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

This script outlines the process of detecting objects. The critical step, calculating distance from the camera to each object, depends significantly on your specific setup (like the camera model, whether you have depth sensors, etc.).

I hope this points you in the right direction! 🚀 Let us know if there's anything more we can help with.

[Erubiel-sudo]

Hello, I am running this code, the code works perfectly, however the measurement made in real time is not correct, how can I improve this problem?
Also I would like to measure in mm and cm.

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8m.pt")
names = model.names

Use 0 for the default webcam

cap = cv2.VideoCapture(1)
assert cap.isOpened(), "Error accessing webcam"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

#Init distance-calculation obj
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

while cap.isOpened():
succes, im0 = cap.read()
if not succes:
print("Video is empty or video proccesing has ben succesfully completed")
break
tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)

cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

Hey there! 👋 It's great to hear that the code is running smoothly, but I understand the measurements need some fine-tuning. To improve the accuracy of real-time measurements, you might want to calibrate your distance calculation based on known distances in your scene. This can help translate pixel distances to real-world units like mm or cm.

For measurements in mm and cm, you'll need to adjust the scale factor in the distance_calculation module accordingly. If you have a reference object of known size, you can use it to establish the scale.

Here's a quick example of how you might calibrate your setup:

# After initializing your DistanceCalculation object
# Set a known distance in mm or cm
known_distance_mm = 1000  # replace with the actual distance in mm
dist_obj.set_scale(known_distance_mm)

Remember, the accuracy of your measurements will depend on factors like camera angle, lens distortion, and object placement. Make sure to consider these when setting up your environment. Happy measuring! 📏🤖

[Erubiel-sudo]

Hello, I am running this code, the code works perfectly; I mean, the code can detect de object and it gets a measure. However the measurement made in real time is not correct, how can I improve this problem?
Also I would like to measure in mm and cm.

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8m.pt")
names = model.names

Use 0 for the default webcam

cap = cv2.VideoCapture(1)
assert cap.isOpened(), "Error accessing webcam"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

#Init distance-calculation obj
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

while cap.isOpened():
succes, im0 = cap.read()
if not succes:
print("Video is empty or video proccesing has ben succesfully completed")
break
tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)

cap.release()
cv2.destroyAllWindows()

[pderrenger]

Hey there! 👋 It's great to hear that the code is working for object detection and measurement. If the real-time measurements aren't accurate, here are a couple of things you might want to check:

1. Calibration: Ensure your camera is properly calibrated. Camera calibration is crucial for accurate distance measurements as it accounts for lens distortion and other factors.
2. Scale Factor: You might need to adjust the scale factor in the distance calculation to match the real-world dimensions. This can be done by measuring a known distance in the frame and adjusting the scale accordingly.

For measurements in mm and cm, you can simply convert the output distance from pixels to your desired unit of measurement by applying the correct scale factor.

Here's a modified snippet of your code with a placeholder for the scale factor:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8m.pt")
names = model.names

# Define your scale factor here (pixels to mm/cm)
scale_factor = 1  # Adjust this based on your calibration

cap = cv2.VideoCapture(1)
assert cap.isOpened(), "Error accessing webcam"

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = dist_obj.start_process(im0, tracks)

    # Apply scale factor to distances here
    # Example: distance_in_mm = distance_in_pixels * scale_factor

cap.release()
cv2.destroyAllWindows()

Remember to replace the scale_factor with the actual value you calculate during calibration. Hope this helps! Let us know if you have any more questions. 😊

[Erubiel-sudo]

Hi, I already calibrated my camera to measure the correct distance between objects with the camera at a distance of 1.75 cm. However, when I move the camera away and measure the distance between the objects again, the measurement is incorrect. How can I improve this measurement by moving the camera away and maintaining the correct distance?

[glenn-jocher]

@Erubiel-sudo hi there! 👋 It sounds like you're encountering issues with distance measurements as the camera moves further away. This is a common challenge due to the change in perspective and scale. Here are a couple of suggestions to help improve your distance measurements:

1. Dynamic Calibration: If possible, recalibrate your camera for different distances. This can help adjust for the change in perspective as the camera moves.

2. Depth Sensing: If your camera setup allows, incorporating depth sensors or using stereo cameras can provide more accurate distance measurements that are less affected by changes in the camera's position.

3. Scale Adjustment: Adjust the scale factor in your distance calculation based on the known size of an object in the frame or using depth information if available. This can help compensate for the change in distance.

4. Use 3D Models: If applicable, creating a 3D model of the environment can help in adjusting the measurements based on the camera's position and orientation.

Here's a simple example of adjusting the scale factor based on camera distance (this is a conceptual example, adjust as necessary for your setup):

# Assuming 'distance' is the measured distance at the initial calibration
# and 'camera_distance_change' is the change in distance of the camera from its original position
scale_factor = original_distance / (original_distance + camera_distance_change)
adjusted_distance = measured_distance * scale_factor

Remember, the effectiveness of these methods can vary based on your specific setup and requirements. Experimenting with these approaches should help you find a solution that works best for your scenario. Happy coding! 🚀

[Erubiel-sudo]

Thanks a lot

[glenn-jocher]

@Erubiel-sudo hey there! 👋 It looks like you're diving into distance calculation with YOLOv8 - that's awesome! 🚀 If you're experiencing any specific issues or have questions about implementing distance calculation in your project, could you provide a bit more detail?

For a quick start, make sure you're using the distance_calculation module as shown in the docs. Here's a snippet to get you going:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/your/video.mp4")
dist_obj = distance_calculation.DistanceCalculation()

while True:
    ret, frame = cap.read()
    if not ret:
        break
    tracks = model.track(frame, persist=True)
    frame = dist_obj.start_process(frame, tracks)
    cv2.imshow('Distance Calculation', frame)
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Remember, right-click to delete points and left-click to draw new ones for distance measurement. If there's something more specific you're curious about, feel free to ask!

[abdullahtensor]

Hey, I'm unable the interact with the objects in my .avi file. Does this work on Ubuntu 20.04.6 LTS? My python version is 3.11.8. The code is running and it's detecting objects from my mp4 file, but I'm unable to interact with distance_calculation.avi. I don't get any popup window while running the code file.

Code file

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation

model = YOLO("yolov8m.pt")
names = model.model.names

cap = cv2.VideoCapture("/home/abdullah/Desktop/intern depth map/depthultra/car.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

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

while cap.isOpened():
success, im0 = cap.read()
if not success:
print("Video frame is empty or video processing has been successfully completed.")
break

tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)
video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

[pderrenger]

@abdullahtensor hey there! 👋 It seems like you're facing an issue with displaying the video output for your .avi file on Ubuntu 20.04.6 LTS. From your code snippet, everything looks correctly set up for processing and saving the video. However, if you're expecting a popup window to view the video in real-time, it appears the cv2.imshow() function is not being called within your loop for displaying frames.

To display each frame as it's processed, you can add cv2.imshow("Frame", im0) right after video_writer.write(im0) within your loop. Also, ensure you have a cv2.waitKey(1) call after cv2.imshow() to give OpenCV time to draw the window. Here's the adjusted snippet:

    ...
    video_writer.write(im0)
    cv2.imshow("Frame", im0)  # Display the frame
    if cv2.waitKey(1) == ord('q'):  # Break loop with 'q'
        break
    ...

Make sure you have all necessary GUI packages installed for your Ubuntu system to display windows. Sometimes, running code on a remote server or a headless setup might require additional configurations for displaying GUI windows.

If the issue persists, double-check your environment and dependencies, especially regarding OpenCV compatibility with your system. Let us know how it goes! 🚀

[WooFy11]

can we use google colab to rrun the program and draw the lines?

[glenn-jocher]

Yes, Google Colab is a great environment to run the Ultralytics YOLOv8 program and draw distance lines between objects. Here's a simplified example showing how you can perform distance calculations on a video stream within Colab:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

# Load model
model = YOLO("yolov8n.pt")

# Initialize video
cap = cv2.VideoCapture("path/to/your/video.mp4")
assert cap.isOpened(), "Error opening video file"

# Init distance calculation object
dist_calc = distance_calculation.DistanceCalculation()

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

    # Perform tracking
    tracks = model.track(frame, persist=True, show=False)
    
    # Calculate and draw distances
    frame = dist_calc.start_process(frame, tracks)
    
    # Optional: Display the frame
    cv2.imshow('Frame', frame)
    if cv2.waitKey(1) == ord('q'): break

cap.release()
cv2.destroyAllWindows()

Remember to adjust "path/to/your/video.mp4" to your video's actual path. This example uses defaults for distance calculation, but you can customize its behavior with dist_calc.set_args(). For instance, to enable frame display within Colab, set view_img=True.

Right-click deletes all points, and left-click lets you draw points for distance measurement. Enjoy calculating distances between objects in Colab! 🛰️

[sriram0507]

hi i am trying to measure the distance of potholes from a car camera. can you provide the full code to measure the distance between the camera and the potholes in a video file

[glenn-jocher]

Hey there! 👋 It looks like you're facing an issue where the names attribute of your DistanceCalculation object isn't set properly, leading to a 'NoneType' object is not subscriptable error when attempting to label boxes.

From the snippet you've shared, the names need to be passed to the DistanceCalculation object correctly. It seems it might not be initialized properly before start_process is called. Here's a quick check you can do:

Ensure names=model.model.names is properly set when initializing your DistanceCalculation object. Here's a quick example:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8n.pt")

dist_calc = distance_calculation.DistanceCalculation()
# Make sure to set names correctly here
dist_calc.set_args(names=model.model.names, view_img=True)

This should ensure that self.names in your DistanceCalculation object isn't None when you attempt to access it for box labeling.

If you've already set this correctly, double-check that model.model.names is returning what you expect and isn't None.

Let me know if this helps or if you have any further questions! Happy coding! 🚀

[sriram0507]

this code works perfectly to find the distance between two potholes when i left click on the pothole with bounding box. but instead of showing the distance after clicking on the pothole, i want to show the distance continuosly for nearest potholes without clicking the pothole bounding box. can you provide me the code for that

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

Load the model

model = YOLO("best (2).pt") # Ensure it's trained for pothole detection

Set video source

cap = cv2.VideoCapture("Real-time_dist/sample_video.mp4")
assert cap.isOpened(), "Error reading video file"

Prepare output video writer if needed

video_writer = cv2.VideoWriter("output_with_distance.avi", cv2.VideoWriter_fourcc(*'mp4v'), 30, (int(cap.get(3)), int(cap.get(4))))

Initialize distance calculation object

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=model.model.names, view_img=True) # View_img to display processed frames

Process video

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

# Perform tracking and distance calculation
tracks = model.track(frame, persist=True, show=False)
processed_frame = dist_obj.start_process(frame, tracks)

# Write to output if needed
video_writer.write(processed_frame)

Clean up

cap.release()
video_writer.release()
cv2.destroyAllWindows()

[glenn-jocher]

Hey there! 👋 It's awesome that you've got the distance calculation working for clicked potholes. For showing the distance continuously between the nearest potholes without manual clicks, you can modify your loop to automatically find and display distances between closest detections. Here's a simplified approach:

1. After detecting potholes, calculate pairwise distances between all detections.
2. Identify the pair with the smallest distance (nearest potholes).
3. Display this distance on the video feed.

Here's how you can adjust your loop:

from scipy.spatial import distance

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break
    
    tracks = model.track(frame, persist=True, show=False)
    # Assuming tracks[0].boxes.xyxy contains the detections
    
    # Extract centers of the detected boxes
    centers = [(box[0]+box[2])/2, (box[1]+box[3])/2] for box in tracks[0].boxes.xyxy]

    if len(centers) > 1:
        # Calculate pairwise distances between detections
        dist_matrix = distance.cdist(centers, centers, 'euclidean')
        np.fill_diagonal(dist_matrix, np.inf)  # Ignore self distances
        closest_pair_idx = np.unravel_index(dist_matrix.argmin(), dist_matrix.shape)
        
        # Display the distance of the closest pair
        dist_obj.annotate(frame, f"Closest Distance: {dist_matrix[closest_pair_idx]:.2f}", location=(100, 50))
    
    video_writer.write(frame)

# Proceed with the remaining code for cleanup...

This code snippet assumes tracks[0].boxes.xyxy gives you the bounding boxes and uses scipy for distance calculations. Remember, you'll need to adapt this based on how your tracking information is structured.

This example should give you a continuous measure of the distance between the nearest potholes. Dive into the details and adjust as needed for your setup. 😊 Let us know if you've got more questions or if there's anything else we can help with!

[sriram0507]

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2
from scipy.spatial import distance

model = YOLO("best (1).pt")
names = model.model.names

cap = cv2.VideoCapture("sample_video.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

dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=names, view_img=True)

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

tracks = model.track(frame, persist=True, show=False)
# Assuming tracks[0].boxes.xyxy contains the detections

# Extract centers of the detected boxes
centers = [(box[0]+box[2])/2, (box[1]+box[3])/2] for box in tracks[0].boxes.xyxy]

if len(centers) > 1:
    # Calculate pairwise distances between detections
    dist_matrix = distance.cdist(centers, centers, 'euclidean')
    np.fill_diagonal(dist_matrix, np.inf)  # Ignore self distances
    closest_pair_idx = np.unravel_index(dist_matrix.argmin(), dist_matrix.shape)
    
    # Display the distance of the closest pair
    dist_obj.annotate(frame, f"Closest Distance: {dist_matrix[closest_pair_idx]:.2f}", location=(100, 50))

video_writer.write(frame)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

in this code i get a error in for loop for the statements to be separated by newline or semicolon. and also the np is not defined

[glenn-jocher]

Hey there! 👋 It looks like you're doing some awesome work with distance calculation. Let's address the issues you've run into:

1. For Loop Syntax: Python expects statements to be separated by newlines by default. If you're seeing an "error in for loop for the statements to be separated by newline or semicolon," ensure each statement in your loop is on a new line, or if they're on the same line, they should be separated by semicolons.

2. np Not Defined: This error occurs because np is a common alias for numpy, and it seems you're using it without importing numpy first. Simply add import numpy as np at the beginning of your script.

Here’s a quick fix for your code:

import cv2
import numpy as np  # Make sure to import numpy
from scipy.spatial import distance
from ultralytics import YOLO
from ultralytics.solutions import distance_calculation

model = YOLO("best (1).pt")
cap = cv2.VideoCapture("sample_video.mp4")
# ... rest of your setup

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break
    
    tracks = model.track(frame, persist=True, show=False)
    centers = [(box[0]+box[2])/2, (box[1]+box[3])/2] for box in tracks[0].boxes.xyxy]
    # ... rest of your loop

For showing continuous distances between the nearest potholes without any manual input:

• Ensure you calculate the pairwise distances and find the nearest ones inside your loop, just like your current setup does.
• You've got the right idea with using the distance matrix to find the closest potholes.
• Displaying the distance continuously simply involves updating the displayed distance in every frame based on the current detections.

Hope this helps! Keep up the great work, and feel free to reach out if you have more questions. 😊

[Erubiel-sudo]

Hi, when running the following code:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2
model = YOLO("yolov8m.pt")
names = model.names

Use 0 for the default webcam

cap = cv2.VideoCapture(1)
assert cap.isOpened(), "Error accessing webcam".
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)))
#Start object distance calculation
dist_obj = distance_calculation.distance_calculation()
dist_obj.set_args(names=names, view_img=True)
while cap.isOpened():
succes, im0 = cap.read().
if not succes:
print("Video is empty or video process completed successfully").
break
key = cv2.waitKey(1) & 0xFF
if key == ord('q'):
cap.release()
cv2.destroyAllWindows()
break
tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)
cap.release()
cv2.destroyAllWindows()

I get the following in my terminal:
0: 480x640 1 tv, 1 laptop, 1 mouse, 350.5ms
Speed: 1.0ms preprocessing, 350.5ms inference, 1.0ms postprocessing per shaped image (1, 3, 480, 640)

However, I would like to disappear all that and only have in the terminal the distance between the two selected objects. How can I do this?

[glenn-jocher]

@Erubiel-sudo hey there! For honing in on just the distance between two selected objects in the terminal, you can customize the distance calculation output. Modify the distance_calculation.py function called start_process, specifically where it prints the results. Here's a tiny tweak to guide you:

Find the part in start_process where the distances are printed, then comment out or remove any print statements you don't need, ensuring only the distances between your objects of interest are printed. Supposing distance_calculation's start_process function processes tracks to get distances, focus on that section.

For simplicity, let's say we filter for the two objects based on class names or IDs, and then print their distance:

# Example modification
if target_objects in names:
    print(f"Distance between {object1} and {object2}: {distance} meters")

Ensure you replace target_objects, object1, object2, and distance with the actual variables from your context. This modification will print only the distance between your two selected objects, omitting the other details. 🚀

Most modifications will be context-specific, so adapt the code to fit your actual use case. Happy coding!

[Erubiel-sudo]

Hiii, how can I print the calculated distance I see in the camera window when I select the two detected objects with the mouse but in my terminal? I mean I want to see both sides, in the window and in my terminal.

[glenn-jocher]

Hey there! 😄 You can easily show the calculated distance in your terminal by adding a bit of code to print out the distance values that you're already visualizing in the camera window. Here's a quick example based on the distance_calculation solution you're using:

# After calculating the distance in your loop
print(f"Distance between objects: {dist_obj.distance} meters")

Make sure to replace dist_obj.distance with the actual variable that holds your distance value. This line will print the distance between your selected objects in the terminal parallel to displaying it in the window. Happy coding! 🚀

[zeiinajj]

whenever i try to run any version of this code i get an error message that there's no module called ultralytics.solutions despite having downloaded ultralytics using pip install. TIA!!

[glenn-jocher]

Hey there! 🌟 It seems like there's a small hiccup with the package setup. Could you double-check that you've installed the correct Ultralytics YOLOv8 package with:

pip install ultralytics

If you've already done that and the error persists, it might be a good idea to ensure your environment is using the correct Python version and you are in the right virtual environment (if you're using one).

In some cases, a conflict with existing packages might cause such issues. A fresh virtual environment could help:

python -m venv yolo-env
source yolo-env/bin/activate  # On Windows, use `yolo-env\Scripts\activate`
pip install ultralytics

Give this a try and let us know how it goes! If you're still facing issues, we're here to dive deeper into the problem. 🛠️

[zeiinajj]

yess thank you it was in fact a version mismatch and the code was executed but it doesnt return any distance values,
here's the code im using, Thanks in advance!!

from ultralytics.solutions import distance_calculation
import cv2
import argparse

from ultralytics import YOLO

def parse_arguments() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="YOLOv8 live")
    parser.add_argument(
        "--webcam-resolution",
        default=[1280, 720],
        nargs=2,
        type=str
    )
    arg = parser.parse_args()
    return arg


# Load the model
model = YOLO("yolov8n.pt")

# Initialize the video capture
args = parse_arguments()
frame_width, frame_height = args.webcam_resolution
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, frame_width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, frame_height)
assert cap.isOpened(), "Error opening video file"

# Initialize distance calculation object
# dist_obj = distance_calculation.DistanceCalculation()
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=model.names, view_img=True)
names_dict = {i: name for i, name in enumerate(model.names)}
# dist_obj.set_args(names=names_dict, view_img=True)
# dist_obj.set_args(names=model.names, view_img=True)
# Process video frames
while True:
    success, frame = cap.read()
    if not success:
        break
    # Run object tracking
    tracks = model.track(frame, persist=True)
    # Calculate distances and update the frame
    processed_frame = dist_obj.start_process(frame, tracks)
    # print('####', type(processed_frame), '####')
    # Check if the processed frame is valid
    if processed_frame is not None and processed_frame.size != 0:
        # Display the frame
        cv2.imshow('Distance Calculation', processed_frame)
    else:
        print("Received an empty frame from distance calculation.")
    # Display the frame
    # Calculate distances and update the frame
    # cv2.imshow('Distance Calculation', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

@zeiinajj hey there! 👋 It seems like the issue lies in the start_process function not returning any distance values. Based on the shared code and documentation, I have a couple of suggestions:

1. Ensure you're correctly clicking on the bounding boxes in the displayed video frames with the left mouse button to calculate distances between objects. The distance calculation feature requires user interaction to select which bounding boxes to calculate the distance between.

2. Check if the tracks variable returned from model.track() contains valid tracking information (e.g., bounding boxes with object IDs). This can be quickly verified by printing the contents of tracks.

3. Your current set_args seems fine, but make sure that the names field in DistanceCalculation is being correctly populated. The example in your provided docs uses names = model.model.names, which slightly differs from names=model.names in your code. If model.names is not working as expected, you might want to try using model.model.names instead, ensuring it aligns with the documentation.

4. Double-check you've implemented mouse callback functions for drawing and selecting points if this step is necessary for your application's workflow. The documentation hints at mouse interactions for distance calculations which might not be explicitly coded in your snippet.

Here's an updated snippet for initializing DistanceCalculation, adjusting based on the docs:

# Assuming model is loaded and names are acquired
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(names=model.model.names, view_img=True)

Finally, make sure you're interacting with the video frame window (not just watching it) to trigger distance calculations. If these tips don't resolve the issue, would you mind sharing more about how you're expecting to calculate distances (automatically or via manual selection) and any error messages or outputs you're seeing? This info will help dig deeper into the root cause. Thanks for reaching out! 🚀

[MoAbbasid]

how can I use this in images with normal bounding boxes, how can I use it that way?
TypeError: DistanceCalculation.start_process() missing 1 required positional argument: 'tracks'

[pderrenger]

Hi there! It seems like you're encountering an error related to missing tracks argument in the DistanceCalculation.start_process() method. Make sure you're generating the tracks by calling the model.track() method first and passing its output to distance_calculation.DistanceCalculation.start_process() as shown in the code example below:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8n.pt")

# Assuming you're processing an image ('im0')
tracks = model.track(im0, persist=True)

dist_obj = distance_calculation.DistanceCalculation()
# Now passing 'tracks' to 'start_process'
im0_with_distance = dist_obj.start_process(im0, tracks)

Make sure im0 is your image where you've successfully detected objects using the YOLO model. This workflow allows you to calculate distances between bounding box centroids. If you're already doing this and still facing issues, could you provide more context or code snippets for a clearer picture?

Happy coding! 😊

[MoAbbasid]

@pderrenger but I dont want to use tracking I want to just get the distance after the object detection task

[pderrenger]

Hey there! 😊 If you're looking to calculate distance between detected objects without using tracking, you can directly use the distance_calculation after detection with YOLOv8. Here's a simple example for images. You just need to replace model.track() with model() for detection:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

model = YOLO("yolov8n.pt")

# Load your image
im0 = cv2.imread('path/to/your/image.jpg')

# Detect objects
results = model(im0)

# Init distance calculation object and process the image
dist_obj = distance_calculation.DistanceCalculation()
im0_with_distances = dist_obj.start_process(im0, results)

# Now you can show or save im0_with_distances as needed

Remember to left-click on any two bounding boxes in the output window to see the distance calculation. 📏

Great for ad-hoc distance measurement tasks without the need for tracking across frames. Hope this helps!

[tabi99]

You've set the pixel per meter to 10 in this. Could you tell me how you found out the pixel per meter? In a real-time scenario, there could be different cameras, so for accurate results, the pixel per meter should also be accurate. I'm awaiting your response

[throughheavenandearthimtheonlyone]

What is the minimum measurement in centimeters for each detected object?

[throughheavenandearthimtheonlyone]

Traceback (most recent call last):
File "D:\Kumpulan Projek\Formulatrix\calculate_distance.py", line 26, in
cv2.imshow('Frame', frame)
File "C:\Users\acer\AppData\Local\Programs\Python\Python310\lib\site-packages\ultralytics\utils\patches.py", line 56, in imshow
_imshow(winname.encode("unicode_escape").decode(), mat)
cv2.error: OpenCV(4.9.0) D:\a\opencv-python\opencv-python\opencv\modules\highgui\src\window.cpp:971: error: (-215:Assertion failed) size.width>0 && size.height>0 in function 'cv::imshow'

I have this error, this is my code :
from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

Load model

model = YOLO("assets/models/tipshape.pt")

Initialize video

cap = cv2.VideoCapture("assets/data/Test.mp4")
assert cap.isOpened(), "Error opening video file"

Init distance calculation object

dist_calc = distance_calculation.DistanceCalculation()

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

# Perform tracking
tracks = model.track(frame, persist=True, show=False)

# Calculate and draw distances
frame = dist_calc.start_process(frame, tracks)

# Optional: Display the frame
cv2.imshow('Frame', frame)
if cv2.waitKey(1) == ord('q'): break

cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

@throughheavenandearthimtheonlyone Hi there! It looks like you're encountering an error because the frame being passed to cv2.imshow() is empty, which typically happens if cap.read() reads an empty frame or the end of the video is reached. You've already included a check for if not success: break, but cv2.imshow('Frame', frame) is still being called on an empty frame.

To fix this, you can reposition your cv2.imshow() call inside the if not success: condition to ensure it only attempts to display non-empty frames. Here’s the corrected part of your code:

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break  # If there's no frame read, break out of the loop

    # Perform tracking and calculate and draw distances
    tracks = model.track(frame, persist=True, show=False)
    frame = dist_calc.start_process(frame, tracks)

    # Optional: Display the frame
    if frame.size > 0:
        cv2.imshow('Frame', frame)
        if cv2.waitKey(1) == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()

Here, if frame.size > 0: ensures that only non-empty frames are displayed. 👍 Let me know if this helps or if you have any more questions!

[throughheavenandearthimtheonlyone]

Yes thanks, but now its different error
This is the error :
Traceback (most recent call last):
if frame.size > 0:
AttributeError: 'NoneType' object has no attribute 'size'

[glenn-jocher]

Hey there! It seems like the error is due to trying to access .size on a None type, which means that frame is None. This usually happens if cap.read() fails to read the frame correctly. You should check if frame is None before trying to access its attributes. Here's a quick fix for your code:

while cap.isOpened():
    success, frame = cap.read()
    if not success or frame is None:
        break  # If there's no frame read or frame is None, break out of the loop

    # Perform tracking and calculate and draw distances
    tracks = model.track(frame, persist=True, show=False)
    frame = dist_calc.start_process(frame, tracks)

    # Optional: Display the frame
    cv2.imshow('Frame', frame)
    if cv2.waitKey(1) == ord('q'):
        break

This code adjustment ensures that we safely handle cases where the frame might be None. Let me know if this resolves the issue! 😊

[skp4595]

how is this "Conversion factor from pixels to meters" working?
how have you calibrated ?
have you compared it with the ground truth?

[glenn-jocher]

The "Conversion factor from pixels to meters" in the DistanceCalculation is a user-defined parameter that translates pixel measurements into real-world units (meters). This factor depends on the specific setup and calibration of your camera system, including its field of view and the actual distance from the camera to the objects being measured.

Calibration typically involves measuring known distances in the camera's view to establish a relationship between pixel dimensions and real-world metrics. This can be done by placing markers at known distances and adjusting the pixels_per_meter value until the calculated distances match the real-world measurements.

We haven't provided specific ground truth comparisons in the documentation, as calibration can vary widely depending on individual use cases and environments. It's recommended to perform your own calibration tests to fine-tune this parameter for your specific requirements. If you need further guidance on this, feel free to ask! 📏👀

[A-tavv]

is it gonna integrate with object detection by YOLO v8 both together showing the bounding boxes with Distance and type of the objects?

[glenn-jocher]

Absolutely! You can integrate distance calculation with object detection using YOLOv8. This setup will allow you to display bounding boxes along with the calculated distances and object types. By leveraging the DistanceCalculation class in conjunction with YOLOv8's tracking capabilities, you can achieve this seamlessly.

Here's a brief example to get you started:

import cv2
from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
names = model.model.names

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
dist_obj = solutions.DistanceCalculation(names=names, view_img=True)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = dist_obj.start_process(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

For more details on how to implement this, you can refer to the Distance Calculation Guide. If you have any further questions, feel free to ask! 😊

[cstonestreet]

How can I adapt the code from above to work with an instance segmentation model? I am detecting railroad lines, so the bounding boxes are not very accurate a lot of the time, and I want to use the masks from my segmentation model to calculate my distances.

Here is my code:
import cv2
from ultralytics import YOLO, solutions

model = YOLO("YOLOv8-pretrained-200-epochs.pt")
names = model.model.names

cap = cv2.VideoCapture("IMG_2688.MOV")
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

dist_obj = solutions.DistanceCalculation(names=names, view_img=True)

while cap.isOpened():
success, im0 = cap.read()
if not success:
print("Video frame is empty or video processing has been successfully completed.")
break

tracks = model.track(im0, persist=True, show=False)
im0 = dist_obj.start_process(im0, tracks)
video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

[pderrenger]

To adapt your code for instance segmentation and use masks for distance calculation, you'll need to modify your model loading and processing steps to handle segmentation outputs. Here's how you can adjust your code:

1. Load a Segmentation Model: Ensure you're using a YOLO model trained for segmentation, such as yolov8n-seg.pt.

2. Modify Distance Calculation: Instead of using bounding box centroids, you'll calculate distances based on the centroids of the segmentation masks.

Here's an updated version of your code snippet:

import cv2
from ultralytics import YOLO, solutions

# Load a segmentation model
model = YOLO("yolov8n-seg.pt")  # Make sure the model is trained for segmentation
names = model.model.names

cap = cv2.VideoCapture("IMG_2688.MOV")
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
dist_obj = solutions.DistanceCalculation(names=names, view_img=True)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    # Perform segmentation and tracking
    results = model.segment(im0, show=False)  # Use segment instead of track
    masks = results.masks  # Get segmentation masks
    centroids = [mask.centroid for mask in masks]  # Calculate centroids from masks

    # Optionally, visualize the centroids and calculate distances
    for centroid in centroids:
        cv2.circle(im0, centroid, 5, (0, 255, 0), -1)  # Draw centroids

    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

This code now handles segmentation masks and calculates centroids directly from these masks, which should be more accurate for your use case with railroad lines. Adjust further based on your specific requirements and the outputs from your model.

[cstonestreet]

Using that code I am receiving this error:
Traceback (most recent call last):
File "C:\Users\cmsto\PycharmProjects\YOLOv8-distance-calculation\distance-calculation.py", line 27, in
results = model.segment(im0, show=False) # Use segment instead of track
^^^^^^^^^^^^^
File "C:\Users\cmsto\PycharmProjects\YOLOv8-distance-calculation.venv\Lib\site-packages\torch\nn\modules\module.py", line 1709, in getattr
raise AttributeError(f"'{type(self).name}' object has no attribute '{name}'")
AttributeError: 'YOLO' object has no attribute 'segment'

[pderrenger]

@cstonestreet hello,

It seems like you're encountering an issue because the segment method is not available in the YOLO object. This typically happens if the model loaded is not configured for segmentation tasks or if there's a version mismatch where the segmentation feature isn't supported.

Please ensure that:

1. You are using a YOLO model specifically trained for segmentation tasks, such as yolov8n-seg.pt.
2. Your Ultralytics YOLO installation is up-to-date as segmentation capabilities might have been introduced in a later version than the one you're using.

You can update your installation via pip:

pip install --upgrade ultralytics

If the issue persists after these checks, it might be helpful to revisit the documentation or reach out with more details so we can assist you better.

[cstonestreet]

I am still having the same issues. I have verified that my model is configured for segmentation. Here is my current code:
from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

Load the model

model = YOLO("YOLOv8-pretrained-200-epochs-seg.pt")

Initialize video capture from a .MOV video file

video_path = 'IMG_2688.MOV'
cap = cv2.VideoCapture(video_path) # Use '0' for webcam

Check if the source is opened successfully

if not cap.isOpened():
raise Exception("Error opening video source")

Initialize the distance calculation object

dist_obj = distance_calculation.DistanceCalculation(names=model.model.names, view_img=True)

while cap.isOpened():
success, im0 = cap.read()
if not success:
break # Exit loop if no more frames

# Track objects and calculate distance
tracks = model.track(im0, persist=True, show=True, imgsz=640, classes=[1])
im0 = dist_obj.start_process(im0, tracks)

# Display the image with calculated distances
cv2.imshow('Distance Calculation', im0)
if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
    break

cap.release()
cv2.destroyAllWindows()

Currently, this code displays two images per frame, one with bounding boxes and one with masks. However, I cannot perform the distance calculation on either of them. I just want to display the image with the masks and perform distance calculations on the masks.

[pderrenger]

Hello there! 👋

Thank you for sharing your code and providing detailed context. It looks like you're on the right track with using the segmentation model for distance calculation. Let's refine your approach to ensure you can perform distance calculations on the segmentation masks and display the results correctly.

Here's an updated version of your code that focuses on using the segmentation masks for distance calculation:

from ultralytics import YOLO
from ultralytics.solutions import distance_calculation
import cv2

# Load the segmentation model
model = YOLO("YOLOv8-pretrained-200-epochs-seg.pt")

# Initialize video capture from a .MOV video file
video_path = 'IMG_2688.MOV'
cap = cv2.VideoCapture(video_path)  # Use '0' for webcam

# Check if the source is opened successfully
if not cap.isOpened():
    raise Exception("Error opening video source")

# Initialize the distance calculation object
dist_obj = distance_calculation.DistanceCalculation(names=model.model.names, view_img=True)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break  # Exit loop if no more frames

    # Perform segmentation
    results = model(im0, imgsz=640, conf=0.3, iou=0.5, classes=[1])
    
    # Extract masks and calculate centroids
    masks = results.masks
    centroids = [mask.centroid for mask in masks]

    # Optionally, visualize the centroids and calculate distances
    for centroid in centroids:
        cv2.circle(im0, centroid, 5, (0, 255, 0), -1)  # Draw centroids

    # Process the image with distance calculations
    im0 = dist_obj.start_process(im0, results)

    # Display the image with calculated distances
    cv2.imshow('Distance Calculation', im0)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

cap.release()
cv2.destroyAllWindows()

Key Changes:

1. Segmentation Inference: Use model(im0, imgsz=640, conf=0.3, iou=0.5, classes=[1]) to perform segmentation and get the results.
2. Extract Masks: Access the masks from the results using results.masks.
3. Calculate Centroids: Calculate centroids from the masks and draw them on the image.
4. Distance Calculation: Use the dist_obj.start_process(im0, results) to process the image with distance calculations.

This should help you perform distance calculations on the segmentation masks and display the results in a single image. If you encounter any further issues or need additional assistance, feel free to ask! 😊

Happy coding! 🚀

[cstonestreet]

I am trying to calculate the distance from each detected object to the vertical center of the screen so I can compare how far each of them are from the center. I would prefer to do this using the masks because I have an instance segmentation model, but I can do it with bounding boxes too. How can I figure out how far the centroids of each box or mask are from the center? For example, if my image is 640 pixels wide and 320 pixels tall, I want the center of the 640.

[glenn-jocher]

@cstonestreet hello!

Thank you for reaching out with your question. To calculate the distance from each detected object to the vertical center of the screen using either bounding boxes or masks, you can follow the steps below. This method will work for both bounding boxes and instance segmentation masks.

Using Bounding Boxes

1. Calculate the Centroid of Each Bounding Box:
   The centroid of a bounding box can be calculated as the midpoint of its width and height.

2. Calculate the Vertical Center of the Image:
   For an image of width 640 pixels, the vertical center is at x = 320.

3. Calculate the Distance:
   The distance from each centroid to the vertical center can be calculated using the Euclidean distance formula.

Here’s a Python example using bounding boxes:

import cv2
from ultralytics import YOLO

# Load the model
model = YOLO("yolov8n.pt")

# Define the image dimensions
image_width = 640
image_height = 320
vertical_center = image_width / 2

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

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

    # Run inference
    results = model(frame)

    for result in results:
        for box in result.boxes:
            # Calculate the centroid of the bounding box
            x_center = (box.xyxy[0] + box.xyxy[2]) / 2
            y_center = (box.xyxy[1] + box.xyxy[3]) / 2

            # Calculate the distance to the vertical center
            distance = abs(x_center - vertical_center)
            print(f"Distance to vertical center: {distance:.2f} pixels")

cap.release()
cv2.destroyAllWindows()

Using Masks

If you prefer to use instance segmentation masks, you can calculate the centroid of each mask and then compute the distance similarly.

import cv2
from ultralytics import YOLO

# Load the model
model = YOLO("yolov8n-seg.pt")

# Define the image dimensions
image_width = 640
image_height = 320
vertical_center = image_width / 2

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

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

    # Run inference
    results = model(frame)

    for result in results:
        for mask in result.masks:
            # Calculate the centroid of the mask
            moments = cv2.moments(mask)
            if moments["m00"] != 0:
                x_center = int(moments["m10"] / moments["m00"])
                y_center = int(moments["m01"] / moments["m00"])

                # Calculate the distance to the vertical center
                distance = abs(x_center - vertical_center)
                print(f"Distance to vertical center: {distance:.2f} pixels")

cap.release()
cv2.destroyAllWindows()

Additional Resources

For more detailed information on distance calculation using Ultralytics YOLOv8, you can refer to our Distance Calculation Guide.

If you encounter any issues or have further questions, please ensure you are using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example will help us assist you better. You can find more information on creating a reproducible example here.

Happy coding! 🚀

[palsreejib]

Hi, I am very new to deep learning, and I'm trying to build a model from YOLOv8 with transfer learning to estimate the speed and calculate the distance of vehicles in a given data set. Although the ultralytics documentation is quite robust, I am still determining how to code them together. I want to train my model on the custom data set, and finally, from the measured distance and speed, I want to calculate the time to collision. So, I would appreciate any help from the community; thanks! By the way, I am working with a dataset consisting of temporally nearby frames.

[glenn-jocher]

Hi @palsreejib,

Thank you for your detailed question! Let's address your concerns:

1. File Path Error:
   The issue might be related to the way the path is specified. In Python, backslashes (\) in strings can be interpreted as escape characters. To avoid this, you can either use raw strings by prefixing the string with r or replace backslashes with forward slashes (/). Here’s how you can specify the path correctly:

   root_folder = r"D:\Downloads\Intel_Unnati\DataSets\idd_temporal_train_1\idd_temporal_train_1\00031"

   Alternatively:

   root_folder = "D:/Downloads/Intel_Unnati/DataSets/idd_temporal_train_1/idd_temporal_train_1/00031"

2. Dataset Path Clarification:
   Yes, you should provide the path to the folder that contains subfolders with images. The code will then iterate through each subfolder and process the images within them. Here’s a quick recap of the structure:

   dataset/
   ├── images/
   │   ├── train/
   │   ├── val/
   │   └── test/
   ├── labels/
   │   ├── train/
   │   ├── val/
   │   └── test/
   └── dataset.yaml
   

   Ensure that your dataset.yaml correctly points to these directories.

3. Training with Custom Dataset:
   Make sure your dataset is structured correctly and your dataset.yaml file is properly configured. Here’s a quick example:

   train: path/to/dataset/images/train
   val: path/to/dataset/images/val
   test: path/to/dataset/images/test  # Optional
   
   nc: 80  # Number of classes
   names: ['class1', 'class2', 'class3', ...]  # List of class names

   Then, you can train your model with:

   from ultralytics import YOLO
   
   # Load a pretrained YOLOv8 model
   model = YOLO('yolov8n.pt')
   
   # Train the model on your custom dataset
   model.train(data='path/to/dataset.yaml', epochs=50, imgsz=640)

If you continue to face issues, please ensure you are using the latest versions of torch and ultralytics:

pip install --upgrade torch ultralytics

Feel free to reach out if you have any more questions or need further assistance. The YOLO community and the Ultralytics team are here to help! 😊

Happy coding and best of luck with your project! 🚀

[palsreejib]

Hey @glenn-jocher, I tried rerunning the code this time with a simple video, but I am getting the following error:

AssertionError Traceback (most recent call last)
in <cell line: 10>()
8
9 cap = cv2.VideoCapture(r"D:\Documents\Jupyter")
---> 10 assert cap.isOpened(), "Error reading video file"
11 w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
12

AssertionError: Error reading video file

Also how can I can calculate the accuracy of the model, maybe like plot a loss curve in a different code block? Anyways could you please help me with the error?

[glenn-jocher]

Hi @palsreejib,

Thank you for your detailed question! Let's address the issues you're encountering.

1. File Path Error

The error AssertionError: Error reading video file suggests that OpenCV is unable to open the video file. Please ensure that the path to your video file is correct and that the file exists at that location. Here’s how you can specify the path correctly:

cap = cv2.VideoCapture(r"D:\Documents\Jupyter\your_video_file.mp4")
assert cap.isOpened(), "Error reading video file"

2. Calculating Model Accuracy and Plotting Loss Curve

To calculate the accuracy of your model and plot a loss curve, you can use the training results provided by YOLOv8. Here’s an example of how you can do this:

from ultralytics import YOLO
import matplotlib.pyplot as plt

# Load a pretrained YOLOv8 model
model = YOLO('yolov8n.pt')

# Train the model on your custom dataset
results = model.train(data='path/to/dataset.yaml', epochs=50, imgsz=640)

# Plotting the loss curve
plt.figure(figsize=(10, 5))
plt.plot(results['train']['loss'], label='Training Loss')
plt.plot(results['val']['loss'], label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Loss Curve')
plt.legend()
plt.show()

Additional Resources

For more detailed guidance on distance calculation, you can refer to the Distance Calculation Guide. This guide provides comprehensive instructions and examples to help you implement distance calculation effectively.

Feel free to reach out if you have any more questions or need further assistance. The YOLO community and the Ultralytics team are here to help! 😊

Happy coding and best of luck with your project! 🚀

[palsreejib]

Hey, I tried the modifications but am still getting some errors; somehow, my Colab is not able to work with OpenCV, and I am also getting a return-type error.

WARNING ⚠️ Environment does not support cv2.imshow() or PIL Image.show()

0: 384x640 2 persons, 4 cars, 1 bus, 279.6ms
Speed: 15.7ms preprocess, 279.6ms inference, 1.6ms postprocess per image at shape (1, 3, 384, 640)

TypeError Traceback (most recent call last)
in <cell line: 22>()
32 current_centroids = {}
33 for track in tracks:
---> 34 track_id = track['id']
35 centroid = track['bbox'].center # Assuming bbox has a center method
36 current_centroids[track_id] = centroid

2 frames
/usr/local/lib/python3.10/dist-packages/ultralytics/engine/results.py in getitem(self, idx)
153 def getitem(self, idx):
154 """Return a Results object for a specific index of inference results."""
--> 155 return self._apply("getitem", idx)
156
157 def len(self):

/usr/local/lib/python3.10/dist-packages/ultralytics/engine/results.py in _apply(self, fn, *args, **kwargs)
198 v = getattr(self, k)
199 if v is not None:
--> 200 setattr(r, k, getattr(v, fn)(*args, **kwargs))
201 return r
202

/usr/local/lib/python3.10/dist-packages/ultralytics/engine/results.py in getitem(self, idx)
74 def getitem(self, idx):
75 """Return a new BaseTensor instance containing the specified indexed elements of the data tensor."""
---> 76 return self.class(self.data[idx], self.orig_shape)
77
78

TypeError: new(): invalid data type 'str'

[glenn-jocher]

Hi @palsreejib,

Thank you for your patience and for providing detailed information about the issues you're facing. Let's address them one by one.

1. OpenCV and Colab Environment

The warning Environment does not support cv2.imshow() or PIL Image.show() indicates that Colab does not support displaying images directly using OpenCV's imshow or PIL's show methods. Instead, you can use cv2_imshow from google.colab.patches to display images in Colab.

2. TypeError in Tracking Code

The TypeError: new(): invalid data type 'str' suggests there might be an issue with how the tracking results are being accessed. Let's ensure that the tracking results are being handled correctly.

Updated Code Example

Here’s an updated version of your code that should work in Colab and handle the tracking results correctly:

import cv2
from ultralytics import YOLO, solutions
from google.colab.patches import cv2_imshow

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")
names = model.model.names

# Open the video file
cap = cv2.VideoCapture(r"D:\Documents\Jupyter\your_video_file.mp4")
assert cap.isOpened(), "Error reading video file"

# Video writer setup (optional, if you want to save the output as a video)
output_video_path = "distance_speed_calculation.avi"
fps = 30  # Assuming 30 frames per second
w, h = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init distance-calculation obj
dist_obj = solutions.DistanceCalculation(names=names, view_img=True)

# Dictionary to store previous centroids for speed calculation
prev_centroids = {}

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    # Perform tracking
    tracks = model.track(im0, persist=True, show=False)
    im0 = dist_obj.start_process(im0, tracks)

    # Calculate speed
    current_centroids = {}
    for track in tracks:
        track_id = track.id
        bbox = track.bbox
        centroid = ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)  # Calculate centroid
        current_centroids[track_id] = centroid

        if track_id in prev_centroids:
            prev_centroid = prev_centroids[track_id]
            distance = ((centroid[0] - prev_centroid[0]) ** 2 + (centroid[1] - prev_centroid[1]) ** 2) ** 0.5
            speed = distance * fps  # Speed in pixels per second
            cv2.putText(im0, f"Speed: {speed:.2f} px/s", (int(centroid[0]), int(centroid[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)

    prev_centroids = current_centroids

    # Write the frame to the video
    video_writer.write(im0)

    # Display the frame in Colab
    cv2_imshow(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

Plotting Loss Curve

To plot the loss curve, you can use the training results provided by YOLOv8. Here’s an example:

from ultralytics import YOLO
import matplotlib.pyplot as plt

# Load a pretrained YOLOv8 model
model = YOLO('yolov8n.pt')

# Train the model on your custom dataset
results = model.train(data='path/to/dataset.yaml', epochs=50, imgsz=640)

# Plotting the loss curve
plt.figure(figsize=(10, 5))
plt.plot(results['train']['loss'], label='Training Loss')
plt.plot(results['val']['loss'], label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Loss Curve')
plt.legend()
plt.show()

Additional Resources

For more detailed guidance on distance calculation, you can refer to the Distance Calculation Guide.

Feel free to reach out if you have any more questions or need further assistance. The YOLO community and the Ultralytics team are here to help! 😊

Happy coding and best of luck with your project! 🚀

[wslovenide]

May I ask if it is possible to detect the length and width of objects in the video

[wslovenide]

the unit of length and width is cm, mm

[glenn-jocher]

@wslovenide yes, you can detect the length and width of objects in a video using Ultralytics YOLOv8. By calculating the bounding box dimensions, you can convert these pixel measurements to real-world units like cm or mm using a conversion factor. For more details, you can refer to the distance calculation guide at https://docs.ultralytics.com/guides/distance-calculation/. This will help you set up the necessary calculations and visualizations.

[laptop1990]

where is DistanceCalculation.py file?

[pderrenger]

@laptop1990 it looks like you're encountering an import error with the DistanceCalculation class. Please ensure you are using the latest version of the Ultralytics package, as updates may resolve this issue. If the problem persists, verify that the DistanceCalculation class is correctly implemented in the ultralytics.solutions module. You can refer to the Ultralytics documentation on distance calculation for further guidance. If the issue continues, please provide more details so we can assist you better.

[laptop1990]

import cv2
import os
from ultralytics import YOLO
import numpy as np
import logging

Set up logging

logging.basicConfig(level=logging.INFO)

Constants

MODEL_PATH = r'D:\map and path creation\model\best.pt'
IMAGE_PATH = r"D:\map and path creation\image\1 (182).jpg"
DISTANCE_THRESHOLD = 100
DISPLAY_HEIGHT = 720
LOCKPIN_CLASS_ID = 1 # Assuming lockpin class has ID 1. Adjust accordingly if different.
REFERENCE_PIXEL_DISTANCE = 600 # Example: measured pixel distance in the image
REFERENCE_REAL_DISTANCE = 500 # Example: real-world distance in mm

Function to resize the image with aspect ratio

def resize_with_aspect_ratio(image, width=None, height=None, inter=cv2.INTER_AREA):
dim = None
(h, w) = image.shape[:2]
if width is None and height is None:
return image
if width is None:
r = height / float(h)
dim = (int(w * r), height)
else:
r = width / float(w)
dim = (width, int(h * r))
return cv2.resize(image, dim, interpolation=inter)

Load the YOLOv8 model

if not os.path.isfile(MODEL_PATH):
raise FileNotFoundError(f"Model file not found: {MODEL_PATH}")

model = YOLO(MODEL_PATH)

Open the image file

if not os.path.isfile(IMAGE_PATH):
raise FileNotFoundError(f"Image file not found: {IMAGE_PATH}")

results = model.track(IMAGE_PATH, tracker="bytetrack.yaml", persist=True)

if not results:
logging.error("No results returned from model tracking.")
exit()

img = results[0].plot()
height, width, _ = img.shape

boxes = results[0].boxes.xyxy.cpu().numpy().astype(int) if results[0].boxes.xyxy is not None else []
ids = results[0].boxes.id.cpu().numpy().astype(int) if results[0].boxes.id is not None else []
class_ids = results[0].boxes.cls.cpu().numpy().astype(int) if results[0].boxes.cls is not None else []

if len(boxes) == 0 or len(ids) == 0:
logging.warning("No detections found in the image.")
exit()

List to store center points of lockpin class

center_points = []

for box, id, cls in zip(boxes, ids, class_ids):
if cls == LOCKPIN_CLASS_ID:
int_id = int(id)

    # Extract bounding box coordinates
    x_min, y_min, x_max, y_max = box
    
    # Calculate center point of bounding box
    center_x = (x_min + x_max) // 2
    center_y = (y_min + y_max) // 2

    # Calculate distance from left side of the frame to center point
    distance_from_left = center_x

    # Log center coordinates and distance
    logging.info(f"ID: {int_id} - Center Point: ({center_x}, {center_y}), Distance from left: {distance_from_left}")
    
    # Append center point to the list
    center_points.append((center_x, center_y))

    # Draw a circle at the center of the bounding box
    cv2.circle(img, (center_x, center_y), 10, (0, 255, 0), thickness=2)

Group center points based on distance threshold

center_points = sorted(center_points, key=lambda x: x[0])

groups = []
current_group = [center_points[0]] if center_points else []

for i in range(1, len(center_points)):
if center_points[i][0] - current_group[-1][0] <= DISTANCE_THRESHOLD:
current_group.append(center_points[i])
else:
groups.append(current_group)
current_group = [center_points[i]]
if current_group:
groups.append(current_group)

Function to calculate real-world distance

def calculate_real_distance(pixel_distance, reference_pixel_distance, reference_real_distance):
real_distance_mm = (pixel_distance / reference_pixel_distance) * reference_real_distance
return real_distance_mm / 1000, real_distance_mm # Convert to meters and mm

Draw vertical lines for each group and calculate distances

previous_avg_x = None
for i, group in enumerate(groups):
avg_x = int(np.mean([point[0] for point in group]))
cv2.line(img, (avg_x, 0), (avg_x, height), (0, 0, 255), thickness=2)
cv2.putText(img, f'rail{i+1}', (avg_x + 5, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

if previous_avg_x is not None:
    pixel_distance = abs(avg_x - previous_avg_x)
    real_distance_m, real_distance_mm = calculate_real_distance(pixel_distance, REFERENCE_PIXEL_DISTANCE, REFERENCE_REAL_DISTANCE)
    
    # Draw a horizontal line between the vertical lines
    mid_y = height // 2
    cv2.line(img, (previous_avg_x, mid_y), (avg_x, mid_y), (255, 0, 0), thickness=2)
    
    # Display the calculated real-world distance
    distance_text = f'{real_distance_m:.2f}m'
    mid_x = (previous_avg_x + avg_x) // 2
    cv2.putText(img, distance_text, (mid_x, mid_y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
    
    logging.info(f"Distance between rail{i} and rail{i+1}: {real_distance_m:.2f} meters ({real_distance_mm:.2f} mm)")

previous_avg_x = avg_x

Resize the image for display

resized_img = resize_with_aspect_ratio(img, height=DISPLAY_HEIGHT)
cv2.imshow('Detected Frame', resized_img)

Wait for 'q' key to close the display window

while True:
if cv2.waitKey(0) & 0xFF == ord("q"):
break

cv2.destroyAllWindows()

here is code i want to calculate real or actual distance between two vertical line
please update in code if have any idea...

[pderrenger]

It looks like you're trying to calculate the real distance between two vertical lines using Ultralytics YOLOv8. To address the import error, please ensure you have the latest version of the Ultralytics package installed. You can update it using pip install --upgrade ultralytics.

For calculating distances, you should use the DistanceCalculation class correctly. Ensure your import statement is correct and matches the latest documentation. If the issue persists, please refer to the Ultralytics documentation on distance calculation for detailed guidance. If you need further assistance, feel free to ask!

[laptop1990]

yes ,we are trying to calculate the real distance between two vertical lines using Ultralytics YOLOv8 please update in code
if you have any idea about this or method or library please check in above code....

[pderrenger]

To calculate the real distance between two vertical lines using Ultralytics YOLOv8, you can utilize the DistanceCalculation class. Ensure you have the latest version of the Ultralytics package installed. The DistanceCalculation class helps in converting pixel distances to real-world measurements. For detailed implementation, refer to the distance calculation guide. If you encounter any issues, please check if they persist with the latest package version.

[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-jocher]

@Dmitrii-Smirnov to calculate distances between detected people in each frame and save the results to a CSV file, you can use the DistanceCalculation class as shown in the example. The method calculate_distance(obj1, obj2) is correct for your task. For detailed guidance, please refer to our documentation: https://docs.ultralytics.com/guides/distance-calculation/.

[Dmitrii-Smirnov]

Thank you!

[glenn-jocher]

@Dmitrii-Smirnov to calculate distances between detected people in each frame and save the results to a CSV file, you can use the DistanceCalculation class. Here's a basic implementation:

import cv2
import csv
from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
names = model.model.names

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

dist_obj = solutions.DistanceCalculation(names=names, view_img=False)

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

        tracks = model.track(im0, persist=True, show=False)
        distances = dist_obj.calculate_distances(tracks)

        for (obj1, obj2, distance) in distances:
            writer.writerow([frame_count, obj1, obj2, distance])

        frame_count += 1

cap.release()

This script captures video frames, calculates 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/.

[gaodaren47297]

Hi，Is there a method to calculate the distance between the camera and the objects？

[glenn-jocher]

@gaodaren47297 to calculate the distance between the camera and objects using Ultralytics YOLOv8, you can utilize the DistanceCalculation class to estimate distances based on bounding box centroids. This involves processing video frames with YOLOv8 and calculating distances between selected objects. For a detailed guide, please refer to the distance calculation documentation on our website. If you have further questions, feel free to ask here.

[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-jocher]

@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.

[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-jocher]

@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!

[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-jocher]

@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="yolo11n.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!

[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!

[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-jocher]

@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.

[dgnovo]

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

[glenn-jocher]

@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 DistanceCalculation implementation to customize the process for your needs: https://docs.ultralytics.com/guides/distance-calculation/.