modes/track/

[giscus[bot]]

modes/track/

Learn how to use Ultralytics YOLO for object tracking in video streams. Guides to use different trackers and customise tracker configurations.

https://docs.ultralytics.com/modes/track/

[AdadAlShabab]

Can I run two models simultaneously in one video?
Ex:
model = YOLO('E:/Ultralytics/best.pt')
model = YOLO('yolov8m-pose.pt')
results = model.track(source="file.mp4", show=True, conf=0.3, save=False)
results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

[pderrenger]

@AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

import threading
from ultralytics import YOLO

# Load the models
model1 = YOLO('E:/Ultralytics/best.pt')
model2 = YOLO('yolov8m-pose.pt')

# Function to run tracking
def track_video(model, source, conf, show, save):
    results = model.track(source=source, show=show, conf=conf, save=save)
    # Process results here or return them

# Create threads for each model
thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))

# Start the threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

[Rid1Whitehead]

Hi,

First of all, I have been loving working with Yolov8. Great tool!

However, I have been having difficulties with a certain task. I want to use model.track on videos that I have, and then use save_crop = True, but save with a naming convention where I can track each persons ID. Currently, save_crop just gives me the cropped images of the objectes detected, but there is not way to know from which frame of the video are the crops, also, which ID is attached which cropped image. The visualization through cv2.imshow shows the IDs accross the different frames, but I cant find a way to save them. The naming convention I am looking for is something like this: "frame_30_ID_1.jpg" My current code looks something like this:

from ultralytics import YOLO
import cv2

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

video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

ret = True
frame_count = 0 # Initialize a frame counter

while ret:
ret, frame = cap.read()
frame_count += 1 # Increment the frame counter

# Check if the frame is the 30th frame
if ret and frame_count % 30 == 0:
    results = model.track(frame, persist=True, save_crop = True, save_txt = True)
    frame_ = results[0].plot()

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

cap.release()
cv2.destroyAllWindows()

Any help would be greatly apprecitated! Thanks!

[pderrenger]

@Rid1Whitehead hello! I'm glad to hear you're enjoying working with YOLOv8! 😊

For your task of saving cropped images with a specific naming convention that includes the frame number and ID, you'll need to customize the saving part of the code. The save_crop functionality in YOLOv8 does not currently support custom naming directly related to frame and ID out of the box.

Here's a modified version of your code that manually saves the cropped images with the desired naming convention:

from ultralytics import YOLO
import cv2
import os

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

video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

ret = True
frame_count = 0  # Initialize a frame counter
save_dir = "path/to/save/crops"  # Directory to save the crops
os.makedirs(save_dir, exist_ok=True)  # Create the directory if it doesn't exist

while ret:
    ret, frame = cap.read()
    frame_count += 1  # Increment the frame counter

    if ret:
        results = model.track(frame, persist=True)
        for i, det in enumerate(results[0].boxes.xyxy):
            # Extract bounding box coordinates
            x1, y1, x2, y2 = map(int, det[:4])
            crop = frame[y1:y2, x1:x2]  # Crop the detected object

            # Save the cropped image with the desired naming convention
            crop_name = f"frame_{frame_count}_ID_{results[0].boxes.id[i]}.jpg"
            crop_path = os.path.join(save_dir, crop_name)
            cv2.imwrite(crop_path, crop)

        frame_ = results[0].plot()

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

cap.release()
cv2.destroyAllWindows()

In this code, we loop through each detection in the current frame, extract the bounding box coordinates, crop the detected object from the frame, and save it with the naming convention you specified. Make sure to replace "path/to/save/crops" with the actual path where you want to save the cropped images.

Please note that this code assumes that the model.track() method returns the IDs in the results[0].boxes.id attribute. If the IDs are not available or the attribute name is different, you'll need to adjust the code accordingly.

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

[AdadAlShabab]

Hi @pderrenger . Can I run the models using my phones camera? Can you please share the code to invoke my mobile's camera to test the model? Thanks in advance.

[pderrenger]

@AdadAlShabab hi there! 👋 Yes, you can use your phone's camera to test the YOLO models. If you're looking to connect directly from your phone, you might need an app that can stream your camera feed to a URL. Then, you can use that URL as the source in the model.track() method. Here's a basic example of how you might set it up in Python:

from ultralytics import YOLO

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

# Replace 'your_stream_url' with the URL from your phone's camera stream
results = model.track(source='your_stream_url', show=True)

Make sure your phone and the computer running the model are on the same network. Happy tracking! 😊

[Liuchunxiao111]

There's no problem at all using your way, but when I use it, the video streaming latency is extraordinarily high, why is that?

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model= YOLO('weights/det/yolov8n.pt')

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

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

[pderrenger]

Hi there! 🙌 The high latency you're experiencing during video streaming might be due to a few factors. Here are a couple of things you could check or adjust to potentially reduce the latency:

1. Network Speed: If you're streaming the video over a network, ensure that your network connection is fast and stable. Camera streaming apps can sometimes consume a lot of bandwidth.

2. Frame Processing: The model's predictions and the layer of annotations being added to each frame can be computationally intensive. You could try to reduce the image size for detection or lower the frame rate to see if it helps.

3. Hardware Acceleration: If possible, make sure that your system is using any available hardware acceleration to speed up video decoding and model inference.

4. Less Compute-Intensive Model: If latency is still an issue, consider using a smaller, less compute-intensive YOLO model.

Here’s a quick example of reducing image size which might help speed up the process:

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('weights/det/yolov8n.pt')

# Reduce frames size to increase performance
def resize_frame(frame, scale=0.5):
    width = int(frame.shape[1] * scale)
    height = int(frame.shape[0] * scale)
    dimensions = (width, height)

    return cv2.resize(frame, dimensions, interpolation=cv2.INTER_AREA)

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    success, frame = cap.read()

    if success:
        # Resize frame
        frame = resize_frame(frame, scale=0.5)

        # Run YOLOv8 tracking on the frame
        results = model.track(frame, persist=True)

        # Visualize the results
        annotated_frame = results[0].plot()
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

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

cap.release()
cv2.destroyAllWindows()

This adjusts the frame size being processed, which could potentially reduce the latency you're experiencing. Hope this helps! 😊 If issues persist, feel free to provide more information about your setup.

[Liuchunxiao111]

@pderrenger Thanks for your reply!

What puzzles me is that when I use the first method, the picture is smooth and when I use the second method, the picture has a high latency, why is that? I don't think it's a network or hardware acceleration issue.

Way 1

from ultralytics import YOLO

# Load your trained model
model= YOLO('weights/det/yolov8n.pt')

# Replace 'your_stream_url' with the URL from your phone's camera stream
results = model.track(source="http://192.168.9.123:4747/video", show=True)

Way2

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model= YOLO('weights/det/yolov8n.pt')

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

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

[pderrenger]

Hey @Liuchunxiao111! 🌟 The difference in latency between the two methods might be due to how the frames are processed and displayed. In the first method, the model.track() function handles both the tracking and the frame retrieval internally, which is optimized for efficiency. In the second method, using OpenCV's VideoCapture and processing each frame in a loop with model.track() introduces overhead, especially if the frame processing isn't keeping up with the frame rate of the video stream.

To reduce latency in the second method, you might consider:

• Reducing the resolution of the video stream.
• Simplifying the model if possible, or using a lighter model.
• Ensuring that the code runs on the most capable hardware available (like using a GPU if available).

These tweaks can help align the processing speed more closely with the incoming frame rate, reducing the noticeable lag. Hope this helps! 😊

[Boaruzhanchik]

Hi, help me understand why I get this error when tracking with segmentation model . My ultimate goal is to use a custom car plate segmentation model for tracking. Thank you very much

  File "/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8_tracking_car_number/tracking_v4.py", line 80, in <module>
    annotated_frame = results[0].plot()
  File "/home/iosif/.local/lib/python3.10/site-packages/ultralytics/engine/results.py", line 239, in plot
    annotator.masks(pred_masks.data, colors=[colors(x, True) for x in idx], im_gpu=im_gpu)
  File "/home/iosif/.local/lib/python3.10/site-packages/ultralytics/utils/plotting.py", line 237, in masks
    self.im[:] = im_mask_np if retina_masks else ops.scale_image(im_mask_np, self.im.shape)
ValueError: could not broadcast input array from shape (384,640,3) into shape (568,1012,3)


from ultralytics import YOLO
import cv2
from collections import defaultdict
import numpy as np

class_list = [0, 2]
model = YOLO("/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8s-seg.pt")
cap = cv2.VideoCapture('/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8_tracking_car_number/reac_high_way2.mp4')
track_history = defaultdict(lambda: [])

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

    if success:
        results = model.track(frame, show=False, verbose=False, conf=0.4, classes=class_list, persist=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xywh.cpu()
            track_ids = results[0].boxes.id.cpu().numpy().astype(int)
            annotated_frame = results[0].plot()

            for box, track_id in zip(boxes, track_ids):
                x, y, w, h = box
                track = track_history[track_id]
                track.append((float(x), float(y)))
                if len(track) > 40:
                    track.pop(0)
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(annotated_frame, [points], isClosed=False, color=(0, 0, 255), thickness=5)
            cv2.imshow("YOLOv8 Tracking", annotated_frame)


            class_ids = []
            boxes_id = results[0].boxes.id
            if len(boxes_id) > 1:
                id_values = boxes_id.tolist()
            else:
                id_value = boxes_id.item()

            clss = results[0].boxes.cls.cpu().tolist()
            names = results[0].names
            for box, cls in zip(boxes_id, clss):
                class_ids.append(cls)
                if cls == 0.0:
                    print("People detect")

        

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

cap.release()
cv2.destroyAllWindows()

[pderrenger]

Hey there! 👋 It looks like you're encountering a shape mismatch error when plotting your tracking results. This often happens when the image dimensions don't align with the mask dimensions expected by the plot() function.

To resolve this, ensure that the image size you're using for tracking matches the size expected by the model. If you're using a custom model, double-check that the image size during training and inference is consistent.

Here's a quick fix you might try:

# Before plotting, resize your frame to match the model's expected input size
frame_resized = cv2.resize(frame, (model.imgsz[1], model.imgsz[0]))

# Now use the resized frame for tracking and plotting
results = model.track(frame_resized, show=False, verbose=False, conf=0.4, classes=class_list, persist=True)

Make sure to replace model.imgsz[1] and model.imgsz[0] with the actual width and height used during training if model.imgsz is not available.

Give this a shot, and if you're still stuck, feel free to share more details or reach out again! Happy tracking! 🚗💨

[Boaruzhanchik]

Thank you more for such a quick response, it worked

[glenn-jocher]

@Boaruzhanchik hey, that's awesome to hear it worked out for you! 🎉 If you dive into tracking with your custom car plate segmentation model and have any more questions or cool results to share, don't hesitate to reach out. Happy tracking! 🚗🔍

[Elvis-Kiilu2]

@glenn-jocher Hey, how do you implement with custom seg modem, kindly illustrate

[glenn-jocher]

Hey there! Implementing tracking with a custom segmentation model is pretty straightforward. You'll want to load your model and then use the track() method, specifying any particular classes you're interested in. Here's a quick example using a custom segmentation model for car plates:

from ultralytics import YOLO

# Load your custom segmentation model
model = YOLO('path/to/your/custom-seg-model.pt')

# Run tracking on your video source
results = model.track(source='path/to/your/video.mp4', classes=[your_car_plate_class_id])

Just replace 'path/to/your/custom-seg-model.pt' with the actual path to your model and your_car_plate_class_id with the class ID for car plates in your model. If you need more help or have specific questions, feel free to ask! 🚀

[potatoouoo]

Yolov8 has very high overall practicality. Can I implement tracking with two cameras? I hope that when a car tracked by camera A moves to camera B, its frame ID remains the same. However, currently there is always an ID switch happening. Is it because of the model's accuracy?
EX:
def cam1():
model = YOLO('updated-model.pt')
# cap.imgCap()
results = model.track(source="http://192.168.50.204:8080/?action=stream",show = True)
cv2.waitKey(0)
cv2.destroyAllWindows()

def cam2():
model = YOLO('updated-model.pt')
# cap.imgCap()
results = model.track(source="http://192.168.50.69:8080/?action=stream",show = True)
cv2.waitKey(0)
cv2.destroyAllWindows()

cap=cam

a = threading.Thread(target=cam1)
b = threading.Thread(target=cam2)

a.start()
b.start()

[glenn-jocher]

Hey there! Tracking continuity across multiple cameras, especially to maintain the same ID as an object moves from camera A to camera B, is indeed a complex task that involves more than just the accuracy of the model. It requires a method to correlate tracks across the different camera views, often referred to as multi-camera tracking or re-identification (Re-ID).

Regarding access to the global track ID or maintaining consistent IDs across cameras, it's correct that basetrack.py (or similar files, depending on the tracking implementation you're using) manages these IDs. However, for multi-camera setups, you might need to implement or use an existing Re-ID system that can match IDs based on features or appearance.

A simplistic approach could involve:

1. Extracting features of tracked objects.
2. Comparing features of new detections in the second camera with ongoing tracks from the first camera.
3. Assigning the same ID based on the similarity of the features.

This can get quite involved, as it requires managing the timing and spatial-correlation of detections across cameras, and the model's accuracy is just one of many factors.

For directly accessing or setting the track ID, if you're using a specific tracker that has its global track ID in basetrack.py, you might interact with it directly within your code (varying by implementation). However, multi-camera ID continuity typically requires a higher-level management system than what's provided in individual tracker files.

I hope that sheds a bit more light on it! Let me know if you delve into the re-identification approach or if you have other questions. 😊👍

[potatoouoo]

I have a new question, can I know the distance to the camera while tracking?

[glenn-jocher]

Hey there!

Regarding your question about knowing the distance to the camera while tracking, YOLOv8 or most object tracking algorithms, including those implemented in Ultralytics YOLO, primarily focus on detecting objects and potentially tracking their movement across frames. They don't inherently provide distance measurements since that would require additional depth-sensing hardware or methods.

However, if you have a calibrated camera setup or additional information about the scene, you might estimate distances using object sizes or other cues. For instance, in specific, controlled environments, the apparent size of known objects can give clues about distance based on their expected real-world size.

Alternatively, employing depth cameras or stereo vision setups can directly provide depth information. If using such sensors, depth data can be combined with tracking data to estimate distances of tracked objects.

I hope that helps a bit! If you're diving deeper into this, consider exploring topics like camera calibration, depth sensing technologies, and stereo vision. 😊📏🎥

[potatoouoo]

Hello, I would like to ask, my current tracking program is as shown below
retList2, frameTmp2 = cap2.imgCap()
results = model.track(frameTmp2,persist=True,show = True)

             if text2:
                 boxes = results[0].boxes.xywh.cpu()
                 if results[0].boxes.id is not None:
                     track_ids1 = results[0].boxes.id.int().cpu().tolist()
                     plate_info = tracker.get_plate_info()
                     print(plate_info)
                     time.sleep(1)

I need the X1X2Y1Y2 of the tracking frame in each frame to calculate the distance. Is there a way to get it?

[glenn-jocher]

Hello! To get the bounding box coordinates (X1, Y1, X2, Y2) for each tracked object, you can access the .xyxy attribute from the results object. Here’s how you can modify your code to print these coordinates along with the track IDs:

def cam1():
    global shard_track
    model = YOLO('updated-model.pt')
    shard_track = model.track(source="http://192.168.50.204:8080/?action=stream", show=True)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def track_and_print_cam1():
    global shard_track
    if hasattr(shard_track, 'xyxy'):
        for det in shard_track.xyxy[0]:  # Assuming shard_track is the results object
            x1, y1, x2, y2, conf, cls, track_id = det
            print(f'Track ID: {track_id.item()}, BBox: ({x1.item()}, {y1.item()}, {x2.item()}, {y2.item()})')
    else:
        print("No tracking data found.")

This modification ensures you're extracting the bounding box coordinates directly from the detection results, which should help you calculate distances or any other metrics based on the positions of the objects. If you have any more questions or need further assistance, feel free to ask! 😊

[samyak197]

Hey there,
First of all, I love working with YOLO , functionalities for basically everything.

          Currently i was working with a project that requires me to track different employee in a shop and was wandering if YOLO could help me assigning identities to each employees and if i t cpuld track for the entire working day.

[pderrenger]

@samyak197 hey there! 😊

Absolutely, YOLO can assist with tracking employees in a shop. You can use our tracking models to assign unique IDs and track them throughout the day. For long-term tracking, make sure your video feed is continuous and the model is configured for persistent tracking.

Here's a quick example using YOLOv8:

from ultralytics import YOLO

# Load your custom trained model or an official YOLOv8 model
model = YOLO('path/to/your/custom-model.pt')  # Custom trained model

# Track employees in a video
results = model.track(source="path/to/shop/video.mp4", persist=True)

This will keep the identities consistent across frames. For more details, check out our tracking documentation. If you have any more questions or need further assistance, feel free to ask. Happy tracking! 🚀

[ParkerLischwe]

Hi I saw that I can use an openvino IR format model just like any other pytorch model and then run tracking like normal. I was wondering how I would load the IR '.xml' and '.bin' files as arguments into YOLO(), or if I should load my model using openvino library? Thanks.

[glenn-jocher]

Hey there! 👋

To load OpenVINO IR '.xml' and '.bin' files into YOLO(), you'll want to simply point to their containing directory, i.e.:

from ultralytics import YOLO

# Load your YOLOv8 OpenVINO model
model = YOLO('path/to/yolov8n_openvino_model/')  # exported with YOLO('yolov8n.pt').export(format='openvino')

# Track employees in a video
results = model.track(source="path/to/shop/video.mp4", persist=True)

Once you have your model loaded with OpenVINO, you can then proceed with tracking as you would normally with the YOLO model. You might want to use stream=True also for longer videos and streams. If you need further assistance, feel free to ask. Happy tracking! 😊

[ParkerLischwe]

Will give this a try, appreciate the timely response!

[pderrenger]

@ParkerLischwe glad to hear you're giving it a try! If you have any questions or need a hand with the tracking setup, just drop a message. Happy tracking! 😊🚀

[ANIRUDH1080Z]

Can i use yolov8 model to track and reidentify person with same id assigned to it in multiple camera feed ?

[glenn-jocher]

@ANIRUDH1080Z yes, you can use YOLOv8 models for multi-object tracking across multiple camera feeds. Each detected person can be assigned a unique ID that persists as they move through the field of view of different cameras. You can choose from different trackers like BoT-SORT and ByteTrack, and even customize the tracker configurations to suit your specific needs. Here's a simple example using the default tracker:

from ultralytics import YOLO

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

# Perform tracking on a video source
results = model.track(source="path/to/camera_feed.mp4", show=True)

For tracking across multiple cameras, you might need to synchronize the cameras and handle the ID reidentification logic, as the trackers maintain IDs within a single video stream. If you have a custom solution or improvements, consider contributing to our Trackers section! 🚀

[ANIRUDH1080Z]

Thank u so much for enlightening me about this.

[glenn-jocher]

You're welcome! I'm glad the information was helpful. If you're looking to implement multi-object tracking across multiple camera feeds, you can certainly use YOLOv8 models. While YOLOv8 can assign unique IDs within a single video stream, tracking across multiple cameras (especially with non-overlapping fields of view) typically requires additional logic to handle ID reidentification.

For such cases, you might consider integrating your YOLOv8 tracking with a reidentification (ReID) system that can match IDs based on appearance features. Here's a simple example of how you might set up tracking for a single camera feed:

from ultralytics import YOLO

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

# Perform tracking on a video source
results = model.track(source="path/to/camera_feed.mp4", show=True)

For multi-camera setups, after tracking, you would extract features from detected objects and use a ReID model to match identities across different camera feeds.

If you're developing a solution or have improvements, we'd love to see your contributions to our tracking capabilities! 🚀

[kshweikeh]

How can we only track moving objects in the Plotting Tracks Over Time code:

from collections import defaultdict

import cv2
import numpy as np

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)

Store the track history

track_history = defaultdict(lambda: [])

Loop through the video frames

while cap.isOpened():
# Read a frame from the video
success, frame = cap.read()

if success:
    # Run YOLOv8 tracking on the frame, persisting tracks between frames
    results = model.track(frame, persist=True)

    # Get the boxes and track IDs
    boxes = results[0].boxes.xywh.cpu()
    track_ids = results[0].boxes.id.int().cpu().tolist()

    # Visualize the results on the frame
    annotated_frame = results[0].plot()

    # Plot the tracks
    for box, track_id in zip(boxes, track_ids):
        x, y, w, h = box
        track = track_history[track_id]
        track.append((float(x), float(y)))  # x, y center point
        if len(track) > 30:  # retain 90 tracks for 90 frames
            track.pop(0)

        # Draw the tracking lines
        points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
        cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

    # Display the annotated frame
    cv2.imshow("YOLOv8 Tracking", annotated_frame)

    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break
else:
    # Break the loop if the end of the video is reached
    break

Release the video capture object and close the display window

cap.release()
cv2.destroyAllWindows()

[kshweikeh]

I forgot to write "only " so its MOVING OBJECTS ONLY

[glenn-jocher]

@kshweikeh hey there! 👋 To track only moving objects, you can modify the code to calculate the displacement of each object between frames and only plot the tracks for those with significant movement. Here's a quick example of how you might do that:

# ... [previous code]

# Define a movement threshold (this value may need tuning)
movement_threshold = 5  # pixels

# Loop through the video frames
while cap.isOpened():
    # ... [previous code]

    # Get the previous and current center points
    for track_id in track_ids:
        if len(track_history[track_id]) >= 2:
            prev_center = track_history[track_id][-2]
            curr_center = track_history[track_id][-1]
            displacement = np.sqrt((curr_center[0] - prev_center[0]) ** 2 + (curr_center[1] - prev_center[1]) ** 2)

            # Only plot the track if the displacement is above the threshold
            if displacement > movement_threshold:
                points = np.array(track_history[track_id], dtype=np.int32).reshape((-1, 1, 2))
                cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

    # ... [previous code]

This snippet calculates the Euclidean distance between the previous and current positions of each tracked object and only draws the track if the object has moved more than the movement_threshold. You can adjust the threshold to fit the specifics of your scenario. Happy coding! 🚀

[kshweikeh]

Thanks!!

[glenn-jocher]

@kshweikeh hey there! 👋

Absolutely, happy to help! For tracking moving objects with YOLOv8, you can utilize the track method with a custom tracker configuration that focuses on objects with significant displacement between frames. Here's a quick snippet to get you started:

from ultralytics import YOLO

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

# Run the tracker
results = model.track(source='path/to/your/video.mp4', tracker='custom_tracker.yaml')

In your custom_tracker.yaml, you might want to adjust parameters that affect the detection of stationary vs. moving objects, such as minimum displacement thresholds or object persistence criteria.

If you need more guidance or have specific requirements, feel free to share, and we can dive deeper! 🚀

[RNVALA]

import cv2
from ultralytics import YOLO
import numpy as np

model = YOLO('yolov8_custom_train.engine', task="detect")

Path to the input video file

input_video_path = '/content/gdrive/MyDrive/yolov8-tensorrt/inference/output_video.mp4'

Path to the output video file

output_video_path = 'outputtest_video.mp4'

Define the coordinates of the polygon

polygon_points = [(670, 66), (1237, 550), (514, 1054), (161, 295)]
polygon_points = np.array(polygon_points)

Open the input video file

cap = cv2.VideoCapture(input_video_path)

Get video properties

frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

Define the codec and create VideoWriter object

fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))

Function for finding the centroid

def calculate_centroid(box):
x_min, y_min, x_max, y_max = map(int, box)
centroid_x = (x_min + x_max) // 2
centroid_y = (y_min + y_max) // 2
return (centroid_x, centroid_y)

Function to check if two bounding boxes overlap

def check_overlap(box1, box2):
x1_min, y1_min, x1_max, y1_max = map(int, box1)
x2_min, y2_min, x2_max, y2_max = map(int, box2)
overlap_x = max(0, min(x1_max, x2_max) - max(x1_min, x2_min))
overlap_y = max(0, min(y1_max, y2_max) - max(y1_min, y2_min))
overlap_area = overlap_x * overlap_y
return overlap_area

Read until video is completed

while cap.isOpened():
# Read a frame from the video
ret, frame = cap.read()

# If frame is read correctly ret is True
if not ret:
    break

results = model.track(source=frame, device=0)
# Extract bounding boxes, classes, names, and confidences
boxes = results[0].boxes.xyxy.tolist()
classes = results[0].boxes.cls.tolist()
names = results[0].names
confidences = results[0].boxes.conf.tolist()
#id=results[0].boxes.id
# Iterate through the results
red_area_count = 0
blue_area_count = 0
crowded_area_detected = False
crowded_box = None

for i, box1 in enumerate(boxes):
    overlap_count = 0
    for j, box2 in enumerate(boxes):
        if i != j:
            overlap_area = check_overlap(box1, box2)
            if overlap_area > 0:
                overlap_count += 1
                if overlap_count >= 2:
                    crowded_area_detected = True
                    if crowded_box is None:
                        crowded_box = box1
                    else:
                        crowded_box = [
                            min(crowded_box[0], box1[0]),
                            min(crowded_box[1], box1[1]),
                            max(crowded_box[2], box1[2]),
                            max(crowded_box[3], box1[3])
                        ]
                    break

for box, cls, conf in zip(boxes, classes, confidences):
    x1, y1, x2, y2 = box
    confidence = conf
    detected_class = cls
    name = names[int(cls)]
    
    if cv2.pointPolygonTest(polygon_points, calculate_centroid(box), False) >= 0:
        red_area_count += 1
        color = (0, 0, 255)
    else:
        color = (0, 255, 0)
        blue_area_count += 1

    x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
    cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
for i,det in enumerate(results[0].boxes.xyxy):
    x1, y1, x2, y2 = map(int, det[:4])
    cv2.putText(frame, f'ID: {results[0].boxes.id[i]}', (x1+5, y1+25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2, cv2.LINE_AA)
    
if crowded_area_detected:
    crowded_boxes = [box for box in boxes if check_overlap(crowded_box, box) > 0]
    x1, y1, x2, y2 = crowded_box
    for box in crowded_boxes:
        if box != crowded_box and check_overlap(crowded_box, box) > 0:
            x1 = min(x1, box[0])
            y1 = min(y1, box[1])
            x2 = max(x2, box[2])
            y2 = max(y2, box[3])
    cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 255), 2)
    cv2.putText(frame, 'Crowded Area', (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 255), 2)

font = cv2.FONT_HERSHEY_SIMPLEX

cv2.putText(frame, 'People working with attention - {}'.format(blue_area_count), (1125, 24), font, 1, (0, 255, 0), 2, cv2.LINE_AA)
cv2.putText(frame, 'People not working - {}'.format(red_area_count), (1124, 75), font, 1, (0, 0, 255), 2, cv2.LINE_AA)
cv2.line(frame, (668, 66), (1237, 550), (255, 0, 0), 2)
cv2.line(frame, (1237, 550), (515, 1052), (255, 0, 0), 2)

# Write the frame into the output video file
out.write(frame)

# Display the frame
# cv2_imshow(frame)

# Press Q on keyboard to exit
if cv2.waitKey(25) & 0xFF == ord('q'):
    break

Release video objects

cap.release()
out.release()

Close all OpenCV windows

cv2.destroyAllWindows()

In this, I am tracking a label Person but in the next 2 to 3 frames, ids are changing so any solution for this?
means if person having id 1, so after few frame it give as id 3, and every time the id is changing

[pderrenger]

Hey there! 👋 It looks like you're experiencing some ID consistency issues with your custom-trained model during tracking. This can happen due to various reasons, such as similar-looking objects or occlusions.

One approach to mitigate this is to fine-tune your tracker's hyperparameters. If you're using the default BoT-SORT tracker, you might want to experiment with the bytetrack.yaml configuration, which is designed to handle ID switches more robustly. Here's a quick example of how to switch to ByteTrack:

from ultralytics import YOLO

# Load your custom-trained model
model = YOLO('yolov8_custom_train.engine', task="detect")

# Perform tracking with ByteTrack
results = model.track(source="your_video.mp4", tracker="bytetrack.yaml")

If you've already tried adjusting the tracker settings and the issue persists, consider revisiting your training dataset to ensure it's diverse and representative enough to handle the scenarios where ID switches occur.

Keep us posted on your progress, and if you need more assistance, we're here to help! 😊

[RNVALA]

I have already used the bytetrack.yaml and this is ouput video , https://drive.google.com/file/d/1E95m456dbZAUDRrodfrvrsSA4zcs3KiA/view?usp=sharing , please analyze it

[pderrenger]

Hey there! Thanks for reaching out and sharing the video link. 🎥 I took a look, and it seems like the ID switches might be due to occlusions or similar-looking objects. Here are a couple of quick suggestions:

1. Tweak the IOU Threshold: Adjust the iou_thresh parameter in your bytetrack.yaml to a value that might help in maintaining consistent IDs.
2. Increase Detection Confidence: A higher conf_thresh could reduce false positives, which sometimes cause ID confusion.

If you've already fine-tuned these without success, consider:

• Re-training with Augmented Data: More varied training data can improve tracking robustness.
• Post-Processing: Implement a custom ID management system in post-processing to smooth out ID switches.

If you're still facing issues, feel free to share more details or reach out for further assistance. We're here to help! 😊👍

[Dmonzer]

What is the difference between these attributes of results[0].boxes:
xywh: tensor([], size=(0, 4))
xywhn: tensor([], size=(0, 4))
xyxy: tensor([], size=(0, 4))
xyxyn: tensor([], size=(0, 4))

[glenn-jocher]

Hey there! 👋 The attributes you're asking about represent different formats of bounding box coordinates:

• xywh: Bounding boxes in (center x, center y, width, height) format.
• xywhn: Normalized (center x, center y, width, height), with values from 0 to 1 relative to image size.
• xyxy: Bounding boxes in (top left x, top left y, bottom right x, bottom right y) format.
• xyxyn: Normalized (top left x, top left y, bottom right x, bottom right y), with values from 0 to 1.

The tensors being empty (size=(0, 4)) suggests no detections were made in the frame. If you have further questions or need assistance, feel free to ask! Happy coding! 😊

[WooFy11]

is it possible to use our own weighs as a model to track? or we must include the yolov8n.pt?

[pderrenger]

Absolutely, you can use your own custom weights for tracking! Just load your trained model instead of the default yolov8n.pt. Here's a quick example in Python:

from ultralytics import YOLO

# Load your custom trained model
model = YOLO('path/to/your/custom-weights.pt')

# Perform tracking with your model
results = model.track(source="path/to/your/video.mp4", show=True)

And that's it! Your custom model will now be used for tracking objects in your video stream. 🚀 If you have any more questions or need further assistance, feel free to ask. Happy tracking!

[WooFy11]

do you a discord so we can discuss about my project?

[pderrenger]

Hey there! 👋 We don't have an official Discord channel, but we're happy to help you right here or on our GitHub discussions page. If you have any questions about your project or need assistance with object tracking using YOLOv8, feel free to drop your questions, and we'll do our best to assist you! 🚀 If it's code-specific, you can also share snippets or error messages, and we'll take a look. Happy tracking!

[WooFy11]

i had an error when everytime i try to run a code, it crashed on 4xx/600, and i must restart it, and 2nd question can we make a custom annotator?

[pderrenger]

Hey there! 👋 It sounds like you're encountering a crash during your code execution. To better assist you, could you please share the specific error message you're getting? This will help us pinpoint the issue more accurately.

Regarding your second question, yes, you can create a custom annotator. If you're working with YOLOv8, you can use tools like CVAT or LabelImg for annotation, and then train your model with these custom annotations. Here's a quick example of how you might load and use your custom model for tracking:

from ultralytics import YOLO

# Load your custom trained model
model = YOLO('path/to/your/custom_model.pt')

# Perform tracking on your video
results = model.track(source='path/to/your/video.mp4', show=True)

This will use your custom weights for tracking objects in the video. If you have any more questions or need further assistance, feel free to ask! 🚀

[tumitoto007]

So I am using Yolov8 for my current project, it's been a breeze so far. I do have a question on the tracking method provided by the Yolov8. When I am using the generic yolov8n model(or even a custom model mixed with few objects), I know I can specifically filter out things that doesn't interest me by their ID as below:

    for data in .....boxes.data.tolist():
            # extract the id associated with the detection
            objectID= data[5]
   if not interested skip this object....

But, when I caught the an object that I am interested, can I at that time or at that frame, issue a track command to start tracking it? if it can be done, can you tell me how? an short example will be even better! thanks in advance.

[glenn-jocher]

@tumitoto007 hey there! 😊 It's great to hear that YOLOv8 has been a breeze for your project. Regarding your question about initiating tracking on a specific object at a certain frame, YOLOv8's tracking functionality is designed to automatically track all detected objects continuously across frames. However, if you're interested in tracking a specific object after its detection, you can filter detections by their IDs as you've mentioned and then focus on tracking that specific object ID across the frames.

Here's a simplified example to illustrate how you might approach this:

from ultralytics import YOLO

# Load your model
model = YOLO('yolov8n.pt')  # or your custom model

# Assuming you're processing video frames in a loop
interested_object_id = None  # Placeholder for the ID of the object you're interested in tracking
for frame in video_frames:
    results = model.track(frame, persist=True)
    for box in results[0].boxes:
        objectID = box.id.item()  # Get the ID of the current object
        if objectID == interested_object_id:
            # This is the object you're interested in, now you can track it specifically
            # Process the tracking data as needed
            pass

In this example, interested_object_id should be set to the ID of the object you're interested in tracking once you've identified it. From that point on, you can specifically process or track that object in subsequent frames.

Remember, the tracking starts automatically for all detected objects, so the key is filtering and focusing on the object of interest in your processing loop.

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

[tumitoto007]

Cool! I will give this a try once I get back to town. Thanks again for your great support.

[glenn-jocher]

Hey there! 🎉 I'm thrilled to hear you're planning to give tracking a try with YOLOv8 once you're back in town. It sounds like you're on an exciting journey with your project! If you have any questions or need further assistance when you dive into it, don't hesitate to reach out. Our community and docs are here to support you every step of the way. Happy tracking, and safe travels back to town! 🚀

[KhizarHashmi]

Hi, I want some detailed help and guidance on how to use custom tracker models with my custom yolov8 pose model, the Re-identification problem is being face using bytetrack.yaml so I think I should use StrongSORT or DeepSORT. Therefore, I want the ultralytics team to help me on selecting my tracker model or use multiple tracker models, and guide me properly on how to use them with my YOLOv8 custom trained model.
Thanks

[KhizarHashmi]

@glenn-jocher

[glenn-jocher]

@KhizarHashmi hi there! 👋 It sounds like you're exploring advanced tracking options for your custom YOLOv8 pose model. If ByteTrack isn't meeting your re-identification needs, exploring StrongSORT or DeepSORT could indeed be beneficial. These trackers offer sophisticated mechanisms for handling occlusions and maintaining identity across frames, which might be what you're looking for.

To integrate a custom tracker like StrongSORT or DeepSORT with your YOLOv8 model, you'll typically need to:

1. Ensure your tracker can process the detection output format of YOLOv8. This usually involves bounding box coordinates, confidence scores, and class IDs.
2. Modify your tracking script to use the YOLOv8 model for detection, feeding these detections into your chosen tracker for each frame of your video.

Here's a simplified example of how you might set this up in Python, assuming you have a function custom_tracker that takes detections and returns tracked objects:

from ultralytics import YOLO

# Load your custom trained YOLOv8 model
model = YOLO('path/to/your/custom_model.pt')

# Function to perform detection and tracking on a frame
def detect_and_track(frame):
    # Perform detection
    results = model(frame)
    
    # Extract detections (example format, adjust as needed)
    detections = results.pandas().xyxy[0]  # DataFrame of detections
    
    # Perform tracking with your custom tracker
    tracked_objects = custom_tracker(detections)
    
    return tracked_objects

# Example usage with a video stream
# ... video capture setup here ...
while True:
    ret, frame = cap.read()
    if not ret:
        break
    tracked_objects = detect_and_track(frame)
    # ... visualization and further processing here ...

Regarding using multiple trackers, it's possible to switch between trackers based on the scenario or even combine their strengths, though this can get complex. You might start with one tracker and evaluate its performance thoroughly before experimenting with combining them.

For more detailed guidance on integrating specific trackers or handling complex tracking scenarios, the documentation and community forums for those trackers can be valuable resources. Additionally, our Ultralytics Docs provide further insights into tracking configurations and options.

If you're developing new tracking capabilities or have insights to share, we'd love to see your contributions to our GitHub repo. Your expertise could greatly benefit the YOLO and tracking community! 🚀

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

[Vinrub]

import random
import cv2
import numpy as np
from ultralytics import YOLO

opening the file in read mode

my_file = open("utils/coco.txt", "r")

reading the file

data = my_file.read()

replacing end splitting the text | when newline ('\n') is seen.

class_list = data.split("\n")
my_file.close()

Generate random colors for class list

detection_colors = []
for i in range(len(class_list)):
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
detection_colors.append((b, g, r))

load a pretrained YOLOv8n model

model = YOLO("weights/yolov8n.pt", "v8")

Vals to resize video frames | small frame optimise the run

frame_wid = 640
frame_hyt = 480

def CarBehaviour(frame, color_threshold=1100):
# Convert the frame to HSV for color thresholding
hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

# Define the lower and upper bounds for the color of the rear lights (adjust as needed)
lower_color = np.array([0, 100, 100])  # Lower bound for red color
upper_color = np.array([10, 255, 255]) # Upper bound for red color

# Create a mask using the inRange function to threshold the color
mask = cv2.inRange(hsv_frame, lower_color, upper_color)

# Calculate the number of nonzero pixels in the mask
color_pixels = cv2.countNonZero(mask)

# Check if color pixels are present
if color_pixels > color_threshold:
    return True, 'Braking'  # If color threshold is met, indicate braking
else:
    return False, 'Not Braking'  # Otherwise, indicate not braking

def detect_and_draw(frame, model, class_list, detection_colors):
# Predict on image
detect_params = model.track(source=[frame], conf=0.45, save=False)

# Convert tensor array to numpy
DP = detect_params[0].cpu().numpy()

if len(DP) != 0:
    for i in range(len(detect_params[0])):
        boxes = detect_params[0].boxes
        box = boxes[i]  # returns one box
        clsID = box.cls.cpu().numpy()[0]
        conf = box.conf.cpu().numpy()[0]
        bb = box.xyxy.cpu().numpy()[0]

        cv2.rectangle(
            frame,
            (int(bb[0]), int(bb[1])),
            (int(bb[2]), int(bb[3])),
            detection_colors[int(clsID)],
            3,
        )

        # Display class name and confidence
        font = cv2.FONT_HERSHEY_COMPLEX
        cv2.putText(
            frame,
            class_list[int(clsID)] + " " + str(round(conf, 3)) + "%",
            (int(bb[0]), int(bb[1]) - 10),
            font,
            1,
            (255, 255, 255),
            2,
        )

# Check car behavior
is_braking, behavior = CarBehaviour(frame)
# Display car behavior
cv2.putText(
    frame,
    "Car Behavior: " + behavior,
    (50, 50),
    cv2.FONT_HERSHEY_SIMPLEX,
    1,
    (0, 255, 0),
    2,
    cv2.LINE_AA,
)

Open video capture

cap = cv2.VideoCapture("/home/opencv_env/Vehicle-rear-lights-analyser-master/testing_data/road_2.mp4")

if not cap.isOpened():
print("Cannot open camera")
exit()

while True:
# Capture frame-by-frame
ret, frame = cap.read()
# if frame is read correctly ret is True

if not ret:
    print("Can't receive frame (stream end?). Exiting ...")
    break

#  resize the frame | small frame optimise the run
# frame = cv2.resize(frame, (frame_wid, frame_hyt))

# Detect and draw objects
detect_and_draw(frame, model, class_list, detection_colors)

# Display the resulting frame
cv2.imshow("ObjectDetection", frame)

# Terminate run when "Q" pressed
if cv2.waitKey(1) == ord("q"):
    break

When everything done, release the capture

cap.release()
cv2.destroyAllWindows()
in this code can i add tracking id number using yolov8

[glenn-jocher]

Absolutely, you can add tracking IDs to your detections using YOLOv8! 🚀 To do this, you'll want to utilize the track method available in the Ultralytics YOLO API. This method not only performs object detection but also assigns unique IDs to each detected object, allowing you to track their movement across frames.

Here's a simplified example to get you started:

from ultralytics import YOLO

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

# Assuming 'frame' is your input frame
results = model.track(source=[frame])

# Now, each detected object in 'results' has a unique tracking ID
for det in results[0].boxes:
    # Extract tracking ID
    track_id = det.id.cpu().numpy()
    print(f"Tracking ID: {track_id}")

This will print the tracking ID for each detected object in the frame. Make sure to loop over your video frames to continuously track objects. Happy tracking! 🎉

[devonFowler]

Is there a way to change the text color or remove a bounding box and label background color. An object is occasionally displayed in White with White text, which is not visible on the image displayed.

All suggestions are appreciated.

[pderrenger]

@devonFowler hi there!

To address the issue of text and bounding box colors blending into the background, you can customize the appearance of the annotations. Here’s how you can modify the text color and remove the background color for bounding boxes and labels:

Customizing Text and Bounding Box Colors

You can use the plot() method from the Results object to customize the appearance of your annotations. Here’s an example of how to change the text color and remove the background color:

from ultralytics import YOLO
import cv2

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

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

# Loop through the video frames
while cap.isOpened():
    success, frame = cap.read()
    if success:
        # Run YOLOv8 tracking on the frame
        results = model.track(frame, persist=True)

        # Customize the plot
        for result in results:
            annotated_frame = result.plot(
                line_width=2,  # Set the line width of bounding boxes
                font_size=1,   # Set the font size
                font='Arial.ttf',  # Set the font type
                color=(0, 0, 255),  # Set the text color to red (BGR format)
                background=False  # Remove background color
            )

        # Display the annotated frame
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

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

In this example:

• color=(0, 0, 255) sets the text color to red. You can change the BGR values to any color you prefer.
• background=False removes the background color from the text labels.

Additional Customization Options

You can further customize the appearance by adjusting other parameters such as line_width and font_size to better suit your needs.

For more detailed information on tracking and customization, you can refer to the Ultralytics YOLO Tracking Documentation.

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

[Kunal8020]

I am tracking five small objects that are being transferred from one bowl to another using a grasping instrument. I need to detect if an object falls from the instrument during the transfer. I am using Ultralytics YOLO for tracking, but I encounter an issue: during the transfer, when an object is held by the instrument or falls, it changes its ID and assigns a new one. This ID change is preventing me from proceeding further. How can I address this issue and ensure consistent tracking of the objects?

[pderrenger]

@Kunal8020 it sounds like you're encountering an issue with object ID consistency during tracking, which is crucial for your application. This ID switching can happen due to the tracker losing the object temporarily, especially when it's occluded or changes appearance significantly.

To address this, you might want to fine-tune the tracking parameters. For instance, increasing the track_high_thresh can help maintain the same ID by ensuring the tracker is more confident before assigning a new ID. Additionally, using the persist=True argument can help the tracker maintain IDs across frames more effectively.

Here's a quick example of how you might adjust these settings:

from ultralytics import YOLO

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

# Run tracking with adjusted parameters
results = model.track(source="path/to/your/video.mp4", conf=0.3, iou=0.5, persist=True, track_high_thresh=0.7, show=True)

If you haven't already, ensure you're using the latest version of the Ultralytics package, as updates often include improvements and bug fixes that could resolve your issue. For more detailed configurations, you can refer to the Ultralytics tracking documentation.

[vivekpayasi]

I see that the examples here are using multi-threading for concurrent processing, but would that be necessary if have a GPU which can handle processing in parallel rather than in concurrency.

Maybe I'm missing something.

I'm trying to process (track) in multiple streams with access to one Nvidia GPU. And I have the following questions:

1. Does it support parallel processing (not concurrent) of multiple streams in a single GPU?
2. How can we identify how many streams it can process given single GPU?
3. Should we integrate the YOLO model (post exporting to tensorRT) with DeepStream? Will it make the inference considerably faster? Or is it on par with Ultralytics/YOLO's native support?
4. Since model.predict or model.track can take multiple streams/videos as input, do we need to explicitly loop through every frame? These functions also provide additional params like vid_stride, stream=True, saving the annotated video etc. which are very useful. So I was wondering if we really need to loop through the frames via cv2, and if we can give the paths directly to these functions.

Any help would be much appreciated. Thanks!

[glenn-jocher]

@vivekpayasi great questions!

1. Yes, YOLOv8 supports parallel processing of multiple streams on a single GPU. The GPU handles the computations in parallel, which can be more efficient than multi-threading on the CPU.
2. The number of streams your GPU can handle depends on its memory and compute capabilities. Monitoring GPU utilization during processing can help determine the optimal number of streams.
3. Integrating with DeepStream can indeed speed up inference, especially with TensorRT optimizations. DeepStream is designed for high-throughput applications and can offer performance benefits over native YOLO.
4. You don't need to loop through frames manually. model.track can handle video streams directly, and parameters like vid_stride and stream=True are designed to optimize this process.

For more details, check out our tracking documentation.

[vivekpayasi]

@glenn-jocher Thanks for your reply.

I tried the following code by giving .streams file which contains paths to 5 videos.

model = YOLO("yolov8x-worldv2.pt")
classes_list = ["person", "helmet", "gloves", "mask", "shoes", "glasses"]
model.set_classes(classes_list)
model.to('cuda')

results = model.track(source='video_sources.streams',
                      half=True, device='cuda:0',
                      stream=True, show=False, vid_stride=vid_stride)

frame_idx = 0
for result in results:
    check_ppe_compliance(result, frame_idx)
    frame_idx += 1

But only the first frames of each video seem to be processed, not the rest of the frames of the videos. (ss attached)

Am I doing this correctly?

Shall I spawn a separate thread for each stream/video and initialize a model for each thread, because I've seen this way in many docs and examples? What is the difference between giving the .streams file directly vs spawning a thread for each stream separately?

Thanks!

[Orziqulov-Javohir]

I really need help to do this programm:
I wanna select region via mouse "dangerous zone"
Track detected person, If person enters this zone crop and save person's photo
Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI

[Orziqulov-Javohir]

It is kind a security program detecting who entered zone

[Orziqulov-Javohir]

import cv2
from ultralytics import YOLO
import time

Load the YOLOv8 model

model = YOLO("yolov8n.pt") # pretrained YOLOv8n model

Initialize video capture for multiple cameras

camera_ids = [

'rtsp://admin:admin12345@172.17.67.20:554',

'rtsp://admin:admin12345@172.17.67.16:554',
'rtsp://admin:admin12345@172.17.67.18:554',
'rtsp://admin:admin12345@172.17.67.19:554',
'rtsp://admin:admin12345@172.17.67.17:554',
'rtsp://admin:admin12345@172.17.67.21:554',
'rtsp://admin:admin12345@172.17.67.17:554',
'rtsp://admin:admin12345@172.17.67.21:554',
'rtsp://admin:admin12345@172.17.67.17:554',
]

caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

Open the video file

roi_start = [(0, 0)] * len(caps)
roi_end = [(0, 0)] * len(caps)
drawing = [False] * len(caps)

tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones

def draw_rectangle(event, x, y, flags, param):
global roi_start, roi_end, drawing
idx = param # Use param to identify the camera index
if event == cv2.EVENT_LBUTTONDOWN:
drawing[idx] = True
roi_start[idx] = (x, y)
roi_end[idx] = (x, y)
print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}")
elif event == cv2.EVENT_MOUSEMOVE:
if drawing[idx]:
roi_end[idx] = (x, y)
print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}")
elif event == cv2.EVENT_LBUTTONUP:
drawing[idx] = False
roi_end[idx] = (x, y)
print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

Create a window and set mouse callback for each camera

for idx in range(len(caps)):
window_name = f'Video {idx}'
cv2.namedWindow(window_name)
cv2.setMouseCallback(window_name, draw_rectangle, idx)

def is_inside_roi(x, y, roi_start, roi_end):
x1, y1 = roi_start
x2, y2 = roi_end
return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

while True:
frames = []
for cap in caps:
ret, frame = cap.read()
if not ret:
continue
# frame = cv2.resize(frame, (640, 480))
frames.append(frame)

for idx, frame in enumerate(frames):
    window_name = f'Video {idx}'
    
    # Draw the ROI rectangle on the frame
    if drawing[idx] or roi_start[idx] != roi_end[idx]:
        cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
        cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

    # Run YOLOv8 tracking on the frame, persisting tracks between frames
    results = model.track(frame, tracker="bytetrack.yaml", persist=True)

    for result in results:
        boxes = result.boxes

        for box in boxes:
            x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
            cls = box.cls.tolist()[0]
            if cls == 0:  # Person class in COCO dataset
                # Check if the center of the person is inside the ROI
                cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):
                    # Check if this person is already tracked
                    person_id = box.id.tolist()[0] if box.id is not None else None
                    
                    if person_id not in tracked_persons[idx]:
                        tracked_persons[idx].append(person_id)
                        # Crop and save the frame
                        crop = frame[int(y1):int(y2), int(x1):int(x2)]
                        cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                        # Draw a label on the person
                        cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                        cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)

    cv2.imshow(window_name, frame)

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

Release all video captures

for cap in caps:
cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

Your approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!

[mariem158]

import cv2
import numpy as np
import pandas as pd
from ultralytics import YOLO
from collections import defaultdict
from google.colab.patches import cv2_imshow
from google.colab import drive
from google.colab import files
import os
import math

Mount Google Drive

drive.mount('/content/drive')

Camera calibration parameters (example values, should be adjusted for your camera)

fx, fy, cx, cy = 1000, 1000, 640, 360 # Example values for focal lengths and optical centers
k1, k2, p1, p2, k3 = 0, 0, 0, 0, 0 # Example distortion coefficients
camera_matrix = np.array([[fx, 0, cx],
[0, fy, cy],
[0, 0, 1]])
dist_coeffs = np.array([k1, k2, p1, p2, k3])

Homography matrix (example values, should be derived from calibration)

H = np.array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])

Function to convert pixels to meters

def pixel_to_meter(x, y, H):
point = np.array([x, y, 1])
world_point = np.dot(H, point)
world_point = world_point / world_point[2]
return world_point[0], world_point[1]

Function to apply a simple moving average

def moving_average(data, window_size):
return np.convolve(data, np.ones(window_size)/window_size, mode='valid')

Function to interpolate missing frames

def interpolate(data, timestamps):
data_interpolated = []
timestamps_interpolated = np.arange(timestamps[0], timestamps[-1], 1/fps)

for i in range(len(data[0])):
    series = [point[i] for point in data]
    series_interpolated = np.interp(timestamps_interpolated, timestamps, series)
    data_interpolated.append(series_interpolated)

return list(zip(*data_interpolated)), timestamps_interpolated

Load the YOLOv8 model trained on VisDrone dataset

model_path = "/content/drive/MyDrive/drone/runs/detect/train3/weights/best.pt"
model = YOLO(model_path)

Open the video file

video_path = "/content/drive/MyDrive/drone/les résultats/vidéojdidzone1.mp4"
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
print(f"Erreur lors de l'ouverture de la vidéo {video_path}")
exit()

fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

Create a VideoWriter object to save the output video

fourcc = cv2.VideoWriter_fourcc(*'mp4v')
output_video_path = '/content/drive/MyDrive/drone/les résultats/video_outputzon1.mp4'
out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))

Drone altitude

drone_height = 100 # meters

Camera field of view

fov_degrees = 62.2
fov_radians = np.deg2rad(fov_degrees)

Calculate the visible width in meters at the given altitude

visible_width = 2 * (drone_height * np.tan(fov_radians / 2))
conversion_factor = visible_width / width

Dictionary to store vehicle information

vehicle_data = defaultdict(lambda: {'timestamps': [], 'positions': [], 'speeds': [], 'accelerations': []})

Vehicle class IDs (based on YOLO's COCO dataset)

vehicle_classes = {2, 3, 5, 8} # COCO classes: car, motorcycle, bus, truck
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break

frame_number = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
results = model.track(frame, persist=True, tracker="/content/drive/MyDrive/drone/botsort.yaml")

for result in results:
    if hasattr(result, 'plot'):
        frame_with_boxes = result.plot()
        if frame_with_boxes is not None:
            out.write(frame_with_boxes)
        for box in result.boxes:
            if int(box.cls) in vehicle_classes:  # Filter to detect only vehicles
                if box.id is not None:  # Check if box.id is not None
                    obj_id = int(box.id)
                else:
                    print(f"Warning: box.id is None for box with cls {box.cls} at frame {frame_number}")
                    continue  # Skip this box if id is None
                x, y, w, h = box.xywh.cpu().numpy().flatten() * conversion_factor
                timestamp = frame_number / fps
                position = (x, y)

                # Record time and position
                vehicle_data[obj_id]['timestamps'].append(timestamp)
                vehicle_data[obj_id]['positions'].append(position)

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

Apply interpolation and smoothing to the positions

window_size = 5 # Define the window size for moving average
for obj_id, info in vehicle_data.items():
if len(info['positions']) >= window_size:
positions, timestamps = interpolate(info['positions'], info['timestamps'])
positions_x = [pos[0] for pos in positions]
positions_y = [pos[1] for pos in positions]

    smooth_positions_x = moving_average(positions_x, window_size)
    smooth_positions_y = moving_average(positions_y, window_size)

    # Update the positions with smoothed values
    info['positions'] = list(zip(smooth_positions_x, smooth_positions_y))
    info['timestamps'] = timestamps[:len(smooth_positions_x)]

Calculate speed and acceleration based on smoothed positions

for obj_id, info in vehicle_data.items():
for i in range(len(info['positions'])):
if i == 0:
info['speeds'].append(0)
info['accelerations'].append(0)
else:
dx = info['positions'][i][0] - info['positions'][i-1][0]
dy = info['positions'][i][1] - info['positions'][i-1][1]
dt = info['timestamps'][i] - info['timestamps'][i-1]
if dt > 0:
speed = np.sqrt(dx2 + dy2) / dt
info['speeds'].append(speed)

            if i > 1:
                prev_speed = info['speeds'][i-1]
                acceleration = (speed - prev_speed) / dt
                info['accelerations'].append(acceleration)
            else:
                info['accelerations'].append(0)
        else:
            info['speeds'].append(0)
            info['accelerations'].append(0)

Convert the data to a DataFrame

data = []
for obj_id, info in vehicle_data.items():
for i in range(len(info['timestamps'])):
data.append([
info['timestamps'][i],
obj_id,
info['positions'][i][0],
info['positions'][i][1],
info['speeds'][i],
info['accelerations'][i]
])

df = pd.DataFrame(data, columns=['Timestamp', 'ID', 'Position X (m)', 'Position Y (m)', 'Speed (m/s)', 'Acceleration (m/s^2)'])

Save DataFrame to Excel file

excel_path = '/content/drive/MyDrive/drone/les résultats/excelzone1.xlsx'
df.to_excel(excel_path, index=False)
print(f"DataFrame saved to {excel_path}")

Check if the file exists and download it

if os.path.exists(excel_path):
print("Downloading Excel file...")
files.download(excel_path)
else:
print(f"Failed to create the file {excel_path}.") ce code me donne des valeurs de vitesses et accélérations aberrantes , dites moi quels sont less solutions sachant que j'aimerais que la vitesse se calcule par rapport à X avec la formule suivante : vitesse_x = (position_x du centre de la boite englobante - position_x précédente de la boite englobante ) /dt et pour l'accéleration= (vitesse - vitesse précedente) / dt

[glenn-jocher]

@mariem158 it looks like you're encountering issues with speed and acceleration calculations in your tracking script. To address this, ensure that your calculations are based on the correct positions and timestamps. For speed, use the difference in the x-coordinates divided by the time difference. For acceleration, use the difference in speed divided by the time difference. If you continue to face issues, try simplifying your script to isolate the problem. For more detailed guidance on tracking with YOLO, please refer to our tracking documentation.

[Orziqulov-Javohir]

please help me to connect many cameras logic

import cv2
from ultralytics import YOLO
import time

model = YOLO("yolov8n.pt")

camera_ids = [

'rtsp://admin:admin12345@172.17.67.20:554',
'rtsp://admin:admin12345@172.17.67.16:554',
'rtsp://admin:admin12345@172.17.67.18:554',
'rtsp://admin:admin12345@172.17.67.19:554',

]

caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

roi_start = [(0, 0)] * len(caps)
roi_end = [(0, 0)] * len(caps)
drawing = [False] * len(caps)

tracked_persons = [[] for _ in range(len(caps))]

def draw_rectangle(event, x, y, flags, param):
global roi_start, roi_end, drawing
idx = param
if event == cv2.EVENT_LBUTTONDOWN:
drawing[idx] = True
roi_start[idx] = (x, y)
roi_end[idx] = (x, y)
print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}")
elif event == cv2.EVENT_MOUSEMOVE:
if drawing[idx]:
roi_end[idx] = (x, y)
print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}")
elif event == cv2.EVENT_LBUTTONUP:
drawing[idx] = False
roi_end[idx] = (x, y)
print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

for idx in range(len(caps)):
window_name = f'Video {idx}'
cv2.namedWindow(window_name)
cv2.setMouseCallback(window_name, draw_rectangle, idx)

def is_inside_roi(x, y, roi_start, roi_end):
x1, y1 = roi_start
x2, y2 = roi_end
return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

while True:
frames = []
for cap in caps:
ret, frame = cap.read()
if not ret:
continue

    frames.append(frame)

for idx, frame in enumerate(frames):
    window_name = f'Video {idx}'
    
  
    if drawing[idx] or roi_start[idx] != roi_end[idx]:
        cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
        cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

    
    results = model.track(frame, tracker="bytetrack.yaml", persist=True)

    for result in results:
        boxes = result.boxes

        for box in boxes:
            x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
            cls = box.cls.tolist()[0]
            if cls == 0: 
                cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):

                    person_id = box.id.tolist()[0] if box.id is not None else None
                    
                    if person_id not in tracked_persons[idx]:
                        tracked_persons[idx].append(person_id)
                        crop = frame[int(y1):int(y2), int(x1):int(x2)]
                        cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                        cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                        cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)

    cv2.imshow(window_name, frame)

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

for cap in caps:
cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

@Orziqulov-Javohir to connect multiple cameras for tracking, you can use threading to handle each camera stream concurrently. Ensure each camera's stream is processed independently to avoid frame drops or delays. You can refer to the Ultralytics documentation for detailed guidance on multi-object tracking. If you encounter any issues, please verify that you're using the latest version of the Ultralytics package.

[SaimManzoor49]

I want to track multiple persons in multiple cameras at least in 3. If a person moves from one camera to another he should be assigned the same ID as he has in the first help me how can i do this?

[pderrenger]

To track multiple persons across multiple cameras and maintain the same ID as they move between cameras, you'll need a multi-camera tracking system that can handle re-identification (ReID). Ultralytics YOLO supports object tracking with trackers like BoT-SORT and ByteTrack, but they are typically designed for single-camera scenarios.

For multi-camera tracking, you would need to integrate a ReID model with the tracking system. This involves:

1. Running YOLO for detection and tracking within each camera.
2. Using a ReID model to match identities across different camera feeds.

You can start by setting up YOLO tracking for each camera and then integrate a ReID model to handle cross-camera identity matching. For more details on setting up YOLO tracking, refer to the Ultralytics tracking documentation.

[SaimManzoor49]

which gpu will you suggest for me if i want to run yolo along with some reid model for real time frame processing

[pderrenger]

For running YOLO along with a ReID model for real-time frame processing, I recommend using a high-end GPU like the NVIDIA RTX 3090 or A100. These GPUs offer substantial memory and processing power, which are crucial for handling the computational load of both object detection and re-identification tasks simultaneously. Ensure you have the latest drivers and CUDA version installed to maximize performance.

[mwasela]

Hello,
Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.

Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.

[glenn-jocher]

@mwasela hello,

It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.

For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.

[mwasela]

Yes, i actually managed to do so by reloading a model. I coupled this to a button in my react frontend through a flask endpoint id created ``` def reset_tracker(): global model model = YOLO("best.pt") global track_ids track_ids = [] @app.route('/track-ids', methods=['GET']) def get_track_ids(): return jsonify({"track_ids": track_ids}) # Route @app.route('/reset-tracker', methods=['GET']) def reset_tracker_endpoint(): reset_tracker() return jsonify({"message": "Tracker has been reset."}) def process_video(): global track_ids # Loop through the video frames while cap.isOpened(): # Read a frame success, frame = cap.read() if success: results = model.track(frame, persist=True, conf=0.95) track_ids = results[0].boxes.id.tolist() if results[0].boxes.id is not None else [] annotated_frame = results[0].plot() cv2.imshow("Bag Counter", annotated_frame) if cv2.waitKey(1) & 0xFF == ord("q"): break else: break cap.release() cv2.destroyAllWindows() ```

…

On Fri, 19 Jul 2024, 13:00 vivekpayasi, ***@***.***> wrote: @glenn-jocher <https://github.com/glenn-jocher> Thanks for your reply. I tried the following code by giving .streams file which contains paths to 5 videos. model = YOLO("yolov8x-worldv2.pt") classes_list = ["person", "helmet", "gloves", "mask", "shoes", "glasses"] model.set_classes(classes_list)model.to('cuda') results = model.track(source='video_sources.streams', half=True, device='cuda:0', stream=True, show=False, vid_stride=vid_stride) frame_idx = 0 for result in results: check_ppe_compliance(result, frame_idx) frame_idx += 1 But only the first frames of each video seem to be processed, not the rest of the frames of the videos. (ss attached) Screenshot.2024-07-19.at.15.27.59.png (view on web) <https://github.com/user-attachments/assets/f265915f-5979-428a-bab4-5af07c69aa59> Am I doing this correctly? Shall I spawn a separate thread for each stream/video and initialize a model for each thread, because I've seen this way in many docs and examples? What is the difference between giving the .streams file directly vs spawning a thread for each stream separately? Thanks! — Reply to this email directly, view it on GitHub <#7906 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACXRGWDEQ6CV4BSKX75H44DZNDPT3AVCNFSM6AAAAABCROZ3EGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTAMBZGQYTGMI> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

@mwasela it looks like you're on the right track with your implementation. The issue you're facing with only the first frames being processed might be due to how the streams are being handled. Using a .streams file should work, but if you're encountering issues, spawning separate threads for each stream can indeed help. Each thread can handle its own video stream, ensuring that all frames are processed correctly. This approach can also improve performance by leveraging parallel processing. If you continue to face issues, please ensure you're using the latest version of the Ultralytics package. For more details on tracking, you can refer to our documentation at https://docs.ultralytics.com/modes/track/.

[mariswarycharan]

how to track only one class in yolov8 model but it want to detect all classes

[glenn-jocher]

@mariswarycharan to track only one class while detecting all classes in a YOLOv8 model, you can filter the tracking results by class after detection. This way, the model detects all classes, but the tracker only processes the specified class. You can achieve this by modifying the tracking code to include a class filter. For more detailed guidance, please refer to the Ultralytics documentation on tracking.

[Boaruzhanchik]

@mariswarycharan @glenn-jocher

But you can make it much easier to reduce the load on the system, by using the classes argument to limit the output classes and detect only the objects needed by the user

Existing classes for detection
names: {0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane', 5: 'bus', 6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light', 10: 'fire hydrant', 11: 'stop sign', 12: 'parking meter', 13: 'bench', 14: 'bird', 15: 'cat', 16: 'dog', 17: 'horse', 18: 'sheep', 19: 'cow', 20: 'elephant', 21: 'bear', 22: 'zebra', 23: 'giraffe', 24: 'backpack', 25: 'umbrella', 26: 'handbag', 27: 'tie', 28: 'suitcase', 29: 'frisbee', 30: 'skis', 31: 'snowboard', 32: 'sports ball', 33: 'kite', 34: 'baseball bat', 35: 'baseball glove', 36: 'skateboard', 37: 'surfboard', 38: 'tennis racket', 39: 'bottle', 40: 'wine glass', 41: 'cup', 42: 'fork', 43: 'knife', 44: 'spoon', 45: 'bowl', 46: 'banana', 47: 'apple', 48: 'sandwich', 49: 'orange', 50: 'broccoli', 51: 'carrot', 52: 'hot dog', 53: 'pizza', 54: 'donut', 55: 'cake', 56: 'chair', 57: 'couch', 58: 'potted plant', 59: 'bed', 60: 'dining table', 61: 'toilet', 62: 'tv', 63: 'laptop', 64: 'mouse', 65: 'remote', 66: 'keyboard', 67: 'cell phone', 68: 'microwave', 69: 'oven', 70: 'toaster', 71: 'sink', 72: 'refrigerator', 73: 'book', 74: 'clock', 75: 'vase', 76: 'scissors', 77: 'teddy bear', 78: 'hair drier', 79: 'toothbrush'}

from ultralytics import YOLO
import cv2

modelv8_s = YOLO('yolov8s.pt')
img = 'path to image'
img = cv2.imread(img)
class_list = [2] # number classes

results = modelv8_s(img,verbose=True,show=True,classes = class_list)

[glenn-jocher]

@Boaruzhanchik thank you for your suggestion. Using the classes argument to limit the output classes is indeed an effective way to reduce system load. This approach allows the model to detect all classes but only track the specified ones, optimizing performance. For more detailed configurations and examples, please refer to the Ultralytics documentation on tracking.

[mariswarycharan]

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) # Loop through the video frames while cap.isOpened(): # Read a frame from the video success, frame = cap.read() if success: # Run YOLOv8 tracking on the frame, persisting tracks between frames results = model.track(frame, persist=True) # Visualize the results on the frame annotated_frame = results[0].plot() # Display the annotated frame cv2.imshow("YOLOv8 Tracking", annotated_frame) # Break the loop if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord("q"): break else: # Break the loop if the end of the video is reached break # Release the video capture object and close the display window cap.release() cv2.destroyAllWindows() How to do this in this code to track only one class while detecting all classes in a YOLOv8 model, you can filter the tracking results by class after detection. This way, the model detects all classes, but the tracker only processes the specified class. You can achieve this by modifying the tracking code to include a class filter.

…

On Sat, 27 Jul, 2024, 9:01 am Glenn Jocher, ***@***.***> wrote: @mariswarycharan <https://github.com/mariswarycharan> to track only one class while detecting all classes in a YOLOv8 model, you can filter the tracking results by class after detection. This way, the model detects all classes, but the tracker only processes the specified class. You can achieve this by modifying the tracking code to include a class filter. For more detailed guidance, please refer to the Ultralytics documentation on tracking <https://docs.ultralytics.com/modes/track/>. — Reply to this email directly, view it on GitHub <#7906 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AY7YK3AKOZ36IG63QH4N44DZOMIBXAVCNFSM6AAAAABCROZ3EGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTAMJWGU2DAOI> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

@mariswarycharan to track only one class while detecting all classes, you can filter the tracking results by class after detection. Modify the tracking code to include a class filter. For detailed guidance, please refer to the Ultralytics documentation on tracking at https://docs.ultralytics.com/modes/track/. This will help you configure the tracker to process only the specified class while detecting all classes.

[SaimManzoor49]

i am extracting features of a bounding box of person and then matching these features if any person appears so if the features matches how can i assign a custom id to the detected person

[glenn-jocher]

@SaimManzoor49 to assign a custom ID to a detected person based on feature matching, you can leverage the tracking capabilities of Ultralytics YOLO. The built-in trackers like BoT-SORT and ByteTrack already handle object IDs, but if you need custom logic, you can modify the tracking configuration or implement a custom tracker. Ensure you are using the latest version of the package for optimal performance. For more detailed guidance, refer to the Ultralytics tracking documentation.

[Nithinpbabu]

can i use Tracking on YOLO v9 / YOLO v10?

[glenn-jocher]

@Nithinpbabu yes, you can use tracking with YOLOv9 and YOLOv10. The tracking functionality in Ultralytics YOLO supports various models, including YOLOv9 and YOLOv10, for Detect, Segment, and Pose tasks. You can use trackers like BoT-SORT and ByteTrack by specifying the appropriate configuration file. For more details on tracking configurations and examples, please refer to our tracking documentation.

[btmvai]

In the default setting of Ultralytics tracking, each person's ID is counted only once, even if they cross from the left side to the right side of a line.
However, I want to count a person each time they cross the line: once when they move from left to right, and again when they return from right to left.
My goal is to count the number of people entering and exiting, then compare these counts.
How can I configure the code to achieve this?

[pderrenger]

@btmvai to achieve counting each time a person crosses a line in both directions, you will need to implement a custom logic that tracks the direction of movement. This involves monitoring the position of each person and determining when they cross the line from left to right or right to left. You can use the tracker's output to get the positions and IDs of the tracked objects and then apply your custom logic to count the crossings. For more detailed guidance on tracking configurations, please refer to the Ultralytics tracking documentation.

[nounotabe]

Is it possible to speed up inference by processing video frames in batches?

[Boaruzhanchik]

Hi,t
o speed up the output of the model use the argument device='cuda:0' , you can also use vid_stride=2 which means the number of frames to process, in this case the number 2 means that you will process every second frame, this can significantly increase the speed of the model and the application.

[nounotabe]

Wow! Sounds great！Could you tell me more details?

1. In the doc, vid_stride is boolean refer to video frame-rate stride. Do you mean set it as True?
2. What does "video frame-rate stride" mean?
3. I need to do something with tracking and counting. Does it also work?

[nounotabe]

I also found this "vid_stride int Frame stride for video inputs. Allows skipping frames in videos to speed up processing at the cost of temporal resolution. A value of 1 processes every frame, higher values skip frames." It seems that some frames are not processed and not suitable for tracking？

[glenn-jocher]

@nounotabe you're correct that vid_stride allows skipping frames to speed up processing, which can indeed affect tracking accuracy. Setting vid_stride to a higher value (e.g., 2) means processing every second frame, which can increase speed but may miss some object movements, making it less suitable for precise tracking tasks. For tracking and counting, it's best to process every frame (i.e., vid_stride=1) to maintain accuracy. If you need further optimization, consider using a more powerful GPU or optimizing the model itself. For more details, you can refer to the Ultralytics tracking documentation.