guides/object-counting/

[giscus[bot]]

guides/object-counting/

Object Counting Using Ultralytics YOLO11, Ultralytics YOLOv8, YOLOv9, YOLOv10

Code Example

Python

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Define region points
# region_points = [(20, 400), (1080, 400)]  # For line counting
region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)]  # For rectangle region counting
# region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360), (20, 400)]  # For polygon region counting

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

# Init Object Counter
counter = solutions.ObjectCounter(
    show=True,  # Display the output
    region=region_points,  # Pass region points
    model="yolo11n.pt",  # model="yolo11n-obb.pt" for object counting using YOLO11 OBB model.
    # classes=[0, 2],  # If you want to count specific classes i.e person and car with COCO pretrained model.
    # show_in=True,  # Display in counts
    # show_out=True,  # Display out counts
    # line_width=2,  # Adjust the line width for bounding boxes and text display
)

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

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

CLI

# Run a counting example
yolo solutions count show=True

# Pass a source video
yolo solutions count source="path/to/video/file.mp4"

# Pass region coordinates
yolo solutions count region=[(20, 400), (1080, 400), (1080, 360), (20, 360)]

Documentation

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

[nubrandsta]

Very cool and simple implementation!

[nubrandsta]

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

[pderrenger]

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

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

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

[nubrandsta]

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

[pderrenger]

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

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

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

[FaiqaShabbir]

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

[pderrenger]

Hey there! 👋

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

# Initialize Object Counter
counter = object_counter.ObjectCounter()

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

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

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

[yeongnamtan]

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

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

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

[pderrenger]

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

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

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

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

[yeongnamtan]

thank you. It is working now.

[pderrenger]

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

[Boaruzhanchik]

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

Line pedestrian

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

[glenn-jocher]

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

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

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

[syariffortask]

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

[glenn-jocher]

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

from ultralytics import YOLO, object_counter
import cv2

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

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

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

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

    # Track objects
    results = model.track(im0)

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

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

cap.release()
cv2.destroyAllWindows()

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

[syariffortask]

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

[glenn-jocher]

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

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

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

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

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

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

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

[Anandukc]

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

[glenn-jocher]

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

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

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

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

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

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

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

cap.release()
cv2.destroyAllWindows()

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

[kuangb17]

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

[glenn-jocher]

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

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

from ultralytics import YOLO

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

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

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

[kuangb17]

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

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

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

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

[glenn-jocher]

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

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

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

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

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

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

[Anandukc]

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

[glenn-jocher]

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

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

import numpy as np

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

        # Now you can continue with your speed calculation logic

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

[yeongnamtan]

I get below error...

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

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

[glenn-jocher]

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

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

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

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

[SudhanshuBlaze]

Hi,

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

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


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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    for result in tracks:
        for track in result.boxes:
            id = int(track.id)
            if track.xyxy.numel() == 4:
                x_min, y_min, x_max, y_max = track.xyxy[0]  # Unpack from the first row

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

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

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

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

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

[glenn-jocher]

Hi there!

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

1 pixel per second = 3.6 km/h

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

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

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

    # Perform tracking for all counters
    tracks = tracker.track(im0, persist=True, show=False, classes=classes_to_count)
    
    for result in tracks:
        for track in result.boxes:
            id = int(track.id)
            if track.xyxy.numel() == 4:
                x_min, y_min, x_max, y_max = track.xyxy[0].tolist()  # Unpack from the first row

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

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

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

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

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

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

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

[ShreyasChhetri]

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

[pderrenger]

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

from ultralytics import YOLO
import cv2

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

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

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

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

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

cap.release()
cv2.destroyAllWindows()

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

[ShreyasChhetri]

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

[glenn-jocher]

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

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

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

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

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

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

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

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

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

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

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

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

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

[akhilesh99sharma]

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

TypeError: 'int' object is not iterable

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

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

model = YOLO(MODEL)
model.fuse()

classes_to_count = [0,1,2]

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

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

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

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

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

cap.release()
cv2.destroyAllWindows()

`

[glenn-jocher]

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

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

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

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

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

[Kindstep]

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

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

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

[akhilesh99sharma]

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

[glenn-jocher]

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

A few things to check:

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

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

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

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

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

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

[Kindstep]

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

[glenn-jocher]

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

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

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

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

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

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

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

cap.release()
cv2.destroyAllWindows()

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

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

[Kindstep]

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

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

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

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

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

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

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

model = YOLO('output/train17/weights/best.pt')
cap = cv2.VideoCapture(best_stream.url)
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

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

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

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

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

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

#last_count = counter.out_counts

results = counter.start_counting(im0, tracks)

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

video_writer.write(im0)

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

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

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

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

And once again, seriously, thanks for the help!

[glenn-jocher]

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

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

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

# Initialize counters
ski_counts = 0
boarder_counts = 0

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

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

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

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

    video_writer.write(im0)

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

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

[Kindstep]

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

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

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

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

model = YOLO('insert trained model here')
cap = cv2.VideoCapture(best_stream.url)
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

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

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

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

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

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

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

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

results = counter.start_counting(o_frame, tracks)

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

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

video_writer.write(o_frame)

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

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

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

[glenn-jocher]

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

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

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

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

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

[yasirgultak]

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

[pderrenger]

Hey there! 👋

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

from ultralytics import YOLO
import cv2

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

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

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

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

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

cap.release()

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

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

[AqsaRasheed]

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

[yasirgultak]

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

[AqsaRasheed]

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

@glenn-jocher , please guide. thanks

[pderrenger]

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

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

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

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

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

[dhamothar]

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

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

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

Thank you.

[glenn-jocher]

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

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

cap.set(cv2.CAP_PROP_BUFFERSIZE, 3)

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

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

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

[dhamothar]

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

[glenn-jocher]

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

[ShreyasChhetri]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    cv2.destroyAllWindows()

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

[pderrenger]

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

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

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

from ultralytics import YOLO
import cv2

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

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

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

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

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

[ShreyasChhetri]

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

[pderrenger]

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

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

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

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

[MadsVintherM]

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

Would this work?

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

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

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

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

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

# Initialize timer
start_time = time.time()

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

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

cap.release()
cv2.destroyAllWindows()

[pderrenger]

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

from ultralytics import YOLO, solutions
import cv2
import time

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

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

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

# Initialize timer
start_time = time.time()

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

cap.release()
cv2.destroyAllWindows()

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

[MadsVintherM]

Thanks for the feedback @pderrenger

[pderrenger]

You're welcome!

[Rafi0198]

I want to count total incount and outcount. Not class wise. How to? Seems like the feature got updated as I could do the overall count a few months back.

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

[g-i-o-r-g-i-o]

What is the minimal code that I can use to have:

yolo (defining parameters, if any)

bytetrack (defining parameters, if any)

get the coordinates of the boxes and id of the object

then I'll define a geometric condition, let's say behind a line etc

[glenn-jocher]

@g-i-o-r-g-i-o to achieve object tracking and counting with YOLO and ByteTrack, you can use the following minimal code setup. This will allow you to get the coordinates and IDs of detected objects and apply a geometric condition:

import cv2
from ultralytics import YOLO

# Initialize model and video capture
model = YOLO('yolo11n.pt')
cap = cv2.VideoCapture('path/to/video.mp4')

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

    # Run detection and tracking
    results = model.track(frame, persist=True, tracker='bytetrack.yaml')
    
    # Process results
    for r in results:
        for box in r.boxes:
            x1, y1, x2, y2 = box.xyxy
            obj_id = box.id
            # Apply geometric condition here, e.g., check if behind a line

    # Display or save results
    cv2.imshow('Frame', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

For more detailed guidance, please visit the object counting guide.

[smc0927]

If I want a target to be detected only once, is it possible? If so, how can I do it?

[RizwanMunawar]

@smc0927 Hi! I’m not entirely sure I understand your question. Could you please clarify a bit?

Generally, the counting process is designed to occur only once for each track ID. Once an object is counted, it won't be counted again, even if it crosses the same region or line multiple times.

[smc0927]

ok, I want to print out the coordinates of the target, but that's not what I want because it's going to be printed multiple times over a period of time. I want it to be output only once, is there a way to achieve this?

[RizwanMunawar]

@smc0927 Yes it's possible. You can simply iterate over the detection results. BTW, this discussion is more related to Ultralytics solutions, while your question is related to prediction :)

Sample Code

from ultralytics import YOLO
model = YOLO("yolo11n.pt")
results = model.predict("path/to/im0")

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

      for box, cls in enumerate(boxes, clss):
          # Here you can add the logic to display single-time details of the object

Thanks :)

[smc0927]

If I aim to utilize the camera for real-time counting instead of analyzing counts from recorded video, what approach should I take?

[glenn-jocher]

For real-time object counting using a camera, you can use the YOLO11 model with a live video stream as the input source. Set up the camera feed as the video source in your code, and utilize the ObjectCounter to count objects directly from the stream. For more detailed guidance, please refer to the object counting section in the Ultralytics documentation.

[Dheeraj-0721]

Hey there!
I am using yolo for detection and want to detect all items with the count from cart image and also want to tick only detected items in the image so that I can see clearly which items are not detected. If it is possible, please provide me the code or guide me here.

[glenn-jocher]

@Dheeraj-0721 to detect and count items in a cart image using YOLO, you can utilize the ObjectCounter from the Ultralytics solutions. This tool allows you to define regions for counting and can highlight detected items. For detailed guidance, please refer to the Object Counting guide.

[Dheeraj-0721]

I had went through that and I have implemented the code but not getting counts of detected items. However, It's counting but can't coming counts in in_count and out_count. I am using below code so could you please correct me here?

detection.py

import cv2
import numpy as np
from ultralytics import YOLO, solutions
from sqlalchemy.orm import Session
from app.models import Product # Import your database model
import base64
import time

Initialize the YOLO model with the trained weights file

model = YOLO("app/packageV8_latest5.pt")

def detect_objects_from_camera(db_session: Session):
print('Camera is coming:::')
# image path for detection
frame = cv2.imread("app/A1_cart_mix.png")

print("Press 'q' to close the camera window")

# Save the captured frame as an image file
 image_save_path = "captured_image.jpg"
# print(f"Image saved at: {image_save_path}")

# Encode the original frame as base64
 resize1 = cv2.resize(frame, (380, 480))
 _, originalBuffer = cv2.imencode('.jpg', resize1)  
original_resize1_base64 = base64.b64encode(originalBuffer).decode('utf-8')
print('Camera is coming:::1::',original_frame_base64)

# Set up dimensions and object counter
resize_width, resize_height = 380, 480
w, h = frame.shape[1], frame.shape[0]
region_points = [(resize_width - (400 * resize_width // w), 0), (resize_width - (400 * resize_width // w), resize_height)]
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
 print(w, h, fps)
resize_width, resize_height = 380, 480

 new_fps = fps * 2
# Define region points
region_points = [(20, 400), (1080, 404), (1080, 120), (20, 120)]

# Initialize Object Counter
counter = solutions.ObjectCounter(
    show=True,
    region=region_points,
    model="app/packageV8_latest5.pt",
    # classes=model.names,
    line_width=2,
)

# Resize and detect objects
 resize = cv2.resize(frame, (resize_width, resize_height))
 counted_frame = counter.count(resize)
print("counting:::", counter.in_count, counter.out_count)
# Prepare detected items with data fetched from the database
detected_items = []
for cls, count in counter.classwise_counts.items():
    print(f"Class: {cls}, Count: {count}")
    # Fetch item info from the database based on detected class
    item_info = db_session.query(Product).filter_by(code=cls).first()
     
    if item_info:
        detected_items.append({
            "name": item_info.name,
            "description": item_info.description,
            "nluNumber": item_info.NLUNumber,
            "quantity": count,
            "microsName1": f"Micro_{item_info.name}"
        })
    else:
        # Handle case where item info is not found in the database
        detected_items.append({
            "name": cls,
            "description": f"Detected {cls}",
            "nluNumber": 0,  # Default or placeholder NLU number
            "quantity": count,
            "microsName1": f"Micro_{cls}"
        })

# Encode the original frame as base64
_, originalBuffer = cv2.imencode('.jpg', resize)
original_frame_base64 = base64.b64encode(originalBuffer).decode('utf-8')
detected_items = [
    {"name": "example_item", "description": "Example description", "nluNumber": 123, "quantity": 1, "microsName1": "Micro_example"}
]
# Encode the detected frame as base64
_, detectedBuffer = cv2.imencode('.jpg', im0)
detected_frame_base64 = base64.b64encode(detectedBuffer).decode('utf-8')

# cap.release()

# Return detected items and frame
return {
    "detected_items": detected_items,
    "count": len(detected_items),
    "detected_frame": detected_frame_base64 ,
    "non_detected_frame": original_frame_base64
}

[glenn-jocher]

It seems like the issue might be with how the counting is being implemented in your code. Ensure that the ObjectCounter is correctly initialized with the appropriate region and model. Double-check the region coordinates and ensure the model path is correct. If the issue persists, consider reviewing the Object Counting guide for additional insights and examples.

[RizwanMunawar]

🎉 Big News Alert! 🚀 Ultralytics Solutions CLI is here from ultralytics>=8.3.28! Now, you can easily harness the power of advanced YOLO solutions straight from the command line. Simplify your workflow, and streamline object detection, tracking, counting, and more—all with just a few commands! Get ready to experience a whole new level of efficiency! 💥

CLI Usage Overview

yolo SOLUTIONS SOLUTION_NAME ARGS

• SOLUTIONS is a mandatory keyword.
• SOLUTION_NAME (optional): Choose from ['count', 'heatmap', 'queue', 'speed', 'workout', 'analytics'].
• ARGS (optional): Use custom arg=value pairs, like show_in=True, to customize settings.

Examples

yolo solutions count show=True  # For object counting

yolo solutions source="path/to/video/file.mp4"  # Specify a video file path

Start exploring now and let Ultralytics Solutions CLI power up your projects!

[faheem-khaskheli]

i have created a line, at 15 degree angle, if a person come down it should count as in, and if a person goes up it count as out.

• down = in
• up = out
  but model does not work like this, model count direction is reversed.

how can i solve this?

[glenn-jocher]

@faheem-khaskheli to resolve the direction issue, ensure the line's orientation is correctly defined in your code. You might need to adjust the logic that determines the direction based on the line's angle. If the model's counting direction is reversed, check the implementation of the ObjectCounter and verify the region or line points are set correctly.

[faheem-khaskheli]

@glenn-jocher is there any way i can use ultralytics solution for this problem? i have checked the code and it is only checking dx > 0 for in else out.

[glenn-jocher]

@faheem-khaskheli to address the reversed counting direction, adjust the logic in your code to correctly interpret the angle of the line. Ensure that the conditions for dx > 0 and dx < 0 align with the intended "in" and "out" directions based on your line's orientation.

[427cll]

Hi, when I use YOLO11 to detect the number of pedestrians entering the door, the number of people increases by 1 when the bottom center of the boxbounding passes through the line drawn at the bottom of the door. However, I encountered a problem where when multiple people enter together, due to obstruction, the number of people who are obstructed may not be recorded. Do you have any good solutions

[glenn-jocher]

To address the issue of occlusion when multiple people enter together, consider using a tracking algorithm like ByteTrack or BoT-SORT with persistent tracking enabled to maintain object IDs across frames, which can help in accurately counting individuals even when they are temporarily obstructed.

[Juanrp7]

Hi, I would like implementing a counting with people who in with tote bags(shopping bags) and people who out with tote bag(shopping bags). I have implementing the code mentioned in (https://docs.ultralytics.com/guides/object-counting/#advantages-of-object-counting) but doesn't work fine. Sometimes count people when out when really they are in.
The dataset COCO doesn't have the class tote bag but I seem that the datasert LVIS have already. I don't know how to implement the dataset LVIS in my project.

This is the my specification of my device that I have:

• AMD Ryzen 7 PRO 7730U with Radeon Graphics 2.00 GHz
• 32,0 GB (30,8 GB usable).

Please give me some tips for a better predection of the object and how to implement the object tote bags(shopping bags).

I'll appreciate your help.

[glenn-jocher]

@Juanrp7 to improve object counting with tote bags, consider training a custom model using the LVIS dataset, which includes the tote bag class. You can integrate this dataset into your project by following the Ultralytics documentation on custom dataset training. For better predictions, ensure your model is well-trained on relevant data and adjust the confidence threshold as needed.

[teddyy88]

horizontal line crossed to the center point of bounding box then object count increment , some time object count not increment .
What is solution ?? what is problem ? how to solve this problem ??

from collections import defaultdict
import cv2
from ultralytics.utils.checks import check_imshow, check_requirements
from ultralytics.utils.plotting import Annotator, colors
check_requirements("shapely>=2.0.0")
from shapely.geometry import LineString, Point, Polygon
from ultralytics import YOLO
import numpy as np

MODEL_PATH = r"object.pt"
VIDEO_PATH = r"dddd.mp4"

class ObjectCounter:
def init(self):
# Initialize attributes
self.is_drawing = False
self.selected_point = None
self.reg_pts = [(20, 400), (260, 400)]
self.line_dist_thresh = 10
self.counting_region_h = None
self.counting_region_v = None
self.region_color = (255, 0, 255)
self.region_thickness = 1
self.im0 = None
self.tf = None
self.in_counts_v = 0
self.out_counts_v = 0
self.counting_list = []
self.counting_list_v = []
self.view_img = False
self.view_in_counts = True
self.view_out_counts = True
self.names = None
self.annotator = None
self.wall_tie_counts = 0
self.v_lockpin_counts = 0
self.h_lockpin_counts = 0
self.h_lockpin_within_counts = 0
self.count_txt_thickness = -1
self.count_txt_color = (0, 0, 0)
self.count_color = (255, 255, 255)
self.track_history = defaultdict(list)
self.track_thickness = 2
self.draw_tracks = False
self.track_color = (0, 255, 0)
self.env_check = check_imshow(warn=True)
self.prev_x1 = None

def set_args(self, classes_names, reg_pts_h, reg_pts_v, count_reg_color=(255, 0, 255), line_thickness=2, 
             track_thickness=2, view_img=False, view_in_counts=True, view_out_counts=True, draw_tracks=False,
             count_txt_thickness=-1, count_txt_color=(0, 0, 0), count_color=(255, 255, 255), track_color=(0, 255, 0), 
             region_thickness=1, line_dist_thresh=10):
    
    # Set configuration arguments
    self.tf = line_thickness
    self.view_img = view_img
    self.view_in_counts = view_in_counts
    self.view_out_counts = view_out_counts
    self.track_thickness = track_thickness
    self.draw_tracks = draw_tracks

    # Validate and set horizontal region points
    if len(reg_pts_h) == 2:
        print("Horizontal Line Counter Initiated.")
        self.reg_pts_h = reg_pts_h
        self.counting_region = LineString(self.reg_pts_h)
    else:
        print("Invalid Region points provided for horizontal line. Using default horizontal line.")
        self.counting_region = LineString(self.reg_pts)

    # Validate and set vertical region points
    if len(reg_pts_v) == 2:
        print("Vertical Line Counter Initiated.")
        self.reg_pts_v = reg_pts_v
        self.counting_region_v = LineString(self.reg_pts_v)
    else:
        print("Invalid Region points provided for vertical line. Using default vertical line.")
        self.counting_region_v = LineString(self.reg_pts)

    self.names = classes_names
    self.track_color = track_color
    self.count_txt_thickness = count_txt_thickness
    self.count_txt_color = count_txt_color
    self.count_color = count_color
    self.region_color = count_reg_color
    self.region_thickness = region_thickness
    self.line_dist_thresh = line_dist_thresh
    
def detect_movement(self, prev_frame, curr_frame):
    # Detect movement between previous and current frame
    prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
    curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_BGR2GRAY)

    prev_pts = cv2.goodFeaturesToTrack(prev_gray, maxCorners=200, qualityLevel=0.01, minDistance=30)
    if prev_pts is not None:
        curr_pts, status, _ = cv2.calcOpticalFlowPyrLK(prev_gray, curr_gray, prev_pts, None)
        good_new = curr_pts[status == 1]
        good_old = prev_pts[status == 1]

        if len(good_new) > 0 and len(good_old) > 0:
            movement_x = np.mean(good_new[:, 0] - good_old[:, 0])
            if movement_x > 0:
                print("\033[91mMovement: Left\033[0m")
            elif movement_x < 0:
                print("\033[93mMovement: Right\033[0m")
            else:
                print("No movement detected")
        else:
            print("No feature points detected in both frames")
    else:
        print("No feature points detected in the previous frame")

def mouse_event_for_region(self, event, x, y, flags, params):
    # Handle mouse events for region selection
    if event == cv2.EVENT_LBUTTONDOWN:
        for i, point in enumerate(self.reg_pts):
            if isinstance(point, (tuple, list)) and len(point) >= 2 and (abs(x - point[0]) < 10 and abs(y - point[1]) < 10):
                self.selected_point = i
                self.is_drawing = True
                break
    elif event == cv2.EVENT_MOUSEMOVE:
        if self.is_drawing and self.selected_point is not None:
            self.reg_pts[self.selected_point] = (x, y)
            self.counting_region = Polygon(self.reg_pts)
    elif event == cv2.EVENT_LBUTTONUP:
        self.is_drawing = False
        self.selected_point = None

def extract_and_process_tracks(self, tracks):
    # Extract and process tracks
    boxes = tracks[0].boxes.xyxy.cpu()
    clss = tracks[0].boxes.cls.cpu().tolist()
    track_ids = tracks[0].boxes.id.int().cpu().tolist()

    self.annotator = Annotator(self.im0, self.tf, self.names)
    self.annotator.draw_region(reg_pts=self.reg_pts_h, color=self.region_color, thickness=self.region_thickness)
    self.annotator.draw_region(reg_pts=self.reg_pts_v, color=self.region_color, thickness=self.region_thickness)

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

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

        if self.draw_tracks:
            self.annotator.draw_centroid_and_tracks(track_line, color=self.track_color, track_thickness=self.track_thickness)
        prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None

        if len(self.reg_pts) == 2:
            if prev_position is not None:
                distance = Point(track_line[-1]).distance(self.counting_region)
                if distance < self.line_dist_thresh and track_id not in self.counting_list:
                    self.counting_list.append(track_id)
                    detected_class_name = self.names[cls]

                    if detected_class_name == "walltie":
                        self.wall_tie_counts += 1
                    elif detected_class_name == "v_lockpin":
                        self.v_lockpin_counts += 1

        if len(self.reg_pts_v) == 2:
            if prev_position is not None:
                x1, y1 = self.reg_pts_v[0]
                x2, y2 = self.reg_pts_v[1]
                x, _, _, _ = box

                if x < x1:
                    distance = Point(track_line[-1]).distance(self.counting_region_v)
                    if distance < self.line_dist_thresh and track_id not in self.counting_list_v:
                        self.counting_list_v.append(track_id)
                        detected_class_name = self.names[cls]
                        if detected_class_name == "h_lockpin":
                            self.h_lockpin_counts += 1
                elif x > x2:
                    distance = Point(track_line[-1]).distance(self.counting_region_v)
                    if distance < self.line_dist_thresh and track_id not in self.counting_list_v:
                        self.counting_list_v.append(track_id)
                        detected_class_name = self.names[cls]
                        if detected_class_name == "h_lockpin":
                            self.h_lockpin_counts += 1

    # Draw count labels directly
    self.draw_count_labels()

def draw_count_labels(self):
    # Custom method to draw count labels
    wall_tie_label = f"WallTie Count: {self.wall_tie_counts}"
    v_lockpin_label = f"VLockpin Count: {self.v_lockpin_counts}"
    h_lockpin_label = f"HLockpin Count: {self.h_lockpin_counts}"
    counts_label = f"{wall_tie_label}    {v_lockpin_label}    {h_lockpin_label}"

    # Coordinates for text labels
    font = cv2.FONT_HERSHEY_TRIPLEX
    font_scale = 0.5  # Adjust font scale to decrease text size
    font_color = self.count_txt_color
    font_thickness = max(1, self.count_txt_thickness)  # Ensure font_thickness is at least 1
    bg_color = self.count_color
    margin = 15  # Adjust margin to decrease padding

    # Calculate the size of the text box
    (text_width, text_height), _ = cv2.getTextSize(counts_label, font, font_scale, font_thickness)
    box_width = text_width + 2 * margin
    box_height = text_height + 2 * margin

    # Position the box at the top of the frame, centered horizontally
    img_h, img_w, _ = self.im0.shape
    box_x = (img_w - box_width) // 2  # Center horizontally
    box_y = margin  # Position at the top with a margin
    box_coords = ((box_x, box_y), (box_x + box_width, box_y + box_height))

    # Draw the background rectangle
    cv2.rectangle(self.im0, box_coords[0], box_coords[1], bg_color, cv2.FILLED)

    # Calculate the position for the text to be centered within the rectangle
    text_x = box_x + margin
    text_y = box_y + margin + text_height - 5  # Adjust text_y for padding inside the box

    # Put the text on top of the rectangle
    cv2.putText(self.im0, counts_label, (text_x, text_y), font, font_scale, font_color, font_thickness)

def display_frames(self):
    # Display frames with annotation
    if self.env_check:
        cv2.namedWindow("Object Counter")
        cv2.setMouseCallback("Object Counter", self.mouse_event_for_region, {"region_points": self.reg_pts})
        cv2.imshow("Object Counter", self.im0)
        key = cv2.waitKey(1)
        if key == ord("q"):
            cv2.destroyAllWindows()
            exit()

def start_counting(self, im0, tracks):
    # Start counting objects in the frame
    self.im0 = im0

    if tracks[0].boxes.id is None:
        if self.view_img:
            self.display_frames()
        return im0
    self.extract_and_process_tracks(tracks)

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

if name == "main":
model = YOLO(MODEL_PATH)
cap = cv2.VideoCapture(VIDEO_PATH)
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
print(w, h, fps)

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

object_counter = ObjectCounter()
object_counter.set_args(view_img=True,
                        reg_pts_h=[(20, 400), (800, 400)],
                        reg_pts_v=[(540, 100), (540, h)],
                        classes_names=model.names,
                        draw_tracks=True)

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

    frame_counter += 1
    if frame_counter % 5 != 0:
        continue

    if prev_frame is not None:
        object_counter.detect_movement(prev_frame, frame)

    prev_frame = frame

    tracks = model.track(frame, persist=True, show=False)
    frame = object_counter.start_counting(frame, tracks)
    video_writer.write(frame)

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

[glenn-jocher]

@teddyy88 it seems like the issue might be related to the line distance threshold or the tracking algorithm's sensitivity. Try adjusting the line_dist_thresh parameter to ensure the bounding box center crosses the line accurately. Additionally, verify that the tracking algorithm is correctly maintaining object IDs across frames.

[teddyy88]

the tracking algorithm's sensitivity.??? means?

[teddyy88]

"If I remove the line_dist_thresh and use cv2.line, the object count should increment when a line crosses the center point of the object, if possible.

[glenn-jocher]

To address the issue of your object count not incrementing when a line crosses the center point of the bounding box, consider the following: Ensure the tracking algorithm maintains object IDs consistently across frames, which can impact accurate counting. Adjusting the line_dist_thresh parameter or using cv2.line as you mentioned could help, but remember that maintaining a stable track ID is crucial for correct counting. For more details, you can refer to the Ultralytics Object Counting Guide.

[smc0927]

Hello, I would like to add negative samples during the training process. How should I proceed? Is the label of the negative sample image an empty txt file or do I not need labels

[glenn-jocher]

@smc0927 to add negative samples during training with YOLO11, you can use empty .txt files for images without objects. This indicates that no objects are present in those images.

[furiouskhan007]

This line counter is working fine. But People entering from right side while It counting it as out. How to change the logic? So if people enter from right side, it should be count in.
import cv2
from ultralytics import solutions

Open the video file

cap = cv2.VideoCapture("49.mp4")
assert cap.isOpened(), "Error reading video file"

Get video properties

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

Define region points for a vertical line at the right edge

These points create a vertical line (from bottom to top at the right side)

region_points = [(w - 100, h), (w - 100, 0)] # Vertical line at the right side
#region_points = [(w - 100, 0), (w - 100, h)] # Vertical line from top to bottom

Set up video writer to save processed video

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

Initialize the Object Counter

counter = solutions.ObjectCounter(
show=True, # Display the output frame
region=region_points, # Region where we count objects (vertical line)
model="yolo11n.pt", # Load YOLOv5 model
classes=[0], # Classes to track (0 for person, could be adjusted for others like car, etc.)
show_in=False, # Show the count inside the frame
show_out=True, # Display count output separately if needed
)

Process the video

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

# Perform object counting
im0 = counter.count(im0)

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

Release resources

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

[glenn-jocher]

@furiouskhan007 to change the counting direction for objects entering from the right side, you'll need to reverse the order of your region points coordinates. In your current setup, modify the region points to:

region_points = [(w - 100, 0), (w - 100, h)]  # Vertical line from top to bottom

This will make objects moving from right to left count as "in" and left to right as "out". The direction is determined by the order of coordinates - the first point is considered the start and the second point the end of the counting line.

For additional details on region point configuration, see https://docs.ultralytics.com/guides/object-counting/.

[furiouskhan007]

region_points = [(w - 100, 0), (w - 100, h)]
I changes these points but results is always Person: in 0 and out 2?

[glenn-jocher]

To fix the counting direction, try reversing the y-coordinates in your vertical line points:

region_points = [(w - 100, h), (w - 100, 0)]  # Bottom to top for "in" from right side

This will count objects moving right-to-left as "in" and left-to-right as "out". The counting direction is determined by the order of points - the first point is considered the start of the line.

[moshiour]

Hi,

Object counting using function is very clean and easy to deploy. How do I get ride of printed output per frame info?
I do not want to print every frame info. Also, I have used verbose=False.
Here is my examplecode:

def count_objects_in_region(video_path, output_video_path, model_path):
"""Count objects in a specific region within a video."""
cap = cv2.VideoCapture(video_path)
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
# Video writer
#video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

region_points = [(800, 1200), (2080, 1204), (2080, 360), (800, 360)]
counter = solutions.ObjectCounter(
    show=False,
    region=region_points,
    
    show_in=False,  # Display in counts
    show_out=False,  # Display out counts
    persist=True,
    verbose=False,
    model=model_path,
    draw_tracks=False,
    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
   
    
    im0 = counter.count(im0)
    #video_writer.write(im0)
    
cap.release()
#return counter.in_count, counter.out_count
return counter.classwise_counts

vid_id = 1
in_video_path = vid_path[vid_id]
output_video_path = data_res + vid_path[vid_id].split("/")[-1].split(".")[-2] + ".avi"
res_cout = count_objects_in_region(in_video_path, output_video_path, model_path)

Here is output
Ultralytics Solutions: ✅ {'region': [(800, 1200), (2080, 1204), (2080, 360), (800, 360)], 'show_in': False, 'show_out': False, 'colormap': None, 'up_angle': 145.0, 'down_angle': 90, 'kpts': [6, 8, 10], 'analytics_type': 'line', 'json_file': None, 'show': False, 'model': '/data/forsmark_eel/training/segment_yolov11/eel_segment_v2/weights/best.pt', 'draw_tracks': False, 'line_thickness': 2, 'verbose': False, 'persist': True}
WARNING ⚠️ Environment does not support cv2.imshow() or PIL Image.show()
The DISPLAY environment variable isn't set.

0: 576x1024 3 sticklebacks, 14.4ms
Speed: 8.3ms preprocess, 14.4ms inference, 2.3ms postprocess per image at shape (1, 3, 576, 1024)

0: 576x1024 3 sticklebacks, 11.6ms
Speed: 6.3ms preprocess, 11.6ms inference, 1.9ms postprocess per image at shape (1, 3, 576, 1024)

0: 576x1024 1 stickleback, 11.2ms
Speed: 6.5ms preprocess, 11.2ms inference, 1.8ms postprocess per image at shape (1, 3, 576, 1024)

0: 576x1024 2 sticklebacks, 10.6ms
Speed: 6.2ms preprocess, 10.6ms inference, 1.7ms postprocess per image at shape (1, 3, 576, 1024)

Any suggestion would be great help. Thank you in advance!

[moshiour]

@RizwanMunawar

Hi, thanks for accepting the request. It it ready to update repo and use it?

[RizwanMunawar]

@moshiour Hi! Yes, it's ready to use. You can get started by running git clone https://github.com/ultralytics/ultralytics. Once the new Ultralytics version is officially released, it will be included, and you'll be able to install it directly with pip install ultralytics. We’re aiming to publish the new release today or tomorrow. Thank you!

[moshiour]

@RizwanMunawar Thanks a lot for updating. Its working the tag verbose. However, new warning appears
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!
WARNING ⚠️ no tracks found!

Is there anyway to suppress it?

Thank you in advance!

[RizwanMunawar]

@moshiour This is just a warning, and it displays, that there are no tracks found in the frame, you can disable it in the solutions.py.

ultralytics/ultralytics/solutions/solutions.py

Line 115 in 69c12a4

LOGGER.warning("WARNING ⚠️ no tracks found!")

[moshiour]

@RizwanMunawar Thanks a lot!

[leonidasavila]

Hi team! Excellent work, we are using YOLO in my startup https://www.linkedin.com/company/uiflou/

¿Can you help to count object with my own model? In which file i do the counter setup?
Thanks

The code:

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("produc.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Define region points
region_points = [(950, 100), (950, 600)]  # For line counting

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

# Init Object Counter
counter = solutions.ObjectCounter(
    show=True,  # Display the output
    region=region_points,  # Pass region points
    model="yolov8m_custom.pt",  # model="yolo11n-obb.pt" for object counting using YOLO11 OBB model.
    classes=[1, 2],  # If you want to count specific classes i.e person and car with COCO pretrained model.
    # show_in=True,  # Display in counts
    # show_out=True,  # Display out counts
    # line_width=2,  # Adjust the line width for bounding boxes and text display
)

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

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

[RizwanMunawar]

@leonidasavila Hi, what's the issue you are facing? Can you please share more information?

Thank you! 😊

[Martinnemo]

hi guys.

Thanks for an awesome job with all of ultralytics!

I'm having a problem where/ how to implement the conf and model.track in the code above ?
Can you help ? :)

[RizwanMunawar]

@Martinnemo Hi, the implementation for object counting is available at: https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/object_counter.py

Thank you! 😊

[Martinnemo]

I mean, i following code, how do i apply the confidence function:

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

Define region points

region_points = [(20, 400), (1080, 400)] # For line counting

region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)] # For rectangle region counting

region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360), (20, 400)] # For polygon region counting

Video writer

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

Init Object Counter

counter = solutions.ObjectCounter(
show=True, # Display the output
region=region_points, # Pass region points
model="yolo11n.pt", # model="yolo11n-obb.pt" for object counting using YOLO11 OBB model.
# classes=[0, 2], # If you want to count specific classes i.e person and car with COCO pretrained model.
# show_in=True, # Display in counts
# show_out=True, # Display out counts
# line_width=2, # Adjust the line width for bounding boxes and text display
)

Process video

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

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

[glenn-jocher]

To apply the confidence threshold (conf) to filter detections, you can pass it as a parameter when initializing the ObjectCounter. Here's an example:

counter = solutions.ObjectCounter(
    show=True,
    region=region_points,
    model="yolo11n.pt",
    conf=0.5  # Adjust the confidence threshold as needed
)

This will only count objects with a detection confidence score above the specified threshold (0.5 in this case). Let me know if you need further clarification!

[Juanrp7]

Hi everyone,

Which model would you recommend for tracking and counting objects using footage from a security camera located in a shopping mall?
Also, what are the minimum requirements to use it?

Thanks..!

[glenn-jocher]

@Juanrp7 for tracking and counting objects in a shopping mall, I recommend using YOLO11 with the ObjectCounter solution. It provides state-of-the-art accuracy and real-time processing, ideal for surveillance. Minimum requirements include a GPU with CUDA support for efficient inference. For implementation details, refer to the object counting guide: https://docs.ultralytics.com/guides/object-counting/.

[Sea-queue]

Hi, Is the Yolo11 Object Counting open source? I have a hard time to find the source code.

Generally, Yolo models are good out of box already, I just want to perform customized features and analysis. For example:

For the Yolo object detection, I want to get the raw data, e.g. for each frame of the testing video, I want to get the raw data such as classification, confidence score and bounding box values for each frame.

For the Object Counting, I want to read the code how the in and out and the affective region over all is defined when the target object cross it to increase the count.

It seems counting only when the center of the object is overlapping with the center of the effective region. And it ignores all the previous detections. I want to add weights to all the detection of the target object, so the counting won't rely on the only one frame.

Is there a way to retrieve the raw data on each frame? Does it track each object, too? I saw in the output, there is a trailing line for each object's moving path.

[glenn-jocher]

@Sea-queue the YOLO11 Object Counting functionality is not open source, as it is part of Ultralytics' proprietary solutions. However, you can use the ObjectCounter class to retrieve raw data such as classification, confidence scores, bounding box values, and track objects, including their movement paths. For implementing custom behaviors like weighted detection or adjusting the region logic, you would need to modify the provided API functionalities or consider an Enterprise License for access to specific use-case customizations. For more details, refer to the Object Counting documentation.