guides/speed-estimation/

[giscus[bot]]

guides/speed-estimation/

Speed Estimation Using Ultralytics YOLOv8

https://docs.ultralytics.com/guides/speed-estimation/

[WooFy11]

how do we add bytetrack for the tracker?

[glenn-jocher]

Hey there! 😊 Adding ByteTrack to your tracker in YOLOv8 is straightforward. When you're using the track function or CLI command, simply specify "bytetrack.yaml" as the tracker option. Here's a quick example in Python:

from ultralytics import YOLO

# Initialize your model
model = YOLO("yolov8n.pt")

# Use ByteTrack for tracking
tracks = model.track(source="path/to/your/video.mp4", persist=True, tracker="bytetrack.yaml")

And if you're working with the CLI:

yolo track model=yolov8n.pt source="path/to/your/video.mp4" tracker="bytetrack.yaml"

This way, YOLOv8 will use ByteTrack as the tracking method. Let us know how it goes or if you need further help! 🚀

[AbdulFaiz123]

Hi , Thanks for providing detailed explanation about the Speed Estimation , I have one question , How can I collect average speed of a vehicle . as i tried

results = model.track(im0, persist=True, show=False,classes=vehicles_class)

    print('speed:', results[0].speed)

speed: {'preprocess': 1.1341571807861328, 'inference': 55.93609809875488, 'postprocess': 1.6450881958007812}

[pderrenger]

Hey there! 😊 It looks like you're interested in calculating the average speed of vehicles using Ultralytics YOLOv8. From your code snippet, it seems you're getting processing speeds rather than vehicle speeds.

To collect average vehicle speed, you'll need to measure the distance traveled by a vehicle in a certain period. The speed calculation is not directly provided by the track method but can be achieved with some additional steps, as outlined in the Speed Estimation guide.

Here's a simplified approach to get you started:

1. Define a line across the road in the video where you'll measure vehicle crossing times.
2. Use the track method to get vehicle tracks (as you did).
3. Determine when a vehicle crosses the line and calculate the time taken to cross a known distance.

Remember, the actual vehicle speed estimation accuracy will depend on correct calibration (e.g., the real distance represented in the video frame). The example in our documentation should provide a good starting point, involving both position tracking and time measurements to estimate speed.

Good luck, and feel free to reach out if you have more questions! 🚗💨

[lucabondin7]

Is it possible to record and store all the speeds of detected vehicles in a list or array?

[edwardhab]

I am experiencing the same issue regarding extracting the object's speed. From the source file, I see the estimate_speed method doesn't have a "return_speeds" argument.

def estimate_speed(im0, tracks, region_color=(255, 0, 0))

[edwardhab]

Never mind resolved :)

[glenn-jocher]

@edwardhab glad to hear you resolved your issue! 😊 If you have any more questions or encounter any challenges while working with speed estimation or any other feature in Ultralytics YOLOv8, please don't hesitate to reach out. Our community and documentation are here to assist you. Happy coding with YOLOv8! 🚀

[JazzPauw]

I do not seem to have the return_speeds method available either.

[glenn-jocher]

Hey there! 😊 It seems like you're exploring the speed estimation features in Ultralytics YOLOv8. For calculating speeds using object tracking, the current example provided in the documentation does not explicitly have a return_speeds method. Instead, the speed_obj.estimate_speed(im0, tracks) method is designed to annotate the input frame with estimated speeds and other relevant information.

To programmatically access and store speed estimations, you would modify or extend the functionality around the estimate_speed method according to your specific requirements. Here's a simplified concept (note, you might need to adapt speed_estimation.SpeedEstimator based on how you manage speed data):

# Example extension to capture speeds
speeds = []

# Assuming `track` objects contain speed, extract and store it
for track in tracks:
    if hasattr(track, 'speed'):
        speeds.append(track.speed)  # Store or process the speed

# Now 'speeds' list contains the speed of each tracked object

The snippet assumes that each track object has a speed attribute which may not directly align with the speed_estimation.SpeedEstimator implementation and serves as an illustrative example. Dive into the source or consider contributing to extend functionalities! If you're modifying existing utilities or extending YOLOv8 for specific tasks and have any questions or novel contributions, our GitHub and community forums are great places for discussions. Keep experimenting! 🚀

[victorvargass]

When I set reg_pts into a vertical line (not horizontal as default and the example), it does not count anything...
Why?

[glenn-jocher]

Hey there! 🌟 It seems like the tracking and counting might not be working as expected when your reg_pts are set vertically. This could be because the speed estimation example primarily focuses on horizontal movement across the defined line. The specific orientation of line_pts as a horizontal line in the example is designed to track and count objects crossing that line, typically set up for scenarios like vehicles moving on a road.

If you're aiming to count vertical movement, you might need to adjust the implementation slightly to ensure the tracking aligns with the direction of object movement. Here's how you could adjust the line_pts for vertical tracking, making sure it spans the height of the frame:

line_pts = [(640, 0), (640, 720)]  # Assuming a 1280x720 video resolution

This example sets a vertical line at the center (x=640) of the frame, stretching from the top (y=0) to the bottom (y=720). Make sure the reg_pts align with the main axis of movement in your video for accurate tracking and speed estimation.

Keep in mind, tracking efficiency can vary with different orientations and movements. If further issues arise, consider the object tracking behavior and the speed estimation logic to ensure it fully supports the specific directions of movement in your use case. 🚀

[victorvargass]

Yes, that is exactly what I tried to do but it seems that it does not detect the bounding boxes when the cars pass along a vertical line. I don't know if it makes sense.
I will attach an example frame of both cases, one with a horizontal line (which in this case does not make sense since the vehicles go horizontally) and another with a vertical line, where it does not detects any speed value.

Horizontal line, and detects the speed

Vertical line, and no detects anything

Thanks for your reply!

[glenn-jocher]

Hey there! 👋 Thanks for sharing the details and the example frames. It helps a lot in understanding the issue you're facing with vertical line speed estimation.

It seems like your setup is correct, but the direction of the vehicle movements in conjunction with the orientation of the reg_pts could be causing the issue. When vehicles move horizontally across a vertical line, the detection and speed estimation should theoretically work, but there might be specifics related to the object tracking or the speed estimation calculation that aren't aligning perfectly with vertical movements.

Here's a small snippet that might help ensure your setup for vertical tracking is correctly initialized:

# Assuming a 720p (1280x720) video resolution
line_pts_vertical = [(640, 0), (640, 720)]  # Setting a vertical line

speed_obj.set_args(reg_pts=line_pts_vertical, ...)

Make sure the line_pts are set exactly where the vehicles usually pass and that it spans the expected path vertically.

If your setup looks similar and it's still not working, it could be beneficial to look into how the speed estimation logic handles the coordinates and movement direction. Speed estimation might have optimal performance with horizontal movements, so additional adjustments could be required to reliably capture vertical movements.

If you could provide more context on how the vehicles are moving and how the speed_obj.estimate_speed method processes tracks, it might shine more light on potential adjustments. Let's keep troubleshooting this together! 🚀

[victorvargass]

Thanks for your reply!
But it still not working :/
The car pass the line and doesnt show the speed.
It seems like the speed_estimation class doesnt work for vertical moving detection, but object_counter works(cause I need both in my project)

https://github.com/ultralytics/ultralytics/assets/13999704/a13e8f95-c3cb-4437-be2a-f03150cfc022
I upload a video with vertical line and it shows that doesnt count the speed

https://github.com/ultralytics/ultralytics/assets/13999704/6ee36123-e003-4d0e-acb6-998d8b8c1b49
I upload another video with horizontal line and it shows that count the speed...

I use ultralytics.solutions.speed_estimation like the example https://docs.ultralytics.com/guides/speed-estimation
https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/speed_estimation.py

Thank you!

[glenn-jocher]

@victorvargass hi there! 👋 Thanks so much for sharing the additional details and your video examples. It looks like you've thoroughly tested the different scenarios and provided valuable insights.

The Ultralytics team is continuously working to improve our models, including features like speed estimation. Based on what you've described and shown in the videos, it seems there might be a limitation in the current implementation of the speed_estimation class regarding vertical line crossing for speed detection. 🤔

For now, as a workaround, you could consider manually calculating speed for vertical movements by tracking the object's position change over time and considering the frame rate of your video. Here's a very basic idea of how you might approach it:

# Calculate speed based on vertical movement
# This is a simplistic example
if len(tracks) > 0:
    current_position = tracks[0].xyxy[1] # Assuming y_min for simplicity
    previous_position = ... # Store and retrieve last frame's position
    frame_time = 1.0 / fps # Time per frame
    speed = (current_position - previous_position) / frame_time
    print(f"Speed: {speed} pixels/sec")

However, integrating this logic efficiently will require keeping track of previous positions and ensuring you're calculating the speed for the right object across frames, which can get complex.

We appreciate your feedback and examples, as they help us understand user experiences and improve. Let's keep the dialogue open! Feel free to contribute any additional thoughts or findings; we value your inputs tremendously. 🚗💨

[AbdullahHabib-github]

Hey!
I'm trying to get the snippets of cars that cross a certain speed, how do i do that?
(I tried a few resources but all in vain, i'm getting overwhelmed and any help is appreciated)
Thank you so much for helping.

[pderrenger]

Hi there!

To capture snippets of cars exceeding certain speeds using Ultralytics YOLOv8, you can leverage the speed_estimation feature outlined in the documentation. Here’s a simplified example to get you started:

from ultralytics import YOLO
from ultralytics.solutions import speed_estimation
import cv2

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

# Set up video capture
cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error opening video file"
fps = cap.get(cv2.CAP_PROP_FPS)

# Define the speed limit (e.g., 30 units)
speed_limit = 30

# Initialize speed estimation
speed_obj = speed_estimation.SpeedEstimator()
speed_obj.set_args(reg_pts=[(0, 360), (1280, 360)], names=model.names, view_img=True)

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

    # Track objects in the frame
    tracks = model.track(img, persist=True, show=False)
    
    # Estimate the speed of detected objects
    img = speed_obj.estimate_speed(img, tracks)
    
    # Check if any car exceeds the speed limit
    for track in tracks:
        if track.label == 'car' and track.speed > speed_limit:
            # Process the snippet e.g., save or alert
            print(f"Car exceeding speed: {track.speed}")
            
cap.release()
cv2.destroyAllWindows()

This script loads a detection model, captures video frames, and calculates the speed of cars. It checks if any car exceeds a predefined speed limit, and then you can add custom actions such as saving the snippet or sending an alert.

Don't hesitate to adjust parameters like speed_limit to fit your specific scenario! Happy coding! 😊

[Hamzasayha]

Hello, thank you for sharing. I have a problem and I hope you can help me solve it. I want to hide label names. What I mean is that I don't want the names of cars or trucks to appear above the specified object (vehicles), I only want to show the speed. Is this possible? I have tried a lot and I couldn't hide them.

[pderrenger]

@Hamzasayha hello! I'm glad to assist you with hiding label names while displaying the speed. If you want to hide the names and only display the speed, you need to modify how the image is annotated in your current setup. Here's a quick way to show only the speed without the class labels:

Adjust the part of your code where you handle display or saving frames by omitting the class labels. For example, if you're writing on im0 using OpenCV before saving or showing the frame, ensure that you're not adding text for class labels there.

For a simple demonstration, consider this high-level snippet:

for track in tracks:
    x1, y1, x2, y2, track_id = track[:5]
    cv2.rectangle(im0, (x1, y1), (x2, y2), color=(255, 0, 0), thickness=2)
    speed = calculate_speed(track)   # Your function to calculate speed
    cv2.putText(im0, f'Speed: {speed} km/h', (x2, y2), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 255, 255), 2)

This snippet will add rectangles and speed annotations without class names. Make sure to adjust your calculate_speed() function accordingly to the data your tracks provide.

Happy coding, and let me know how it goes! 😊

[Elian-abboud]

Hey, how can I combine between speed estimation and object counting in on code where the speed & Type name &ID appear on one card ? Thank you all

[glenn-jocher]

Hello! Combining speed estimation and object counting in YOLOv8 while displaying speed, type name, and ID on one card can be achieved by integrating the tracking and speed estimation features. Here’s a brief example on how you could modify the code to include object counting alongside speed estimation:

from ultralytics import YOLO
from ultralytics.solutions import speed_estimation
import cv2

model = YOLO("yolov8n.pt")

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

# Initialize speed estimator
speed_obj = speed_estimation.SpeedEstimator()
line_pts = [(0, 360), (1280, 360)]
speed_obj.set_args(reg_pts=line_pts, view_img=True)

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

    # Track objects
    tracks = model.track(im0, persist=True)
    
    # Estimate speed and count objects
    im0, object_counts = speed_obj.estimate_speed(im0, tracks, return_counts=True)
    
    # Here you can customize how you display the object ID, type, and speed on the card
    for track in tracks:
        label = f"ID: {track['id']} Type: {track['class_name']} Speed: {track['speed']} km/h"
        cv2.putText(im0, label, (track['bbox'][0], track['bbox'][1]-10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)

    # Optionally show the frame
    cv2.imshow('Video', im0)
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

In this script, I modified the speed_estimation.estimate_speed to optionally return counts of detected objects. Each track object includes an ID and their estimated speed, which you can format and display as needed. Adjust the display settings to fit your requirement for the "card" appearance.

Hope this helps! Let me know if you have any more questions. 🚀

[SJTUPanda]

Hi there, the code is good and easy to apply! Several questions:

1. Only estimate the speed of car? Distance calculating is based on the car size?
2. If not, how to know the true length of the target?
3. How to handle the different position/angle/fov of the video?
4. Could the speed_estimate from ultralytics.solutions be involved in the network model? Like the onnx model, then it could be easy to deployed.
   Thank you!

[glenn-jocher]

Hello! Thank you for reaching out with your questions. Let's address them:

1. Speed Estimation Scope: Currently, the solution isn't limited to just cars; it can theoretically be applied to any objects as long as they are identifiable by the model. Distance calculation assumes a correlation with object size, which can vary based on the model's training data.

2. True Length Measurement: To accurately know the real-world dimensions of a target, you typically need additional calibration specific to your setup (like known distances or objects of known size within the scene) or utilize a depth-sensing device.

3. Handling Variations in Position/Angle/FOV: These variations can impact the effectiveness of the speed estimation. Ideally, these should be minimized or standardized, or additional calibration might be necessary to handle diverse scenarios.

4. Integrating speed_estimate: Currently, custom functionalities like speed_estimate cannot be embedded directly into exported models (e.g., ONNX). You would typically run this as a post-processing step after the object detection/tracking.

Here's a simple example that ties into how speed estimation might be used after object tracking:

from ultralytics import YOLO
from ultralytics.solutions import speed_estimation
import cv2

# Load model and define path to video
model = YOLO("yolov8n.pt")
video_path = "path/to/video.mp4"

# Setup video capture and writer
cap = cv2.VideoCapture(video_path)
assert cap.isOpened(), "Error opening video file"
video_writer = setup_video_writer(cap)

# Initialize Speed Estimator
speed_estimator = setup_speed_estimator(model.names)

# Process video
while True:
    success, frame = cap.read()
    if not success:
        break
    tracks = model.track(frame, persist=True, show=False)
    frame_with_estimates = speed_estimator.estimate_speed(frame, tracks)
    video_writer.write(frame_with_estimates)

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

If you have more specific scenarios or setup details, I can provide further guidance. Thanks for your interest in our solutions!

[SJTUPanda]

Thanks for your quick reply. That makes sense but I do not see any other input for the speed_estimator. For example, the target true length and other variables need to be standardized.

I have similar question in the Distance Calculation using Ultralytics YOLOv8. The function doesn't accept many inputs then how could it be calibrated? That's why I thought it's only for the car speed and the car size is hard coded in the function.

[glenn-jocher]

@SJTUPanda hello! Thanks for your follow-up questions. 🚀

The speed estimation and distance calculation functions currently assume certain pre-set conditions since they are designed for general use cases. If you're looking to customize these functions specifically — say for varying object sizes, types, or other unique requirements — you'll typically handle these adjustments outside the function through pre-processing steps or calibrations.

For a more tailored setup, you could:

• Manually input the true dimensions of objects if known.
• Calibrate your camera setup to convert pixel measurements to real-world metrics (maybe using known distances or reference objects in your scenes).

If integrating such specifics directly into the ONNX or other model formats for deployment is necessary, consider applying these calculations as a post-processing step once the detections are made by the model.

This approach provides flexibility to handle different scenarios or camera setups where conditions might vary considerably. If there's a specific scenario or setup you need help with, feel free to share more details! 🛠️

Hope this helps!

[bluniv]

hello, i have a video of people walking and i am able to view their respective speeds on the output video.
I wish to set a speed limit, suppose 3 km/hr in this case. but using the "track.speed" gives processing speed outputs such as {'preprocess': 1.0364055633544922, 'inference': 458.1570625305176, 'postprocess': 2.0647048950195312} .
How can i extract the actual speeds which are being estimated on the output video ? here is my python code:

from ultralytics import YOLO
from ultralytics.solutions import speed_estimation
import cv2

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

cap = cv2.VideoCapture("./video/walking.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter("speed_estimator_1.mp4", cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))

line_pts = [(0, 400), (1280, 400)]
speed_limit = 3.0
counter = 0

speed_obj = speed_estimation.SpeedEstimator()
speed_obj.set_args(reg_pts=line_pts, region_thickness=10, names=names, view_img=True)

while cap.isOpened():
    success, img = cap.read()
    if not success:
        break
    tracks = model.track(img, classes=0, persist=True, show=False)
    img = speed_obj.estimate_speed(img, tracks)
    for track in tracks:
        if track.speed > speed_limit:
            counter+=1
            cv2.putText(img, f"People over speed limit: {counter}", (10, 40), cv2.FONT_HERSHEY_SIMPLEX,
                        1,(0, 0, 255), 2)
        else:
            cv2.putText(img, f"People over speed limit: {counter}", (10, 40), cv2.FONT_HERSHEY_SIMPLEX,
                        1,(0, 0, 255), 2)
    out.write(img)

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

[glenn-jocher]

@bluniv hello! It looks like you're already on the right track for capturing and processing speeds using the speed_estimation module. However, the output you're seeing in track.speed relates to processing speeds, not the estimated speeds of people walking.

To obtain the actual walking speeds from your estimation, you can access the speed attribute directly from each tracked object within your loop where you're processing img. The speed attribute on each track object provided by the estimate_speed method should give you the actual speed of each detected person.

Here’s how you can modify your code slightly to focus directly on these speed values:

while cap.isOpened():
    success, img = cap.read()
    if not success:
        break
    tracks = model.track(img, classes=0, persist=True, show=False)
    img = speed_obj.estimate_speed(img, tracks)
    for track in tracks:
        current_speed = track.speed
        if current_speed > speed_limit:
            counter += 1
            speed_text = f"People over speed limit: {counter}"
        else:
            speed_text = f"People over speed limit: {counter}"
        cv2.putText(img, speed_text, (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    out.write(img)

Make sure that the track.speed is correctly implemented in your SpeedEstimator. If there are issues with this value not showing as expected, double-check the setup or configuration of your SpeedEstimator.

Hope this helps! Let me know if you need further clarification 👍.

[bluniv]

Hello, i tried the method you suggested but you are still using "track.speed" to get the "current_speed". However track.speed keeps returning the processing speeds and not the speed of people walking.

[glenn-jocher]

Hello! It seems like there's been a misunderstanding in the usage of track.speed which indeed refers to processing speeds rather than actual movement speeds of detected objects. For accurate speed estimation of people walking, you'll need to tap directly into the functionalities provided by speed_estimation.SpeedEstimator.

Ensure you have correctly set up the SpeedEstimator and that you are extracting and using the speed values returned by its estimate_speed method. Here's an example of how you can capture the actual speed of each tracked object using the SpeedEstimator:

from ultralytics import YOLO
from ultralytics.solutions import speed_estimation
import cv2

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("./video/walking.mp4")

speed_obj = speed_estimation.SpeedEstimator()
speed_obj.set_args(reg_pts=[(0, 400), (1280, 400)], names=model.model.names, view_img=True)

while cap.isOpened():
    ret, frame = cap.read()
    if ret:
        tracks = model.track(frame, persist=True)
        frame = speed_obj.estimate_speed(frame, tracks)
        for track in tracks:
            actual_speed = track.metadata.get('speed', None)  # Ensure 'speed' is calculated and populated by your SpeedEstimator
            if actual_speed and actual_speed > 3.0:  # If speed exceeds 3 km/hr
                print(f"Object ID {track.id} is over the speed limit at {actual_speed} km/hr")

        cv2.imshow('frame', frame)
        if cv2.waitKey(1) == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()

Make sure your SpeedEstimator is correctly configured to calculate and update the track.metadata['speed'] properly. This snippet directly checks the track.metadata for a 'speed' entry which should be defined elsewhere in your speed estimation setup.

Let me know if this helps or if you need more specific guidance! 😊

[bluniv]

Hello, i get the following error by doing so :

AttributeError: 'Results' object has no attribute 'metadata'. See valid attributes below.
A class for storing and manipulating inference results.
Attributes:
orig_img (numpy.ndarray): Original image as a numpy array.
orig_shape (tuple): Original image shape in (height, width) format.
boxes (Boxes, optional): Object containing detection bounding boxes.
masks (Masks, optional): Object containing detection masks.
probs (Probs, optional): Object containing class probabilities for classification tasks.
keypoints (Keypoints, optional): Object containing detected keypoints for each object.
speed (dict): Dictionary of preprocess, inference, and postprocess speeds (ms/image).
names (dict): Dictionary of class names.
path (str): Path to the image file.
Methods:
update(boxes=None, masks=None, probs=None, obb=None): Updates object attributes with new detection results.
cpu(): Returns a copy of the Results object with all tensors on CPU memory.
numpy(): Returns a copy of the Results object with all tensors as numpy arrays.
cuda(): Returns a copy of the Results object with all tensors on GPU memory.
to(*args, **kwargs): Returns a copy of the Results object with tensors on a specified device and dtype.
new(): Returns a new Results object with the same image, path, and names.
plot(...): Plots detection results on an input image, returning an annotated image.
show(): Show annotated results to screen.
save(filename): Save annotated results to file.
verbose(): Returns a log string for each task, detailing detections and classifications.
save_txt(txt_file, save_conf=False): Saves detection results to a text file.
save_crop(save_dir, file_name=Path("im.jpg")): Saves cropped detection images.
tojson(normalize=False): Converts detection results to JSON format.

[glenn-jocher]

Hello! It looks like there's a bit of confusion regarding the attributes of the Results object. The Results object does not inherently contain a metadata attribute for speed data. Instead, speed estimation needs to be handled separately using the SpeedEstimator from the ultralytics.solutions module, which you seem to be using.

To capture and utilize the speed data, you'll need to ensure that the speed estimation logic within your SpeedEstimator setup is correctly calculating and assigning speed values to each track. Here's a simplified example of how you might adjust your setup to include speed data:

from ultralytics import YOLO, solutions
import cv2

# Initialize model and speed estimator
model = YOLO("yolov8n.pt")
speed_estimator = solutions.SpeedEstimator(reg_pts=[(0, 360), (1280, 360)], names=model.model.names)

cap = cv2.VideoCapture("path/to/video.mp4")
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Track objects and estimate speed
    tracks = model.track(frame, persist=True)
    frame, speeds = speed_estimator.estimate_speed(frame, tracks)

    # Example of accessing speed data
    for track in tracks:
        if 'speed' in track.metadata:
            print(f"ID {track.id}: {track.metadata['speed']} km/h")

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

cap.release()
cv2.destroyAllWindows()

In this example, ensure that your SpeedEstimator is correctly calculating and populating the speed within track.metadata. If SpeedEstimator does not automatically handle this, you might need to manually calculate and assign speed values based on the tracking data and your specific application needs.

Let me know if this helps or if you need further assistance! 😊

[gouni3790]

I have problem. 😂
"AttributeError: module 'ultralytics.solutions' has no attribute 'SpeedEstimator'"
why this error occur?

[pderrenger]

Hey there! 😊 It looks like you're encountering an issue because the SpeedEstimator class isn't being recognized. This could be due to a few reasons:

1. Version Issue: Make sure you are using the latest version of the Ultralytics YOLOv8 library where SpeedEstimator is included.
2. Import Error: Ensure that the import statements are correct. You should have the Ultralytics YOLOv8 library installed and properly referenced in your script.

Here's a quick check you can do:

• Run pip show ultralytics to check the installed version.
• Make sure your import statement is correct as per the documentation.

If you're still having trouble, could you provide more details about your setup or the version of the library you're using? That might help in diagnosing the issue better!