@t47352 reg_pts/line_pts aren’t valid for YOLO11’s solutions.SpeedEstimator; use the documented args (model, fps, meter_per_pixel, etc.) and call it directly, then read per-ID speeds from speed.spd as shown in the guide and API reference.

import cv2, numpy as np
from ultralytics import solutions

cap = cv2.VideoCapture("video.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)

speed = solutions.SpeedEstimator(model="yolo11n.pt", fps=fps, meter_per_pixel=0.05, show=True)

# Optional ROI filter (only keep speeds for boxes whose centroid is inside this polygon)
roi = np.array([(200,0),(200,720),(400,720),(400,0)], dtype=np.int32)

while cap.isOpened():
    ok, im0 = cap.read()
    if not ok:
        break
    res = speed(im0)  # processes and annotates frame
    speeds_in_roi = {}
    for box, tid in zip(speed.boxes, speed.track_ids):  # xyxy and track ids from last frame
        x1,y1,x2,y2 = map(float, box)
        cx, cy = (x1+x2)/2, (y1+y2)/2
        if cv2.pointPolygonTest(roi, (cx, cy), False) >= 0 and tid in speed.spd:
            speeds_in_roi[tid] = speed.spd[tid]  # km/h for objects in your area

• CLI (no ROI filtering):

yolo solutions speed source="video.mp4" model=yolo11n.pt meter_per_pixel=0.05 show=True

For supported arguments and examples see the Speed Estimation guide and the SpeedEstimator API reference: Speed Estimation using Ultralytics YOLO11 and SpeedEstimator class reference. If an error persists, please share the exact command and the output of yolo checks.

@NawzH the current Ultralytics YOLO11 Speed Estimator assumes a stationary camera setup for accurate speed estimation. For a moving vehicle, additional considerations such as compensating for the camera's motion using GPS or IMU data would be required. This functionality is not natively supported in our implementation but could potentially be developed with custom modifications.

Hello Glenn, thank you for your response. I plan to use an OBD reader to capture the speed of the recording vehicle and am also now considering incorporating GPS data to aid in the estimation process.

Since I am exploring the route of custom modifications, could you kindly point me to any guidance or documentation that might assist with integrating GPS and OBD data into the YOLO speed estimator? Any advice or resources would be greatly appreciated!

Thank you for your interest! While we don't have direct documentation on integrating GPS and OBD data into the YOLO speed estimator, a possible approach would involve synchronizing GPS/OBD speed data with object tracking outputs to adjust for the capturing vehicle's motion. You may start by modifying the SpeedEstimator class in ultralytics/solutions/speed_estimation.py to incorporate this additional data.

@SourceOfNootmite to use speed estimation for other objects like people, trains, or animals, you can specify the desired object classes by setting the classes argument in the SpeedEstimator. For example, classes=[0] for people or classes=[1, 2] for specific vehicles. Refer to Speed Estimation Documentation for detailed examples. Let me know if you need further clarification!

@1024-Zhang to write the detected vehicle ID and speed into a CSV file, use the speeds returned by the current SpeedEstimator in results.speed_dict ({track_id: km/h}) after each frame:

import csv
import time

with open("speeds.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["timestamp", "id", "speed_kmh"])
    # inside your frame loop
    results = speed_obj(im0)
    for track_id, speed in results.speed_dict.items():
        writer.writerow([time.time(), track_id, speed])

See the Speed Estimation guide for the full setup. Let me know if you need further clarification!

@samkitshah18 the current solutions.SpeedEstimator computes each tracked object's speed once it has been tracked for max_hist frames, then keeps that speed for the object's ID rather than updating it continuously. If you need continuously updated speeds, you can modify the SpeedEstimator source (ultralytics/solutions/speed_estimation.py) to not lock IDs, or compute speeds yourself from the track history. Keep persist=True tracking so IDs stay consistent. See the Speed Estimation guide for the current arguments. Let us know if you need further clarification!

Thank you for your response ! I tried to implement it.

My code:

from ultralytics.solutions import speed_estimation
import cv2

model = YOLO("yolo11n.pt")

video_path = 'Path'
cap = cv2.VideoCapture(video_path)
assert cap.isOpened(), "Error opening video file"

fps = int(cap.get(cv2.CAP_PROP_FPS))
w, h = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
video_writer = cv2.VideoWriter("speed_estimation8.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

speed_obj = speed_estimation.SpeedEstimator(
    region=[(0, 0), (w, 0), (w, h), (0, h)],
    names=model.names,
    show=True,
)

object_speeds = {}

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

    tracks = model.track(img, persist=True, show=True, tracker="bytetrack.yaml") 

    if tracks is not None:
        updated_tracks = []
        for track in tracks:
            obj_id = track.id if hasattr(track, 'id') else None
            if obj_id is not None:
                if obj_id not in object_speeds:
                    object_speeds[obj_id] = []

                if hasattr(track, 'speed'):
                    object_speeds[obj_id].append(track.speed)

                updated_tracks.append(track)

        img = speed_obj.estimate_speed(img)

    video_writer.write(img)

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

Now it detects 0 speed for all the cars even though it tracks and detects cars.

After Speed Detection: https://streamable.com/67n3f4

Can you please point me what am I missing here ?

The current SpeedEstimator no longer has a reg_pts argument or a speed region: it estimates the speed of every tracked object across the whole frame, so you don't need to define one. If speeds look wrong, check fps, meter_per_pixel and max_hist against the Speed Estimation guide, and make sure tracking IDs are consistent. Let me know how it goes!

Thank you ! In my use case, I've several videos from varied camera angles so defining the reg_pts is not feasible and I want to track the objects in the entire video and not just a region. Even when I try to narrow down the region, using the persist=True in the above code does not update the speed of vehicles in the above code. Can you please provide any suggestions on how to resolve this ?

@samkitshah18 the current SpeedEstimator already tracks speeds across the entire frame without a region, and reg_pts is no longer an argument, so there is nothing to disable. If the speed doesn't update, note that each object's speed is calculated after it has been tracked for max_hist frames and then kept for that ID. Verify that frame-to-frame object IDs are consistent, and tune meter_per_pixel and fps for your video. Let us know if you have further issues!

@moshiour thank you for your comment. It seems there might be a discrepancy between the examples. Please ensure you're using the correct tracking setup as shown in the discussion. For detailed guidance, refer to our speed estimation documentation at https://docs.ultralytics.com/guides/speed-estimation/. If you have further questions, feel free to ask here.

@glenn-jocher Thanks for clearification!

@hardslugger yes, the current SpeedEstimator doesn't require you to draw lines or regions: reg_pts is no longer an argument. It estimates the speed of every tracked object in the frame, so just set fps and a meter_per_pixel scale that fits your camera's perspective. For more details, visit our speed estimation guide.

@eps1lonline to add the speed of the car to an array, use the speeds returned by the current SpeedEstimator in results.speed_dict ({track_id: km/h}). Here's a minimal example:

speeds = {}

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    results = speed_obj(im0)
    speeds.update(results.speed_dict)  # last known speed per track ID
    video_writer.write(results.plot_im)

print(list(speeds.values()))

This stores one speed per tracked car.

@glenn-jocher, good day.

I wanted to know the speed of each car in km/h and put it in an array, but after looking at the code, I realized that this is not necessary, because all the speeds of cars can be obtained by accessing the Speed_obj object like this: Speed_obj.spd, we get a dictionary, where the index is the car number, and the value is the speed itself.

Now I have a couple of other questions:

1. For movement, we use the formula: U=S/t, where U is the speed of the car; S is the distance traveled by the car; t is time. My object: Speed_obj stores the coordinates along which each car moved, in order to get these coordinates, we must access the object like this: Speed_obj.trk_history. The distance itself is the Euclidean distance, i.e. we find the distance from the starting point to the next point, from this point to another point and so on until we reach the final one. So here's the question, I got that the distance = 600 pixels, how does your model convert pixels into meters, kilometers in order to calculate the speed?

2. What is Speed_obj.spdl, it stores an array of several dozens that are constantly changing (10, 10, 10, 10, 10, 10...)

Thank you for your attention!

@eps1lonline 1. The solution uses a calibration factor, meter_per_pixel, to convert pixels to real-world meters. You'll need to measure a known distance in the video to set this factor accurately.

1. speed_obj.spdl belonged to an older version and no longer exists. In the current SpeedEstimator, the speeds are returned in results.speed_dict ({track_id: km/h}) each time you call it on a frame. See the speed estimation guide for details.