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! 👋 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. 🚗💨

[fzappala]

Hello, i had the same problem. I changed the function calculate_speed inside the class

def calculate_speed(self, trk_id, track):
"""
print("reg_pts[0][0]", self.reg_pts[0][0])
print("track[-1][0]", track[-1][0])
print("self.reg_pts[1][0]", self.reg_pts[1][0])
"""

    if not self.reg_pts[0][1] < track[-1][1] < self.reg_pts[1][1]:
        return
    
    if self.reg_pts[1][0] - self.spdl_dist_thresh < track[-1][0] < self.reg_pts[1][0] + self.spdl_dist_thresh:
      direction = "known"
    elif self.reg_pts[0][0] - self.spdl_dist_thresh < track[-1][0] < self.reg_pts[0][0] + self.spdl_dist_thresh:
      direction = "known"
    else:
      direction = "unknown"

    print("DIRECTION", direction)

    if self.trk_previous_times.get(trk_id) != 0 and direction != "unknown" and trk_id not in self.trk_idslist:
        self.trk_idslist.append(trk_id)

        time_difference = time() - self.trk_previous_times[trk_id]
        
        if time_difference > 0:
            dist_difference = np.abs(track[-1][0] - self.trk_previous_points[trk_id][0])
            print("DIST DIFF", dist_difference)
            print("TIME DIFF", time_difference)
            speed = dist_difference / time_difference
            print("SPEED", speed)
            self.dist_data[trk_id] = speed

    self.trk_previous_times[trk_id] = time()
    self.trk_previous_points[trk_id] = track[-1]

now if you make a vertical line, it should calculate the speed

[glenn-jocher]

Hello @fzappala,

Thank you for sharing your solution and the detailed code modifications! It's great to see the community actively contributing to improving the functionality of our tools. 🚀

To ensure we can investigate and address this issue effectively, could you please provide a minimum reproducible example? This will help us replicate the problem on our end and work towards a solution. You can find guidelines for creating a minimum reproducible example here.

Additionally, please verify that you are using the latest versions of torch and ultralytics. If not, kindly upgrade your packages and try running your code again. This ensures that any recent fixes or improvements are included in your setup.

pip install --upgrade torch ultralytics

Your modification to the calculate_speed function seems to address the vertical line issue by adjusting the conditions for speed calculation. This is a valuable insight, and we appreciate your effort in sharing it with the community.

If you continue to experience issues, please share the specific versions of your packages and any additional context that might help us understand the problem better.

Thank you for your collaboration and patience. Let's work together to enhance the capabilities of Ultralytics YOLOv8! 😊

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

Hello! To address your challenges:

1. Filtering Stationary Vehicles: You can filter out stationary vehicles by checking if the estimated speed is 0 km/hr. Modify your tracking loop to only draw bounding boxes or count vehicles when the speed is above a certain threshold.

2. Classifying Fast-Moving Bicycles as People: For the misclassification issue, you can add a condition to check if an object classified as a person is moving faster than 20 km/hr, and then reclassify it as a bicycle. Here’s a simplified approach:

for track in tracks:
    label, speed = track.label, track.speed  # Assuming these attributes are available
    if label == 'person' and speed > 20:
        label = 'bicycle'
    if speed > 0:  # This filters out stationary objects
        draw_bbox(im0, track.bbox, label=label, speed=speed)

Make sure to adjust the attributes like track.label, track.speed, and track.bbox based on how your tracking results are structured.

This should help you tailor the detection and tracking to better fit your requirements! 😊

[SudhanshuBlaze]

I got your logic, but I have another doubt, how do I prevent the plotting of bounding box around the object as it happens in the below function, help me update this function object_counter.py

function in object_counter.py

    def extract_and_process_tracks(self, tracks):
        """Extracts and processes tracks for object counting in a video stream."""

        # Annotator Init and region drawing
        self.annotator = Annotator(self.im0, self.tf, self.names)

        # Draw region or line
        self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)

        if tracks[0].boxes.id is not None:
            boxes = tracks[0].boxes.xyxy.cpu()
            clss = tracks[0].boxes.cls.cpu().tolist()
            track_ids = tracks[0].boxes.id.int().cpu().tolist()

            # Extract tracks
            for box, track_id, cls in zip(boxes, track_ids, clss):
                # Draw bounding box
                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))

                # Store class info
                if self.names[cls] not in self.class_wise_count:
                    self.class_wise_count[self.names[cls]] = {"IN": 0, "OUT": 0}

                # Draw Tracks
                track_line = self.track_history[track_id]
                track_line.append((float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2)))
                if len(track_line) > 30:
                    track_line.pop(0)

                # Draw track trails
                if self.draw_tracks:
                    self.annotator.draw_centroid_and_tracks(
                        track_line,
                        color=self.track_color if self.track_color else colors(int(track_id), True),
                        track_thickness=self.track_thickness,
                    )

                prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None

                # Count objects in any polygon
                if len(self.reg_pts) >= 3:
                    is_inside = self.counting_region.contains(Point(track_line[-1]))

                    if prev_position is not None and is_inside and track_id not in self.count_ids:
                        self.count_ids.append(track_id)

                        if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
                            self.in_counts += 1
                            self.class_wise_count[self.names[cls]]["IN"] += 1
                        else:
                            self.out_counts += 1
                            self.class_wise_count[self.names[cls]]["OUT"] += 1

                # Count objects using line
                elif len(self.reg_pts) == 2:
                    if prev_position is not None and track_id not in self.count_ids:
                        distance = Point(track_line[-1]).distance(self.counting_region)
                        if distance < self.line_dist_thresh and track_id not in self.count_ids:
                            self.count_ids.append(track_id)

                            if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
                                self.in_counts += 1
                                self.class_wise_count[self.names[cls]]["IN"] += 1
                            else:
                                self.out_counts += 1
                                self.class_wise_count[self.names[cls]]["OUT"] += 1

        labels_dict = {}

        for key, value in self.class_wise_count.items():
            if value["IN"] != 0 or value["OUT"] != 0:
                if not self.view_in_counts and not self.view_out_counts:
                    continue
                elif not self.view_in_counts:
                    labels_dict[str.capitalize(key)] = f"OUT {value['OUT']}"
                elif not self.view_out_counts:
                    labels_dict[str.capitalize(key)] = f"IN {value['IN']}"
                else:
                    labels_dict[str.capitalize(key)] = f"IN {value['IN']} OUT {value['OUT']}"

        if labels_dict:
            self.annotator.display_analytics(self.im0, labels_dict, self.count_txt_color, self.count_bg_color, 10, self.text_offset)

[pderrenger]

Hello! To prevent drawing bounding boxes around stationary objects or those with a speed of 0 km/hr, you can modify the extract_and_process_tracks function in your object_counter.py to include a speed check before drawing the box. Here’s how you can update your function:

1. Check Speed Before Drawing: Add a condition to check if the speed is greater than 0 before drawing the bounding box and processing the track.

2. Modify Class Based on Speed: For handling the misclassification of bicycles as people when moving faster than 20 km/hr, you can add a condition to reclassify the detected object based on its speed.

Here's an updated snippet of your function incorporating these changes:

def extract_and_process_tracks(self, tracks):
    """Extracts and processes tracks for object counting in a video stream."""
    self.annotator = Annotator(self.im0, self.tf, self.names)
    self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)

    if tracks[0].boxes.id is not None:
        boxes = tracks[0].boxes.xyxy.cpu()
        clss = tracks[0].boxes.cls.cpu().tolist()
        track_ids = tracks[0].boxes.id.int().cpu().tolist()
        speeds = tracks[0].boxes.speeds.cpu().tolist()  # Assuming speed is calculated and available

        for box, track_id, cls, speed in zip(boxes, track_ids, clss, speeds):
            if speed > 0:  # Only draw box if speed is greater than 0
                if cls == self.names.index('person') and speed > 20:
                    cls = self.names.index('bicycle')  # Reclassify as bicycle if speed > 20 km/hr
                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))

            # Further processing...

Make sure to adjust the speeds attribute according to how you are calculating or retrieving speed data in your tracks. This snippet assumes that each track has a speed attribute that you can use to make decisions about drawing and classifying objects.

This should help you control the visualization of bounding boxes based on the object's speed and adjust classifications dynamically based on their movement characteristics. 😊

[SudhanshuBlaze]

Hi, with your help I am successfully implemented the detection of stationary objects and speed calculation.

I am calculating speed every 10 frames, but I am not sure how to pass the speed variable in the counter.start_counting() function such that speed data for each ID is available in the extract_and_process_tracks() function.

Checkout my below code:

# Initialize tracking dictionary
last_positions = {}
stationary_ids = set()
frame_interval = 10  # Check position every x frames
frame_count = 0  # Initialize frame counter

movement_threshold = 2  # Minimum pixels an object must move to be considered in motion
pixel_to_meter = 0.5  # Conversion factor: 1 pixel = 0.5 meters

tracker = model  

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

    frame_count += 1  # Increment frame counter

    # vid_stride=5
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count, device='mps', vid_stride=5)
        
    for result in tracks:
        for track in result.boxes:
            id = int(track.id)

            if track.xyxy.numel() == 4:
                x_min, y_min, x_max, y_max = track.xyxy[0]  # Unpack from the first row

                # Calculate center coordinates (x, y), width (w), and height (h)
                x = (x_min + x_max) / 2
                y = (y_min + y_max) / 2
                w = x_max - x_min
                h = y_max - y_min

            current_time = time.time()  # Get the current timestamp
            
            if frame_count % frame_interval == 0:
                if id in last_positions:
                    last_x, last_y, _, _, last_time = last_positions[id]
                    # Calculate movement
                    distance_pixels = ((last_x - x) ** 2 + (last_y - y) ** 2) ** pixel_to_meter
                    delta_time = current_time - last_time

                    if distance_pixels < movement_threshold:
                        stationary_ids.add(id)
                    else:
                        stationary_ids.discard(id)
                    
                    # print(f"Object {stationary_ids} is stationary.")  
                    
                    speed_pixels_per_second = distance_pixels / delta_time
                    # Convert speed to kilometers per hour
                    speed_km_per_hour = speed_pixels_per_second * 3.6

                    print(f"Object {id} moved with speed {speed_km_per_hour:.2f} km/h")

                    
            # Update position and timestamp x frames
            last_positions[id] = (x, y, w, h, current_time)


    # Perform counting and draw tracks for each counter
    im0 = counter_1.start_counting(im0, tracks, stationary_ids)
    im0 = counter_2.start_counting(im0, tracks, stationary_ids)
    im0 = counter_3.start_counting(im0, tracks, stationary_ids)
    im0 = counter_4.start_counting(im0, tracks, stationary_ids)
    
    # Write the frame to the output video
    video_writer.write(im0)

object_counter.py

def start_counting(self, im0, tracks, stationary_ids):
    """
    Main function to start the object counting process.

    Args:
        im0 (ndarray): Current frame from the video stream.
        tracks (list): List of tracks obtained from the object tracking process.
    """
    self.im0 = im0  # store image
    self.stationary_ids = stationary_ids
    self.extract_and_process_tracks(tracks) 

    if self.view_img:
        self.display_frames()
    return self.im0

object_counter.py

def extract_and_process_tracks(self, tracks):
    """Extracts and processes tracks for object counting in a video stream."""

    # Annotator Init and region drawing
    self.annotator = Annotator(self.im0, self.tf, self.names)

    # Draw region or line
    self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)

    if tracks[0].boxes.id is not None:
        boxes = tracks[0].boxes.xyxy.cpu()
        cls = tracks[0].boxes.cls.cpu().tolist()
        track_ids = tracks[0].boxes.id.int().cpu().tolist()

        # Extract tracks
        for box, track_id, cls in zip(boxes, track_ids, cls):
            # Skip if class not person or object is stationary
            if cls!=0 and track_id in self.stationary_ids:
                continue

......

[pderrenger]

Hello @SudhanshuBlaze,

Great to hear that you've successfully implemented the detection of stationary objects and speed calculation! 🎉

To pass the speed data for each ID to the counter.start_counting() function and make it available in the extract_and_process_tracks() function, you can modify your code to include the speed information in the tracks. Here's how you can achieve this:

Step-by-Step Solution:

1. Update the Tracking Loop: Include the speed calculation within your tracking loop and store the speed in a dictionary.
2. Pass the Speed Data: Modify the start_counting function to accept the speed data and pass it to extract_and_process_tracks.

Updated Code:

Main Script

# Initialize tracking dictionary
last_positions = {}
stationary_ids = set()
frame_interval = 10  # Check position every x frames
frame_count = 0  # Initialize frame counter
movement_threshold = 2  # Minimum pixels an object must move to be considered in motion
pixel_to_meter = 0.5  # Conversion factor: 1 pixel = 0.5 meters

tracker = model  
speed_data = {}  # Dictionary to store speed data

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

    frame_count += 1  # Increment frame counter

    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count, device='mps', vid_stride=5)
        
    for result in tracks:
        for track in result.boxes:
            id = int(track.id)

            if track.xyxy.numel() == 4:
                x_min, y_min, x_max, y_max = track.xyxy[0]  # Unpack from the first row

                # Calculate center coordinates (x, y), width (w), and height (h)
                x = (x_min + x_max) / 2
                y = (y_min + y_max) / 2
                w = x_max - x_min
                h = y_max - y_min

            current_time = time.time()  # Get the current timestamp
            
            if frame_count % frame_interval == 0:
                if id in last_positions:
                    last_x, last_y, _, _, last_time = last_positions[id]
                    # Calculate movement
                    distance_pixels = ((last_x - x) ** 2 + (last_y - y) ** 2) ** pixel_to_meter
                    delta_time = current_time - last_time

                    if distance_pixels < movement_threshold:
                        stationary_ids.add(id)
                    else:
                        stationary_ids.discard(id)
                    
                    speed_pixels_per_second = distance_pixels / delta_time
                    speed_km_per_hour = speed_pixels_per_second * 3.6

                    speed_data[id] = speed_km_per_hour  # Store speed data

                    print(f"Object {id} moved with speed {speed_km_per_hour:.2f} km/h")

            # Update position and timestamp x frames
            last_positions[id] = (x, y, w, h, current_time)

    # Perform counting and draw tracks for each counter
    im0 = counter_1.start_counting(im0, tracks, stationary_ids, speed_data)
    im0 = counter_2.start_counting(im0, tracks, stationary_ids, speed_data)
    im0 = counter_3.start_counting(im0, tracks, stationary_ids, speed_data)
    im0 = counter_4.start_counting(im0, tracks, stationary_ids, speed_data)
    
    # Write the frame to the output video
    video_writer.write(im0)

object_counter.py

Update the start_counting and extract_and_process_tracks functions to accept and use the speed data:

def start_counting(self, im0, tracks, stationary_ids, speed_data):
    """
    Main function to start the object counting process.

    Args:
        im0 (ndarray): Current frame from the video stream.
        tracks (list): List of tracks obtained from the object tracking process.
        stationary_ids (set): Set of stationary object IDs.
        speed_data (dict): Dictionary of speed data for each object ID.
    """
    self.im0 = im0  # store image
    self.stationary_ids = stationary_ids
    self.speed_data = speed_data  # Store speed data
    self.extract_and_process_tracks(tracks) 

    if self.view_img:
        self.display_frames()
    return self.im0

def extract_and_process_tracks(self, tracks):
    """Extracts and processes tracks for object counting in a video stream."""

    # Annotator Init and region drawing
    self.annotator = Annotator(self.im0, self.tf, self.names)
    self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)

    if tracks[0].boxes.id is not None:
        boxes = tracks[0].boxes.xyxy.cpu()
        cls = tracks[0].boxes.cls.cpu().tolist()
        track_ids = tracks[0].boxes.id.int().cpu().tolist()

        for box, track_id, cls in zip(boxes, track_ids, cls):
            # Skip if class not person or object is stationary
            if cls != 0 and track_id in self.stationary_ids:
                continue

            speed = self.speed_data.get(track_id, 0)  # Get speed for the track ID
            if speed > 0:  # Only draw box if speed is greater than 0
                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id} Speed: {speed:.2f} km/h", color=colors(int(track_id), True))

            # Further processing...

This approach ensures that the speed data is passed along with the tracks and used appropriately in the extract_and_process_tracks function. This should help you achieve the desired functionality. 😊

Feel free to reach out if you have any more questions or need further assistance!

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

[Aspoir]

What's your ultralytics version, my version is 8.3.17, I copy this code, but speed_obj not have set_args, and the params and return of speed_obj.estimate_speed also incorrect.

AttributeError: 'SpeedEstimator' object has no attribute 'set_args'

[glenn-jocher]

It seems like you're encountering an issue with the SpeedEstimator class. Please ensure you're using the latest version of the Ultralytics package, as the method signatures might have changed. You can refer to the speed estimation guide for updated examples and usage.

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

[fzappala]

Hello, i have one question.

the distance in the class SpeedEstimator (calculate_speed)
dist_difference = np.abs(track[-1][1] - self.trk_previous_points[trk_id][1])
is calculated in pixels, right?

speed = dist_difference / time_difference

how do you convert the speed to km/ph?

[pderrenger]

@fzappala hello,

Thank you for your question! Yes, the dist_difference in the SpeedEstimator class is calculated in pixels. To convert the speed from pixels per second to kilometers per hour (km/h), you need to know the real-world distance that each pixel represents. Here's a step-by-step guide on how to achieve this conversion:

1. Determine Real-World Distance per Pixel:

   • Measure a known distance in the real world (e.g., the width of a road) and find the corresponding distance in pixels in your video frame.
   • For example, if 100 pixels represent 10 meters, then each pixel represents 0.1 meters.

2. Convert Speed to Real-World Units:

   • Use the real-world distance per pixel to convert the speed from pixels per second to meters per second.
   • Finally, convert meters per second to kilometers per hour by multiplying by 3.6 (since 1 m/s = 3.6 km/h).

Here's a code snippet to illustrate this:

import cv2
from ultralytics import YOLO, solutions

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

# Open the video file
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("speed_estimation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Define region points for speed estimation
line_pts = [(0, 360), (1280, 360)]

# Initialize speed estimation object
speed_obj = solutions.SpeedEstimator(
    reg_pts=line_pts,
    names=names,
    view_img=True,
)

# Real-world distance per pixel (e.g., 0.1 meters per pixel)
distance_per_pixel = 0.1

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)

    # Estimate speed in pixels per second
    im0, speeds = speed_obj.estimate_speed(im0, tracks)

    # Convert speed to km/h
    speeds_kmh = [speed * distance_per_pixel * 3.6 for speed in speeds]

    # Display or save the results
    for speed_kmh in speeds_kmh:
        print(f"Speed: {speed_kmh:.2f} km/h")

    video_writer.write(im0)

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

In this example:

• distance_per_pixel is the real-world distance that each pixel represents.
• speeds is the list of speeds in pixels per second returned by the estimate_speed method.
• speeds_kmh converts these speeds to kilometers per hour.

For more detailed information and additional resources, please visit our Speed Estimation Guide.

Feel free to reach out if you have any more questions! 😊

[NoviceAlchemist]

您好 我想问一下：我想对整个画面检测速度的话请问需要怎么修改 我修改相关参数没有效果

[pderrenger]

@hpz98 您好，

感谢您的提问！要对整个画面进行速度检测，您可以参考以下步骤：

1. 确保使用最新版本：请确认您使用的是最新版本的Ultralytics YOLOv8，以确保您获得最新的功能和修复。如果还没有，请更新到最新版本。

2. 提供可复现的示例：为了更好地帮助您解决问题，建议您提供一个最小可复现的代码示例。您可以参考最小可复现示例指南来创建一个示例。

3. 调整参数：您提到修改相关参数没有效果。请确保您正确设置了SpeedEstimator和model.track的参数。例如：

   speed_obj = solutions.SpeedEstimator(
       reg_pts=[(0, 360), (1280, 360)],  # 根据您的视频调整
       names=names,
       view_img=True,
       line_thickness=2,
       region_thickness=5,
       spdl_dist_thresh=10
   )

4. 代码示例：以下是一个完整的代码示例，展示如何进行速度检测：

   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("speed_estimation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
   
   line_pts = [(0, 360), (1280, 360)]
   
   # Init speed-estimation obj
   speed_obj = solutions.SpeedEstimator(
       reg_pts=line_pts,
       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 = speed_obj.estimate_speed(im0, tracks)
       video_writer.write(im0)
   
   cap.release()
   video_writer.release()
   cv2.destroyAllWindows()

5. 参考文档：更多详细信息和参数设置，请参考我们的速度估计指南。

希望这些信息对您有所帮助！如果您有更多问题，请随时告知 😊

祝好，
Ultralytics 团队

[NoviceAlchemist]

再向您请教一个问题，我看了测速的相关文档，SpeedEstimator里面有一个参数是spdl_dist_thresh，文档中并没有进一步说明，我想知道这个参数是计算识别框速度到线段的距离阈值，还是计算与摄像头之间的距离阈值？因为文档中出现的代码我进行使用后发现速度出现了很多400km/s这样的速度检测结果，并不符合实际情况。

[pderrenger]

您好，

感谢您的提问！关于SpeedEstimator中的spdl_dist_thresh参数，它确实是用于计算识别框速度的距离阈值。具体来说，它定义了在速度计算过程中，物体在两个帧之间移动的最小距离阈值。如果物体的移动距离小于这个阈值，则不会计算速度。这有助于过滤掉一些微小的抖动和噪声，从而提高速度估计的准确性。

对于您提到的速度检测结果出现异常高的情况（如400km/s），这通常是由于以下几个原因之一：

1. 帧率不准确：请确保您的视频帧率（FPS）设置正确。如果帧率设置错误，速度计算将会不准确。
2. 距离参数设置不当：请检查reg_pts参数，确保它们正确反映了视频中的实际距离。
3. 物体检测不稳定：如果物体在帧之间的检测不稳定，可能会导致速度计算错误。可以尝试调整model.track中的conf和iou参数，以提高检测的稳定性。

以下是一个示例代码，展示如何设置这些参数：

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("speed_estimation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

line_pts = [(0, 360), (1280, 360)]

# Init speed-estimation obj
speed_obj = solutions.SpeedEstimator(
    reg_pts=line_pts,
    names=names,
    view_img=True,
    spdl_dist_thresh=10  # 调整距离阈值
)

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, conf=0.5, iou=0.5)  # 调整检测参数

    im0 = speed_obj.estimate_speed(im0, tracks)
    video_writer.write(im0)

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

请确保您使用的是最新版本的Ultralytics YOLOv8，以获得最新的功能和修复。如果问题仍然存在，请提供一个最小可复现的代码示例，这将有助于我们更好地诊断和解决问题。您可以参考最小可复现示例指南来创建一个示例。

希望这些信息对您有所帮助！如果您有更多问题，请随时告知 😊

祝好，
Ultralytics 团队

[lostsalchichon]

Hi! First, thank you for this great model. Second, I have got the model working with the one line, as explained in the blog. But will it work with two or three lines, in order to make the model more precise. As in: line_pts = [(0, 360), (1280, 360)], [(0, 720), (1280, 720)]

Thank you!

[glenn-jocher]

Thank you for your kind words! Yes, you can use multiple lines for more precise speed estimation. You can define multiple region points like this: line_pts = [(0, 360), (1280, 360)], [(0, 720), (1280, 720)]. This will allow the model to estimate speed more accurately by considering multiple reference points. For more detailed guidance, please refer to our speed estimation guide.

[eps1lonline]

Hi everyone, how can i add to array the speed of the car that passed the line? here is the code

import os
import cv2
import time

from ultralytics import YOLO, solutions

# Запуск таймера
start_time = time.time()

# Путь, где будет сохранятся файл
current_directory = os.getcwd()
print("The resulting file is saved to the path:", current_directory)

# Загрузка модели YOLOv8
model = YOLO("yolov8n.pt")
names = model.model.names

# Открытие видеофайла
videoFile = "car7.mp4"
cap = cv2.VideoCapture(videoFile)
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 = cv2.VideoWriter(
    "speed_estimation.avi",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps, (w, h))

# Определение линии
line_pts = [(0, int(h/2)), (int(w), int(h/2))]

# Инициализация объекта оценки скорости
speed_obj = solutions.SpeedEstimator(reg_pts=line_pts,
                                      names=names,
                                      view_img=True,)

speeds = []

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = speed_obj.estimate_speed(im0, tracks)
    video_writer.write(im0)
    
    print(speed_obj.spdl)
        

# Освобождение ресурсов
cap.release()
video_writer.release()
cv2.destroyAllWindows()

# Время работы программы
end_time = time.time()
execution_time = end_time - start_time
print("Program running time:", int(execution_time//60), " min ", int(execution_time%60), " sec")

[glenn-jocher]

@eps1lonline to add the speed of the car to an array, you can append the speed from speed_obj.spdl to your speeds list inside the loop. Here's a minimal example:

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = speed_obj.estimate_speed(im0, tracks)
    speeds.append(speed_obj.spdl)  # Add speed to the array
    video_writer.write(im0)

This will store the estimated speeds for each frame in the speeds list.

[eps1lonline]

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

[glenn-jocher]

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

2. Speed_obj.spdl likely stores recent speed estimates for smoothing or averaging. For detailed usage, refer to the documentation or source code.

[hardslugger]

Hi! I am very glad that you introduced Yolov11 speed estimation module. I am very excited to start working with it. I have a question: Can I estimate speed of the vehicle without drawing the horizontal or vertical line? I am working on speed estimation of vehicles from the images captured by a camera mounted on an autonomous vehicle. Let me know how I can work this out?

[glenn-jocher]

@hardslugger to estimate speed without drawing lines, you can modify the reg_pts parameter in the SpeedEstimator to fit your setup. Adjust the region points to align with your camera's perspective for accurate speed estimation. For more details, visit our speed estimation guide.

[moshiour]

Hi,

I would like to write speed using label box. However, the above script for speed estimation does not work. Even, I have already updated yolo11. Please check the above script in examples and here in discussion not same at all.

In the example above no tracking :
speed_obj = solutions.SpeedEstimator(
region=[(0, 360), (1280, 360)],
model="yolo11n.pt",
show=True,
)

while cap.isOpened():
success, im0 = cap.read()
if not success:
break
im0 = speed_obj.estimate_speed(im0)
video_writer.write(im0)

And in the discussion:

Init speed-estimation obj

speed_obj = solutions.SpeedEstimator(
reg_pts=line_pts,
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 = speed_obj.estimate_speed(im0, tracks)
video_writer.write(im0)

==============================================

Thank you in advance!

[glenn-jocher]

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

[moshiour]

@glenn-jocher Thanks for clearification!

[glenn-jocher]

You're welcome! If you encounter any more issues or need further assistance, feel free to reach out. For detailed guidance on speed estimation, please refer to our documentation at https://docs.ultralytics.com/guides/speed-estimation/.