guides/object-counting/

[giscus[bot]]

guides/object-counting/

Object Counting Using Ultralytics YOLOv8

https://docs.ultralytics.com/guides/object-counting/

[nubrandsta]

Very cool and simple implementation!

[nubrandsta]

Is it possible to count the classes that are passing through, rather than just counting all that passes through? i couldn't find a way in the documentation, please notify me if you know how!

[pderrenger]

@nubrandsta absolutely, you can count specific classes as they pass through a region or line. In the example provided in the documentation, you can specify the classes you want to count by setting the classes argument in the model.track() method. Here's a quick snippet to illustrate:

classes_to_count = [0, 2]  # For example, '0' for person and '2' for car
tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)

Just replace [0, 2] with the indices of the classes you're interested in. You can find these indices in your model.names attribute. Happy counting! 😊🔢

[nubrandsta]

@pderrenger Awesome, I've tried it and implemented my own way of doing it and it was easy to work with and it worked well!

[pderrenger]

@nubrandsta That's fantastic to hear! 🎉 If you're looking to count specific classes as they pass through a designated area, you can easily specify which classes to track by using the classes parameter in the model.track() method. Here’s a quick example if you're focusing on counting only certain objects:

# Specify the classes you want to count, e.g., '0' for person, '2' for car
classes_to_count = [0, 2]
tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)

This way, you can tailor the object counting to your specific needs. Keep up the great work! 😊

[FaiqaShabbir]

hey can you tell me how and where to set the args in the above code

[pderrenger]

Hey there! 👋

To set the arguments in the code example you're referring to, you'll want to use the set_args() method of the ObjectCounter class. Here's a quick rundown:

# Initialize Object Counter
counter = object_counter.ObjectCounter()

# Set your desired arguments
counter.set_args(view_img=True,  # To display frames with counts
                 reg_pts=[(20, 400), (1080, 400)],  # Points defining the Region Area
                 classes_names=model.names,  # Dictionary of Class Names
                 draw_tracks=True)  # To enable drawing Track lines

You can customize the set_args() method with any of the optional arguments listed in the docs to fit your specific needs. For example, if you want to change the region color to blue, you would add region_color=(0, 0, 255) inside set_args().

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

[yeongnamtan]

OBJECTCOUNTER used to work for me but when I run it today, I get this erorr ...

TypeError Traceback (most recent call last)
Cell In[5], line 27
24 # Define line points
25 line_points = [(900, 0), (900, 1068)] # line for object counting
---> 27 counter = object_counter.ObjectCounter() # Init Object Counter
28 counter.set_args(view_img=True,
29 reg_pts=line_points,
30 classes_names=model.names,
31 count_reg_color=(255, 0, 0), # change line color according to your needs
32 draw_tracks=True)
34 while cap.isOpened():

TypeError: init() missing 1 required positional argument: 'classes_names'

[pderrenger]

@yeongnamtan hello! It looks like you're encountering a TypeError because the ObjectCounter class is expecting a required positional argument classes_names that wasn't provided.

To resolve this issue, you need to ensure that you pass the classes_names argument when initializing the ObjectCounter. Here's how you can modify your code:

# Initialize Object Counter with required classes_names argument
counter = object_counter.ObjectCounter(
    classes_names=model.names,  # Ensure model.names is correctly defined
    view_img=True, 
    reg_pts=line_points,
    count_reg_color=(255, 0, 0),  # change line color according to your needs
    draw_tracks=True
)

Make sure that model.names is defined and contains the names of the classes your model is trained to detect. This should resolve the error you're seeing. If you have any more questions or need further assistance, feel free to ask!

[yeongnamtan]

thank you. It is working now.

[pderrenger]

Great to hear it's working for you now! If you have any more questions or need further assistance as you continue to use the model, feel free to reach out. Happy counting! 😊🚀

[Boaruzhanchik]

Hi,how can I use object counting with 3 lines and 3 different counters ?
line_points = [(197,164), (486,164)]

Line pedestrian

line_pedestrian_1 = [(234,244),(131,218)]
line_pedestrian_2 = [(490,245),(534,231)]
line_pedestrian_3 = [(112,189),(154,177)]
counter = object_counter.ObjectCounter()
counter.set_args(view_img=False,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=False,
region_thickness = 1)
my code ex:
im0 = counter.start_counting(frame, results)
counter.extract_and_process_tracks(results)
counter.in_counts
counter.out_counts
print(f'In counts:{counter.in_counts}')
print(f'Out counts:{counter.out_counts}')

[glenn-jocher]

@syariffortask hey! If your line points are not appearing on the frame, there could be a couple of things to check out. Ensure that the view_img is set to True when initializing your ObjectCounter to have the frames displayed with the annotated lines. Also, verifying the reg_pts are correctly defined and fall within the frame's dimensions could help. Here's a quick example:

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
                 reg_pts=[(20, 400), (1080, 400)],  # Make sure these points are within your frame's dimensions
                 classes_names=model.names,
                 draw_tracks=True)

Make sure your setup matches your video frame size, and adjust the region_points as necessary. This adjustment should help you visualize the counting line directly on your frames! 😊 Let me know if this does the trick!

[syariffortask]

glenn tell me how you can do that? are you update class ObjectCounter logic in new version ultralytics?

[glenn-jocher]

Hey! 👋 Thanks for reaching out. Yes, we're constantly working on enhancing the ObjectCounter logic and adding new features in the Ultralytics YOLOv8 updates. For counting objects in specific regions or lines and setting it to only count "in" without counting "out", here's a quick example based on your requirement:

from ultralytics import YOLO, object_counter
import cv2

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

# Set up your video source
cap = cv2.VideoCapture("path/to/video.mp4")

# Initialize Object Counter for your line
line_pedestrian_1 = [(0, 244), (131, 244)]  # Define as per your need
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_pedestrian_1, classes_names=model.names)

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

    # Track objects
    results = model.track(im0)

    # Start counting based on tracks and your line
    im0 = counter.start_counting(im0, results)

    # Display
    cv2.imshow("Count", im0)
    if cv2.waitKey(1) == ord('q'):  # press q to quit
        break

cap.release()
cv2.destroyAllWindows()

This sets up an object counting system for pedestrians crossing line_pedestrian_1. Remember, ObjectCounter presently counts both "in" and "out" based on objects crossing the line, but you can customize the output based on the movement direction for more specific "in" count scenarios. Keep up with our GitHub releases for the latest features! 🚀 Let me know if there's anything else I can help with.

[syariffortask]

Thanks for answer my question,
But Can ultralytics predict and count two frame/ two vidio source ?

[glenn-jocher]

@syariffortask hey! Thanks for reaching out with your question. 😊 Yes, YOLOv8 can definitely work with two video sources simultaneously, but it would require running two instances of the video processing loop, each in its own thread or process, due to the way the code execution works.

Here's a simplified example using Python's threading module to process two videos at the same time:

from threading import Thread
from ultralytics import YOLO, object_counter
import cv2

def process_video(video_path):
    model = YOLO("yolov8n.pt")
    cap = cv2.VideoCapture(video_path)
    assert cap.isOpened(), "Error reading video file"
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            break
        results = model.track(frame)
        
        # Here you could use your ObjectCounter as needed
        # For example:
        # im0 = counter.start_counting(frame, results)
        # And then save or display im0
        
    cap.release()

# Define your video sources
video_1 = "path/to/your/first_video.mp4"
video_2 = "path/to/your/second_video.mp4"

# Start processing each video in a separate thread
Thread(target=process_video, args=(video_1,)).start()
Thread(target=process_video, args=(video_2,)).start()

Remember, depending on your system, handling two video streams simultaneously can be resource-intensive. Adjust the frame processing rate if necessary to manage system load. Hope that helps! Let me know if you have more questions. 🚀

[Anandukc]

hello, how can show the inn and out count of classes aswell. i want to do traffic monitoring so i want to get count of nunbers of truck,car,bycycles,bus,moving in and out how can i do that.

[glenn-jocher]

@Anandukc hey there! 😊 Sure, I can help you with that. Here's a simple example code that uses the ObjectCounter from Ultralytics YOLOv8 to count and display the names of different vehicle classes moving in and out:

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

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

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

# Define your line points for counting
line_points = [(20, 400), (1080, 400)]  # Adjust these points as needed

# Initialize Object Counter with desired settings
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_points, classes_names=model.names)

# Process video frames
while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break
    tracks = model.track(frame, persist=True, show=False)
    frame = counter.start_counting(frame, tracks)
    
    # Display in and out counts for each class
    for class_id in counter.in_count:
        print(f"In count for {model.names[class_id]}: {counter.in_count[class_id]}")
    for class_id in counter.out_count:
        print(f"Out count for {model.names[class_id]}: {counter.out_count[class_id]}")

cap.release()
cv2.destroyAllWindows()

This code will print the in and out counts for each class detected in the video. Just make sure to adjust the line_points to where you want to count the objects crossing. Hope this helps clear things up! 🚀

[kuangb17]

Hi, thanks for your work. Very useful and helpful! I still have a question when applying to my project. Although I have searched a lot by myself, I have not figured it out:
For counting/tracking in a video, what parameters that we can adjust to control the frame buffer of the tracking ? Not sure if the expression is clear, let me make an example: if the object is not shown in 10 consecutive frames, we will assign an new ID to the object. Because in my project, the object is consecutive line, if we did not control the frames, the track ID will keep the same almost all the time. In this case, the counting also does not work.
These parameters are similar with max_age and n_init in DeepSORT:
max_age : int
Maximum number of missed frames before a track is deleted.
n_init : int
Number of frames that a track remains in initialization phase.

[glenn-jocher]

Hey there! 😊 For frame buffer control in tracking, you can adjust the max_age parameter, which defines the number of frames to keep a track without a detection. If an object isn't detected for max_age frames, it's considered lost and a new ID will be assigned when it's detected again.

In YOLOv8, you can set this up by modifying the tracker configuration file (like botsort.yaml or bytetrack.yaml). Here's a snippet on how to set max_age:

from ultralytics import YOLO

# Load your model and tracker config
model = YOLO('yolov8n.pt', tracker='botsort.yaml')

# Modify the max_age parameter in the tracker
model.tracker.max_age = 10  # Set to 10 frames as per your example

This will ensure that if an object is not seen for 10 frames, it will be assigned a new ID. Adjust max_age to fit the specifics of your project. Hope this helps with your line tracking! 🚀

[kuangb17]

Thanks for help! Appreciate it. Just to clarify: is it model.track? the model does not have the tracker function but the track.

# Modify the max_age parameter in the tracker
model.track.max_age = 10  # Set to 10 frames as per your example

Also, no parameter "max_age" in model.track. However, I found there is a hyperparameter in bot,sort.yaml, which is similar with max_age.

track_buffer: 10 # buffer to calculate the time when to remove tracks

[glenn-jocher]

@kuangb17 hey there! 😊 You're absolutely right, and thanks for pointing that out. In YOLOv8, the tracking functionality is indeed accessed through model.track() rather than model.tracker. My apologies for any confusion caused.

Regarding the max_age parameter, you've made a great observation! In YOLOv8, similar functionality can be adjusted through the tracker configuration files like botsort.yaml. The track_buffer parameter you found is indeed what controls how long a track is kept without detection, akin to max_age in DeepSORT. Here's how you can adjust it:

# botsort.yaml
track_buffer: 10  # Adjust this to control the frame buffer for tracking

To use this in your project, simply modify the track_buffer value in your botsort.yaml file, and then load the tracker with your model like so:

model = YOLO('yolov8n.pt', tracker='path/to/your/custom_botsort.yaml')

This setup should help you manage the tracking IDs more effectively in your traffic monitoring project. If you have any more questions or need further assistance, feel free to ask. Happy tracking! 🚀

[Anandukc]

How can I integrate speed estimation of vehicles with in and out counting?

[glenn-jocher]

Hello! It looks like you're encountering an issue with the bounding box dimensions when trying to calculate the center points. The error arises because track.xyxy returns a tensor with four elements representing the coordinates [x1, y1, x2, y2], and you're trying to unpack this into two variables.

To fix this, you should calculate the center point by averaging the x and y coordinates separately. Here's how you can adjust your code:

import numpy as np

# Inside your loop
for result in tracks:
    for track in result.boxes:
        track_id = int(track.id)
        bbox = track.xyxy.cpu().numpy()  # Convert to numpy array for easier manipulation
        center_x = (bbox[0] + bbox[2]) / 2  # Average x coordinates
        center_y = (bbox[1] + bbox[3]) / 2  # Average y coordinates

        # Now you can continue with your speed calculation logic

This modification ensures you're correctly calculating the center of each bounding box by averaging the coordinates. If you have further questions or need more assistance, feel free to ask! 😊

[yeongnamtan]

I get below error...

IndexError Traceback (most recent call last)
Cell In[4], line 52
50 track_id = int(track.id)
51 bbox = track.xyxy.cpu().numpy() # Convert to numpy array for easier manipulation
---> 52 center_x = (bbox[0] + bbox[2]) / 2 # Average x coordinates
53 center_y = (bbox[1] + bbox[3]) / 2 # Average y coordinates
55 # Calculate speed if we have a previous position

IndexError: index 2 is out of bounds for axis 0 with size 1

[glenn-jocher]

Hello! It seems like you're encountering an IndexError due to attempting to access an index that doesn't exist in the bounding box array. This error typically occurs if the bounding box data isn't structured as expected, possibly due to no detections being made or an incorrect handling of the data format.

To resolve this, ensure that detections are being made and that the bounding box tensor is correctly accessed. You can add a check to confirm that the bounding box array contains the expected number of elements before attempting to access them. Here’s a quick modification to your code:

# Calculate speed for each tracked vehicle
for result in tracks:
    for track in result.boxes:
        track_id = int(track.id)
        if track.xyxy.numel() == 4:  # Ensure there are 4 elements in the bounding box
            bbox = track.xyxy.cpu().numpy()  # Convert to numpy array for easier manipulation
            center_x = (bbox[0] + bbox[2]) / 2  # Average x coordinates
            center_y = (bbox[1] + bbox[3]) / 2  # Average y coordinates
            # Continue with your speed calculation logic
        else:
            print(f"Skipping track {track_id}: insufficient bounding box data")

This modification checks that each bounding box contains exactly four elements before processing, which should help avoid the IndexError. If the error persists, please ensure your model is correctly detecting objects and that the input data is properly formatted. If you need further assistance, feel free to ask! 😊

[SudhanshuBlaze]

Hi,

The below code snippet is working so far for me to calculate the speed of the vehicles, but it is in pixel per second, how can I convert it to km/hr?

# Initialize tracking dictionary
last_positions = {}
movement_threshold = 1  # Minimum pixels an object must move to be considered in motion


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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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 id in last_positions:
                last_x, last_y, _, _, last_time = last_positions[id]
                # Calculate movement
                distance = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                delta_time = current_time - last_time
                print(f"Object {id} moved {distance:.2f} pixels in {delta_time:.2f} seconds")

                if distance < movement_threshold:
                    print(f"Object {id} is stationary")
                    continue  # Skip stationary objects
                
                speed_units_per_second = distance / delta_time
                speed_km_per_hour = speed_units_per_second * 3.6
                print(f"Object {id} moved with speed {speed_km_per_hour:.2f} km/h")

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

[glenn-jocher]

Hi there!

Great to hear that your code is working well for calculating the speed of vehicles in pixels per second! To convert this speed to kilometers per hour (km/h), you can use the following conversion factor:

1 pixel per second = 3.6 km/h

This conversion factor comes from the fact that there are 3600 seconds in an hour and 1000 meters in a kilometer. Here’s how you can integrate this conversion into your existing code:

# Initialize tracking dictionary
last_positions = {}
movement_threshold = 1  # Minimum pixels an object must move to be considered in motion

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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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].tolist()  # Unpack from the first row

                # Calculate center coordinates (x, y)
                x = (x_min + x_max) / 2
                y = (y_min + y_max) / 2

            current_time = time.time()  # Get the current timestamp

            if id in last_positions:
                last_x, last_y, _, _, last_time = last_positions[id]
                # Calculate movement
                distance = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                delta_time = current_time - last_time
                print(f"Object {id} moved {distance:.2f} pixels in {delta_time:.2f} seconds")

                if distance < movement_threshold:
                    print(f"Object {id} is stationary")
                    continue  # Skip stationary objects
                
                speed_units_per_second = distance / delta_time
                speed_km_per_hour = speed_units_per_second * 3.6
                print(f"Object {id} moved with speed {speed_km_per_hour:.2f} km/h")

            last_positions[id] = (x, y, x_max - x_min, y_max - y_min, current_time)  # Update position and timestamp

In this code, speed_units_per_second is calculated as the distance traveled in pixels divided by the time elapsed in seconds. Multiplying this value by 3.6 converts the speed to kilometers per hour.

Feel free to adjust the movement_threshold and other parameters to suit your specific use case. If you have any further questions or need additional assistance, don't hesitate to ask! 😊

[ShreyasChhetri]

Hi can I use this to setup my laptop camera for live streaming analysis ?

[pderrenger]

Absolutely! You can use Ultralytics YOLOv8 for live streaming analysis with your laptop camera. Here's a quick example to get you started with live object counting:

from ultralytics import YOLO
import cv2

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

# Open your laptop's camera
cap = cv2.VideoCapture(0)  # '0' is typically the built-in webcam
assert cap.isOpened(), "Error accessing webcam"

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

    # Run object detection
    results = model(frame)
    
    # Visualize results
    results.show()

    # Press 'q' to quit
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

This script opens your laptop camera, runs object detection on the live video stream, and displays the results in real-time. Press 'q' to exit the stream. Happy analyzing! 🚀

[ShreyasChhetri]

User
I want to run my Yolov8 model using my laptop camera and stream the analysis simultaneously and save the video after the streaming ends ?
Is this possible with the object counting code above ?

[glenn-jocher]

@ShreyasChhetri yes, it's definitely possible to run your YOLOv8 model with your laptop camera, stream the analysis in real-time, and save the video after the streaming ends. You can adapt the object counting code provided in the Ultralytics docs with a few modifications. Here's a simplified example to get you started:

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

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

# Use laptop camera
cap = cv2.VideoCapture(0)  # '0' for the default camera
assert cap.isOpened(), "Error accessing camera"

# Get video properties for saving
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Setup video writer to save output
video_writer = cv2.VideoWriter("object_counting_output.avi",
                               cv2.VideoWriter_fourcc(*'mp4v'),
                               fps,
                               (w, h))

# Initialize Object Counter
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, draw_tracks=True)

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

    # Perform tracking and object counting
    tracks = model.track(im0, persist=True, show=False)
    im0 = counter.start_counting(im0, tracks)

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

    # Optionally display the frame in real-time
    cv2.imshow("Live Object Counting", im0)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

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

This code captures video from your laptop camera, runs object counting, displays the analysis in real-time, and saves the output to a file named "object_counting_output.avi". Make sure to adjust the model path and any other parameters as needed. Happy coding! 🚀

[akhilesh99sharma]

Hello, I trained a YOLOv8 on my custom dataset of 3 classes. I need to count detections of each class and display them. I used your code but it is showing error: in <cell line: 27>()
33
34 # Display in and out counts for each class
---> 35 for class_id in counter.in_counts:
36 print(f"In count for {model.model.names[class_id]}: {counter.in_counts[class_id]}")
37 for class_id in counter.out_counts:

TypeError: 'int' object is not iterable

Following is my code:
`
from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

MODEL= "/content/drive/MyDrive/content/runs/detect/train/weights/best.pt"
from ultralytics import YOLO

model = YOLO(MODEL)
model.fuse()

classes_to_count = [0,1,2]

cap = cv2.VideoCapture("/content/drive/MyDrive/DJI_0495.MP4")
assert cap.isOpened(), "Error opening video stream or file"

line_points = [(1126, 1118), (2786, 1118)] # Adjust these points as needed

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_points, classes_names=model.names)

while cap.isOpened():
success, frame = cap.read()
if not success:
break
tracks = model.track(frame, persist=True, show=False,classes=classes_to_count)
frame = counter.start_counting(frame, tracks)

for class_id in counter.in_counts:
    print(f"In count for {model.names[class_id]}: {counter.in_counts[class_id]}")
for class_id in counter.out_counts:
    print(f"Out count for {model.names[class_id]}: {counter.out_counts[class_id]}")

cap.release()
cv2.destroyAllWindows()

`

[glenn-jocher]

Hey there! It looks like you're encountering an issue with iterating over counter.in_counts and counter.out_counts as they're expected to be dictionaries but are being treated as integers in your code. Let's correct that by ensuring we're accessing the counts correctly. Here's a quick fix:

Instead of directly iterating over counter.in_counts and counter.out_counts, you should access the counts using the class IDs you're interested in. Here's how you can do it for your 3 classes:

# Assuming your classes are 0, 1, and 2 and they're correctly set in classes_to_count
for class_id in classes_to_count:
    print(f"In count for {model.names[class_id]}: {counter.in_counts.get(class_id, 0)}")
    print(f"Out count for {model.names[class_id]}: {counter.out_counts.get(class_id, 0)}")

This code snippet uses .get(class_id, 0) to safely access the counts for each class, defaulting to 0 if the class ID isn't found in the counts dictionary. This should resolve the TypeError you're encountering. 😊

If you have any more questions or need further assistance, feel free to ask!

[Kindstep]

I am having the same problem. The solution gave a new error:

---> 52 print(f"In count for {model.names[class_id]}: {counter.in_counts.get(class_id, 0)}")

AttributeError: 'int' object has no attribute 'get'

[akhilesh99sharma]

@glenn-jocher, i got the results by printing incounts itself if it is an integer and use the get method if it is a dictionary. It worked but it is giving me wrong results. I created the output video where my target classes are going just one way but it is depicting values in both incounts and outcounts.

[glenn-jocher]

Hey there! It sounds like you've made some progress by adjusting your approach to handle both integers and dictionaries for in_counts and out_counts. However, if you're seeing counts in both directions even when objects are only moving one way, it might be due to how the counting line or region is defined and how the objects are interacting with it. 🤔

A few things to check:

• Line or Region Definition: Ensure your line or region points are correctly set to capture the desired direction of movement. Misalignment might cause unexpected counts.
• Direction Sensitivity: The current setup might not be sensitive to the direction of movement. You might need to adjust your logic to better capture the intended direction.

For debugging, you might also want to visualize the tracks and the counting line or region on the video to see exactly how objects are being counted as they cross the line or enter/exit the region. This could provide insights into why you're getting counts in both directions.

Here's a quick snippet to help visualize the counting line and direction on your frames:

for pt1, pt2 in zip(line_points[:-1], line_points[1:]):
    cv2.line(frame, pt1, pt2, (0, 255, 0), 3)  # Draw the counting line

And remember, the direction of the points in line_points or region_points can affect how the movement is interpreted. Make sure they're ordered in a way that matches your expected direction of travel.

If you're still facing issues, could you share a bit more about how you've set up your counting logic and any specific conditions you're using to determine in/out counts? This might help pinpoint the issue. Keep up the great work! 🚀

[Kindstep]

Just want to say this object counter is great! I am having trouble understanding how to keep count on how many of each class (i am tracking two classes) has been counted. Is it possible to do so? :)

[glenn-jocher]

Hey there! 😊 I'm thrilled to hear you're finding the object counter useful! To keep track of how many of each class you're counting, especially if you're focusing on two specific classes, you can modify the classes argument in the model.track() method to include only the class indices you're interested in. Here's a quick example assuming you're tracking classes 0 and 2:

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

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

# Define your classes to count here (e.g., 0 for person, 2 for car)
classes_to_count = [0, 2]

# Init Object Counter with your specific classes
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
                 classes_names=model.names,
                 draw_tracks=True)

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

    # Start counting with specified classes
    im0 = counter.start_counting(im0, tracks)
    # Here you can access the counts for each class
    print(f"Counts: {counter.counts}")

cap.release()
cv2.destroyAllWindows()

In this snippet, classes_to_count specifies the indices of the classes you want to track and count. The counter.counts will give you the counts for each class after processing each frame. Just replace the class indices with the ones you're interested in, and you're good to go! 🚀

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

[Kindstep]

Thanks for the help! I am getting an error from this that ObjectCounter does not have the attribute 'counts':

AttributeError Traceback (most recent call last)
Cell In[3], line 44
40 #last_count = counter.out_counts
42 results = counter.start_counting(im0, tracks)
---> 44 print(f"Counts: {counter.counts}")
46 delay_time = int((1 / fps) * 1000)
48 video_writer.write(im0)

AttributeError: 'ObjectCounter' object has no attribute 'counts'

This is my code (I am trying to track the amount of skiers vs snowbboarders passing a set point in a slope from a videostream, everything else works, just need to figure this last bit out):

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2
import pafy

video_url = 'https://www.youtube.com/watch?v=cCrstsCrebc'

video = pafy.new(video_url)
best_stream = video.getbest()

model = YOLO('output/train17/weights/best.pt')
cap = cv2.VideoCapture(best_stream.url)
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))

line =[(1200, 640), (1200, 1240)]

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

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
reg_pts=line,
classes_names=model.names,
draw_tracks=True)

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

# 0 = skis, 1 = snowboard
classes_to_count = [0, 1]  
tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)

#last_count = counter.out_counts

results = counter.start_counting(im0, tracks)

print(f"Counts: {counter.counts}")
    
delay_time = int((1 / fps) * 1000)

video_writer.write(im0)

# 'q' = exit
key = cv2.waitKey(delay_time) & 0xFF
if key == ord('q'):
    break

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

I have another code that i started with earlier that almost also works, but then i found this method which just seems a lot more flexible and effective, so i would like to use this instead. :)

if there is no built in system to keep count, is there any way for me to access the class of the object to determine what class just got counted after passing the line? This way i could just simply build a simple conditional that adds counts to custom variables (e.g. ski_counts & boarder_counts).

And once again, seriously, thanks for the help!

[glenn-jocher]

Hey there! Thanks for reaching out and for the kind words. 😊 It looks like you're doing some cool stuff with tracking skiers and snowboarders!

Regarding the error you're encountering, it seems like the ObjectCounter class might not directly expose a counts attribute for accessing the counts directly. However, you can still achieve what you're aiming for by leveraging the results from the start_counting() method, which processes the tracks and can be used to maintain your own count.

Here's a quick workaround to manually keep track of skiers and snowboarders counts:

# Initialize counters
ski_counts = 0
boarder_counts = 0

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

    tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)
    results = counter.start_counting(im0, tracks)

    # Assuming class 0 is skiers and class 1 is snowboarders
    for track in tracks:
        if track.cls == 0:  # Check if the class is skier
            ski_counts += 1
        elif track.cls == 1:  # Check if the class is snowboarder
            boarder_counts += 1

    print(f"Skiers: {ski_counts}, Snowboarders: {boarder_counts}")

    video_writer.write(im0)

In this snippet, after each frame is processed, we iterate through the tracks and increment our custom counters based on the class of each detected object. This way, you can maintain a separate count for skiers and snowboarders as they pass the set point.

And seriously, you're welcome! If you have any more questions or need further assistance, feel free to ask. Happy coding! 🚀

[Kindstep]

Thanks for the help! This did not unfortunately work as is, but I tweaked it a little. I also added some stuff, and now it is working ALMOST perfectly, counting the tracked classes after they have passed the line (missing sometimes when the line gets crowded). I'll share the code if anyone's interested:

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2
import pafy

video_url = 'https://www.youtube.com/watch?v=cCrstsCrebc'

video = pafy.new(video_url)
best_stream = video.getbest()

model = YOLO('insert trained model here')
cap = cv2.VideoCapture(best_stream.url)
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))

region =[(1200, 640), (1200, 1240),(2000,1240),(2000,640)]

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

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
reg_pts=region,
classes_names=model.names,
draw_tracks=False)

ski_counts = 0
snowboard_counts = 0
tracked = []
last_count = 0
counted = 0

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

a_frame = cv2.putText(frame, f"Ski Count: {ski_counts}", (w - 300, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
o_frame = cv2.putText(frame, f"Snowboard Count: {snowboard_counts}", (w - 420, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)

classes_to_count = [0, 1]  
tracks = model.track(o_frame, persist=True, show=False, classes=classes_to_count)

results = counter.start_counting(o_frame, tracks)

for i, r in enumerate(tracks):
    for index, box in enumerate(r.boxes):
        tracker_id = box.id
        
for obj in tracks:
    if counter.out_counts+counter.in_counts > last_count:
        if tracker_id not in tracked:
            if obj.boxes[0].cls == 0:  # Check if the class is skier
                ski_counts += 1
                tracked.append(tracker_id)  
            elif obj.boxes[0].cls == 1:  # Check if the class is snowboarder
                snowboard_counts += 1
                tracked.append(tracker_id)
                                  
last_count = counter.out_counts+counter.in_counts 

delay_time = int((1 / fps) * 1000)

video_writer.write(o_frame)

# 'q' = exit
key = cv2.waitKey(delay_time) & 0xFF
if key == ord('q'):
    break

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

Thanks again for the help! I still need to get my counting logic to be more precise, but the biggest hurdle has now been passed. :)

[glenn-jocher]

Hey there! 🎉 It's fantastic to hear you've made significant progress and are almost at the perfect solution for tracking skiers and snowboarders. Your initiative to tweak and enhance the code is exactly the kind of spirit that drives progress in projects like these.

Regarding the occasional misses when the line gets crowded, that's a common challenge in object tracking, especially in dense scenarios. Tweaking the iou thresholds and perhaps the conf confidence levels might help reduce those misses. Additionally, exploring different tracking algorithms (if you haven't already) could offer improvements in crowded scenes.

For the counting logic to be more precise, ensuring that each object is counted only once as it crosses the line is key. Your approach of tracking object IDs is on point. To further refine it, you might consider checking the direction of movement to ensure counts are incremented only when objects move in the desired direction across the line.

If you're open to sharing your code, I'm sure many in the community, including myself, would love to see it and perhaps offer suggestions for improvement. And if you have specific questions or hit another roadblock, feel free to ask!

Keep up the great work, and thanks for contributing to the community with your question and willingness to share your solution. Happy coding! 🚀

[yasirgultak]

Is there any possibility to crop a image of the objects touching the line?
Thanks

[pderrenger]

Hey there! 👋

Absolutely, you can crop images of objects touching a line by utilizing the tracking information provided by YOLOv8. Here's a quick example on how you might do it:

from ultralytics import YOLO
import cv2

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

# Define your line points
line_points = [(20, 400), (1080, 400)]

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

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

    # Track objects
    results = model.track(frame, persist=True)
    
    # Loop through detections and crop if touching the line
    for det in results[0].boxes.xyxy:
        x1, y1, x2, y2, conf, cls = det
        # Check if object is touching the line and crop
        if line_touching(x1, y1, x2, y2, line_points):
            cropped_img = frame[int(y1):int(y2), int(x1):int(x2)]
            # Save or process cropped_img as needed

cap.release()

You'll need to implement the line_touching function to check if the bounding box touches your defined line. This function would involve some geometry to check if any of the bounding box's edges intersect with your line.

Hope this helps! Let us know if you have any more questions. 😊

[AqsaRasheed]

the code is working quite but when my video start playing line region is not at appropriate location because my video dimensions are not appropriate it goes out of the windows frame due to which whole dimension of video are not. is ultralytics YOLOv8 require specific dimension based video ???

[yasirgultak]

@AqsaRasheed where did you find line_touching function ? or did you write a code ?

[AqsaRasheed]

@yasirgultak , u're getting wrong . I am using the same code as provided here for objects counting using line. My point of concern is only this when I run the code ( inference ) with basic commands for running the inference. Line counter initiated when window appears like this .. Please see the following output https://drive.google.com/file/d/1sk5YKjTWJVu7ZiOmRSIp_Nyer4fMythN/view?usp=sharing
the window only shows a 10% view of the actual video.

@glenn-jocher , please guide. thanks

[pderrenger]

Hey @AqsaRasheed! It seems like the window displaying only a small portion of your video is due to the resolution mismatch between your video and the display window. YOLOv8 itself doesn't require videos of specific dimensions, but when displaying them, it's crucial to ensure the window size matches or scales appropriately to the video's resolution.

Regarding the line_touching function, it's not provided out-of-the-box. It's a conceptual function you'd need to implement based on your specific requirements. For example, you could write a function that checks if any of the corners of the bounding box intersect with your defined line. Here's a simple pseudo-implementation to give you an idea:

def line_touching(x1, y1, x2, y2, line_points):
    # This is a simplified example. You'll need to implement the actual intersection logic
    # based on your line's and bounding box's coordinates.
    line_start, line_end = line_points
    # Check if any of the bounding box's corners are above or below the line
    # and implement the logic to determine if it's "touching" the line.
    return True or False

For the window size issue, you might want to dynamically resize the window based on the video's resolution or ensure the display settings are appropriate for the video's size. If you're using OpenCV for displaying the video, you can resize the window using cv2.resizeWindow or adjust the frame size using cv2.resize before displaying it.

I hope this helps! Let me know if you have any more questions. 😊

[dhamothar]

It is excellent, and it works great. Thank you. It works great when I run the object count with the standalone video file. But in the same program, when I tried with the RSTP URL, I saw that sometimes objects suddenly disappear and are missing from the frame(Which gives the wrong count). Initially, I thought it was a problem with the feed, and I checked through the extended time with VLC player, and there was no interruption from the rstp feed. This happens only when I run through the object detection example with the feed. Do I have to do any specific settings I have to do? Initially, I thought this was an issue because of the CPU. Later, I moved my code to the Lambda machine, where it runs as CUDA. Still, I see the missing frames. I would appreciate any suggestions/guidance here. I have tried using nano and small models.

One more question..
With multiple counters, I see that the counter displays were overlayed on top of one other. So i have done

cv2.putText(im0, 'Arrival Count::' + str(arr_counter.in_counts + arr_counter.out_counts), arr_count_loc,
cv2.FONT_HERSHEY_SIMPLEX, 1, (225, 255, 255), thickness=2, lineType=cv2.LINE_AA)
cv2.putText(im0, 'Departure Count::' + str(dep_counter.in_counts + dep_counter.out_counts), dep_count_loc,
cv2.FONT_HERSHEY_SIMPLEX, 1, (225, 255, 255), thickness=2, lineType=cv2.LINE_AA)
cv2.imshow("MWAA Arrival/Departure Vehicle Count", im0) which gives multiple display windows one from counter.set_args(view_img=True

Thank you.

[glenn-jocher]

Hey there! 🚀 Thanks for reaching out and sharing your experience with the object counting feature. It's great to hear it's working well with standalone video files!

Regarding the issue with RTSP streams where objects sometimes disappear, this could be related to frame drops or latency in the stream that might not be noticeable in VLC but could affect real-time processing. One suggestion is to adjust the buffer_size of your video capture to ensure more stable frame rates. You can do this with OpenCV by setting the buffer size before the loop:

cap.set(cv2.CAP_PROP_BUFFERSIZE, 3)

This sets the buffer size to 3 frames, which might help with smoother frame processing. Adjust the buffer size based on your stream's performance.

For the overlay issue with multiple counters, it seems like you've managed a workaround by specifying different locations for the text overlays. If you're still facing issues with multiple display windows, ensure that each cv2.imshow() call uses a unique window name or consolidate your visualizations into a single window by combining the text overlays before calling cv2.imshow().

If these suggestions don't resolve the issues, please feel free to share more details or code snippets, and we'll be happy to dive deeper into this. Keep up the great work!

[dhamothar]

wow.. thats so quick. Thanks for the quick suggestion. It appears to be we can't set the buffersize using this cap.set(cv2.CAP_PROP_BUFFERSIZE, 3) anymore. So tried reducing the frame rate from 30 to 15 the results were much better. Do you see any downside of setting lower framerate? Once again thank you for your guidance.

[glenn-jocher]

Hey there! 🚀 Glad to hear adjusting the frame rate improved your results. Lowering the frame rate can indeed help in some scenarios by giving more processing time per frame, which can be beneficial for tracking accuracy. The downside might be missing out on fast-moving objects or subtle movements between frames. However, if your application doesn't require capturing very rapid movements, reducing the frame rate is a practical solution. Keep experimenting to find the best balance for your specific use case. Happy tracking, and feel free to reach out if you have more questions!

[ShreyasChhetri]

Hi , I'm building a project in which I'm using a WEBRTC protocol to stream it via my input device then converting it to numpy arrays and then running the model on that
so what is happening is that even with object tracker it is labelling the same defect multiple times and the same code is running perfectly on Video input .mp4
So can anybody help me with it

AI model code which handles the actual detection of defects and their parameters.

from ultralytics import YOLO
import cv2
import cvzone
import math
import time
import json
import base64
import torch
from ultralytics.solutions import object_counter
import numpy as np
from torchvision.ops import box_area
import logging
import master_manager
from ai_video_recorder import VideoWriterThread

def main():
# Define video writer for video recording to file.
video_writer_thread = None

# Initialize AI model
model = YOLO("ultralytics/ultralytics/yolo/v8/runs/weights/best_car.pt")
# class_names = ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck", "boat",
#                "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat",
#                "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella",
#                "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
#                "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup",
#                "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli",
#                "carrot", "hot dog", "pizza", "donut", "cake", "chair", "sofa", "pottedplant", "bed",
#                "diningtable", "toilet", "tvmonitor", "laptop", "mouse", "remote", "keyboard", "cell phone",
#                "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors",
#                "teddy bear", "hair drier", "toothbrush"
#                ]
# class_names = ["chair", "tvmonitor", "laptop", "mouse", "remote", "keyboard", "cell phone"]
# prev_frame_time = 0

while True:
    # Clean up existing data
    video_writer_thread = None
    
    master_manager.az_logger.log_event("Waiting for video stream to start from peer..", level=logging.INFO)
    master_manager.new_input_video_frame_event.wait()
    master_manager.az_logger.log_event("Video stream from peer is active, entering live analysis mode.", level=logging.INFO)

    while master_manager.streaming_active:
        master_manager.new_input_video_frame_event.wait()  # Wait until a new frame is available
        # new_frame_time = time.time()
        img = master_manager.input_stream_video_frame
        if img.sum() > 0:  # Check if the frame is not empty

            # AI Model code ------------------------------------------------------------
            # List to hold all bounding box data
            bounding_boxes = []
            cosmos_db_data = []
            defect_frames = {}
            # Define line points
            line_position = 0
            box_size = 50
            width = 640
            height = 640
            x_line = int(line_position * width / 100)
            pt1 = (x_line,0 )
            pt2 = (x_line,height )

            pt11 = (x_line-100, height)
            pt22 = (x_line -100,0)

            region_points = [pt1,pt2,pt11,pt22]
            line_points = [pt1,pt2]

            # Keep track of detected defect IDs
            result_dict = {}
            result_list=[]
            frame_results = []
            defect_frames = {}
            # Init Object Counter
            counter = object_counter.ObjectCounter()
            counter.set_args(view_img=True,
                        reg_pts=line_points,
                        classes_names=model.names,
                        draw_tracks=True,region_thickness=1,track_color=(255,255,255))
            
            tracks = model.track(img, persist=True, show=False,tracker = "bytetrack.yaml",classes = [0,1],verbose=True,device=torch.device("cuda" if torch.cuda.is_available() else "cpu")) # list of Results objects
            if tracks and tracks[0].boxes.cpu().numpy().shape[0] > 0:
                for trac in tracks:
                    xyxy = trac.boxes.xyxy.cpu().numpy()
                    xyxy = np.array(xyxy).tolist()
                    # Store each list in a list
                    coordinate_variables = [f"coordinates_list_{i+1}" for i in range(len(xyxy))]
                    length_list, width_list, center_list, area_list = [], [], [], []
                    # Dynamically create variables and store the lists
                    for i, (variable, coordinates) in enumerate(zip(coordinate_variables, xyxy)):
                        # Round coordinates to two decimal places
                        rounded_coordinates = [round(coord, 2) for coord in coordinates]
                        globals()[variable] = rounded_coordinates
                        
                        # Calculate area using torchvision.ops.box_area
                        area = round(float(box_area(torch.tensor([rounded_coordinates]))[0]),2)
                        defect_name = trac.names[int(trac.boxes.cpu().numpy().cls[i])]
                        
                        # Calculate length, breadth, and center coordinates
                        length = round(float(coordinates[2] - coordinates[0]),2)
                        diameter = round(float(coordinates[2] - coordinates[0]),2)
                        width = round(float(coordinates[3] - coordinates[1]),2)
                        coordinate_x = round(float(coordinates[2] + coordinates[0]) / 2,2)
                        coordinate_y = round(float(coordinates[3] + coordinates[1]) / 2,2)
                        center = [coordinate_x,coordinate_y]
                        
                        
                        length_list.append(length)
                        width_list.append(width)
                        center_list.append(center)
                        area_list.append(area)
                    
                        
                        # Check if defect_id is new, then print information
                        if trac.boxes.id is not None:
                            defect_id = int(trac.boxes.id.cpu().numpy().tolist()[i])
                            if defect_id not in defect_frames:
                                defect_frames[defect_id] = img
                                result_dict[defect_id] = {
                                    "defect_name": defect_name,
                                    "defect_id": defect_id,
                                    "length": length,
                                    "width": width,
                                    "area": area,
                                    "diameter": diameter,
                                    "center": center,
                                    "coordinates_list": rounded_coordinates,
                                    "Depth" : "N/A",
                                    "Width/Depth Ratio" : "N/A"
                                    
                                    }
                    # Add dynamic text annotations for each detection
                    for i, coordinates in enumerate(trac.boxes.xyxy.cpu().numpy()):
                        # Get coordinates of the bounding box
                        box = coordinates.tolist()
                        area = round(float(box_area(torch.tensor([box]))[0]), 2)
                        cv2.putText(img, f"Area={str(area)} inch sqr",
                                    (int(box[0] - 1.5 * (box[2] - box[0])), int(box[1] + 1.9 * (box[3] - box[1]))),
                                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA)
                    
                img = counter.start_counting(img, tracks)
                
                # Update in and out counts
                in_counts = counter.in_counts
                out_counts = counter.out_counts
                print(f"In_Counts - {in_counts} and Out_Counts - {out_counts}")
                
                for defect_id, frame in defect_frames.items():
                    # Encode the frame as base64 string
                    _, buffer = cv2.imencode('.jpg', frame)
                    frame_base64 = base64.b64encode(buffer).decode('utf-8')
                    result_dict[defect_id]["frame_base64"] = frame_base64
                
                # Check for missing defect IDs
                # for defect_id in range(1, max(result_dict.keys()) + 1):
                #     if defect_id not in result_dict:
                #         result_dict[defect_id] = {"Message": f"Defect ID {defect_id} is missing because the frames were too close or many detections happened in that frame or there were no detections."}
                
                result = (list(result_dict.values()))
                cosmos_result = result
                cosmos_db_data.append(cosmos_result)
                json_data = json.dumps(cosmos_db_data)

                # Create a dictionary for the current bounding box
                bbox_data = {
                        "frameTransform": {
                            "position": {"x":coordinate_x , "y":coordinate_y },
                            "size": {"x": length, "y": width}
                            },
                        "frameLabel": {
                            "objectType": defect_name,
                        }
                    }

                # # Create an item for current defect's damage
                # dmg_item = {
                #         "damage": "Corrosion",
                #         "coordinates": [640.0, 638.0],
                #         "orientation": [0.0, 10.0, 640.0, 633.0],
                #         "length": 640.0,
                #         "width": 623.0,
                #         "area": 398720.0
                #     }

                # Append damage data to current session damages
                master_manager.output_ai_current_session_damages.append(cosmos_db_data)

                # Append the dictionary to the list
                bounding_boxes.append(bbox_data)
            # End AI model code ------------------------------------------------------------

            # fps = 1 / (new_frame_time - prev_frame_time)
            # prev_frame_time = new_frame_time
            # print("Current FPS: ", fps)

            # Convert the list to a JSON string
            json_data = json.dumps(bounding_boxes)

            # Send bounding box data as output to peer.
            master_manager.output_ai_response = json_data

            master_manager.new_input_video_frame_event.clear()  # Clear the event after processing the frame

            # cv2.namedWindow("Analysis", cv2.WINDOW_NORMAL)
            # cv2.imshow("Analysis", img)

            # Initialize the threaded video writer and recorder
            # Capture the dimensions of the first frame to set the video writer size
            if video_writer_thread is None:  # Check if the video writer is not already created
                frame_height, frame_width = img.shape[:2]  # Get the frame dimensions
                # Create the VideoWriter object with dynamic frame size
                video_writer_thread = VideoWriterThread(master_manager.recorded_media_folder_name, master_manager.recorded_media_file_name, cv2.VideoWriter_fourcc(*'XVID'), 12.0,
                                                    (frame_width, frame_height))

            # Write the processed frame to the video file using the separate thread
            # Add frame to be written by the separate thread
            video_writer_thread.write_frame(img)

            if not master_manager.streaming_active:
                break
        else:
            time.sleep(0.1)

    # Stop the threaded video writer
    if video_writer_thread is not None:
        master_manager.az_logger.log_event("AI has stopped receiving video stream from peer, finalizing recorded video..", level=logging.INFO)
        video_writer_thread.stop()

    cv2.destroyAllWindows()

if name == 'main':
main()
this is the code

[pderrenger]

@ShreyasChhetri hey there! 👋 It seems like you're encountering an issue with object tracking where the same defect is being labeled multiple times in your WEBRTC stream, but it works fine with .mp4 video input. This could be due to the differences in how frames are processed in real-time streaming compared to static video files.

One potential solution is to ensure that your tracking algorithm is correctly initialized and updated for each frame in the stream. Since you're using the YOLO model for tracking, make sure the persist=True flag is correctly utilized, and consider adjusting the iou and conf thresholds to better suit your streaming data. Sometimes, real-time streams might require different threshold settings compared to static video files due to variations in frame quality and rate.

Here's a simplified snippet focusing on the tracking part:

from ultralytics import YOLO
import cv2

# Initialize the YOLO model
model = YOLO("path/to/your/model.pt")

# Assuming 'frame' is your current frame from the WEBRTC stream
while True:
    frame = get_next_frame()  # This is a placeholder function
    if frame is not None:
        # Track objects in the frame
        results = model.track(frame, persist=True, tracker="bytetrack.yaml", conf=0.25, iou=0.45)
        
        # Process results
        for result in results:
            # Your processing code here
            pass
    else:
        break

Make sure to replace "path/to/your/model.pt" with the actual path to your model and get_next_frame() with the function/method you're using to fetch frames from your WEBRTC stream.

If you're still facing issues, it might be helpful to look into the specific characteristics of the frames coming from the WEBRTC protocol and see if there's a need for pre-processing steps to make them more consistent with the frames from a .mp4 video.

Hope this helps! Let us know if you have any more questions. 😊

[ShreyasChhetri]

Hi @pderrenger I have tried it but it was of no use can you suggest something else or is it because of the quality of the video stream ?

[pderrenger]

Hi @ShreyasChhetri! It sounds like the issue might indeed be related to the quality or specific characteristics of the video stream from your WEBRTC protocol. Here are a couple of things you might consider:

1. Frame Rate Consistency: Ensure the frame rate of your WEBRTC stream is consistent. Variability in frame rate can affect tracking performance.
2. Resolution and Quality: Check if the resolution and quality of the stream are sufficient for the model to detect and track objects accurately. Lower resolutions or high compression might lead to poor performance.
3. Lighting and Conditions: Variations in lighting or environmental conditions between your tested .mp4 files and the live stream could also impact detection.

You might also want to experiment with different configurations for the tracking parameters like iou and conf thresholds specifically for your stream conditions. Sometimes, fine-tuning these can help adapt the model better to the specific characteristics of live video streams.

If you continue to experience issues, consider providing a sample frame or more details about the stream's characteristics for more targeted advice. 😊

[MadsVintherM]

Is it possible to make a counter that resets every 10 sec and post out the count at the 10sec mark and then start over, repeat. For like a video running 40-50min or more? counting different plants in video

Would this work?

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2
import time

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

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

# Define your line points for counting
line_points = [(20, 400), (1080, 400)]  # Adjust these points as needed

# Initialize Object Counter with desired settings
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_points, classes_names=model.names)

# Initialize timer
start_time = time.time()

# Process video frames
while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break
    tracks = model.track(frame, persist=True, show=False)
    frame = counter.start_counting(frame, tracks)
    
    # Check if 10 seconds have passed
    current_time = time.time()
    if current_time - start_time >= 10:
        # Reset counters and start time
        counter.in_count = {class_id: 0 for class_id in counter.in_count}
        counter.out_count = {class_id: 0 for class_id in counter.out_count}
        start_time = current_time

    # Optional: Display in and out counts for each class
    # for class_id in counter.in_count:
    #     print(f"In count for {model.names[class_id]}: {counter.in_count[class_id]}")
    # for class_id in counter.out_count:
    #     print(f"Out count for {model.names[class_id]}: {counter.out_count[class_id]}")

cap.release()
cv2.destroyAllWindows()

[pderrenger]

@MadsVintherM yes, it's definitely possible to create a counter that resets every 10 seconds for counting different plants in a video. Your approach looks solid! Just a minor tweak: you might want to directly print or log the counts at the 10-second mark before resetting. Here's a slightly modified version of your code to include that (note: requires latest versions of ultralytics, please upgrade before running):

from ultralytics import YOLO, solutions
import cv2
import time

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

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

# Initialize Object Counter with desired settings
counter = solutions.ObjectCounter()

# Initialize timer
start_time = time.time()

# Process video frames
while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break
    tracks = model.track(frame, persist=True, show=False)
    frame = counter.start_counting(frame, tracks)
    
    # Check if 10 seconds have passed
    current_time = time.time()
    if current_time - start_time >= 10:
        # Print counts here
        print(f"Counts: {counter.in_count}")
        # Reset counters and start time
        counter.in_count = {class_id: 0 for class_id in counter.in_count}
        counter.out_count = {class_id: 0 for class_id in counter.out_count}
        start_time = current_time

cap.release()
cv2.destroyAllWindows()

This will print the counts of each class detected within the 10-second intervals. Make sure to adjust the line_points and other parameters according to your specific video and requirements. Happy coding! 🌱

[MadsVintherM]

Thanks for the feedback @pderrenger

[pderrenger]

You're welcome!

[laptop1990]

when i upload model then procssing speed of output video is very low as compared to real video , so how to incease from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

Load your model

model = YOLO(r"D:\Suraj\yolov8l_walltie.pt")

Setup video capture

cap = cv2.VideoCapture(r"D:\Suraj\HWvideo.mp4")
assert cap.isOpened(), "Error opening video stream or file"

Define your line points for counting

line_points = [(5, 400), (500, 400)] # Adjust these points as needed

Initialize Object Counter with desired settingsq

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_points, classes_names=model.names)

while cap.isOpened():
success, frame = cap.read()
if not success:
break
tracks = model.track(frame, persist=True, show=False)
frame = counter.start_counting(frame, tracks)

# Display total in and out counts
print(f"Total objects counted: {counter.in_counts}")  # Assuming in_counts is total count

key = cv2.waitKey(1)
if key & 0xFF == ord('q') or key == 27:
        break

cap.release()
cv2.destroyAllWindows()

[pderrenger]

It sounds like you're experiencing slower processing speeds with your output video compared to the real video. This can happen for a few reasons, but here are some tips to potentially increase the processing speed:

1. Optimize Model Size: If you're not already using a smaller model variant (like YOLOv8n, YOLOv8s), consider switching to one. Smaller models run faster.

2. Reduce Image Size: Lowering the input image size (imgsz) can significantly speed up processing. Try reducing it to see if it strikes a good balance between speed and accuracy for your use case.

3. Enable Half Precision: If your hardware supports it, running the model in half precision (model.half() in Python) can speed up inference.

4. Batch Processing: If you're processing videos, batch processing frames if possible can lead to better utilization of your hardware.

5. Hardware Acceleration: Ensure you're leveraging GPU acceleration if available. Running on a GPU can be significantly faster than CPU.

6. Optimize Video Writer: The codec and settings for cv2.VideoWriter can impact write speeds. Experiment with different codecs and see if any offer better performance.

Here's a quick example of enabling half precision in your code:

from ultralytics import YOLO
import cv2

# Load your model and switch to half precision
model = YOLO(r"D:\Suraj\yolov8l_walltie.pt").half()

# Setup video capture
cap = cv2.VideoCapture(r"D:\Suraj\HWvideo.mp4")
assert cap.isOpened(), "Error opening video stream or file"

# Your existing code continues here...

Remember, these changes can affect the accuracy of your model, so it's a good idea to test and find the best compromise between speed and accuracy for your specific application. 🚀

[DhruvPatel1015]

my problem is, i have different classes of vehicle like bus,bike,truck,and threewheeler. now i want to detect this classes into the given image and i want to store count of different classes into a variable. please help me

[glenn-jocher]

Hey there! 👋 For counting different vehicle classes in an image and storing their counts, you can use the object_counter solution from Ultralytics YOLOv8. Here's a quick example to get you started:

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

# Load your model
model = YOLO("yolov8n.pt")  # Adjust model path as needed

# Load your image
image_path = "path/to/your/image.jpg"
image = cv2.imread(image_path)

# Initialize Object Counter
counter = object_counter.ObjectCounter()

# Run detection and counting
tracks = model.track(image, persist=True, show=False)
image_with_counts = counter.start_counting(image, tracks)

# Access the counts
counts = counter.counts
print("Vehicle counts:", counts)

# Optionally, display the image
cv2.imshow("Counted Image", image_with_counts)
cv2.waitKey(0)
cv2.destroyAllWindows()

This script will detect vehicles, count them by class, and print the counts. Make sure to adjust the model and image_path to fit your setup. The counts variable will hold the count of different classes. 🚗🚌🏍

For more on object counting, check out the Object Counting using Ultralytics YOLOv8 guide. Happy coding!

[DhruvPatel1015]

TypeError Traceback (most recent call last)
in <cell line: 17>()
15 # Run detection and counting
16 tracks = model.track(image, persist=True, show=False)
---> 17 image_with_counts = counter.start_counting(image, tracks)
18
19 # Access the counts

1 frames
/usr/local/lib/python3.10/dist-packages/ultralytics/solutions/object_counter.py in extract_and_process_tracks(self, tracks)
170 for box, track_id, cls in zip(boxes, track_ids, clss):
171 # Draw bounding box
--> 172 self.annotator.box_label(box, label=f"{track_id}:{self.names[cls]}", color=colors(int(cls), True))
173
174 # Draw Tracks

TypeError: 'NoneType' object is not subscriptable

[glenn-jocher]

@DhruvPatel1015 hey there! It looks like you're encountering a TypeError because the tracks object passed to counter.start_counting() might be None or not properly formatted. This can happen if the tracking didn't return any results or if there's an issue with the model's output processing.

To debug, please ensure:

1. Your model is correctly loaded and capable of detecting objects in the provided image.
2. The tracks object is not None and contains valid tracking data.

Here's a quick check you can add before calling start_counting():

if tracks is not None and hasattr(tracks[0], 'boxes'):
    image_with_counts = counter.start_counting(image, tracks)
else:
    print("No tracks to count or invalid track format.")

This will help avoid the error by ensuring tracks is not None and has the expected attribute. If the problem persists, double-check your model's performance on the image to ensure it's detecting objects as expected. 🕵️‍♂️

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

[Peymankar]

Hi, how can i add classes like bike, motorcycle, truck and etc, in the codes there is just two classes. Also i want to count left and right turns in an intersection but don't know how.

[glenn-jocher]

@Peymankar hello!

To add more classes like bike, motorcycle, truck, etc., you'll need to train your model with a dataset that includes these classes. Ensure your dataset annotations include these classes and modify the data.yaml file to reflect the correct number of classes and class names.

For counting left and right turns at an intersection, you would typically need to define specific regions or lines where these turns are expected to occur. You can use the ObjectCounter with custom reg_pts to define these areas. Track the movement of vehicles and apply logic to count turns based on the direction of movement relative to your defined lines or regions.

Here's a brief example of how you might set up regions to detect turns:

# Define points for left and right turn regions
left_turn_points = [(x1, y1), (x2, y2), ...]
right_turn_points = [(x3, y3), (x4, y4), ...]

# Initialize counters for each turn direction
left_turn_counter = solutions.ObjectCounter(reg_pts=left_turn_points, ...)
right_turn_counter = solutions.ObjectCounter(reg_pts=right_turn_points, ...)

# In your processing loop
tracks = model.track(im0, persist=True)
left_turns = left_turn_counter.count(tracks)
right_turns = right_turn_counter.count(tracks)

Adjust the regions and logic according to the specific layout of your intersection. For more detailed guidance, please refer to our Object Counting Guide.

Let us know if you need further assistance!

[Ajantha-Aravind]

I get the each class count and tracking id in the video frame. I wrote the code for writing the tracking id and count for each class in the text file. only tracking id is written in to the text file. counts for each class is remains zero.

import cv2
from ultralytics import YOLO, solutions

model = YOLO("best.pt")
cap = cv2.VideoCapture("MVI_8803.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))

line_points = [(1000, 0), (1000, 1000)] # line or region points
classes_to_count = [0, 1, 2, 3, 4] # person and car classes for count

Video writer

video_writer = cv2.VideoWriter("object_counting_output1.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

Init Object Counter

counter = solutions.ObjectCounter(
view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
)

Initialize a dictionary to count class occurrences

class_counts = {class_id: 0 for class_id in classes_to_count}
tracking_ids = []

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, classes=classes_to_count)

# Extract and print tracking information
for track in tracks:
    if hasattr(track, 'boxes') and track.boxes is not None:
        for box in track.boxes:
            track_id = box.id  # Replace with the correct attribute if different
            bbox = box.xyxy  # Replace with the correct attribute if different
            class_id = box.cls  # Replace with the correct attribute if different
            tracking_ids.append(track_id)
            if class_id in class_counts:
                class_counts[class_id] += 1
            print(f"Tracking ID: {track_id}, BBox: {bbox}, Class ID: {class_id}")

im0 = counter.start_counting(im0, tracks)
video_writer.write(im0)

Write the tracking IDs and class counts to a text file

with open("tracking_info.txt", "w") as file:
file.write("Tracking IDs:\n")
file.write("\n".join(map(str, tracking_ids)))
file.write("\n\nClass Counts:\n")
for class_id, count in class_counts.items():
class_name = model.names[class_id] if class_id in model.names else f"Class {class_id}"
file.write(f"{class_name}: {count}\n")

print("Tracking information has been written to tracking_info.txt")

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

This is the code. i get the correct count value in video, but i can't get the count value in the text file

[pderrenger]

@Ajantha-Aravind hello,

It seems like you're encountering an issue where the class counts remain zero in your text file output, despite the counts appearing correctly in the video. This could be due to the timing of when the counts are being updated relative to when they are written to the file.

Here are a few things you might want to check:

1. Update Timing: Ensure that the class counts are updated before they are written out to the file. It's possible that the counts are being written before they are updated from the video processing loop.

2. Scope of Variables: Verify that the class_counts dictionary is being correctly updated within the scope of your loop where frames are processed. If the dictionary is being reset or not updated correctly within the loop, it would not hold the correct values when writing to the file.

3. Debugging Output: Add print statements to debug the values inside the loop right before they are written to the file. This can help confirm whether the issue is with updating the counts or writing to the file.

4. File Writing Permissions: Check if there are any issues with file writing permissions that might be preventing the file from being updated correctly.

If these suggestions do not resolve the issue, it might be helpful to isolate the problem by creating a minimal example that only counts objects and writes to a file, to see if the problem persists.

Feel free to share more details if the issue continues, and we can explore further solutions!

[Ajantha-Aravind]

import cv2
from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
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))

line_points = [(20, 400), (1080, 400)] # line or region points
classes_to_count = [0, 2] # person and car classes for count

Video writer

video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

Init Object Counter

counter = solutions.ObjectCounter(
view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
)

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, classes=classes_to_count)

im0 = counter.start_counting(im0, tracks)
video_writer.write(im0)

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

This is the basic code that I have used. from this code how to create the text file with tracking id and count of each class without considering the frames for counting

[pderrenger]

Hello,

Thanks for sharing your code snippet and the issue you're facing with writing the class counts to a text file. It seems like the class counts might not be updating correctly within your loop. To address this, ensure that the class count update is happening within the scope where the tracks are being processed.

Here's a quick suggestion: Instead of updating the class_counts dictionary directly within the loop where you're reading frames and detecting objects, you might want to accumulate counts within each frame processing iteration and then update the dictionary outside that loop or at the end of each frame processing.

Also, ensure that the classes_to_count array correctly references the classes you're interested in counting, and that these classes are being detected in your video frames.

If you continue to face issues, please provide more details about the output you're seeing in the video and any errors or unexpected outputs in your console. This will help in diagnosing the issue more effectively.

[SudhanshuBlaze]

Hi, this is my code for tracking vehicles in a traffic, but at the moment it is also detecting vehicles which are not moving and stationary. (1) Is it possible to stop detecting those objects (vehicles) which are not moving?

(2) Also, it is detecting some moving bicycles as persons, so is it possible to add some if condition to check if moving people have 'x' speed then we can classify them as bicycles/motorcycles?

(3): The model is pretty good at detecting and tracking the vehicles, but sometimes misclassifies some vehicles, like it sometimes detects buses as trains, and bigger cars as trucks. So I want to fine-tune the model on my dataset (video) to “classify” the vehicles correctly. I don't want to fine tune for detection or tracking as it is already good in it, so I want to only fine tune it for classifying the vehicle's correctly. Please guide me with the steps or resources.

Current code:

import cv2
from ultralytics import YOLO, solutions

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

# Open the video file
cap = cv2.VideoCapture("resources/DJI_0505.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))

classes_to_count = list(range(0, 23))  # classes to count 

# Define the lines or regions points
line_points_1 = [(300, 600), (700, 550)]  # first line points
line_points_2 = [(800, 550), (1700, 350)]  # second line points
line_points_3 = [(174, 1150), (174, 1800)]  # second line points
line_points_4 = [(640, 1674), (1006, 1578)]  # second line points


# Video writer
video_writer = cv2.VideoWriter("real_object_counting_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counters
counter_1 = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points_1,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 0),
    count_reg_color=(229, 255, 204),  # Very light green
    count_bg_color=(229, 255, 204)  # Very light green
)

counter_2 = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points_2,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(-250, 0),
    count_reg_color=(153, 204, 255),  # Light blue
    count_bg_color=(153, 204, 255)  # Light blue
)

counter_3 = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points_3,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(-500, 0),
    count_reg_color=(255, 204, 204),  # Light red
    count_bg_color=(255, 204, 204)  # Light red
)

counter_4 = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points_4,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(-750, 0),
    count_reg_color=(210, 180, 140),  # Light brown
    count_bg_color=(210, 180, 140)  # Light brown
)


# Init separate trackers for each counter
tracker = model  # Tracker for the first counter

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

    # Perform tracking for the first counter, options: tracker="bytetrack.yaml"
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)

    im0 = counter_1.start_counting(im0, tracks)

    # Perform tracking for the second counter
    im0 = counter_2.start_counting(im0, tracks)
    
    im0 = counter_3.start_counting(im0, tracks)
    
    im0 = counter_4.start_counting(im0, tracks)
    # Write the frame to the output video
    video_writer.write(im0)

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

[glenn-jocher]

Hello! Thanks for reaching out with the details of the issue you're encountering.

The error you're seeing is due to trying to access an attribute id that doesn't exist in the Results object directly. In Ultralytics YOLO, the tracking information, including IDs, is contained within the boxes attribute of the Results object. You should modify your code to access the IDs from the boxes attribute.

Here's how you can adjust your code:

# Perform tracking for all counters
tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)

for box in tracks.boxes:
    id = box.id
    x, y, w, h = box.xyxy
    if id in last_positions:
        last_x, last_y = last_positions[id][:2]
        # Calculate movement
        distance = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
        if distance < movement_threshold:
            continue  # Skip stationary objects
    last_positions[id] = (x, y, w, h)  # Update position

Make sure to replace the loop where you previously accessed track.id and track.xywh with the above code. This should resolve the AttributeError by correctly accessing the tracking ID and bounding box coordinates from the boxes attribute.

If you need further assistance or have more questions, feel free to ask. Happy coding! 🚀

[SudhanshuBlaze]

Hi, Thanks for the prompt response, yes your piece of code for filtering out stationery object just worked fine after tweaking it a little. So at the moment I am able to print the objectId of a stationary object as you can see in the code, so the next job is how to prevent the plotting of a bounding box over it?

Code Snippet to filter out stationery object:

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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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

            if id in last_positions:
                last_x, last_y = last_positions[id][:2]
                # Calculate movement
                distance = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                if distance < movement_threshold:
                    print(f"Object {id} is stationary")
                    continue  # Skip stationary objects
            last_positions[id] = (x, y, w, h)  # Update position

    
    # Perform counting and draw tracks for each counter
    im0 = counter_1.start_counting(im0, tracks)
    im0 = counter_2.start_counting(im0, tracks)
    im0 = counter_3.start_counting(im0, tracks)
    im0 = counter_4.start_counting(im0, tracks)

I think for that we need to update the extract_and_process_tracks() function for it which is present in: /ultralytics/solutions/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)

[glenn-jocher]

Hi there! 😊

I'm glad to hear that the code for filtering out stationary objects is working well for you after some tweaks. Now, let's address how to prevent the plotting of bounding boxes around these stationary objects.

To achieve this, you can modify the extract_and_process_tracks() function in the object_counter.py file to skip drawing bounding boxes for stationary objects. Here's how you can do it:

1. Add a Check for Stationary Objects: Before drawing the bounding box, check if the object is stationary and skip the drawing if it is.

Here's the updated code for the extract_and_process_tracks() function:

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):
            # Check if the object is stationary
            if track_id in self.stationary_ids:
                continue  # Skip drawing for stationary objects

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

In this code, self.stationary_ids should be a list of IDs for stationary objects. You can maintain this list in your main loop where you detect stationary objects.

Here's how you can update your main loop to maintain self.stationary_ids:

# Initialize tracking dictionary
last_positions = {}
movement_threshold = 20  # Minimum pixels an object must move to be considered in motion
stationary_ids = set()

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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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

            if id in last_positions:
                last_x, last_y = last_positions[id][:2]
                # Calculate movement
                distance = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                if distance < movement_threshold:
                    print(f"Object {id} is stationary")
                    stationary_ids.add(id)
                    continue  # Skip stationary objects
                else:
                    stationary_ids.discard(id)
            last_positions[id] = (x, y, w, h)  # Update position

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

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

In this updated code, stationary_ids is a set that keeps track of stationary object IDs. The extract_and_process_tracks() function then uses this set to skip drawing bounding boxes for these objects.

I hope this helps! If you have any further questions or need more assistance, feel free to ask. Happy coding! 🚀

[SudhanshuBlaze]

Hi Glenn,

Thank you for amazing support 🙏🏼 , your solution worked perfectly fine. However I did a small tweak in the solution which I would also like to share with the community. 😄

Instead of checking the movement of object in every consecutive frame and adding to stationary_ids set, I am doing this for every 10 frames, because there is no significant movement of any object between consecutive frames, so the interval of 10 frames gives us a solid basis to decide whether the object is actually stationary or just moving slow. Below is the code snippet for it ⬇️

# Initialize tracking dictionary
last_positions = {}
stationary_ids = set()
frame_interval = 10  # Check position every 10 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

    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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 id in last_positions and frame_count % frame_interval == 0:
                last_x, last_y, _, _, last_time = last_positions[id]
                # Calculate movement
                distance_pixels = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                delta_time = current_time - last_time
                print(f"Object {id} moved {distance_pixels:.2f} pixels in {delta_time:.2f} seconds")

                if distance_pixels < movement_threshold:
                    stationary_ids.add(id)
                else:
                    stationary_ids.discard(id)
                
                print(f"Object {stationary_ids} is stationary.")
                # Convert distance from pixels to meters
                distance_meters = distance_pixels * pixel_to_meter
                # Calculate speed in pixels per second
                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 every frame
            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)

[glenn-jocher]

@SudhanshuBlaze hi there,

Thank you so much for your kind words and for sharing your solution with the community! 🙏🏼 It's fantastic to see how you've optimized the detection of stationary objects by checking their movement every 10 frames instead of every frame. This approach indeed provides a more reliable basis for determining whether an object is stationary or just moving slowly. 😄

For those interested, here's the updated code snippet that implements this improvement:

# Initialize tracking dictionary
last_positions = {}
stationary_ids = set()
frame_interval = 10  # Check position every 10 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

    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    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 id in last_positions and frame_count % frame_interval == 0:
                last_x, last_y, _, _, last_time = last_positions[id]
                # Calculate movement
                distance_pixels = ((last_x - x) ** 2 + (last_y - y) ** 2) ** 0.5
                delta_time = current_time - last_time
                print(f"Object {id} moved {distance_pixels:.2f} pixels in {delta_time:.2f} seconds")

                if distance_pixels < movement_threshold:
                    stationary_ids.add(id)
                else:
                    stationary_ids.discard(id)
                
                print(f"Object {stationary_ids} is stationary.")
                # Convert distance from pixels to meters
                distance_meters = distance_pixels * pixel_to_meter
                # Calculate speed in pixels per second
                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 every frame
            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)

This code snippet checks the movement of objects every 10 frames, which helps in accurately identifying stationary objects without unnecessary computations for every frame.

For those looking to implement similar functionality, you can refer to the Object Counting Guide for more detailed examples and explanations.

Thank you again for your contribution to the community! If you have any further questions or need additional assistance, feel free to reach out. Happy coding! 🚀

[Avingshu123]

can anyone tell me whenever I tried to run the code for region based counting in jupyter notebook it's output video doesn't show the region for counting even though it assign individual no. for each boxes enclosing the vehicles which passes a certain region

[pderrenger]

Hello! It sounds like the region for counting isn't visible in your output video, even though the tracking and numbering are functioning correctly. This issue might be related to how the region is being drawn or updated in the video frames.

Here are a couple of things you could check:

1. Visibility of the Region: Ensure that the view_img parameter in your ObjectCounter initialization is set to True. This parameter controls whether the video stream (and any overlays like counting regions) is displayed.

2. Region Drawing Settings: Check the count_reg_color, line_thickness, and region_thickness parameters to make sure they are set to values that make the region visible against your video background.

3. Update and Redraw: Make sure that the region points (reg_pts) are correctly defined and that they match the coordinates where you expect to see the region.

If these settings look correct, it might help to manually force a redraw of the region in each frame, or check if the overlay is somehow being cleared or overwritten after drawing. If the issue persists, reviewing the specific sections of your code handling the drawing operations could provide further insights.

For more detailed guidance, you might find additional resources and community discussions helpful on our Object Counting Guide.

[Hamzasayha]

hi I hope this message finds you well. I am currently working on a project where I need to use the YOLO v8 model for tracking, counting objects and speed estimating in a video. I combined object counting code with speed estimating code and it worked fine but I need to save the result of the vehicles counted in a CSV file. How can I do it? I tried multiple ways but all of them gave me errors. this is my code now
import cv2
from ultralytics import YOLO, solutions

model = YOLO("yolov8x.pt")
cap = cv2.VideoCapture("/content/drive/MyDrive/Video/Trim.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))

line_points = [(500, 1100), (3500, 1100)] # line or region points
classes_to_count = [2, 3, 5, 7] # person and car classes for count

Video writer

video_writer = cv2.VideoWriter("/content/drive/MyDrive/Video/object_counting_output3.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

Init Object Counter

counter = solutions.ObjectCounter(
view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,
line_thickness=6,
)

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, classes=classes_to_count)

im0 = counter.start_counting(im0, tracks)
video_writer.write(im0)

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

[glenn-jocher]

Hello! I'm glad to hear that you've successfully integrated object counting and speed estimating using YOLOv8. To save the vehicle counts to a CSV file, you can use Python's built-in csv module. Here's a simple way to modify your code to include CSV writing functionality:

import cv2
import csv
from ultralytics import YOLO, solutions

model = YOLO("yolov8x.pt")
cap = cv2.VideoCapture("/content/drive/MyDrive/Video/Trim.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))

line_points = [(500, 1100), (3500, 1100)]
classes_to_count = [2, 3, 5, 7]

video_writer = cv2.VideoWriter("/content/drive/MyDrive/Video/object_counting_output3.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
counter = solutions.ObjectCounter(view_img=True, reg_pts=line_points, classes_names=model.names, draw_tracks=True, line_thickness=6)

# Prepare CSV file to write counts
with open('/content/drive/MyDrive/Video/vehicle_counts.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Frame', 'Vehicle Count'])

    frame_number = 0
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            break
        tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)
        im0 = counter.start_counting(im0, tracks)
        video_writer.write(im0)

        # Write count results to CSV
        vehicle_count = len(tracks)  # Assuming tracks holds the count of vehicles
        writer.writerow([frame_number, vehicle_count])
        frame_number += 1

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

This modification opens a CSV file for writing and appends the frame number and vehicle count for each frame processed. Adjust the vehicle_count logic based on how your tracks variable is structured or if you need to filter by specific classes.

If you encounter any errors with this approach, please share the error messages, and I'll be happy to help further!

[Peymankar]

Hi, how can i select the exact coordinates for counting line in my video, i can not place the lines exactly where i need it.

[glenn-jocher]

Hello,

To precisely place counting lines in your video using Ultralytics YOLOv8, you can follow these steps:

1. Open your video in a video editing tool that displays pixel coordinates (like OpenCV or any other video software that shows coordinates).
2. Play the video and pause at the frame where you want to place the counting line.
3. Note the coordinates by moving your mouse to the desired start and end points of the line. Most video tools will show the x, y coordinates at the bottom or side of the window.
4. Enter these coordinates into your script in the reg_pts list. For example, if your points are (50, 200) and (700, 200), you would set reg_pts=[(50, 200), (700, 200)].

This method ensures that the counting lines are placed exactly where you need them for accurate object counting.

If you need further assistance or have more questions, feel free to ask!

[Peymankar]

Hi, how can i put the counting lines exactly where i need it, i mean how it is possible to find the coordonates of the places i want to put the counter line.

[SudhanshuBlaze]

I use this tool called ImageJ to get the coordinates and then use the coordinates in the code to plot the region counter:

[Peymankar]

Thank you for your response🙏

[glenn-jocher]

@SudhanshuBlaze using a tool like ImageJ to obtain coordinates for placing counting lines is a great approach! Once you have the coordinates, you can define them in your code as shown in the examples from the Ultralytics documentation. This method ensures that your counting lines are precisely where you need them for accurate object tracking and counting.

If you have any more questions or need further assistance with your setup, feel free to ask! Happy counting! 🚀

[zij212]

Hello! I used the same model to 1) detect a custom class and 2) count custom class. I noticed that the tracker don't detect the object sometimes, or create duplicates when lighting changes.

Here're 2 videos to demonstrate what I meant: 1) moss rose detection 2) moss rose counter.

• At 0:03, the detector picked up the flower at the center of the frame, however, the counter wasn't able to do it.
• Between 0:32 and 0:36 in the counter video, the same yellow moss rose got counted 3 times.

Can you help me understand what I should look into to address this type of behavior? I used the default arguments in model.predict() for detection. And in model.track() for counting, I used persist=True, show=False, conf=0.25, iou=0.7, tracker="bytetrack.yaml".

Thank you in advance!

[pderrenger]

Hello! Thank you for sharing your experience and the detailed videos. It seems like the issues you're encountering with object detection and counting, particularly with tracking consistency and duplicate counts, might be influenced by a few factors.

1. Lighting Changes: Sudden lighting changes can affect the appearance of objects, leading the tracker to lose track or create duplicates. You might consider preprocessing your video to stabilize lighting conditions or adjust the model's confidence thresholds to be more robust against such changes.

2. Tracker Configuration: Since you're using bytetrack.yaml with conf=0.25 and iou=0.7, tweaking these parameters could help. Increasing the confidence threshold (conf) might reduce false positives, while adjusting the IoU threshold (iou) could help in handling overlaps better.

3. Region Definition: Ensure that the counting regions are defined accurately and are stable across frames. Any shift or overlap in regions might lead to repeated counts.

4. Advanced Tracking Settings: Exploring advanced tracking features like occlusion handling or using more sophisticated tracking algorithms might provide better results, especially in challenging scenarios like the ones you described.

For further refinement, you might also consider custom training with augmented data that simulates the lighting variations and scenarios observed in your specific use case.

If adjustments to these parameters still don't resolve the issues, please consider providing more details about the environmental conditions and the specific model configurations. This will help us give more targeted advice. Thank you for using Ultralytics YOLOv8, and we look forward to assisting you further!

[zij212]

Thank you for the suggestions. I will try them out!

[pderrenger]

@zij212 great to hear that you'll be trying out the suggestions! If you have any more questions or need further assistance as you adjust the settings, feel free to reach out. Happy tracking! 😊🌼

[smc0927]

AttributeError: module 'ultralytics.solutions' has no attribute 'ObjectCounter'
How to solve this kind of problem？

[AshishreddyM26]

I am using ultralytics 8.1.37, I tried reinstalling the ultralytics but getting the same error again. I am using jupyter notebook also tried in VS Code, but the issue isn't resolved.
So, how can I solve the issue.

Thank you,
Ashish

[AshishreddyM26]

Got it fixed.

Thanks

[pderrenger]

Hi Ashish,

I'm glad to hear you got it fixed! 🎉 If you have any more questions or need further assistance, feel free to reach out. The YOLO community and the Ultralytics team are always here to help.

For anyone else facing similar issues, make sure you're using the latest version of the Ultralytics library and check the documentation for any updates or changes. If you encounter any more problems, don't hesitate to ask.

Happy coding! 🚀

[smc0927]

Thank you for your guidance, my ultralytics=8.2.28,import cv2
from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("E:\YOLOv8\people1.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))

line_points = [(20, 400), (1080, 400)] # line or region points
classes_to_count = [0, 2] # person and car classes for count

Video writer

video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

Init Object Counter

counter = solutions.ObjectCounter(
view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
)

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, classes=classes_to_count)

im0 = counter.start_counting(im0, tracks)
video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()
this is my code,It still has such problems

[pderrenger]

@smc0927 hi there!

Thank you for sharing your code and the details of the issue you're facing. It looks like you're encountering an AttributeError because the ObjectCounter attribute is not recognized within the ultralytics.solutions module. This can happen due to a few reasons, such as version mismatches or changes in the library's API.

Given that you're using ultralytics==8.2.28, let's ensure everything is set up correctly. Here are a few steps to help resolve the issue:

1. Check the Correct Import Path: Ensure that the ObjectCounter is correctly imported. The ObjectCounter might have been moved or renamed in newer versions. Try updating your import statement to:

   from ultralytics.solutions import ObjectCounter

2. Update to the Latest Version: Sometimes, updating to the latest version of the library can resolve such issues. You can update the Ultralytics package using:

   pip install --upgrade ultralytics

3. Verify the ObjectCounter Class: Double-check the documentation or the source code to ensure that ObjectCounter is available in the solutions module. If it has been moved, the documentation should provide the correct path.

Here’s an updated version of your code with the correct import statement:

import cv2
from ultralytics import YOLO
from ultralytics.solutions import ObjectCounter  # Ensure this import is correct

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("E:/YOLOv8/people1.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))

line_points = [(20, 400), (1080, 400)]  # line or region points
classes_to_count = [0, 2]  # person and car classes for count

# Video writer
video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

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, classes=classes_to_count)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

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

If the issue persists, please let me know the exact error message you're encountering, and we can further troubleshoot it together. Feel free to reach out if you have any more questions or need additional assistance. Happy coding! 😊

[priyadharshini114]

Hi team,
I have doubts on how to implement three or more lines at the same time and how to change the visual name on the video, i.e., if I use it one line, I can count in our vehicle. Like wise, I want to count three or more way roads. I have a region of line. 

[Peymankar]

Hi there, I have tried every thing but i still have problem with overlap of count boxes. every thing is the latest version and i tried different text offsets. i would be thankful if you show me a way to prevent the overlap of text boxes.

[glenn-jocher]

Hi there,

Thank you for reaching out and providing detailed information about the issue you're facing. I'm sorry to hear that the text boxes are still overlapping despite trying different offsets. Let's work together to resolve this! 😊

Steps to Troubleshoot

1. Ensure Latest Versions: First, please verify that you are using the latest versions of torch and ultralytics. You can upgrade them using the following commands:

   pip install --upgrade torch ultralytics

2. Minimum Reproducible Example: If the issue continues, could you please provide a minimum reproducible code example? This will help us better understand the problem and provide a more accurate solution. You can refer to our Minimum Reproducible Example Guide for more details on how to create one.

Custom ObjectCounter with Text Offset

Here’s a refined version of the custom ObjectCounter class to ensure the text offsets are applied correctly:

import cv2
from ultralytics import YOLO, solutions

# Custom wrapper class for ObjectCounter
class CustomObjectCounter(solutions.ObjectCounter):
    def __init__(self, *args, text_offset=(0, 0), **kwargs):
        super().__init__(*args, **kwargs)
        self.text_offset = text_offset

    def display_analytics(self, im0, text, txt_color, bg_color, margin):
        horizontal_gap = int(im0.shape[1] * 0.02)
        vertical_gap = int(im0.shape[0] * 0.01)
        text_y_offset = self.text_offset[1]
        text_x_offset = self.text_offset[0]
        for label, value in text.items():
            txt = f"{label}: {value}"
            text_size = cv2.getTextSize(txt, 0, self.sf, self.tf)[0]
            if text_size[0] < 5 or text_size[1] < 5:
                text_size = (5, 5)
            text_x = text_x_offset + im0.shape[1] - text_size[0] - margin * 2 - horizontal_gap
            text_y = text_y_offset + text_size[1] + margin * 2 + vertical_gap
            rect_x1 = text_x - margin * 2
            rect_y1 = text_y - text_size[1] - margin * 2
            rect_x2 = text_x + text_size[0] + margin * 2
            rect_y2 = text_y + margin * 2
            cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
            cv2.putText(im0, txt, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
            text_y_offset += text_size[1] + vertical_gap  # Update text_y_offset for the next label

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

# Open the video file
cap = cv2.VideoCapture("/content/Naples Italy Traffic2.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))

classes_to_count = list(range(0, 23))  # classes to count

# Define the lines or regions points
line_points_1 = [(545, 268), (753, 288)]  # first line points
line_points_2 = [(874, 260), (1004, 266)]  # second line points
line_points_3 = [(25, 318), (302, 268)]  # third line points
line_points_4 = [(969, 404), (1096, 286)]  # fourth line points

# Video writer
video_writer = cv2.VideoWriter("out_object_counting_output7.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Custom Object Counters
counter_1 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_1,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 0),
    count_reg_color=(229, 255, 204),  # Very light green
    count_bg_color=(229, 255, 204)  # Very light green
)

counter_2 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_2,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 50),  # Adjusted text offset
    count_reg_color=(153, 204, 255),  # Light blue
    count_bg_color=(153, 204, 255)  # Light blue
)

counter_3 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_3,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 100),  # Adjusted text offset
    count_reg_color=(255, 204, 204),  # Light red
    count_bg_color=(255, 204, 204)  # Light red
)

counter_4 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_4,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 150),  # Adjusted text offset
    count_reg_color=(210, 180, 140),  # Light brown
    count_bg_color=(210, 180, 140)  # Light brown
)

# Init separate trackers for each counter
tracker = model  # Tracker for the first counter

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

    # Perform tracking for the first counter, options: tracker="bytetrack.yaml"
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)

    # Perform counting for each counter
    im0 = counter_1.start_counting(im0, tracks)
    im0 = counter_2.start_counting(im0, tracks)
    im0 = counter_3.start_counting(im0, tracks)
    im0 = counter_4.start_counting(im0, tracks)

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

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

Additional Tips

• Adjust Text Offsets: Ensure that the text_offset values are set appropriately to avoid overlap. You can experiment with different values to find the best fit.
• Check Display Function: Verify that the display_analytics method correctly applies the offsets. You can add print statements to debug the positions if necessary.

If you have any further questions or need additional assistance, feel free to ask. We're here to help! 🚀

Happy coding!

[Peymankar]

Hi dear Glenn,
i have installed all the latest versions, changed the offsets and added print statements but it seems that the text boxes are already glued to the corner of monitor and overlapping each other, isn't there any other solution?

[glenn-jocher]

@Peymankar hi there,

Thank you for reaching out and providing detailed information about the issue you're facing. It's great to hear that you've already tried updating to the latest versions and adjusting the offsets. Let's work together to resolve this! 😊

Addressing the Overlapping Text Boxes

It seems like the text boxes are still overlapping despite the adjustments. To tackle this, we can ensure that each text box is placed with enough vertical spacing to avoid overlap. Here's a refined approach to achieve this:

1. Custom ObjectCounter Class: We'll extend the ObjectCounter class to include a custom text_offset parameter and ensure that the text boxes are spaced correctly.

2. Dynamic Text Placement: We'll dynamically adjust the position of each text box based on its size and the specified offset.

Here's an updated version of your code:

import cv2
from ultralytics import YOLO, solutions

# Custom wrapper class for ObjectCounter
class CustomObjectCounter(solutions.ObjectCounter):
    def __init__(self, *args, text_offset=(0, 0), **kwargs):
        super().__init__(*args, **kwargs)
        self.text_offset = text_offset

    def display_analytics(self, im0, text, txt_color, bg_color, margin):
        horizontal_gap = int(im0.shape[1] * 0.02)
        vertical_gap = int(im0.shape[0] * 0.01)
        text_y_offset = self.text_offset[1]
        text_x_offset = self.text_offset[0]
        for label, value in text.items():
            txt = f"{label}: {value}"
            text_size = cv2.getTextSize(txt, 0, self.sf, self.tf)[0]
            if text_size[0] < 5 or text_size[1] < 5:
                text_size = (5, 5)
            text_x = text_x_offset + im0.shape[1] - text_size[0] - margin * 2 - horizontal_gap
            text_y = text_y_offset + text_size[1] + margin * 2 + vertical_gap
            rect_x1 = text_x - margin * 2
            rect_y1 = text_y - text_size[1] - margin * 2
            rect_x2 = text_x + text_size[0] + margin * 2
            rect_y2 = text_y + margin * 2
            cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
            cv2.putText(im0, txt, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
            text_y_offset += text_size[1] + vertical_gap  # Update text_y_offset for the next label

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

# Open the video file
cap = cv2.VideoCapture("/content/Naples Italy Traffic2.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))

classes_to_count = list(range(0, 23))  # classes to count

# Define the lines or regions points
line_points_1 = [(545, 268), (753, 288)]  # first line points
line_points_2 = [(874, 260), (1004, 266)]  # second line points
line_points_3 = [(25, 318), (302, 268)]  # third line points
line_points_4 = [(969, 404), (1096, 286)]  # fourth line points

# Video writer
video_writer = cv2.VideoWriter("out_object_counting_output7.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Custom Object Counters
counter_1 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_1,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 0),
    count_reg_color=(229, 255, 204),  # Very light green
    count_bg_color=(229, 255, 204)  # Very light green
)

counter_2 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_2,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 50),  # Adjusted text offset
    count_reg_color=(153, 204, 255),  # Light blue
    count_bg_color=(153, 204, 255)  # Light blue
)

counter_3 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_3,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 100),  # Adjusted text offset
    count_reg_color=(255, 204, 204),  # Light red
    count_bg_color=(255, 204, 204)  # Light red
)

counter_4 = CustomObjectCounter(
    view_img=True,
    reg_pts=line_points_4,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    text_offset=(0, 150),  # Adjusted text offset
    count_reg_color=(210, 180, 140),  # Light brown
    count_bg_color=(210, 180, 140)  # Light brown
)

# Init separate trackers for each counter
tracker = model  # Tracker for the first counter

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

    # Perform tracking for the first counter, options: tracker="bytetrack.yaml"
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)

    # Perform counting for each counter
    im0 = counter_1.start_counting(im0, tracks)
    im0 = counter_2.start_counting(im0, tracks)
    im0 = counter_3.start_counting(im0, tracks)
    im0 = counter_4.start_counting(im0, tracks)

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

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

Additional Tips

• Adjust Text Offsets: Ensure that the text_offset values are set appropriately to avoid overlap. You can experiment with different values to find the best fit.
• Check Display Function: Verify that the display_analytics method correctly applies the offsets. You can add print statements to debug the positions if necessary.

If you have any further questions or need additional assistance, feel free to ask. We're here to help! 🚀

Happy coding!

[Peymankar]

Hi there, thank you for your code but nothing changes and the overlap still exists i have tried every solution and codes for hours and days, my last try is with below code but no result.
import cv2
from ultralytics import YOLO, solutions

Custom wrapper class for ObjectCounter

class CustomObjectCounter(solutions.ObjectCounter):
def init(self, *args, text_position=(0, 0), **kwargs):
super().init(*args, **kwargs)
self.text_position = text_position

def display_analytics(self, im0, text, txt_color, bg_color, margin):
    current_x_offset, current_y_offset = self.text_position
    for label, value in text.items():
        txt = f"{label}: {value}"
        text_size = cv2.getTextSize(txt, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
        text_x = current_x_offset + margin
        text_y = current_y_offset + margin + text_size[1]
        cv2.rectangle(im0, (text_x - margin, text_y - text_size[1] - margin), (text_x + text_size[0] + margin, text_y + margin), bg_color, -1)
        cv2.putText(im0, txt, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.6, txt_color, 2, lineType=cv2.LINE_AA)
        current_y_offset += text_size[1] + margin * 2  # Stack vertically

Load the YOLO model

model = YOLO("yolov9e.pt")

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

classes_to_count = list(range(0, 23)) # classes to count

Define the lines or regions points

line_points_1 = [(545, 268), (753, 288)] # first line points
line_points_2 = [(874, 260), (1004, 266)] # second line points
line_points_3 = [(25, 318), (302, 268)] # third line points
line_points_4 = [(969, 404), (1096, 286)] # fourth line points

Video writer

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

Init Custom Object Counters

counter_1 = CustomObjectCounter(
view_img=True,
reg_pts=line_points_1,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
text_position=(10, 30), # Adjusted text position for first counter
count_reg_color=(229, 255, 204), # Very light green
count_bg_color=(229, 255, 204) # Very light green
)

counter_2 = CustomObjectCounter(
view_img=True,
reg_pts=line_points_2,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
text_position=(300, 30), # Adjusted text position for second counter
count_reg_color=(153, 204, 255), # Light blue
count_bg_color=(153, 204, 255) # Light blue
)

counter_3 = CustomObjectCounter(
view_img=True,
reg_pts=line_points_3,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
text_position=(600, 30), # Adjusted text position for third counter
count_reg_color=(255, 204, 204), # Light red
count_bg_color=(255, 204, 204) # Light red
)

counter_4 = CustomObjectCounter(
view_img=True,
reg_pts=line_points_4,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
text_position=(900, 30), # Adjusted text position for fourth counter
count_reg_color=(210, 180, 140), # Light brown
count_bg_color=(210, 180, 140) # Light brown
)

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, classes=classes_to_count)

# Perform counting for each counter
im0 = counter_1.start_counting(im0, tracks)
im0 = counter_2.start_counting(im0, tracks)
im0 = counter_3.start_counting(im0, tracks)
im0 = counter_4.start_counting(im0, tracks)

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

Release resources

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

[AshishreddyM26]

Hello,

Is it possible to perform detection and tracking in a region of interest, lets say 400x400 pixels in the center of the frame?

When I am using the ObejctCounter, I am getting the results related to the specific region which is really great, but the detection and tracking are performing on the whole frame here, my query is, can we detect and track only in the specific region instead of the whole frame? if yes can you provide some insights into it.

Thankyou,
Ashish

[pderrenger]

Hello Ashish,

Thank you for your question! It's great to hear that you're finding the ObjectCounter useful for your specific region of interest.

To address your query: Yes, it is possible to perform detection and tracking within a specific region of interest (ROI) instead of the entire frame. Here's how you can achieve this:

1. Crop the Frame to the ROI: Before passing the frame to the model for detection and tracking, you can crop the frame to the desired 400x400 pixels region. This will ensure that the model only processes this specific area.

2. Adjust Coordinates Post-Detection: After detection and tracking, you may need to adjust the coordinates of the detected objects back to the original frame coordinates if you need to visualize or further process them in the context of the full frame.

Here's a code example to illustrate this approach:

import cv2
from ultralytics import YOLO, solutions

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

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

# Define the region of interest (ROI)
roi_x, roi_y, roi_w, roi_h = (w//2 - 200, h//2 - 200, 400, 400)  # Center 400x400 pixels

# Video writer
video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=[(roi_x, roi_y), (roi_x + roi_w, roi_y), (roi_x + roi_w, roi_y + roi_h), (roi_x, roi_y + roi_h)],
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    
    # Crop the frame to the ROI
    roi_frame = im0[roi_y:roi_y + roi_h, roi_x:roi_x + roi_w]
    
    # Perform detection and tracking on the cropped frame
    tracks = model.track(roi_frame, persist=True, show=False)
    
    # Adjust the coordinates of the tracks to the original frame
    for track in tracks:
        track.boxes.xyxy[:, [0, 2]] += roi_x  # Adjust x coordinates
        track.boxes.xyxy[:, [1, 3]] += roi_y  # Adjust y coordinates
    
    # Perform counting
    im0 = counter.start_counting(im0, tracks)
    
    # Write the frame to the output video
    video_writer.write(im0)

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

In this example:

• We define the ROI as a 400x400 pixels region centered in the frame.
• We crop the frame to this ROI before passing it to the model for detection and tracking.
• After detection and tracking, we adjust the coordinates of the detected objects back to the original frame coordinates.

This approach ensures that detection and tracking are performed only within the specified region, optimizing processing time and resources.

For more detailed information and additional examples, you can refer to our Object Counting Guide.

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

[smc0927]

cannot import name 'ObjectCounter' from 'ultralytics.solutions' (E:\YOLOv8\ultralytics\solutions_init_.py)
Thanks，but，the problem became like this

[glenn-jocher]

Hello! 👋

It looks like you're encountering an issue with importing ObjectCounter from ultralytics.solutions. Let's troubleshoot this together.

1. Ensure Latest Versions: First, please make sure you are using the latest versions of both torch and ultralytics. You can update them using the following commands:

   pip install --upgrade torch ultralytics

2. Verify Import Path: The ObjectCounter class should be available in the ultralytics.solutions module. If you are still facing issues, please ensure that your installation is correct and that there are no local modifications that might be causing this problem.

3. Minimum Reproducible Example: If the issue persists, could you provide a minimum reproducible example? This will help us understand the context better and provide a more accurate solution. You can refer to our Minimum Reproducible Example Guide for more details.

Here's a quick example of how to use ObjectCounter for object counting:

import cv2
from ultralytics import YOLO, solutions

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

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

# Define region points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

# Video writer
video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=region_points,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

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 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

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

For more detailed information on object counting, you can refer to our Object Counting Guide.

If you continue to face issues, please share the specific error message and any additional details that might help us diagnose the problem. We're here to help! 😊

[smc0927]

Thanks

[glenn-jocher]

@smc0927 hello!

Thank you for reaching out and for your interest in using Ultralytics YOLOv8 for object counting! 😊

It looks like you're encountering an issue with importing ObjectCounter from ultralytics.solutions. Let's work through this together to get you up and running.

Steps to Resolve the Issue:

1. Ensure Latest Versions:
   First, please make sure you are using the latest versions of both torch and ultralytics. You can update them using the following commands:

   pip install --upgrade torch ultralytics

2. Verify Import Path:
   The ObjectCounter class should be available in the ultralytics.solutions module. If you are still facing issues, please ensure that your installation is correct and that there are no local modifications that might be causing this problem.

3. Minimum Reproducible Example:
   If the issue persists, could you provide a minimum reproducible example? This will help us understand the context better and provide a more accurate solution. You can refer to our Minimum Reproducible Example Guide for more details.

Example Code for Object Counting:

Here's a quick example of how to use ObjectCounter for object counting:

import cv2
from ultralytics import YOLO, solutions

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

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

# Define region points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

# Video writer
video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=region_points,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

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 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

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

Additional Resources:

For more detailed information on object counting, you can refer to our Object Counting Guide.

If you continue to face issues, please share the specific error message and any additional details that might help us diagnose the problem. We're here to help! 😊

[tommfarmer]

Hi! How can I hide the "#" in the labels? I just want to display the name of the class without the "#" in the video. For example, if the label of the detected object shows "lemon#3", I just want it to display "lemon". Here's my code. Thanks and nice work!

import cv2
from ultralytics import YOLO, solutions
from tqdm import tqdm

model = YOLO(MODEL)
cap = cv2.VideoCapture(SOURCE_VIDEO_PATH)
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))

# Define line points
line_points = [(350, 10), (350, 480-10)]

# Video writer
video_writer = cv2.VideoWriter("lemon_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    line_thickness=2,
    view_out_counts=False
)

# Get total number of frames in video
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# Initialize tqdm for progress tracking
pbar = tqdm(total=total_frames, desc='Processing frames')

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.77)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

    # Update progress bar
    pbar.update(1)

# Close progress bar
pbar.close()

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

[pderrenger]

@tommfarmer hi there! Thanks for your kind words and for sharing your code. To remove the "#" and just display the class name in your video labels, you can modify the ObjectCounter class to format the labels as needed. Here's how you can do it:

1. Modify the ObjectCounter initialization: You can customize the label formatting directly within the ObjectCounter class by adjusting the start_counting method to strip out the "#" and any following characters.

Here's a modified version of your code to achieve this:

import cv2
from ultralytics import YOLO, solutions
from tqdm import tqdm

model = YOLO("yolov8n.pt")
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))

# Define line points
line_points = [(350, 10), (350, 480-10)]

# Video writer
video_writer = cv2.VideoWriter("lemon_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    line_thickness=2,
    view_out_counts=False
)

# Get total number of frames in video
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# Initialize tqdm for progress tracking
pbar = tqdm(total=total_frames, desc='Processing frames')

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.77)

    # Modify the labels to remove the "#" and any following characters
    for track in tracks:
        for box in track.boxes:
            box.label = box.label.split('#')[0]

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

    # Update progress bar
    pbar.update(1)

# Close progress bar
pbar.close()

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

In this code, before calling counter.start_counting(im0, tracks), we iterate over the tracks and modify the label attribute of each box to remove the "#" and any following characters.

This should display only the class name without the "#" in your video labels. If you have any further questions or need additional assistance, feel free to ask! 😊

For more detailed information on object counting and other features, you can visit our Object Counting Guide.

Happy coding! 🚀

[tommfarmer]

Thank you very much for your help @pderrenger! 😊 However, I got an error on the line: box.label = box.label.split('#')[0] with the following message: 'Boxes' object has no attribute 'label'. Could you help me again by fixing this error?

[pderrenger]

Hi @tommfarmer! 😊

Thank you for your patience and for providing the details. It looks like the Boxes object indeed does not have a label attribute, which caused the error. To achieve your goal of displaying only the class name without the "#" in the video, we need to handle the labels differently.

Here's an updated version of your code that modifies the ObjectCounter to strip out the "#" and any following characters from the labels:

import cv2
from ultralytics import YOLO, solutions
from tqdm import tqdm

model = YOLO("yolov8n.pt")
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))

# Define line points
line_points = [(350, 10), (350, 480-10)]

# Video writer
video_writer = cv2.VideoWriter("lemon_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    line_thickness=2,
    view_out_counts=False
)

# Get total number of frames in video
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# Initialize tqdm for progress tracking
pbar = tqdm(total=total_frames, desc='Processing frames')

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.77)

    # Modify the labels to remove the "#" and any following characters
    for track in tracks:
        for box in track.boxes:
            class_id = int(box.cls)
            class_name = model.names[class_id]
            box.label = class_name.split('#')[0]

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

    # Update progress bar
    pbar.update(1)

# Close progress bar
pbar.close()

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

In this code, we extract the class ID from each box and use it to get the class name from model.names. We then split the class name at the "#" and take the first part to remove the unwanted characters.

This should ensure that only the class name is displayed in your video labels. If you encounter any further issues or need additional assistance, feel free to reach out. 😊

For more detailed information on object counting and other features, you can visit our Object Counting Guide.

Happy coding! 🚀

[tommfarmer]

Thanks again @pderrenger! 😊 The code works, but unfortunately, nothing changes 😓. It still displays the "#".

I printed in the console "class_name", and it only prints "lemon" with nothing after it. So, when I print class_name.split('#')[0], it still prints "lemon" because there's nothing after it. However, the code works. For example, when I print class_name.split("o")[0], it prints "lem". I tested this by displaying it in the video, hoping it would display just "lem", but it still displays the full name in the video labels as "lemon#(number)".

Could you help me?

[TanrionTV]

Hello,

I would like to use your program to count grey sections.
However, I have two problems:
- Firstly, when I use the tracker some detections disappear.
That's why I can't think of anything to improve it.
- and secondly, some tracking identifiers are reallocated to objects that have nothing to do with the initial one.
I was thinking of modifying botrack so that it only assigns the same identifiers for 10 frames, for example, but I have no idea how to do this.
Do you think this is feasible?

I have an i9 vPro and a Nvidia A2000.

Here's the program I use:

import cv2
from ultralytics import YOLO, solutions

MODEL_PATH = r'model\best.pt'
model=YOLO(MODEL_PATH)
cap = cv2.VideoCapture('test_26_50mm.avi')
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))

# Define line points
# Conveyor
#line_points = [(0, 800), (2000, 800)]
# Bar line vertical
line_points = [(2000, 0), (2000, 2500)]
# Bar line horizontal
#line_points = [(0,2200), (2500, 2200)]
 
# Video writer  
video_writer = cv2.VideoWriter('results\output_bar_counting.avi', cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=False,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    track_thickness=2,
    line_thickness=5,
    line_dist_thresh = 200,
    view_out_counts=False

)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(frame, persist=True, show=False, tracker = 'botsort.yaml', conf = 0.6)

    frame = counter.start_counting(frame, tracks)
    video_writer.write(frame)

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

I would have liked to share some pictures with you, but I couldn't. If you can help me, I would appreciate it.

[glenn-jocher]

@TanrionTV hello,

Thank you for your thoughtful question! Cropping the area for tracking can indeed be a useful strategy, especially when dealing with closely packed objects. By focusing on a smaller region, you can potentially improve the accuracy and consistency of the tracking.

Here’s how you can implement cropping in your existing code:

1. Crop the Frame: Before passing the frame to the model for tracking, crop it to the region of interest.
2. Adjust Coordinates: Ensure that the coordinates of the detections are adjusted back to the original frame size if needed.

Here’s an example of how you might modify your code to include cropping:

import cv2
from ultralytics import YOLO, solutions

MODEL_PATH = r'model\best.pt'
model = YOLO(MODEL_PATH)
cap = cv2.VideoCapture('test_26_50mm.avi')
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))

# Define line points
line_points = [(2000, 0), (2000, 2500)]

# Define crop region (x, y, width, height)
crop_region = (500, 500, 1000, 1000)

# Video writer  
video_writer = cv2.VideoWriter('results\output_bar_counting.avi', cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=False,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    track_thickness=2,
    line_thickness=5,
    line_dist_thresh=200,
    view_out_counts=False
)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    
    # Crop the frame
    x, y, w, h = crop_region
    cropped_frame = frame[y:y+h, x:x+w]

    # Perform tracking on the cropped frame
    tracks = model.track(cropped_frame, persist=True, show=False, tracker='botsort.yaml', conf=0.3, iou=0.4)

    # Adjust coordinates back to the original frame
    for track in tracks:
        track.boxes.xyxy[:, [0, 2]] += x
        track.boxes.xyxy[:, [1, 3]] += y

    frame = counter.start_counting(frame, tracks)
    video_writer.write(frame)

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

Alternative Trackers

If BoT-SORT is not meeting your needs, you might want to try ByteTrack, which is another robust tracker supported by Ultralytics. You can switch to ByteTrack by changing the tracker parameter:

tracks = model.track(frame, persist=True, show=False, tracker='bytetrack.yaml', conf=0.3, iou=0.4)

Additional Tips

• Frame Rate: Given that your camera records at 24fps, ensure that your model and tracker can handle this frame rate efficiently. Sometimes, reducing the frame rate can help improve tracking stability.
• Experiment with Parameters: Continue experimenting with different conf and iou values, as well as tracker-specific parameters in the YAML files.

For more detailed guidance on object counting and tracking, you can refer to our Object Counting Guide.

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

[TanrionTV]

thank you ! but i have this error :
track.boxes.xyxy[:, [0, 2]] += x
~~~~~~~~~~~~~~~~^^^^^^^^^^^
RuntimeError: Inplace update to inference tensor outside InferenceMode is not allowed.You can make a clone to get a normal tensor before doing
inplace update.See pytorch/rfcs#17 for more details.

[glenn-jocher]

Hello,

Thank you for your detailed feedback and for sharing your code! 😊

The error you're encountering is due to an inplace update on a tensor that is not allowed in inference mode. To resolve this, you can clone the tensor before performing the inplace update. Here’s how you can modify your code:

import cv2
from ultralytics import YOLO, solutions

MODEL_PATH = r'model\best.pt'
model = YOLO(MODEL_PATH)
cap = cv2.VideoCapture('test_26_50mm.avi')
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))

# Define line points
line_points = [(2000, 0), (2000, 2500)]

# Define crop region (x, y, width, height)
crop_region = (500, 500, 1000, 1000)

# Video writer  
video_writer = cv2.VideoWriter('results\output_bar_counting.avi', cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=False,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=False,
    track_thickness=2,
    line_thickness=5,
    line_dist_thresh=200,
    view_out_counts=False
)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    
    # Crop the frame
    x, y, w, h = crop_region
    cropped_frame = frame[y:y+h, x:x+w]

    # Perform tracking on the cropped frame
    tracks = model.track(cropped_frame, persist=True, show=False, tracker='botsort.yaml', conf=0.3, iou=0.4)

    # Adjust coordinates back to the original frame
    for track in tracks:
        track.boxes.xyxy = track.boxes.xyxy.clone()  # Clone the tensor to avoid inplace update error
        track.boxes.xyxy[:, [0, 2]] += x
        track.boxes.xyxy[:, [1, 3]] += y

    frame = counter.start_counting(frame, tracks)
    video_writer.write(frame)

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

Alternative Trackers

If BoT-SORT is not meeting your needs, you might want to try ByteTrack, which is another robust tracker supported by Ultralytics. You can switch to ByteTrack by changing the tracker parameter:

tracks = model.track(frame, persist=True, show=False, tracker='bytetrack.yaml', conf=0.3, iou=0.4)

Additional Tips

• Frame Rate: Given that your camera records at 24fps, ensure that your model and tracker can handle this frame rate efficiently. Sometimes, reducing the frame rate can help improve tracking stability.
• Experiment with Parameters: Continue experimenting with different conf and iou values, as well as tracker-specific parameters in the YAML files.

For more detailed guidance on object counting and tracking, you can refer to our Object Counting Guide.

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

[Tanrion]

Thank you for your help! Your fix gives me this error:

    track.boxes.xyxy = track.boxes.xyxy.clone() # Clone the tensor to avoid the inplace update error
    ^^^^^^^^^^^^^^^^
AttributeError : the ‘xyxy’ property of the ‘Boxes’ object has no setter

but I managed to fix it with the following patch:

    # Track the cropped image
    tracks1 = model.track(frame, persist=True, show=False, tracker = ‘bytetrack.yaml’, conf = 0.2,iou=0.4, vid_stride=1, augment=True, retina_masks=False)


    # Adjust the coordinates to the original image
    tracks = deepcopy(tracks1)
    for track in tracks :
        track.boxes.xyxy[ :, [0, 2]] += x
        track.boxes.xyxy[ :, [1, 3]] += y += y

However, even when cropping the image, the tracker reallocates the old identifiers to the new objects.
I've also tried using bytetrack by adjusting the parameters but the results are even worse.
I'm starting to run out of ideas. Is it possible to send you the video (20mo), maybe you'll see it more clearly than I do.

Thank you very much for your advice!

[Tanrion]

I've added you to my "bar_counting" project on github so you can see the video if you want

[ShreyasChhetri]

Hi ,
so this is my code
import numpy as np
from ultralytics import YOLO
import torch
import matplotlib.pyplot as plt
import time
import os
from ultralytics.solutions import object_counter
from PIL import Image
import json
import base64
import cv2
from torchvision.io import read_image
from torchvision.utils import draw_bounding_boxes
from torchvision.ops import box_area
from torchvision.transforms.functional import to_tensor
from pprint import pprint

Load a pretrained YOLOv8n model
model = YOLO('../ultralytics/ultralytics/yolo/v8/runs/weights/best_car_1.pt')

img = Image.open('./image_1.jpg')

Define line points
line_position = 0
box_size = 50
width = 640
height = 640

width = int(img_array.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(img_array.get(cv2.CAP_PROP_FRAME_HEIGHT))
x_line = int(line_position * width / 100)
pt1 = (x_line,0 )
pt2 = (x_line,height )

pt11 = (x_line-100, height)
pt22 = (x_line -100,0)

region_points = [pt1,pt2,pt11,pt22]
line_points = [pt1,pt2]

Keep track of detected defect IDs
result_dict = {}
result_list=[]
frame_results = []

def image_pred(image):

img_array = np.copy(image_arr)

Init Object Counter

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,region_thickness=1,track_color=(255,255,255))

Run inference on the source

tracks = model.track(image, persist=True, show=False,tracker = "bytetrack.yaml",classes = [0,1],verbose=True) # list of Results objects
for trac in tracks:
xyxy = trac.boxes.xyxy.cpu().numpy()
xyxy = np.array(xyxy).tolist()
# Store each list in a list
coordinate_variables = [f"coordinates_list_{i+1}" for i in range(len(xyxy))]
length_list, width_list, center_list, area_list = [], [], [], []
# Dynamically create variables and store the lists
for i, (variable, coordinates) in enumerate(zip(coordinate_variables, xyxy)):
# Round coordinates to two decimal places
rounded_coordinates = [round(coord, 2) for coord in coordinates]
globals()[variable] = rounded_coordinates

    # Calculate area using torchvision.ops.box_area
    area = round(float(box_area(torch.tensor([rounded_coordinates]))[0]),2)
    defect_name = trac.names[int(trac.boxes.cpu().numpy().cls[i])]
    
    # Calculate length, breadth, and center coordinates
    length = round(float(coordinates[2] - coordinates[0]),2)
    diameter = round(float(coordinates[2] - coordinates[0]),2)
    width = round(float(coordinates[3] - coordinates[1]),2)
    coordinate_x = round(float(coordinates[2] + coordinates[0]) / 2,2)
    coordinate_y = round(float(coordinates[3] + coordinates[1]) / 2,2)
    center = [coordinate_x,coordinate_y]
    
    
    length_list.append(length)
    width_list.append(width)
    center_list.append(center)
    area_list.append(area)

    
# Check if defect_id is new, then print information
    defect_id = int(trac.boxes.id.cpu().numpy().tolist()[i])
    if defect_id not in result_dict:
        result_dict[defect_id] = {
                "defect_name": defect_name,
                "defect_id": defect_id,
                "length": length,
                "width": width,
                "area": area,
                "diameter": diameter,
                "center": center,
                "coordinates_list": rounded_coordinates,
                "Depth" : "N/A",
                "Width/Depth Ratio" : "N/A",
                "frame_np": None
                
            }
        
# Add bounding box to the image
    cv2.rectangle(image, (int(coordinates[0]), int(coordinates[1])),
                (int(coordinates[2]), int(coordinates[3])), (0, 255, 0), 2)

# Add dynamic text annotations for each detection
for i, coordinates in enumerate(trac.boxes.xyxy.cpu().numpy()):
    # Get coordinates of the bounding box
    box = coordinates.tolist()
    area = round(float(box_area(torch.tensor([box]))[0]), 2)
    cv2.putText(image, f"Area={str(area)} inch sqr",
                (int(box[0] - 1.5 * (box[2] - box[0])), int(box[1] + 1.9 * (box[3] - box[1]))),
                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA)

img_ = counter.start_counting(image, tracks)
cv2.imshow("window",img)
cv2.waitKey(9000)
cv2.destroyAllWindows()
in_counts = counter.in_counts
out_counts = counter.out_counts

print(f"In_Counts - {in_counts} and Out_Counts - {out_counts}")

Store the processed image as a numpy array

for defect_id in result_dict:
result_dict[defect_id]["frame_np"] = img_

Display the image

plt.imshow(image)
plt.axis('off')
plt.show()

print(result_list)

pprint(list(result_dict.values()))

image_pred(img)
I just want to see the output image without the incount outcount on the top of the processed image and the blue line also gone so can anyone help me modify it a bit I want to use the track option only

[glenn-jocher]

Hi there,

Thank you for sharing your code! It looks like you're working on an object counting project using YOLOv8. To help you achieve your goal of removing the in-count and out-count text as well as the blue line from the processed image, you can adjust the ObjectCounter settings.

Here's a modified version of your code with the necessary changes:

import cv2
from ultralytics import YOLO, solutions
from PIL import Image
import torch
from torchvision.ops import box_area

# Load a pretrained YOLOv8n model
model = YOLO('../ultralytics/ultralytics/yolo/v8/runs/weights/best_car_1.pt')

img = Image.open('./image_1.jpg')

# Define line points
line_position = 0
width = 640
height = 640

# Assuming img_array is defined elsewhere in your code
width = int(img_array.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(img_array.get(cv2.CAP_PROP_FRAME_HEIGHT))
x_line = int(line_position * width / 100)
pt1 = (x_line, 0)
pt2 = (x_line, height)

line_points = [pt1, pt2]

# Keep track of detected defect IDs
result_dict = {}

def image_pred(image):
    # Init Object Counter
    counter = solutions.ObjectCounter(
        view_img=True,
        reg_pts=line_points,
        classes_names=model.names,
        draw_tracks=True,
        line_thickness=1,
        view_in_counts=False,  # Disable in-count display
        view_out_counts=False,  # Disable out-count display
        count_reg_color=(0, 0, 0),  # Set region color to black (invisible)
    )

    # Run inference on the source
    tracks = model.track(image, persist=True, show=False, tracker="bytetrack.yaml", classes=[0, 1], verbose=True)
    for trac in tracks:
        xyxy = trac.boxes.xyxy.cpu().numpy()
        xyxy = np.array(xyxy).tolist()
        coordinate_variables = [f"coordinates_list_{i+1}" for i in range(len(xyxy))]
        length_list, width_list, center_list, area_list = [], [], [], []

        for i, (variable, coordinates) in enumerate(zip(coordinate_variables, xyxy)):
            rounded_coordinates = [round(coord, 2) for coord in coordinates]
            globals()[variable] = rounded_coordinates
            area = round(float(box_area(torch.tensor([rounded_coordinates]))[0]), 2)
            defect_name = trac.names[int(trac.boxes.cpu().numpy().cls[i])]
            length = round(float(coordinates[2] - coordinates[0]), 2)
            diameter = round(float(coordinates[2] - coordinates[0]), 2)
            width = round(float(coordinates[3] - coordinates[1]), 2)
            coordinate_x = round(float(coordinates[2] + coordinates[0]) / 2, 2)
            coordinate_y = round(float(coordinates[3] + coordinates[1]) / 2, 2)
            center = [coordinate_x, coordinate_y]
            length_list.append(length)
            width_list.append(width)
            center_list.append(center)
            area_list.append(area)

            defect_id = int(trac.boxes.id.cpu().numpy().tolist()[i])
            if defect_id not in result_dict:
                result_dict[defect_id] = {
                    "defect_name": defect_name,
                    "defect_id": defect_id,
                    "length": length,
                    "width": width,
                    "area": area,
                    "diameter": diameter,
                    "center": center,
                    "coordinates_list": rounded_coordinates,
                    "Depth": "N/A",
                    "Width/Depth Ratio": "N/A",
                    "frame_np": None
                }

            cv2.rectangle(image, (int(coordinates[0]), int(coordinates[1])),
                          (int(coordinates[2]), int(coordinates[3])), (0, 255, 0), 2)

        for i, coordinates in enumerate(trac.boxes.xyxy.cpu().numpy()):
            box = coordinates.tolist()
            area = round(float(box_area(torch.tensor([box]))[0]), 2)
            cv2.putText(image, f"Area={str(area)} inch sqr",
                        (int(box[0] - 1.5 * (box[2] - box[0])), int(box[1] + 1.9 * (box[3] - box[1]))),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1, cv2.LINE_AA)

    img_ = counter.start_counting(image, tracks)
    cv2.imshow("window", img_)
    cv2.waitKey(9000)
    cv2.destroyAllWindows()
    in_counts = counter.in_counts
    out_counts = counter.out_counts

    for defect_id in result_dict:
        result_dict[defect_id]["frame_np"] = img_

    plt.imshow(image)
    plt.axis('off')
    plt.show()

    pprint(list(result_dict.values()))

image_pred(img)

Key Changes:

1. Disable In-Count and Out-Count Display: Set view_in_counts=False and view_out_counts=False in the ObjectCounter initialization.
2. Invisible Region Color: Set count_reg_color=(0, 0, 0) to make the region color black, effectively making it invisible against a black background.

Please ensure you have the latest versions of torch and ultralytics installed. If you encounter any issues, please provide a minimum reproducible example as outlined here.

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

[ShreyasChhetri]

Hi @glenn-jocher it is working perfectly Thank You