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

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

Integrating speed estimation with vehicle counting in YOLOv8 can be approached by combining the tracking capabilities of YOLOv8 with additional logic to calculate speed. Here's a basic outline using the tracking example from our docs:

1. Track vehicles using model.track() as shown in the object counting example.
2. For each vehicle, record the positions of the bounding box centers at different frames.
3. Calculate the distance traveled between frames and divide by the time elapsed (you'll need the video FPS for this).
4. Convert the speed to your desired units (e.g., miles per hour or kilometers per hour).

Here's a simplified code snippet to illustrate the concept:

from ultralytics import YOLO
import cv2

# Load model and video
model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)

# Initialize previous positions dictionary
prev_positions = {}

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

    # Track objects
    tracks = model.track(frame, persist=True)

    # Calculate speed for each tracked vehicle
    for track in tracks.boxes:
        track_id = int(track.id)
        center_x, center_y = track.xyxy[0:2].mean(axis=0).tolist()

        # Calculate speed if we have a previous position
        if track_id in prev_positions:
            prev_x, prev_y, prev_frame = prev_positions[track_id]
            distance = ((center_x - prev_x) ** 2 + (center_y - prev_y) ** 2) ** 0.5
            time = (tracks.frame - prev_frame) / fps
            speed = distance / time  # This will be in pixels per second

            # Convert speed to real-world units here

        # Update previous positions
        prev_positions[track_id] = (center_x, center_y, tracks.frame)

    # Rest of your counting and visualization logic here

cap.release()

Remember to adjust the speed calculation to account for the scale of the scene and convert pixels to real-world units. You might also want to filter tracks by class to focus on vehicles. Happy coding! 🚗💨

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

[Air1Kheji]

Hello, can someone help me add the object counter in my code. Because I have been having trouble in debugging it to my code.
from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2
import numpy as np
import os
import glob
import math
model=YOLO("C:\Computervisionprojects\YOLOv8-CrashCourse\YOLO-Weights\dataset.pt")
def video_detection(path_x):
video_capture = path_x
#Create a Webcam Object
cap=cv2.VideoCapture(video_capture)
frame_width=int(cap.get(3))
frame_height=int(cap.get(4))

model=YOLO("C:\Computervisionprojects\YOLOv8-CrashCourse\YOLO-Weights\dataset.pt")
classNames = [
"Bread plate",
"Butter knife",
"Champagne flute",
"Cocktail fork",
"Coffee pot",
"Collins glass",
"Creamer container",
"Cup with underliner",
"Dessert fork",
"Dessert plate",
"Dessert spoon",
"Dinner fork",
"Dinner knife",
"Dinner plate",
"Dinner spoon",
"Fish fork",
"Fish knife",
"Fish plate",
"Juice glass",
"Red wine glass",
"Salad fork",
"Salad knife",
"Salad plate",
"Salt & Pepper shaker",
"Service spoon",
"Show plate",
"Soup bowl",
"Soup plate",
"Soup spoon",
"Sugar container",
"Table napkin",
"Teaspoon",
"Water goblet",
"White wine glass"]

while True:
    success, img = cap.read()
    results=model(img,stream=True)
    
    
    for r in results:
        boxes=r.boxes
        for box in boxes:
            x1,y1,x2,y2=box.xyxy[0]
            x1,y1,x2,y2=int(x1), int(y1), int(x2), int(y2)
            print(x1,y1,x2,y2)
            cv2.rectangle(img, (x1,y1), (x2,y2), (255,0,255),3)
            conf=math.ceil((box.conf[0]*100))/100
            cls=int(box.cls[0])
            class_name=classNames[cls]
            label=f'{class_name}{conf}'
            t_size = cv2.getTextSize(label, 0, fontScale=1, thickness=1)[0]
            print(t_size)
            c2 = x1 + t_size[0], y1 - t_size[1] - 3
            cv2.rectangle(img, (x1,y1), c2, [255,0,255], -1, cv2.LINE_AA)  # filled
            cv2.putText(img, label, (x1,y1-2),0, 1,[255,255,255], thickness=1,lineType=cv2.LINE_AA)
    yield img

[Air1Kheji]

I want to add an object counter to count the different object being detected by the web camera.

[pderrenger]

Hello! Sure, I can help you integrate an object counter with your YOLO model for webcam streams. 🚀 Here's a simplified example that captures video from your webcam and counts the objects detected by YOLOv8. You simply need to attach an instance of ObjectCounter from the ultralytics.solutions package and provide the necessary arguments:

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

# Initialize YOLO model
model = YOLO('yolov8n.pt')  # Make sure to provide the correct path to your .pt model file

# Open webcam
cap = cv2.VideoCapture(0)  # Use 0 for webcam
assert cap.isOpened(), "Error opening video stream or file"

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

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

    # Predict and track objects
    results = model.track(frame, persist=True, show=False)

    # Count objects in frame
    frame = counter.start_counting(frame, results)

    # Display the frame
    cv2.imshow('Object Detection and Counting', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # press 'q' to exit
        break

cap.release()
cv2.destroyAllWindows()

In this example, ensure that your model path is correct, and adjust the ObjectCounter settings as needed to fit your particular requirements. This basic setup should get you started with real-time object counting from your webcam!

If you have any specific requirements or encounter any issues, just let me know!

[Air1Kheji]

how can i display the count with the classname. for example :

Spoon : 5
Water Goblet : 3

[pderrenger]

Hello!

To display the object count with the classname in the format you mentioned, you can modify your code to aggregate the counts based on class names and then print them out. Here’s how you can do it:

from collections import defaultdict

# Initialize counts dictionary
object_counts = defaultdict(int)

# Accumulate counts per class
for r in results:
    boxes = r.boxes
    for box in boxes:
        class_id = int(box.cls[0])  # Get class id
        object_counts[classNames[class_id]] += 1  # Increment count for the class

# Display counts
for class_name, count in object_counts.items():
    print(f'{class_name}: {count}')

Place the counting logic right after making predictions with your model and before plotting the images with bounding boxes. This will print out the counts for each object class detected in the frame as they appear on your camera feed.

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

[nyperu]

how can we reset the out_counts and in_counts? Or how can we set in_counts or out_counts?

[nyperu]

i have to make a trigger method to reset everything. thats why i need this solusion

[glenn-jocher]

To reset the in_counts and out_counts in your object counting setup, you can directly set these attributes to zero within your tracking loop or create a method to reset them as needed.

Here's a simple example on how you might implement a reset mechanism in your object counting code:

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

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

# Initialize the Object Counter
counter = object_counter.ObjectCounter()

def reset_counts():
    counter.in_count = 0
    counter.out_count = 0

# Main video loop
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break

    # Reset counts based on a condition or trigger
    if condition_to_reset_counts:
        reset_counts()

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

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

In this code, reset_counts() is a function you can call to reset the in_counts and out_counts to zero whenever a specific condition is met, such as a button press or another trigger in your application. Adjust condition_to_reset_counts as per your requirements.

[lamb412]

Hey, this problem ocurs when I am streamming with IP camera through RTSP?
Can anyone help me to deal with this, thank you.

[h264 @ 0000020b2141f040] left block unavailable for requested intra4x4 mode -1
[h264 @ 0000020b2141f040] error while decoding MB 0 23, bytestream 17505

[glenn-jocher]

Hi there! It looks like you're facing decoding errors with your RTSP stream. These errors are typically due to issues with the stream itself, such as network instability or an unsupported codec configuration.

Here's a quick suggestion that might help:

1. Verify Network Stability: Ensure that the network connection is stable and the bandwidth is sufficient for the stream's bitrate.

2. Adjust Codec Settings: If you have control over the camera settings, try adjusting the codec parameters like frame rate or bitrate, or switching to a different codec supported by both the camera and your decoding setup.

3. Reconnect Logic: Implement logic in your code to handle reconnections in case of stream interruptions. Here’s a small snippet:

   import cv2
   from ultralytics import YOLO
   
   model = YOLO("yolov8n.pt")
   cap = None
   
   def open_stream(url):
       global cap
       cap = cv2.VideoCapture(url)
       if not cap.isOpened():
           print("Failed to open stream")
           return False
       return True
   
   def read_stream():
       global cap
       success, frame = cap.read()
       if not success:
           print("Stream error, reconnecting...")
           open_stream(stream_url)
       return frame
   
   stream_url = 'rtsp://your_camera_ip'
   if open_stream(stream_url):
       while True:
           frame = read_stream()
           if frame is not None:
               # Process frame with the model
               results = model.predict(frame)
   
   cap.release()

This snippet attempts to open the stream and includes basic error handling to attempt reconnection if the stream cannot be read.

If the issue persists, it might help to look into the camera's RTSP settings or consult with the camera manufacturer regarding optimal RTSP stream configurations.

[Rupesh-Kataria]

I have trained a yolov8 model for detecting the object i have its .pt weight file. Now when I used to predict it on the image it draw a rectangular box around the object and a confidence score type value on the top of the object and save that. That is fine . Now I want is that it only should plot only for those object whose confidence score greater than 0.8 . And after that I also want that which object class have how many count in that image. Like if there is image which have 2 dog and 3 cat. So it plot rectangular box around that if there threshold >=0.8 and in the end it tell there are total 5 object. 2 dog 3 cat . It should give total object and how many object of each class.

Can somebody help me to write its code.

[Rupesh-Kataria]

counts = results.pandas().xyxy[0]['name'].value_counts()
AttributeError Traceback (most recent call last)
in <cell line: 1>()
----> 1 counts = results.pandas().xyxy[0]['name'].value_counts()

AttributeError: 'list' object has no attribute 'pandas'

You can also use results.render() to visualize the results with bounding boxes

annotated_image = results.render()[0]
cv2_imshow('Annotated Image', annotated_image)

AttributeError Traceback (most recent call last)
in <cell line: 2>()
1 # You can also use results.render() to visualize the results with bounding boxes
----> 2 annotated_image = results.render()[0]
3 cv2_imshow('Annotated Image', annotated_image)

AttributeError: 'list' object has no attribute 'render'

There is no such attribute of results. Please suggest me some alternative.

[glenn-jocher]

@Rupesh-Kataria hello! It seems like you're encountering an AttributeError because the results object does not have the pandas or render method available. This issue typically occurs when the methods you are attempting to use are not supported by the version or type of the YOLOv8 object used.

Instead of using results.pandas() and results.render(), you can achieve the filtering and counting directly using the attributes from the Results objects returned by the prediction. Here's a modification to your approach:

from ultralytics import YOLO
import cv2

# Load the model
model = YOLO('path/to/your/model.pt')

# Load an image
image = cv2.imread('path/to/your/image.jpg')

# Predict objects in the image
results = model(image)

# Filter results by confidence and count each class
confidence_threshold = 0.8
class_counts = {}
for det in results.xyxy[0]:  # detections in (x1, y1, x2, y2, conf, cls) format
    conf = det[4]
    if conf > confidence_threshold:
        cls_id = int(det[5])
        class_name = model.names[cls_id]
        if class_name in class_counts:
            class_counts[class_name] += 1
        else:
            class_counts[class_name] = 1

print(f"Total objects: {sum(class_counts.values())}")
for class_name, count in class_counts.items():
    print(f"{count} {class_name}")

# Visualize with bounding boxes and display
annotated_image = results.render()[0]  # Render modifies the image in-place
cv2.imshow('Annotated Image', annotated_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This script will check each detection's confidence, only counting those above 0.8, and then display the annotated image with bounding boxes for those detections. This should align with your requirements! 😊 If you need further customizations or run into any more issues, feel free to reach out!

[TiaRidz]

Hi, may I ask is it possible to access the count in and count of the system and to not display it? I have 5 classes to detect and I want it to show the value in different format: i.e. (class: value) instead of (class: IN___OUT_____) Please help me out on this.

[TiaRidz]

I am also using webcam for this coding

[glenn-jocher]

@TiaRidz hello! Using a webcam with the Ultralytics YOLOv8 for object counting is quite straightforward. You can adapt the example code for reading from a video file to use your webcam instead. Here’s a quick guide on how you can modify the code:

Replace the line where you define the cap variable with the webcam source. Usually, 0 is the default ID for the primary webcam:

cap = cv2.VideoCapture(0)  # Use 0 for the default webcam

The rest of the code remains the same. This change will allow your YOLOv8 model to process the video stream directly from your webcam. Make sure your environment has access to the webcam and that it's not being used by another application.

If you encounter any issues or have further questions, feel free to ask. Happy coding! 😊

[Rupesh-Kataria]

Below is the code to calculate number of object of every class in an image. I have provided the image instead of video. I want to consider all region of the image so i have given that by calculating the shape of the image.
But that does not work. I want your help for that. I have second problem I want the bounding box around those object of image whose confidence score greater than 0.80 . So that finally I am able to get count of those classes whose confidence of having greater than 0.80 and it should cover the entire region of image. Note - I have tried glenn-jocher solution (which he given on May 1)for covering the entire region. But that does not work actually I get the error on this line (detections = results.pandas().xyxy[0] ) It say results do not have pandas().xyxy method sort of thing. Please make suitable change in this code only.

region_points = [(0, 0), (0,148), (240,0), (240,148)]
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,reg_pts=region_points,
classes_names=model.names)

results = model.track("check.jpeg", persist=True, show=False)

Count objects in frame

frame = counter.start_counting(x, results)

Display the frame

cv2_imshow( frame)

from collections import defaultdict

Initialize counts dictionary

object_counts = defaultdict(int)

Accumulate counts per class

for r in results:
boxes = r.boxes
for box in boxes:
class_id = int(box.cls[0]) # Get class id
object_counts[class_id] += 1 # Increment count for the class_id

Display counts

for class_id, count in object_counts.items():
print(f'{class_id}: {count}')

[glenn-jocher]

Hello! It sounds like you're dealing with a couple of issues related to object counting and filtering by confidence. Let's address these step by step.

1. Covering the Entire Region of the Image:
   If you're looking to consider the entire region of the image, you should set your region_points to the full dimensions of your image. Here's how you can adjust it:

   height, width = image.shape[:2]
   region_points = [(0, 0), (width, 0), (width, height), (0, height)]

2. Filtering Objects by Confidence Score:
   To filter objects by a confidence score of greater than 0.80, you will need to modify your code to check the confidence score of each detection before counting or displaying it.

   object_counts = defaultdict(int)
   for r in results:
       if r.boxes.conf[0] > 0.80:  # Check if the confidence is greater than 0.80
           class_id = int(r.boxes.cls[0])  # Get class id
           object_counts[class_id] += 1  # Increment count for the class_id

   This snippet assumes that r.boxes contains the bounding boxes detected and r.boxes.conf are the confidence scores of these detections.

3. Error Issues:
   It seems you encountered an error stating results does not have a pandas().xyxy method. The correct way to access detection outputs directly through Ultralytics YOLOv8 would be to use the attributes provided by the results object directly as illustrated above.

Please make sure your ultralytics package is up-to-date as the method to access detections might vary slightly with different versions.

If you need further adjustments or clarification, feel free to ask. Happy coding! 🚀

[Rupesh-Kataria]

Your above code give me wrong output actually I have trained the model on 1 class and there is image which have 3 object it detectect all of them with confidence value 0.89,0.91,0.92. When i print the output using object_counts[0] it give me 1 as output it should give me 3 as output as all detected object have threshold >0.8

[glenn-jocher]

Hi there! It seems there's a bit of confusion with the object counting. When using the results to count objects per class, we need to ensure that we're iterating through all detections correctly in order to accumulate counts appropriately.

Here’s a revised snippet of your code designed to filter by confidence and handle the counting:

from ultralytics import YOLO
import cv2

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

# Detect objects in an image
img = cv2.imread("check.jpeg")
results = model(img)

# Filter detections based on confidence and count each class
object_counts = {}
for det in results.pred[0]:  # results.pred[0] contains detections
    conf = det[4].item()  # Confidence score
    if conf > 0.8:
        class_id = int(det[5].item())  # Class label
        if class_id in object_counts:
            object_counts[class_id] += 1
        else:
            object_counts[class_id] = 1

# Print the count of objects for class '0' or any class you have.
print("Counts per class:", object_counts)

This code snippet filters detections by confidence score greater than 0.8 and counts them per class as expected. If you have further issuess or need more adjustments, feel free to reach out! 😊

[ravirydot1]

Hello ,

I have made an object tracking and counter project. I have modified logic of in and out count in object.counter.py suitable for my own use case. Now everything is working perfect but when I want to use vid_stride argument in my script for frame skipping , its not working . It by default give result for stride = 1 even when i use stride=5 in argument in my script.
Can you please guide me how to solve this issue ?

[glenn-jocher]

@ravirydot1 hello,

Thanks for reaching out! It seems there might be an issue with how the vid_stride argument is being implemented or passed in your script. If you are using it directly from the CLI commands or integrating it in a Python script, make sure it is correctly set when calling the tracking function.

Here's a quick example of how you should typically pass the vid_stride argument in a Python script using YOLOv8:

from ultralytics import YOLO

# Initialize the model
model = YOLO('yolov8n.pt')

# Load your video
cap = cv2.VideoCapture('path/to/your/video.mp4')

# Set up necessary tracking configurations
while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Apply vid_stride for skipping frames
    results = model.track(frame, vid_stride=5)  # Skip frames

    # Visualize or process the results
    # e.g., results.show(), results.save(), etc.

Make sure that other parts of your script or integration do not reset this parameter or conflict with its utilization. If the issue persists despite correct implementation, it might be helpful to check your YOLOv8 version or consider updating it.

Feel free to share more detailed code snippets if the problem continues. I'm here to help!

Best regards!

[lange4531]

Hello there,

At the moment my code is making object detections outside of my specified region I have created upon the video, and I was hoping by creating a region of interest YOLO would not do detections anywhere else but inside of this region. This is however not working. Is there a way to force this somehow?
I appreciate any advice!

import cv2
from ultralytics import YOLO
from ultralytics.solutions import object_counter
import time
import matplotlib.pyplot as plt

model = YOLO('bestleafseg.pt')

Define line and region for counting

line_start, line_end = (0, 756), (1920, 756) # Adjusted to 70% of the frame height
region_points = [(0, 1080), (1920, 1080), (1920, 540), (0, 540)] # Region covering the bottom half of the frame

cap = cv2.VideoCapture('C:\Users\Stell\Desktop\DVA 309\GX010009.MP4')
assert cap.isOpened(), "Error opening video stream or file"

counter = object_counter.ObjectCounter()
counter.names = model.names # Set the class names

counter.in_counts = {class_id: 0 for class_id in counter.names.keys()}
counter.out_counts = {class_id: 0 for class_id in counter.names.keys()}

seen_ids = set()
timestamps = {}

start_time = time.time()

Process video

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

cv2.line(frame, line_start, line_end, (0, 255, 0), 2)


results = model.track(frame, persist=True, conf=0.8)


for detection in results:
    for track in detection.boxes:
        # Extract bounding box coordinates from the tensor
        x, y, w, h = track.xywh[0].tolist()  # Convert tensor to list and unpack
        
        # Ensure track.id is not None before accessing .item()
        if track.id is not None:
            id = track.id.item()  
        else:
            continue 

        bbox_center = (x + w // 2, y + h // 2)

        # Check if the center of the bbox crosses the line + hasn't been counted
        if line_start[1] <= bbox_center[1] <= line_end[1] and id not in seen_ids:
            seen_ids.add(id)
            timestamps[id] = time.time() - start_time  # Record the time at which each plant crosses the line

# Set arguments for region counting
counter.set_args(classes_names=model.names, reg_pts=region_points, view_img=True, draw_tracks=True, line_thickness=2)


try:
    frame = counter.start_counting(frame, results)
except TypeError as e:
    print(f"Error in start_counting: {e}")
    print(f"self.names: {counter.names}")
    continue


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


current_time = time.time()
if current_time - start_time >= 10:
 
    print(f"Counts: {counter.in_counts}")
    # Reset counters and start time
    counter.in_counts = {class_id: 0 for class_id in counter.names.keys()}
    counter.out_counts = {class_id: 0 for class_id in counter.names.keys()}
    start_time = current_time

cap.release()
cv2.destroyAllWindows()

print(f"Total plants crossed the line: {len(seen_ids)}")
for plant_id, timestamp in timestamps.items():
print(f"Plant ID {plant_id} crossed at {timestamp} seconds")

times = list(timestamps.values())
plt.figure(figsize=(10, 6))
plt.plot(times, list(range(1, len(times) + 1)), marker='o')
plt.xlabel('Time (seconds)')
plt.ylabel('Number of Plants')
plt.title('Plant Growth Over Time')
plt.grid(True)
plt.show()

if times:
average_growth_rate = sum(times) / len(times)
print(f"Average time for plants to reach the line: {average_growth_rate} seconds")

[lange4531]

Have anybody else gone through the same problem as described above?

[pderrenger]

It seems like you're dealing with detections outside of a specified region of interest (ROI), which isn't natively handled by the current YOLO model configuration directly. However, you can filter out detections outside your ROI in your script after detections are made by the model.

Here's a way to modify your script to account for this by checking if detected object centroids or bounding boxes fall within your predefined region:

def in_region(x, y, region_points):
    # This function checks if a point (x, y) is inside the polygon defined by region_points
    from matplotlib.path import Path
    path = Path(region_points)
    return path.contains_point((x, y))

# Results after detection
for detection in results:
    for track in detection.boxes:
        x, y, w, h = track.xywh[0].tolist()
        bbox_center_x = x + w // 2
        bbox_center_y = y + h // 2
        
        # Check if the bbox center is within the region
        if in_region(bbox_center_x, bbox_center_y, region_points):
            # Process only these detections further
            continue

This script snippet will help ensure that only objects within your specified region are considered for further processing or counting. Make sure your region_points correctly define the polygon around your desired area of interest. Adjust region_points in a way that forms a closed polygon around the area you aim to track objects in.

If you have further customization needs or run into any issues, don't hesitate to reach out! 🚀

[ritesh0192]

How to include multiple line in the object counting process?

[glenn-jocher]

To incorporate multiple lines in the object counting process with Ultralytics YOLOv8, you need to specify each line's endpoint coordinates. Here's a quick example on how to set up counting for two lines:

from ultralytics import YOLO, object_counter
import cv2

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

# Define two lines
line_points1 = [(20, 400), (1080, 400)]
line_points2 = [(20, 350), (1080, 350)]

# Initialize Object Counter
counter = object_counter.ObjectCounter()
counter.set_args(view_img=True,
                 reg_pts=[line_points1, line_points2],  # List of lines
                 classes_names=model.names,
                 draw_tracks=True,
                 line_thickness=2)

# Video processing logic
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    # Track objects
    tracks = model.track(im0, persist=True, show=False)
    im0 = counter.start_counting(im0, tracks)

cap.release()
cv2.destroyAllWindows()

Each line is defined by a pair of points and you can add them to the reg_pts argument as a list of line endpoints. This setup will allow object counting across multiple lines. Let me know if there's anything else you'd like to explore! 🚀

[sarachaourar]

Is it possible to do object counting on images? And how can you do that?

[shukurullo2004]

Hello, yolov8 it has not donkey class, how can i give it donkey class. i have donkey images and i autoannotate with Ultralytics, but ultralytics consider donkey as horse. then i trained custom data on yolov8s but it showa warning like labels are mismatched then low and acc are very low. can u help to solve the problem. i am looking forward to your response

[glenn-jocher]

@shukurullo2004 hello! It appears that your model is confusing donkeys for horses, which can happen if the model hasn't been trained explicitly to recognize donkeys as a separate class. Here’s how you can solve this:

1. Create a Custom Dataset: It looks like you’ve annotated donkey images, make sure your dataset specifically labels these images as "donkey" and not "horse". Ensure this label is distinct in your dataset's annotation files.

2. Update Your Dataset Configuration: In your dataset configuration file (probably a .yaml file), ensure that "donkey" is included as a class. Here’s a simplified example of what it might look like:

   train: path/to/train/images
   val: path/to/val/images
   nc: 2  # number of classes
   names: ['horse', 'donkey']

3. Retrain Your Model: With your dataset correctly annotated and configured, train your model again. Make sure to point to your new dataset configuration file when starting training, like this:

   yolo detect train data=your_dataset.yaml model=yolov8s.yaml

4. Handle Warnings: If you still receive warnings about label mismatches, double-check your annotation files to ensure all images labeled as donkeys are correctly marked and no incorrect annotations exist.

These steps should guide you towards training a YOLO model that can accurately differentiate between horses and donkeys. Keep an eye on your training process to tweak parameters if needed! If there’s anything more specific you need help with, let me know! 😊

[sarachaourar]

Hello, can you please tell me how i can do object counting for multiple classes on image files? Thank you for you response.

[glenn-jocher]

@sarachaourar hello! To perform object counting for multiple classes on images using YOLOv8, you can simply utilize a pretrained model and the provided utilities in the Ultralytics framework to detect and count objects in photos. Here’s a brief example of how you might set this up in Python:

from ultralytics import YOLO, draw
import cv2

# Load a pretrained model
model = YOLO('yolov8n.pt')  

# Load an image
image = cv2.imread('path/to/your/image.jpg')

# Run detection
results = model(image)

# Parse results
for i, (start_pt, end_pt, class_name, score) in enumerate(zip(results.xyxy[0][:, 0:2], results.xyxy[0][:, 2:4], results.names, results.xyxy[0][:, 4])):
    print(f"Object {i + 1}: {class_name} with confidence {score:.2f}")

    # Draw bounding boxes
    draw.box_label(image, (start_pt[0], start_pt[1], end_pt[0], end_pt[1]), label=class_name)

# Count each type of object
counts = results.names.count()

# Display the image
cv2.imshow('Detected Objects', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

In this snippet, each detected object is counted and printed alongside its confidence level. This setup helps track multiple object classes simultaneously. Adjust the paths and class names based on your model and data.🚀

[antoniomtz]

Hello, two questions:

1. How can I invert the logic so IN is OUT and OUT is IN?
2. If it's not easy, then, how can I modify the text where is says IN and OUT, I want to customize that text.

Thank you

[glenn-jocher]

Hey there! To invert the IN/OUT logic for your object counting setup, you can simply adjust the orientation or ordering of your defined line points. In your case, where the objects are entering from south to north, and you need this to be counted as IN rather than OUT, you can redefine the points in a way where the vector direction of the line aligns with your desired IN direction.

Here’s a quick snippet on how you might redefine your line points for the counting logic:

# Original points might be defined as south to north
line_points = [(20, 400), (20, 100)]  # Example of South to North

# Invert logic by switching order of points to North to South
line_points = [(20, 100), (20, 400)]

Just alter the order of coordinates based on your scenario. This switch will effectively invert the IN/OUT count as per the Ultralytics YOLOv8 object counter’s logic.

If you wish to customize or remove the text labels showing IN and OUT counts, you might need to change the source code handling the visualization or explore the set_args method properties to disable text flags, if available. Don't hesitate to dive into the documentation or codebase to explore more about customization options!

Hope this helps! Let me know if you have further questions! 🚀

[antoniomtz]

Hello,

I tried that approach using the simple line and it didn’t work. So do I need to use the region instead then?

[glenn-jocher]

Hello! 🚀

It seems like using a region for object counting might be more aligned with your requirements if adjusting the line didn't achieve the desired results. Defining a specific area with region_points rather than just line_points can provide more control, especially for complex scenes.

You can set up a polygonal region as follows:

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

# Use these points in setting up the object counter
counter = object_counter.ObjectCounter()
counter.set_args(reg_pts=region_points, ...)

Adjust the points to fit the specific area where you're observing the entries and exits. Switching to this approach should give you better control over the counting mechanism.

Let me know if this works for you or if further tweaks are needed!

[antoniomtz]

Unfortunately, this approach didn't work. In fact, using polygonal regions affect the output. For example, I have 6 people coming in, and it detects 4 in and 3 out. Whereas using a simple line, it correctly detects the 6 people going to the same direction as OUT.

I don't quite understand how the polygonal region affects the output.

I guess the only way to "fix" this is to have my business logic backwards from the IN/OUT output.

[glenn-jocher]

Hello!

It sounds like the polygonal region might be introducing complexities due to its shape and how objects interact with multiple edges. For a more straightforward approach, sticking with a line might indeed be more effective if it aligns better with the actual movement paths of the objects.

To invert the IN/OUT logic effectively with a line, you could try adjusting the order of the line points as previously suggested. If that doesn't work due to the specifics of your setup, you might consider implementing a custom logic post-detection to swap the counts based on your requirements.

Here's a simple way to manually adjust the counts after detection:

in_count, out_count = out_count, in_count  # Swap the counts

This manual swap can be done right after you fetch the counts from the object counter, allowing you to present or log them according to your business logic.

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

[damlagokalp]

Can you tell me how I can save the count number of the objects printed to the video in the code above, i.e. "in count : out count : " to a txt file?

[pderrenger]

To save the count numbers of objects ("in count" and "out count") to a text file from your video processing code, you can modify the loop where you process each frame to include writing the counts to a file. Here's a simple way to do it using Python's built-in file handling:

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"

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

# Open a text file to write counts
with open('object_counts.txt', 'w') as f:
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            break
        tracks = model.track(im0, persist=True, show=False)
        im0 = counter.start_counting(im0, tracks)
        video_writer.write(im0)

        # Write counts to file
        f.write(f"In count: {counter.in_count}, Out count: {counter.out_count}\n")

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

This modification opens a text file named object_counts.txt in write mode and writes the "in" and "out" counts after processing each frame. The counts are retrieved from the ObjectCounter instance. Make sure to replace counter.in_count and counter.out_count with the actual attributes or methods you use to access these counts in your implementation.

[damlagokalp]

I got it thanks. can I also print these count values separately for different classes that I count?

[pderrenger]

Absolutely! You can print the count values separately for different classes by specifying the classes you want to track. Modify the classes parameter in the model.track() method to include the class indices you're interested in. Here's a quick example if you want to count and print values for classes 'person' (class index 0) and 'car' (class index 2):

# Assuming 'person' is class index 0 and 'car' is class index 2
classes_to_count = [0, 2]  # Add class indices as needed

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)

    # Optionally print to console or handle counts as needed
    print(f"Current frame counts - Persons: {counter.counts[0]}, Cars: {counter.counts[2]}")

Make sure your ObjectCounter is set up to handle these specific classes. Adjust the classes_names parameter if needed to match the indices with the correct class names. This setup will allow you to track and count specified object classes separately.

[hiremeteam]

Hi everyone,

I am developing a car counting system where all vehicles move in a single direction. However, I’ve noticed an issue: when a car's center coordinate moves towards the left, it is counted as "in," and when it moves towards the right, it is counted as "out." It seems that the Region of Interest (ROI) line is divided in half, with one side designated for "in" and the other for "out."

Since all cars are moving in a single direction, I need to modify the counting logic so that it only counts up (or down) rather than differentiating between "in" and "out." How can I adjust the counting arguments to accommodate this single-direction movement?

Thank you for your help!

[glenn-jocher]

Hello!

To adjust your car counting system to count only in one direction, you can modify the ObjectCounter setup in your script. Since all cars are moving in a single direction, you can set up the counting line or region such that it only triggers a count when objects cross in the desired direction.

Here’s a simplified example of how you might adjust your code:

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"

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

# Initialize Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
    count_direction='up'  # or 'down' depending on your specific setup
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = counter.start_counting(im0, tracks)
    cv2.imshow('Frame', im0)

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

cap.release()
cv2.destroyAllWindows()

In this script, adjust the count_direction parameter to either 'up' or 'down' based on the movement direction of the cars. This parameter isn't native to the current Ultralytics implementation and serves here as a conceptual guide. You might need to implement this logic within the ObjectCounter or handle it manually based on the tracking data.

For more detailed guidance, please refer to the Object Counting Guide. 🚗💨

[lzJune]

Hi，I want to know how I can use multiple GPUs in the follow code: track+object Counting

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

Define line points

line_points = [(20, 400), (1080, 400)]

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)

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

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

[glenn-jocher]

@lzJune hello! To utilize multiple GPUs for your object tracking and counting setup with YOLOv8, you can specify the device argument in the YOLO model initialization. Here's how you can modify your code to run on, for example, GPUs 0 and 1:

from ultralytics import YOLO, solutions
import cv2

# Initialize the model on multiple GPUs
model = YOLO("yolov8n.pt", device='0,1')

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 = [(20, 400), (1080, 400)]

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

# Initialize 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:
        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()

This modification tells YOLO to use both GPU 0 and GPU 1 for processing. Make sure your environment is properly set up for multi-GPU use, including appropriate CUDA and PyTorch configurations. For more detailed guidance, you can refer to our documentation on object counting. 🚀

[AjanthaAravind]

Hello glenn, I am using 7 classes to detect defects in product. I am using the specific class for counting individual classes. I want to include tracking id for each defect class in video for rejection purpose. And then how to write the tracking id and count of each class in text file?

[pderrenger]

Hello! To include tracking IDs for each defect class and write the tracking ID and count of each class to a text file, you can use the track() method from the YOLO model to get tracking IDs and the ObjectCounter from the Ultralytics solutions for counting. Here's a concise example on how to implement this:

import cv2
from ultralytics import YOLO, solutions

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

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

# Initialize Object Counter
counter = solutions.ObjectCounter(classes_names=model.names, draw_tracks=True)

# Prepare to write output to a text file
with open("output.txt", "w") as f:
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        # Track objects
        results = model.track(frame, persist=True)
        # Count objects
        frame = counter.start_counting(frame, results)
        
        # Write tracking ID and counts to file
        for track in results:
            f.write(f"Track ID: {track.id}, Class: {model.names[track.cls]}, Count: {counter.counts[track.cls]}\n")

cap.release()

This script will track objects in a video, count them, and write the tracking ID and counts to a text file. Adjust the path/to/your/model.pt and path/to/your/video.mp4 to your model and video paths respectively. Make sure to tailor the ObjectCounter settings to your specific needs. For more detailed guidance, please refer to the Object Counting Guide.

[aynazrmn]

Hello,
I am working on an object detection project using YOLOv8x to analyze around 200,000 wildlife camera trap images. The main objectives are to determine the presence or absence of birds and to quantify the number of birds in each image.

Specifically, I need to:

Count the number of detected birds in each image.
Save images with only 1 bird separately from those with 2 or more birds.
Could you please guide me on how to achieve this?

[pderrenger]

Hello,

For your project on analyzing wildlife camera trap images to detect and count birds, you can utilize the YOLOv8 model along with the ObjectCounter from our solutions module. Here’s a brief guide on how to set this up:

1. Count Detected Birds: You can modify the ObjectCounter to count the number of birds detected in each image. Ensure that your model is trained to accurately detect birds or use a pre-trained model that can.

2. Save Images Based on Count:

   • Modify the output section of the script to check the count of detected birds.
   • Use conditions to save images into separate directories based on the count (e.g., one directory for images with one bird and another for images with two or more birds).

Here is a simplified example to get you started:

import cv2
from ultralytics import YOLO, solutions

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

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

# Setup Object Counter
counter = solutions.ObjectCounter(classes_names=model.names)

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

    # Detect and track objects
    results = model.track(img, persist=True)
    
    # Count objects
    img, counts = counter.start_counting(img, results)
    
    # Save based on counts
    if counts['bird'] == 1:
        cv2.imwrite('path/to/single_birds/image_name.jpg', img)
    elif counts['bird'] > 1:
        cv2.imwrite('path/to/multiple_birds/image_name.jpg', img)

cap.release()

This script needs to be adapted to your specific requirements, such as setting up the correct paths and ensuring the model is correctly detecting birds.

For a more detailed guide and customization options, please refer to our documentation on object counting: Object Counting Guide.

Best of luck with your project! If you have further questions, feel free to ask.

[SudhanshuBlaze]

Hi,

I want to have multiple line counters and track multiple paths for different classes. For instance, I want to have 2 line counters at different regions, one for cars and the other for pedestrians. So, I have created separate trackers and counters to keep separate counts line wise. But the problem which I am facing currently is the “total count box” which appears in the top right corner of the video are overlapping, the cars count box is appearing over the person count box. So my main doubt is how to maintain separate count for cars going into different counter lines and how to change the position of the box which appears in the top right corner?

Please review the code and let me know if I am doing it the right way and if it is possible to do it with 1 tracker variable or multiple like I used.

PS: I might also want to have a 3rd line counter at a different position on the video to count the number of cars which turns and goes right (on intersecting roads). So I can have a track of how many cars went straight, how many cars took the right turning after going straight, and how many pedestrians were there on the road. It would be like analytics dashboard.

import cv2
from ultralytics import YOLO, solutions

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

# Open the video file
cap = cv2.VideoCapture("741755_Kazakhstan Traffic Cars Road_By_Danil_Nevsky_Artlist_HD.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 = [0,1,2,3,4,5,6,7,8,9]  # Classes to count

# Define the lines or regions points
line_points_1 = [(50, 300), (1000, 250)]  # first line points
line_points_2 = [(1400, 750), (1920, 650)]  # second line points

# Video writer
video_writer = cv2.VideoWriter("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,
)

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

# Init separate trackers for each counter
tracker_1 = model  # Tracker for the first counter
tracker_2 = model  # Tracker for the second 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
    tracks_1 = tracker_1.track(im0, persist=True, show=False, classes=classes_to_count)
    im0 = counter_1.start_counting(im0, tracks_1)

    # Perform tracking for the second counter
    tracks_2 = tracker_2.track(im0, persist=True, show=False, classes=classes_to_count)
    im0 = counter_2.start_counting(im0, tracks_2)
    
    # Write the frame to the output video
    video_writer.write(im0)

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

Complete repo: https://github.com/SudhanshuBlaze/multi_vehicle_count/tree/main
Output video: https://github.com/SudhanshuBlaze/multi_vehicle_count/blob/main/object_counting_output.mp4

[pderrenger]

@SudhanshuBlaze hi there,

It sounds like you're making great progress with your object counting setup using multiple lines and classes! To address the overlapping "total count boxes" and manage separate counts for different lines, you can adjust the position of the count display for each ObjectCounter instance.

Here's how you can modify the position of the count boxes:

1. Adjust the Position of Count Boxes:
   Each ObjectCounter instance has parameters for text color, background color, and more. You can add an offset to the position where the count is drawn on the screen. This isn't directly supported, but you can modify the ObjectCounter class in the Ultralytics library to include an x, y offset for the text.

2. Using One vs. Multiple Trackers:
   Using a single tracker instance should generally be sufficient unless there are specific reasons to separate them (like different tracking parameters for each type of object). You can pass the tracks from a single tracker to multiple ObjectCounter instances, each configured for different line points and classes.

3. Adding More Counters:
   For adding more counters, like a third line for counting cars turning right, you can follow the same approach as above. Define new line points and instantiate another ObjectCounter.

Here's a simplified example of how you might adjust the drawing function:

class ObjectCounter:
    def __init__(self, ..., text_offset=(0, 0)):
        self.text_offset = text_offset
        ...

    def draw_counts(self, image):
        # Use self.text_offset to adjust where text is drawn
        position = (default_x + self.text_offset[0], default_y + self.text_offset[1])
        cv2.putText(image, count_text, position, ...)

You'd then instantiate each counter with a different text_offset:

counter_1 = ObjectCounter(..., text_offset=(0, 0))
counter_2 = ObjectCounter(..., text_offset=(0, 50))  # Move the second counter's text down by 50 pixels

This approach keeps your tracking and counting modular and easy to adjust. If you need further customization or encounter any issues, feel free to reach out!

[SudhanshuBlaze]

Hi

I updated the ObjectCounter() class as per your instructions, I added the text_offset variable and draw_counts function, but it seems that it still has no effect on the position of the “total count boxes” in the top right corner. So, after inspecting the ObjectCounter class, I realized there's another function on line 227 of object_counter.py called display_analytics which needs to be updated as well.

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

Can you please help me update this function as well such that the position of boxes can be adjusted?

This function is defined in: /ultralytics/utils/plotting.py

def display_analytics(self, im0, text, txt_color, bg_color, margin):
        """
        Display the overall statistics for parking lots
        Args:
            im0 (ndarray): inference image
            text (dict): labels dictionary
            txt_color (bgr color): display color for text foreground
            bg_color (bgr color): display color for text background
            margin (int): gap between text and rectangle for better display
        """

        horizontal_gap = int(im0.shape[1] * 0.02)
        vertical_gap = int(im0.shape[0] * 0.01)
        text_y_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 = 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 = rect_y2

Thanks in advance.