guides/distance-calculation/

[giscus[bot]]

guides/distance-calculation/

Distance Calculation Using Ultralytics YOLOv8

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!

[Yh11001]

Traceback (most recent call last): File "C:\Users\lenovo\Desktop\ultralytics-main\ultralytics.egg-info\ripeness_demo.py", line 27, in <module> cls_id = result.cls # Get the class ID File "C:\Users\lenovo\Desktop\ultralytics-main\ultralytics\utils\__init__.py", line 160, in __getattr__ raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}") AttributeError: 'Results' object has no attribute 'cls'. See valid attributes below. 在 2024-04-16 08:44:57，"Paula Derrenger" ***@***.***> 写道： Hello Paula, Thanks for reaching out and sharing the specifics of your classes! 🌱 Based on your class names 'low', 'mid', and 'high', I suggest a minor adjustment to the provided example to reflect your class names accurately. Here's how you can customize the output to display the maturity stage according to your classification: fromultralyticsimportYOLOmodel=YOLO("path/to/your/model.pt") # Load your trained modelsuccess, img=cap.read() # Assuming 'cap' is your cv2.VideoCapture objectresults=model.predict(img) # Run prediction on the imageforresultinresults: cls_id=result.cls# Get the class IDmaturity=model.model.names[cls_id] # Get the maturity stage name: 'low', 'mid', or 'high'print(f"Tomato maturity stage: {maturity}") Remember to replace "path/to/your/model.pt" with the actual path to your trained model. This snippet will correctly interpret the class IDs as 'low', 'mid', and 'high', matching your setup. If you have any further questions or need additional assistance, feel free to reach out again. Happy coding! 🚀 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[pderrenger]

Hello Paula,

It seems there's a small mix-up in retrieving the class ID from the results. The correct approach to access class IDs from the results would be to use result.boxes.cls[0] instead of result.cls. Here’s a revised snippet for your use case:

from ultralytics import YOLO

# Load your trained model
model = YOLO("path/to/your/model.pt")  

# Assuming 'cap' is your cv2.VideoCapture object
success, img = cap.read()  

# Run prediction on the image
results = model.predict(img)

# Extract class ID, class name, and display maturity stage
for result in results:
    cls_id = result.boxes.cls[0]  # Adjusted part
    maturity = model.model.names[cls_id]  
    print(f"Tomato maturity stage: {maturity}")

Remember to adjust "path/to/your/model.pt" with the actual path to your trained model. This adjusted snippet will correctly interpret the class IDs as 'low', 'mid', or 'high', aligning with your setup.

Should you run into further questions or require additional guidance, feel free to reach out. Happy to assist! 🚀

[Yh11001]

import cv2 import numpy as np from ultralytics import YOLO # 确保正确导入了YOLOv8 # 加载模型 model = YOLO("C:/Users/lenovo/Desktop/ultralytics-main/runs/detect/train_ripeness/weights/best.pt") # 替换为你的模型路径 # 读取图像 image = cv2.imread("C:/Users/lenovo/Desktop/ultralytics-main/ultralytics/cfg/datasets/demo_images_ripeness/images/val/5.jpg") # 进行预测 results = model.predict(image) # 初始化类别计数 counts = {'low_ripeness': 0, 'mid_ripeness': 0, 'high_ripeness': 0} # 遍历预测结果 for xyxy, conf, cls in zip(results.xyxy[0], results.conf[0], results.cls[0]): x1, y1, x2, y2 = map(int, xyxy) category = model.names[cls] # 获取类别名称 confidence = conf # 获取置信度 # 计算红色占比 (这部分代码可能需要调整以匹配你的实际需求) tomato_region = image[y1:y2, x1:x2] hsv = cv2.cvtColor(tomato_region, cv2.COLOR_BGR2HSV) lower_red = np.array([0, 50, 50]) upper_red = np.array([10, 255, 255]) mask = cv2.inRange(hsv, lower_red, upper_red) red_ratio = cv2.countNonZero(mask) / (x2 - x1) * (y2 - y1) # 根据红色占比计算成熟度百分比 (这里需要定义具体的映射逻辑) maturity_percent = int(red_ratio * 100) # 更新类别计数 (这里假设每个检测到的对象都对应一个成熟度类别) counts[category] += 1 # 显示边界框、类别和成熟度百分比 cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2) cv2.putText(image, f"{category}: {maturity_percent}%", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # 显示类别计数 for i, (category, count) in enumerate(counts.items()): cv2.putText(image, f"{category}: {count}", (10, 30 + 20 * i), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) # 显示图像 cv2.imshow("Tomato Ripeness Detection", image) cv2.waitKey(0) cv2.destroyAllWindows() "Error during execution: Traceback (most recent call last): File "C:\Users\lenovo\Desktop\ultralytics-main\ultralytics.egg-info\count&ripeness.py", line 18, in <module> for xyxy, conf, cls in zip(results.xyxy[0], results.conf[0], results.cls[0]): AttributeError: 'list' object has no attribute 'xyxy'" At 2024-04-16 08:31:05, "Glenn Jocher" ***@***.***> wrote: Hey there! Absolutely, here's a streamlined code snippet based on the guidelines: fromultralyticsimportYOLO# Load your custom tomato maturity modelmodel=YOLO("path/to/your/tomato-model.pt") # Load your imageimg=cv2.imread("path/to/your/image.jpg") # Just as an example# Perform predictionresults=model.predict(img) # Loop through detected tomatoes and print their maturity stagesforresultinresults: maturity=model.names[result.cls] # Get the maturity stage nameprint(f"Tomato maturity stage: {maturity}") # Optionally visualize resultsresults.show() This assumes you've got the appropriate model and an image ready to go. The model.predict part handles identifying tomatoes and their maturity stages, while results.show() directly visualizes those annotations on the image for you. 🍅✨ Hope this helps and happy coding! If there's anything more you need, just shout out. — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[glenn-jocher]

@Yh11001 hey!

It looks like you're trying to access attributes directly from the predict() method results, which is returned as a list. You can access predicted attributes like this:

# Assuming 'results' is the outcome of model.predict(image)
for result in results:
    # Each 'result' contains .xyxy (bounding boxes), .conf (confidences), and .cls (class IDs)
    for xyxy, conf, cls_id in zip(result.xyxy[0], result.conf[0], result.cls[0]):
        # Process each object detected in the image
        print(f"Bounding box: {xyxy}, Confidence: {conf}, Class ID: {cls_id}")

Remember, .xyxy[0], .conf[0], and .cls[0] are tensors for the first image in a batch (in your case, there's only one image). If you're predicting on multiple images in one call to predict(), iterate through results to access each image's predictions.

I hope this clarifies the AttributeError you encountered. If you have further questions, feel free to ask! 🚀

[Yh11001]

from ultralytics.yolo.engine.predictor import BasePredictor from ultralytics.yolo.engine.results import Results from ultralytics.yolo.utils import DEFAULT_CFG, LOGGER, SETTINGS, callbacks, ops from ultralytics.yolo.utils.plotting import Annotator, colors, save_one_box from ultralytics.yolo.utils.torch_utils import smart_inference_mode from ultralytics.yolo.utils.files import increment_path from ultralytics.yolo.utils.checks import check_imshow from ultralytics.yolo.cfg import get_cfg error： ModuleNotFoundError: No module named 'ultralytics.yolo' 在 2024-04-16 09:01:14，"Paula Derrenger" ***@***.***> 写道： @Yh11001 hi Paula! 🌟 Absolutely, glad to help! Your approach to integrating the maturity stage of tomatoes into the visual output is spot-on. Just ensure your model is trained to recognize these stages accurately, and your snippet will do the job beautifully. For a more tailored response or additional queries, feel free to reach out. Keep up the great work, and I'm here for any further assistance you might need. Happy coding! 🚀 Also, do check out our guide on Distance Calculation using Ultralytics YOLOv8. It might add an interesting dimension to your project by measuring distances between detected tomatoes or other objects in the frame! 🍅✨ — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: ***@***.***>

[glenn-jocher]

@Yh11001 hi Paula! 🌟

It looks like the issue is linked to a ModuleNotFoundError for 'ultralytics.yolo'. To tackle this, please ensure you have the Ultralytics YOLOv8 package installed correctly. You can install it using pip like so:

pip install ultralytics

If you've already done this and the issue persists, you might want to double-check your Python environment to ensure it's active and correctly configured. Also, verify that the Ultralytics package is properly installed within that environment by running:

pip list | grep ultralytics

This command should return something similar to ultralytics x.x.x, indicating the version number. If you don't see the ultralytics package listed, please try reinstalling it within your active environment.

Feel free to reach out if you need further assistance. Happy to help with your project on tomato maturity stages—and your distance calculation sounds like an awesome feature! 🍅✨

[hammadsatti16]

Is there any method to calculate the distance of every object with respect to camera

[glenn-jocher]

Absolutely, you can calculate the distance between every detected object and the camera using the distance_calculation module provided by Ultralytics YOLOv8! Here's a snippet demonstrating how to set it up in your video stream processing scenario:

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

model = YOLO("yolov8n.pt")

# Initialize video capture and distance calculation
cap = cv2.VideoCapture("path/to/video.mp4")
dist_obj = distance_calculation.DistanceCalculation()

# Ensure video loads correctly
assert cap.isOpened(), "Error reading video file"

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

    # Run tracking and process for distance calculation
    tracks = model.track(im0, persist=True)
    im0 = dist_obj.start_process(im0, tracks)

    # Visualization or further processing here
    cv2.imshow('Distance Calculation', im0)
    if cv2.waitKey(1) == ord('q'):  # Quit on 'q' key press
        break

cap.release()
cv2.destroyAllWindows()

This sets up YOLOv8 for object detection and tracking on a video file, with the distance between objects being calculated based on their bounding box centroids. Adjust the code as necessary for your application, and feel free to explore the optional arguments for further customization. 🚀

[Sani-Gizmo]

How do I calculate distances between two objects from multiple images/pictures(jpg file). not video

[pderrenger]

@Sani-Gizmo hey there! 😊 To calculate distances between two objects in images, you can utilize the distance_calculation solution provided by Ultralytics YOLOv8. Here's a quick guide on how to adapt the process for still images instead of video:

1. Load your YOLO model and the distance calculation object.
2. For each image, run the model to detect objects and obtain their bounding boxes.
3. Use the distance_calculation object to calculate the distances between objects.

Here's an example for a single image:

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

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

# Init distance-calculation object
dist_obj = distance_calculation.DistanceCalculation()

# Load your image
image_path = 'path/to/your/image.jpg'
image = cv2.imread(image_path)
assert image is not None, "Error reading image file"

# Detect objects in the image
tracks = model.track(image, persist=True, show=False)

# Calculate the distances
image_with_distances = dist_obj.start_process(image, tracks)

# Display or save the result
cv2.imshow("Distance Calculation", image_with_distances)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code will load an image, detect objects, and then calculate and display the distances between detected objects. Remember, left mouse click on any two bounding boxes in the visual output for the distance calculation.

Hope this helps! Don't hesitate to reach out for more help. 🚀

[Sani-Gizmo]

How do I calculate distances between two objects from multiple images/pictures(jpg file),not video, in a folder named 'images 1'.

provide the calculation format and the complete code

[pderrenger]

Hello! To calculate distances between two objects in multiple images within a folder named 'images 1', you can use the following Python script. This script utilizes the Ultralytics YOLOv8 model to detect objects and then calculates the distances between them using the DistanceCalculation solution.

Here's the complete code:

import cv2
import os
from ultralytics import YOLO, solutions

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

# Initialize the distance calculation object
dist_obj = solutions.DistanceCalculation(view_img=True)

# Path to your images folder
folder_path = 'path/to/images 1'

# Process each image in the folder
for filename in os.listdir(folder_path):
    if filename.endswith(".jpg"):  # Check for jpg files
        image_path = os.path.join(folder_path, filename)
        image = cv2.imread(image_path)
        assert image is not None, "Error reading image file"

        # Detect objects in the image
        tracks = model.track(image, persist=True, show=False)

        # Calculate the distances
        image_with_distances = dist_obj.start_process(image, tracks)

        # Display or save the result
        cv2.imshow("Distance Calculation", image_with_distances)
        cv2.waitKey(0)

cv2.destroyAllWindows()

This script will load each JPG image from the specified folder, detect objects, calculate distances between them, and display the results. Make sure to replace 'path/to/images 1' with the actual path to your folder.

Feel free to adjust the script according to your specific requirements. If you have any more questions or need further assistance, just let me know!

[Sani-Gizmo]

provide 'DistanceCalculation'

[pderrenger]

Hello @Sani-Gizmo! 😊

Thank you for your interest in using the DistanceCalculation feature with Ultralytics YOLOv8. It's a powerful tool for measuring distances between objects in your images or videos.

To get you started, here's a quick guide on how to use the DistanceCalculation class with your images:

1. Load the YOLO model and initialize the distance calculation object:

from ultralytics import YOLO, solutions
import cv2
import os

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

# Initialize the distance calculation object
dist_obj = solutions.DistanceCalculation(view_img=True)

2. Process each image in your folder:

# Path to your images folder
folder_path = 'path/to/images 1'

# Process each image in the folder
for filename in os.listdir(folder_path):
    if filename.endswith(".jpg"):  # Check for jpg files
        image_path = os.path.join(folder_path, filename)
        image = cv2.imread(image_path)
        assert image is not None, "Error reading image file"

        # Detect objects in the image
        tracks = model.track(image, persist=True, show=False)

        # Calculate the distances
        image_with_distances = dist_obj.start_process(image, tracks)

        # Display or save the result
        cv2.imshow("Distance Calculation", image_with_distances)
        cv2.waitKey(0)

cv2.destroyAllWindows()

This script will load each JPG image from the specified folder, detect objects, calculate distances between them, and display the results. You can click on any two bounding boxes with the left mouse button to calculate the distance between them. Right-clicking will delete all drawn points.

Feel free to adjust the script according to your specific requirements. If you have any more questions or need further assistance, just let me know! 🚀

[aishuse]

Hi,
How to find distance between 2 classes in an image? Also the calculated distance must show on o/p image.

[pderrenger]

Hi there!

To find and display the distance between two classes in an image using YOLOv8, you can utilize the distance calculation feature of Ultralytics YOLOv8. Here's a simplified example based on the provided documentation:

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

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

# Initialize video capture from an image or video
# For image, replace 'path/to/image.jpg' with your image file path
cap = cv2.VideoCapture('path/to/image.jpg')  # Use '0' for webcam

# Check if the source is opened successfully
assert cap.isOpened(), "Error opening source"

# Initialize the distance calculation object
dist_obj = distance_calculation.DistanceCalculation()
dist_obj.set_args(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=False)
    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()

This script loads an image, performs object tracking, calculates the distance between selected objects, and displays the result. For videos, just replace the 'path/to/image.jpg' with your video file path, or use '0' for real-time webcam input.

Right click to delete all points, and left-click to select objects for distance calculation. The distances will show on the output image. Make sure you have the latest Ultralytics YOLOv8 installed to access these features. 🌟

Let us know if you need further assistance!

[wschaft]

Hi,

How's the distance being measured? In my case, the distance is way off unfortunately. Is it possible to optimize the measurement when knowing the size of some of the detected objects? Like on a sports court for example, where the size of a penalty box is known or the size of a basket, maybe even the size of the ball.

[pderrenger]

Hey there!

Absolutely! Knowing the actual size of objects in the scene, such as a sports court or a ball, can definitely help in optimizing distance measurements. 😊

Here's a quick strategy:

1. Calibrate using a Known Size: First, calculate the pixel-to-real-world ratio by dividing the known size of an object (in real-world units) by its size in pixels in the image.
2. Apply Ratio to Distance Calculation: Use the pixel distances obtained from YOLOv8 and apply the pixel-to-real-world ratio to convert these distances into real-world units.

# Assuming you've calculated the ratio as mentioned
pixel_to_real_ratio = real_world_size / pixel_size

# If dist_obj.start_process() gives you pixel distance
real_world_distance = pixel_distance * pixel_to_real_ratio

This way, you can enhance the accuracy of the distance calculation by leveraging known sizes within your scene. Remember, consistent camera angles and minimally warped perspectives will yield the most accurate results. 📏🏀

Feel free to adjust this approach based on your specific requirements!

Happy coding! 🚀

[mirhasnainsiba]

i am getting version incompatibility issue, please tell your python version

[glenn-jocher]

@mirhasnainsiba hey! 😊 For running the YOLOv8 models and the provided distance calculation example, we generally recommend using Python version 3.8 or newer. However, the exact version might also depend on other library requirements you're working with. If you're still facing version compatibility issues, could you please share more details about the error message you're encountering? That way, I can assist you more effectively.

[YoussefMostafaa]

Hello, first of all I am definitely thankful for all your continuous support and help.

I am currently stuck in my bachelor project hoping I could use some help. I am creating an abandoned bags detection system so that it detects a person carrying his bag and if he drops it or leave it behind then this bag's class is defined as abandoned object and if the same person comes back to get his bag this class is changed back to normal, I am thinking about using that distance calculation so that if the bag is away from the person for a certain threshold then it is abandoned. but I am stuck in the code hoping for some help.

Thanks in advance :)

[YoussefMostafaa]

Thank you so much for your help :)

This is a good start indeed, but I am currently facing more than one problem with my code, I know this is a lot to ask but can you help with them. After trying to reach many people you are the only community that could really help me with this thesis. I would be truly speechless if this code actually works

[YoussefMostafaa]

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

ABANDONED_THRESHOLD = 50
model = YOLO("yolov9e.pt")

Inside the loop where you track objects and count them

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

# Detect persons and bags in the frame
detections = model(im0)
persons = filter(lambda p: p == 0,detections[0].boxes.cls.tolist())
bags = detections.filter(names=['backpack'])

# Track persons and bags across frames
person_tracks = model.track(im0, persist=True, show=False, classes=[0])  # Assuming '0' is the ID for person
bag_tracks = model.track(im0, persist=True, show=False, classes=[24])     # Assuming '1' is the ID for bag

# Iterate over person tracks
for person_track in person_tracks:
    person_id, person_bbox = person_track['track_id'], person_track['bbox']

    # Find associated bag for the person
    associated_bag = None
    for bag_track in bag_tracks:
        bag_id, bag_bbox = bag_track['track_id'], bag_track['bbox']

        # Calculate distance between person and bag
        distance = calculate_distance(person_bbox, bag_bbox)  # Implement this function

        # If the distance exceeds a threshold, consider the bag abandoned
        if distance > ABANDONED_THRESHOLD:
            associated_bag = bag_track
            break

    # Update bag class if it's associated with the person
    if associated_bag:
        associated_bag['class'] = 'abandoned bag'

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

[glenn-jocher]

Hello! 😊 It looks like you've made a solid start on implementing abandoned bag detection with YOLOv8! Here are a couple of suggestions to further streamline and clarify your approach:

1. Distance Function: Make sure you implement the calculate_distance function correctly. It could be a simple Euclidean distance function between the centroids of the bounding boxes of the person and the bag.

def calculate_distance(bbox1, bbox2):
    x1, y1, x2, y2 = bbox1
    center1 = ((x1+x2)/2, (y1+y2)/2)
    
    x1, y1, x2, y2 = bbox2
    center2 = ((x1+x2)/2, (y1+y2)/2)
    
    distance = ((center2[0] - center1[0]) ** 2 + (center2[1] - center1[1]) ** 2) ** 0.5
    return distance

2. Filtering Detections and Tracks: Ensure that your detection and tracking filters for persons and bags precisely select the relevant objects. If 'backpack' is the correct class name for bags, and assuming class '0' is for persons, the code seems correctly set up for filtering. Just ensure you have the correct class IDs.

3. Video Codec: When writing the output video, there seems to be a typo in the codec argument for VideoWriter. If you're saving it as '.avi', 'XVID' could be a better fit. For MP4 format, using .mp4 as the extension should resolve compatibility issues.

video_writer = cv2.VideoWriter("test3.mp4",
                       cv2.VideoWriter_fourcc(*'mp4v'),
                       fps,
                       (w, h))

4. Updating Object Class: To dynamically update an object's classification based on conditions (e.g., distance), consider maintaining a separate data structure to handle these states since altering bag_track['class'] doesn't directly affect the writing process. You might need a custom function to overlay updated class text onto the im0 based on this extra data structure.

5. Persisting Tracks: persist=True is a smart move for maintaining identity consistency over frames. Ensure the tracking algorithm (like botsort or bytetrack) is configured to best suit your scene dynamics.

6. Visual Inspection: Lastly, for debugging and verification, it's valuable to visually inspect the output frames or video to ensure the logic is correctly identifying and tracking abandoned bags.

I hope these tips help improve your code! If further issues arise, don't hesitate to ask. Your project sounds fantastic, and we're excited to see it succeed! 🚀

[YoussefMostafaa]

I'm still having troubles updating the object class can you please help me

[glenn-jocher]

Hey there!

Updating the object class on-the-fly depends largely on how you’re handling your object tracking and the logic flow in your code. Here's a simple example of how you might update and visualize the class of an object based on its distance from another object:

# Assuming 'person_id' and 'bag_id' are tracked object IDs and classes have been detected
if distance > ABANDONED_THRESHOLD:
    # Mark the bag as abandoned
    for track in tracks:
        if track.track_id == bag_id:
            track.cls = model.names.index('abandoned bag')
            cv2.putText(im0, 'Abandoned Bag', (track.x1, track.y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,0,255), 2)

This is just a rough sketch, you’ll need to adapt it to fit the structure of your tracking and detection setup. In this snippet, we're directly modifying the class of the track and adding a label in the frame.

If you need more targeted help, could you share a bit more about how you're structuring your tracking updates? That way, we can provide more precise advice! 😊

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