guides/region-counting/

[giscus[bot]]

guides/region-counting/

Object Counting in Different Region using Ultralytics YOLOv8

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

[genprokuror]

How to launch it in PYTHON? Why its code for bash script? I have no idea how launch it. I respect all developers and so on, but i cant uderstand how to launch and use it(
UNIX terminals showing nothing(

[AqsaRasheed]

the code does not show me a video or any interactive window for video playback where I can drag or move regions , it may be working on defaults position . Just it saving results on the following directory
D:\pyCharmProjects\ultralytics\examples\YOLOv8-Region-Counter\ultralytics_rc_output

[AqsaRasheed]

Got solution by myself .. Thank you

[pderrenger]

Hey there! 🎉 Glad to hear you found a solution on your own. If you have any insights or tips from your experience that you think could benefit others, feel free to share. And of course, if you run into any more questions or need further assistance down the road, don't hesitate to reach out. Happy coding with Ultralytics YOLOv8! 🚀

[felixho789]

what's your solution, I have no video or interactive window to me as well

[pderrenger]

If you're not seeing the video or interactive window, it might be defaulting to save mode. Ensure you're using the --view-img flag to display the video interactively. If the issue persists, try updating to the latest version of the Ultralytics package. Let me know if you need more help!

[adisa39]

how do I specify the counting region or box

[glenn-jocher]

Hey there! 👋

To specify a counting region or box for object counting with Ultralytics YOLOv8, you can interactively set the region during video playback. Simply click and drag using the left mouse button to move the region within the video. Here's a quick example on how to run the region counting:

python yolov8_region_counter.py --source "path/to/video.mp4" --save-img

This command will start the inference on your video, and you'll be able to adjust the counting region as needed. Don't forget, you can also specify other options like --weights for custom models or --classes to count specific object classes. 😊

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

[yeongnamtan]

I would like to do object counting for unattended items eg. on a train platform. How do I go about this because we do not know what those "unattended items" could be eg. it could be a parcel, bag or anything. Also how do i classify it as "unattended" (based on idle time?) ? Your advice is appreciated.

[glenn-jocher]

Hello!

Thank you for your question. To perform object counting for unattended items on a train platform, you can leverage Ultralytics YOLOv8's capabilities for object detection and tracking. Here’s a step-by-step approach to achieve this:

1. Object Detection: Use YOLOv8 to detect various objects such as parcels, bags, etc. Since you do not know the exact nature of the unattended items, you might want to train a model on a diverse dataset that includes various types of objects that could be left unattended.

2. Tracking and Idle Time Calculation: To classify an item as "unattended," you can track the detected objects over time and calculate their idle time. If an object remains stationary for a predefined duration, you can classify it as unattended.

Here’s a basic example to get you started:

Step 1: Install Required Libraries

Clone the Ultralytics repository, install dependencies, and navigate to the local directory:

# Clone Ultralytics repo
git clone https://github.com/ultralytics/ultralytics

# Navigate to the local directory
cd ultralytics/examples/YOLOv8-Region-Counter

Step 2: Run Region Counting Using Ultralytics YOLOv8

Execute the following basic commands for inference. You can interactively move the region within the video by clicking and dragging using the left mouse button:

# Save results
python yolov8_region_counter.py --source "path/to/video.mp4" --save-img

# Run model on CPU
python yolov8_region_counter.py --source "path/to/video.mp4" --device cpu

# Change model file
python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/model.pt"

# Detect specific classes (e.g., first and third classes)
python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 2

# View results without saving
python yolov8_region_counter.py --source "path/to/video.mp4" --view-img

Step 3: Implement Idle Time Tracking

You can modify the script to include logic for tracking objects and calculating their idle time. Here’s a simplified example:

import time
from collections import defaultdict

# Dictionary to store the last seen time of each object
object_last_seen = defaultdict(lambda: time.time())

# Function to update idle time
def update_idle_time(detections):
    current_time = time.time()
    for obj_id, bbox in detections.items():
        if obj_id in object_last_seen:
            idle_time = current_time - object_last_seen[obj_id]
            if idle_time > IDLE_THRESHOLD:
                print(f"Object {obj_id} is unattended for {idle_time} seconds")
        object_last_seen[obj_id] = current_time

# Call this function within your main loop where detections are processed

For more detailed guidance and examples, please refer to our Object Counting in Different Regions documentation.

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

[Anandukc]

Hey does it support conf argument. If no how can I add conf argument in the function in code. Or is there a alternative way to adjust the confidence value

[pderrenger]

Hey there! 👋 For adding a confidence threshold (conf) to your object counting in multiple regions using model.track, you don't need to modify the parse_opt() function directly. Instead, you can pass the conf argument directly when calling model.track in your script. Here's a quick example:

results = model.track(source="path/to/video.mp4", conf=0.25)

This sets the confidence threshold to 25%, filtering out detections below this confidence level. Adjust the 0.25 value as needed for your specific use case. Happy coding! 😊

[Anandukc]

How can I add a condition in object detection like 'if person is detected'

[pderrenger]

Hey there! 👋 To add a condition for detecting a person using YOLOv8, you can simply check if the class ID for 'person' (usually 0) is present in the detection results. Here's a quick example:

results = model.predict(source='path/to/image.jpg')
# Assuming 'person' class ID is 0
if any(detection.class_id == 0 for detection in results.detections):
    print("Person detected!")

This code snippet checks if any of the detected objects in the image have a class ID of 0 (which typically corresponds to 'person'). Adjust the class ID as needed based on your model's specific class labels. Happy coding! 😊

[Anandukc]

if any(detection.class_id == 0 for detection in results.detections):
^^^^^^^^^^^^^^^^^^
AttributeError: 'list' object has no attribute 'detections'

[pderrenger]

@Anandukc hey there! 😊 It looks like you're encountering an issue because you're trying to access detections directly from a list. When working with YOLOv8's predict results, try leveraging the .xyxy attribute for detections. For example, to check for a person (typically class ID 0):

results = model.predict(source='path/to/image.jpg')
# Convert results to numpy array and check for 'person'
if np.any(results.xyxy[0][:, -1] == 0):
    print("Person detected!")

This approach converts the predictions to a more accessible format, allowing you to check for specific class IDs.

Also, be sure to explore the Object Counting in Different Regions guide on our docs page for more detailed instructions on setting up region counting! 🚀

If you’ve got more questions, feel free to drop them here. Happy coding!

[mtalhaubaid]

I'm experiencing slow performance and lag when running 'yolov8_region_counter.py' with an RTSP stream as input, even though GPU utilization is confirmed. The script runs smoothly and quickly when using a webcam. I'm using an RTX 3090 graphics card. How can I resolve this issue?

[glenn-jocher]

Hey there! 🚀 It sounds like you're facing a bit of a performance snag with RTSP streams despite having a robust GPU setup. This could stem from network latency or the inherent variability in stream quality, which isn't as pronounced when using a direct webcam input.

One immediate thing you could try is adjusting the buffer size for the RTSP stream. You can do this by adding buffer size options (rtsp_transport tcp and buffer_size 102400) in your video source path like so:

# Add RTSP buffer options
source = "rtsp://yourstream?rtsp_transport=tcp&buffer_size=102400"

Another option is to experiment with reducing the frame rate of the input stream or pre-processing video frames to a lower resolution before feeding them into yolov8_region_counter.py, which can help to alleviate the load on your system.

If you're still facing issues, consider checking for any software updates for your NVIDIA drivers or CUDA Toolkit that might help optimize GPU utilization further.

Hope this helps get things running smoothly! Let us know how it goes. 😊

[JovRobinson]

Is it possible to count the region of just one particular class of our choice? And also possibly extract that count data to analysis?

[glenn-jocher]

Yes, it's definitely possible to count objects of a specific class within a region using Ultralytics YOLOv8! 🌟 You can filter the counts for just the class you are interested in by utilizing the --classes argument. Following that, you can extract this count data for further analysis quite easily.

Here's a quick example on how you could achieve this:

python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 --save-img

In this example, the --classes 0 argument specifies that you're interested in counting objects of class 0 (you can replace 0 with the class ID of your choice). This way, you get counts and visual results for just the specified class. For extracting the data, if the script outputs to the console you can redirect that to a file or modify the code to save the counts directly into a format you prefer (like CSV or JSON).

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

[rrodrigo0000]

Can you write the code to save the counts directly into a .CSV format?

[glenn-jocher]

Hey there! 👋 Sure, saving object counts directly to a CSV file is quite straightforward. Here's a quick example to get you started:

import csv

counts = {'class_0': 10, 'class_1': 5}  # Example object counts
with open('object_counts.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Class', 'Count'])
    for class_id, count in counts.items():
        writer.writerow([class_id, count])

This code snippet creates a file named object_counts.csv and writes the object counts for each class. You would replace the counts dictionary with the actual counts obtained from your script. Depending on your setup, you may already have class names or IDs and counts available after processing the video with YOLOv8. Just loop through and write them to the CSV as shown. 😊

Hope this helps! If you have any more questions or run into issues, feel free to ask.

[rrodrigo0000]

Great!! Thanks very much!!

[glenn-jocher]

Hey there! You're welcome! 🌟

If you're looking into diving deeper into region-specific object counting with YOLOv8, you might find the feature to select only specific classes particularly useful. For example, to count only certain classes in your video, use the --classes flag like so:

python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 2

This command will count objects belonging to classes 0 and 2. Don't forget, you can always tweak other parameters for your specific needs as outlined in the docs. If you need further help, feel free to ask!

Happy counting! 🚀

[rrodrigo0000]

Hello and thanks for your support!
How could I track a live webcam? Specifically, it would be on the page https://www.earthcam.com/world/ireland/dublin/?cam=templebar and save the results in .mp4 format?
I'm also interested in save the results in a .csv format

[pderrenger]

Hello! 🌟 We're thrilled to help you with your project.

To track objects from a live webcam and save the results, you typically need to stream the webcam feed into your application and then apply YOLOv8 model for object detection and tracking. For tracking objects on web pages like EarthCam, you might need additional tools to capture the feed unless there's a direct stream URL you can access. Saving the results in .mp4 and .csv formats involves a few more steps.

For capturing live webcam streams directly (like your laptop's webcam or an IP camera with a stream URL), you can use the --source 0 argument (for the first webcam) in the Ultralytics YOLO command. Saving the video in .mp4 and counting results in .csv will require custom code modifications.

Here's a simplified approach using Python:

1. Capture the Webcam Feed: If you have direct access to the stream, you can specify the source as the stream's URL. If it’s a webpage like EarthCam, consider using software to create a virtual webcam that mirrors that webpage or use a screen capturing tool and set it as the source.

2. Run Detection and Tracking: Modify the example code to save detection frames and object counts.

3. Save Results: Convert the frames to a video file using OpenCV and save counts to a CSV file.

import cv2
import pandas as pd

# Example code to initialize your model and set up tracking
# Note: Complete setup by loading model is needed

# Placeholder for counts
object_counts = []

cap = cv2.VideoCapture(0)  # Change '0' with your stream source
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640, 480))

while(cap.isOpened()):
    ret, frame = cap.read()
    if ret:
        # Your object detection and counting logic here
        # Modify object_counts as needed
        
        out.write(frame)
    else:
        break

# Save your CSV
df = pd.DataFrame(object_counts, columns=['Frame', 'Count'])
df.to_csv('object_counts.csv', index=False)

cap.release()
out.release()
cv2.destroyAllWindows()

Remember, saving the video this way requires detection and tracking logic to be integrated with your video processing loop. With regards to capturing streams from webpages, that's a more complex scenario that often involves dealing with cross-domain policies, and you may need to explore tools or services that can legally and ethically capture website content for such purposes.

Hope this points you in the right direction! If you're looking into directly capturing streams from web-based cams like EarthCam, it'd be essential to check their API or service offerings for accessing streams programmatically. Happy coding! 🚀

[rrodrigo0000]

perfect! thank you very much for your kind reply.

[pderrenger]

I'm glad you found the information helpful! 😊 If you have any more questions or need further clarification as you work on your project with Ultralytics YOLOv8, feel free to reach out.

For implementing object counting in different regions, you might find the provided command examples particularly useful. Here's a quick example to get you started with running the model on a video and saving the results:

python yolov8_region_counter.py --source "path/to/video.mp4" --save-img

And if you're looking to focus on specific classes:

python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 2

If you have any specific scenarios or setup questions, just drop a message. Happy coding! 🚀

[ZeeshanML]

How can I count cards in multiple regions with the custom count?

[glenn-jocher]

Hey there! To count cards in multiple specific regions using a custom setup with Ultralytics YOLOv8, you can adjust the region parameters and specify the target classes for detection. Here's a simple example to help guide you:

# Assuming you have set up your environment according to the docs
python yolov8_region_counter.py --source "path/to/your/video.mp4" --weights "path/to/your/model.pt" --classes [index_for_cards]

In this command:

• Replace "path/to/your/video.mp4" with the path to your video file.
• "path/to/your/model.pt" should be the path to your trained model.
• Replace [index_for_cards] with the class index(es) corresponding to the cards in your dataset.

To define multiple regions interactively, you could modify the region coordinates directly in your script or use the UI features to drag and adjust regions as needed during video playback (if supported by your implementation). If you need more specific guidance on setting this up, feel free to share more details about your setup! 😊

[cdd17]

How can I write the code to save the counts and directly print it?
And, how to use it in vscode, but not on the command lines?
THANKS!

[glenn-jocher]

Hello! To save and print the counts directly in your code, you can modify the script to include a print statement for the counts. Here’s a simple example on how you might adjust the script:

# After running the detection and counting
count = len(results)  # Assuming 'results' holds your counted objects
print("Object count:", count)

To use this in VSCode instead of the command line, you can open your Python script in VSCode and run it directly from the editor. Make sure you have the Python extension installed in VSCode, and you can run the script by right-clicking in the editor and selecting "Run Python File in Terminal".

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

[ZeeshanML]

How the object tracking will work if I have a same video from different camera shot or angle?
Will it not count the people who are already tracked and counted if the camera shot changes?

[glenn-jocher]

@ZeeshanML hello!

Great question! When dealing with object tracking across different camera angles or shots, there are a few considerations to keep in mind to ensure accurate counting and avoid double-counting:

1. Unique Identifiers: Each detected object is assigned a unique ID by the tracking algorithm. If the camera angle changes, the tracking algorithm might lose the object and reassign a new ID when it reappears in the new shot. This can lead to double-counting.

2. Multi-Camera Tracking: To handle multiple camera angles, you can use multi-camera tracking techniques. These techniques often involve synchronizing the cameras and using algorithms that can recognize and match objects across different views. This is more advanced and may require additional setup and calibration.

3. Region-Based Counting: If you are using region-based counting, ensure that the regions are well-defined and consistent across different camera angles. This can help in maintaining the continuity of object tracking.

Here’s a basic example of how you might set up a region-based counter with YOLOv8 in Python:

from ultralytics import YOLO

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

# Define the regions of interest
regions = [
    {"name": "Region 1", "coords": [(100, 100), (200, 200)]},
    {"name": "Region 2", "coords": [(300, 300), (400, 400)]}
]

# Function to check if a point is inside a region
def is_inside_region(point, region):
    (x, y) = point
    (x1, y1), (x2, y2) = region["coords"]
    return x1 <= x <= x2 and y1 <= y <= y2

# Process the video
video_path = "path/to/video.mp4"
results = model.track(video_path, persist=True)

# Count objects in each region
counts = {region["name"]: 0 for region in regions}
for result in results:
    for box in result.boxes:
        center = box.xywh[0:2]  # Get the center of the bounding box
        for region in regions:
            if is_inside_region(center, region):
                counts[region["name"]] += 1

# Print the counts
for region, count in counts.items():
    print(f"{region}: {count} objects")

This script sets up regions of interest and counts objects within those regions. You can adapt this to handle multiple camera angles by ensuring that the regions are consistent across different views.

For more advanced multi-camera tracking, you might need to look into additional libraries or techniques that support cross-camera object tracking.

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

[HugoLifes]

Its posible, detect the direction of an object like left, right ?

[glenn-jocher]

@HugoLifes hello!

Yes, it is possible to detect the direction of an object, such as left or right, using Ultralytics YOLOv8. This can be achieved by tracking the object's position across multiple frames and determining its movement direction based on the change in coordinates.

Here's a basic approach to achieve this:

1. Track Object Position: Use YOLOv8 to detect and track the object in each frame.
2. Calculate Direction: Compare the object's position in the current frame with its position in the previous frame to determine the direction of movement.

Below is a simplified example to illustrate this concept:

import cv2
from ultralytics import YOLO

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

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Initialize variables to store previous positions
prev_x, prev_y = None, None

# Loop through the video frames
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Run YOLOv8 inference on the frame
    results = model(frame)

    # Get the bounding box coordinates of the detected object
    for result in results:
        for box in result.boxes.xyxy:
            x1, y1, x2, y2 = box[:4]
            x_center = (x1 + x2) / 2
            y_center = (y1 + y2) / 2

            # Determine the direction of movement
            if prev_x is not None and prev_y is not None:
                if x_center > prev_x:
                    direction = "right"
                elif x_center < prev_x:
                    direction = "left"
                else:
                    direction = "stationary"
                print(f"Object is moving {direction}")

            # Update previous positions
            prev_x, prev_y = x_center, y_center

    # Display the frame with annotations
    cv2.imshow("YOLOv8 Direction Detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release the video capture object and close display window
cap.release()
cv2.destroyAllWindows()

This script captures video frames, runs YOLOv8 inference to detect objects, and calculates the direction of movement based on the change in the object's center position between consecutive frames.

For more detailed information and advanced usage, you can refer to our Object Counting in Different Regions guide.

If you encounter any issues or have further questions, feel free to provide more details or a minimum reproducible example, and we'll be happy to assist you further.

[felixho789]

Can I use my own trained model ?
If yes, How do I do that?

[pderrenger]

@felixho789 absolutely, you can use your own trained model for object counting in different regions with Ultralytics YOLOv8! Here's how you can do it:

1. Ensure Your Model is Ready: Make sure your custom-trained model is saved as a .pt file. This file should contain the weights of your trained model.

2. Specify the Model Path: When running the region counting script, use the --weights argument to specify the path to your custom model file.

Here’s an example command to run the region counting script with your custom model:

python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/your_model.pt"

Additional Tips:

• Detect Specific Classes: If you want to detect specific classes, use the --classes argument. For example, to detect the first and third classes:

  python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/your_model.pt" --classes 0 2

• Save Results: To save the results, add the --save-img argument:

  python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/your_model.pt" --save-img

Verify Compatibility:

Ensure you are using the latest version of the Ultralytics repository and dependencies to avoid any compatibility issues. You can update your local repository with:

git pull origin main

For more detailed instructions and additional options, you can refer to the Ultralytics Region Counting Guide.

If you encounter any issues, providing a minimum reproducible example can greatly help in diagnosing the problem. You can find more information on how to create one here.

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

[felixho789]

I tried to use my own trained model, and own video mp4.

the model is trained with only 1 classes.

It ended up with AttributeError: 'NoneType' object has no attribute 'id'.

What's that means and how do I fix it.

[felixho789]

I also no pop up window for the video

[pderrenger]

@felixho789 it sounds like there might be an issue with the model or the video file. The AttributeError: 'NoneType' object has no attribute 'id' typically means that the model didn't detect any objects, resulting in a None value where an object was expected. Ensure your model is correctly trained and the video source is valid. Also, make sure you're using the latest version of the Ultralytics package. If the issue persists, please provide more details or check the latest documentation for updates. For more information, visit Ultralytics Region Counting Guide.

[felixho789]

My model is trained well. It is functional just OBB detection without counting

However, when I tried to use yolov8_region_counter.py
it did not work.
so I am pretty sure the trained model is fine, and there is only 1 class.
The video might not have an object in the first few seconds.
There is no object in the first few seconds of the video I want to use counting.
Is that a problem?

if yes, how do I fix it?

Thank you for your time and assistance

this is my code used to run
:
C:\Users\Felix\ultralytics\examples\YOLOv8-Region-Counter>python yolov8_region_counter.py --source "ganglongvideo.mp4" --weights "best.pt" --view-img --classes 0

This is what it returned :

Polygon Counter Initiated.
0: 1280x1280 (no detections), 4.0ms
Speed: 9.1ms preprocess, 4.0ms inference, 16.7ms postprocess per image at shape (1, 3, 1280, 1280)
Traceback (most recent call last):
File "C:\Users\Felix\ultralytics\examples\YOLOv8-Region-Counter\yolov8_region_counter.py", line 32, in
im0 = counter.start_counting(im0, tracks)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Felix\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\solutions\object_counter.py", line 245, in start_counting
self.extract_and_process_tracks(tracks) # draw region even if no objects
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Felix\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\solutions\object_counter.py", line 151, in extract_and_process_tracks
if tracks[0].boxes.id is not None:
^^^^^^^^^^^^^^^^^^
AttributeError: 'NoneType' object has no attribute 'id'

[pderrenger]

It seems like the issue arises because there are no detections in the initial frames of your video. This can cause the tracks variable to be None, leading to the AttributeError. To fix this, you can add a check to handle cases where no objects are detected. Additionally, ensure your video source is valid and the model is correctly loaded. If the problem persists, try updating to the latest version of the Ultralytics package and see if the issue is reproducible. For more details, you can refer to the Ultralytics Region Counting Guide.

[felixho789]

Does the giving code only work with Detection? Does it work with OBB or instance segmentation??

[pderrenger]

The provided code primarily supports object detection. For OBB (Oriented Bounding Boxes) or instance segmentation, you might need to adapt the script to handle these specific tasks. The core functionality should remain similar, but the way objects are counted and regions are defined might require adjustments. If you encounter any issues, please ensure you're using the latest version of the Ultralytics package. For more details, you can refer to the region counting guide.

[felixho789]

How do I let it return more information,
it just give me processing time, detected or not detected.

Can I let it print object position for each object per frame?

I was using following code:

from ultralytics import YOLO

model = YOLO('best.pt')

results = model('ganglongvideo.mp4', show=True, save=True, stream=True)

for r in results:
boxes = r.boxes # Boxes object for bbox outputs
masks = r.masks # Masks object for segment masks outputs
probs = r.probs # Class probabilities for classification outputs

[pderrenger]

To print the position of each detected object per frame, you can access the bounding box coordinates from the boxes object. Here's a minimal example to get you started:

from ultralytics import YOLO

model = YOLO('best.pt')
results = model('ganglongvideo.mp4', show=True, save=True, stream=True)

for r in results:
    for box in r.boxes:
        print(f"Object position: {box.xyxy}")

This will print the coordinates of each detected object. If you encounter any issues, please ensure you're using the latest version of the Ultralytics package. For more details, refer to the region counting guide.