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

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

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

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

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

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

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

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

[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

[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

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

[WooFy11]

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

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

[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! 🎉

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

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

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

[Engr-Jalal-Saleem]

i want to track objects within a boundry, i am giving you a code which can do tracking with saving images, cropping, and drawing lines.
i have the code how to draw lines, but i do not know how to track objects with the lines or boundries that i drawn.
tell me how can i do it.
import cv2 as cv
import numpy as np
from ultralytics import YOLO
import os
import numpy

def save_image(frame, tracking_id, count):
if not os.path.exists('results'):
os.makedirs('results')
filename = f"results/tracking_id_{tracking_id}image{count}.jpg"
cv.imwrite(filename, frame)

drawing = False
ix, iy = -1, -1
current_frame = None
lines = []
ID_img_count = {}

def draw_line(event, x, y, flags, param):
global ix, iy, drawing, current_frame, lines
if event == cv.EVENT_LBUTTONDOWN:
drawing = True
ix, iy = x, y
elif event == cv.EVENT_MOUSEMOVE:
if drawing:
img = current_frame.copy()
cv.line(img,(ix,iy), (x,y),(0,200,101),2)
for line in lines:
cv.line(img, line[0], line[1], (0,200,101),2)
cv.imshow('Video', img)
elif event == cv.EVENT_LBUTTONUP:
drawing = False
lines.append(((ix, iy), (x,y)))
img = current_frame.copy()
for line in lines:
cv.line(img, line[0], line[1], (0,200,101),2)
cv.imshow('Video', img)

model = YOLO(r"C:\Users\jalal.saleem\Documents\Tinted Screen Detection\Tinted_Screen_Detection-11-07-2024\Tracking Task 2\Models\best.pt")
cap = cv.VideoCapture(r'C:\Users\jalal.saleem\Documents\Tinted Screen Detection\Tinted_Screen_Detection-11-07-2024\src\video.mp4')
cv.namedWindow('Video')
cv.setMouseCallback('Video', draw_line)
annotated_frame = None
while True:
ret, frame = cap.read()
if not ret:
break
elif ret:
current_frame = frame.copy()
current_frame = cv.resize(current_frame, (1280, 720))
for line in lines:
cv.line(current_frame, line[0], line[1], (0,200,101),2)
res = model.track(current_frame, conf=0.75, persist=True, classes = 1) #Tracking

    annotated_frame = res[0].plot()
    bonding_box = (res[0].boxes.xyxy.tolist())
    bonding_box = np.array(bonding_box, dtype=np.int32)
    if len(bonding_box) != 0:
        
        x1, y1, x2, y2 = bonding_box[0][0], bonding_box[0][1], bonding_box[0][2], bonding_box[0][3]
        
        #Coordinates
    center = tuple((((x1 + x2) // 2), ((y1 + y2) // 2)))
    x_center = (x1 + x2) // 2
    y_center=(y1 + y2) // 2
    if lines and len(lines[0]) > 1:
        # if x_center < lines[0][0][0] and x_center > lines[1][0][0] and y_center < lines[0][1][1] and y_center > lines[1][1][1]:
        if center < lines[0][0]:
            print("Line 1 crossed")
    # annotated_frame = cv.circle(annotated_frame, center, 5, (0, 0, 255), -1)
    if type(annotated_frame)==numpy.ndarray:
        cv.imshow('Video', annotated_frame)
    else:
        cv.imshow('Video',  current_frame)
    cv.imshow('Video', annotated_frame)

    for box in res[0].boxes:
        tracking_id = box.id.int().numpy().item()
    if tracking_id not in ID_img_count:
        ID_img_count[tracking_id] = 0
    if ID_img_count[tracking_id] < 5:                   
        cropped_image = annotated_frame[y1+10:y2-5, x1+5:x2-5]                  #Cropping
        save_image(cropped_image, tracking_id, ID_img_count[tracking_id])           #Saving
        ID_img_count[tracking_id] += 1
        
if cv.waitKey(1) & 0xFF == ord('q'):
        # lines= []
        break

cap.release()
cv.destroyAllWindows()

[Engr-Jalal-Saleem]

Thank you for your response.
here is my complete code that you can refer.
As you mentioned, i found the center of bonding boxes, then compare it with the lines drawn....
but unfortunately, i am unable to get the results.
I will be very thankful, if you could help me in this regarding.
Thanks again.
code:"import cv2 as cv
import numpy as np
from ultralytics import YOLO
import os
import numpy

def save_image(frame, tracking_id, count):
if not os.path.exists('results'):
os.makedirs('results')
filename = f"results/tracking_id_{tracking_id}image{count}.jpg"
cv.imwrite(filename, frame)

drawing = False
ix, iy = -1, -1
current_frame = None
lines = []
ID_img_count = {}

def draw_line(event, x, y, flags, param):
global ix, iy, drawing, current_frame, lines
if event == cv.EVENT_LBUTTONDOWN:
drawing = True
ix, iy = x, y
elif event == cv.EVENT_MOUSEMOVE:
if drawing:
img = current_frame.copy()
cv.line(img,(ix,iy), (x,y),(0,200,101),2)
for line in lines:
cv.line(img, line[0], line[1], (0,200,101),2)
cv.imshow('Video', img)
elif event == cv.EVENT_LBUTTONUP:
drawing = False
lines.append(((ix, iy), (x,y)))
img = current_frame.copy()
for line in lines:
cv.line(img, line[0], line[1], (0,200,101),2)
cv.imshow('Video', img)

model = YOLO(r"C:\Users\jalal.saleem\Documents\Tinted Screen Detection\Tinted_Screen_Detection-11-07-2024\Tracking Task 2\Models\best.pt")
cap = cv.VideoCapture(r'C:\Users\jalal.saleem\Documents\Tinted Screen Detection\Tinted_Screen_Detection-11-07-2024\src\video.mp4')
cv.namedWindow('Video')
cv.setMouseCallback('Video', draw_line)
annotated_frame = None
while True:
ret, frame = cap.read()
if not ret:
break
elif ret:
current_frame = frame.copy()
current_frame = cv.resize(current_frame, (1280, 720))
for line in lines:
cv.line(current_frame, line[0], line[1], (0,200,101),2)
res = model.track(current_frame, conf=0.75, persist=True, classes = 1) #Tracking

annotated_frame = res[0].plot()
bonding_box = (res[0].boxes.xyxy.tolist())
bonding_box = np.array(bonding_box, dtype=np.int32)
if len(bonding_box) != 0:
    
    x1, y1, x2, y2 = bonding_box[0][0], bonding_box[0][1], bonding_box[0][2], bonding_box[0][3]
    
    #Coordinates
center = tuple((((x1 + x2) // 2), ((y1 + y2) // 2)))
x_center = (x1 + x2) // 2
y_center=(y1 + y2) // 2
if lines and len(lines[0]) > 1:
    # if x_center < lines[0][0][0] and x_center > lines[1][0][0] and y_center < lines[0][1][1] and y_center > lines[1][1][1]:
    if center < lines[0][0]:
        print("Line 1 crossed")
# annotated_frame = cv.circle(annotated_frame, center, 5, (0, 0, 255), -1)
if type(annotated_frame)==numpy.ndarray:
    cv.imshow('Video', annotated_frame)
else:
    cv.imshow('Video',  current_frame)
cv.imshow('Video', annotated_frame)

for box in res[0].boxes:
    tracking_id = box.id.int().numpy().item()
if tracking_id not in ID_img_count:
    ID_img_count[tracking_id] = 0
if ID_img_count[tracking_id] < 5:                   
    cropped_image = annotated_frame[y1+10:y2-5, x1+5:x2-5]                  #Cropping
    save_image(cropped_image, tracking_id, ID_img_count[tracking_id])           #Saving
    ID_img_count[tracking_id] += 1

if cv.waitKey(1) & 0xFF == ord('q'):
# lines= []
break

cap.release()
cv.destroyAllWindows()
"

[mariem158]

File "", line 91
results = model.track(frame, persist=True, tracker="botsort.yaml")
^
IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR

[glenn-jocher]

The error you're encountering is due to an indentation issue in your code. Ensure that all lines are properly aligned and that there are no unexpected spaces or tabs. If the issue persists, please verify that you are using the latest version of the Ultralytics package. For more details on tracking with YOLO, you can refer to the documentation at https://docs.ultralytics.com/modes/track/.

[ulziitogtoh]

Hi!
i will use yolov8 model for object tracking but firstly, i want to track objects with the Ultralytics tracker using ground truth data, which consists of image sequences with annotated bounding boxes, instead of using the YOLO detection model. is this possible?

[glenn-jocher]

@ulziitogtoh hi! Currently, Ultralytics YOLO does not support tracking using ground truth data directly. The tracking functionality is designed to work with detections generated by YOLO models. For more details on tracking with YOLO, please refer to our documentation: https://docs.ultralytics.com/modes/track/.

[carlosjulioph]

"I need to customize the display of inference results. I only want to show the assigned ID, without including the object class and score. The following lines of code demonstrate the customization by modifying some parameters of the plot() method.

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
        )

[glenn-jocher]

@carlosjulioph to customize the display to show only the assigned ID, you can modify the plot() method to exclude the class and score. Here's an example:

for result in results:
    annotated_frame = result.plot(
        show_labels=False,  # Hide class labels
        show_conf=False,    # Hide confidence scores
        show_ids=True       # Show only IDs
    )

For more details, please refer to the Ultralytics documentation.

[carlosjulioph]

Hi...i get this error: TypeError: plot() got an unexpected keyword argument 'show_labels' . Where can I find the parameters for the plot() method? I've searched the documentation, but I can't seem to find it." Ultralytics version 8,2,2

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
#model = YOLO('weights/det/yolov8n.pt')
model = YOLO('yolov8s-world.pt') # genera mas latencia que yolov8n
class_list = [0]
# 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("2.mp4")
#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.3)

        # Run YOLOv8 tracking on the frame
        # BoT-SORT : modelo por default
        #results = model.track(frame, persist=True,classes=class_list)
        # ByteTrack
        results = model.track(frame, persist=True,classes=class_list, tracker="bytetrack.yaml")
        for result in results:
                annotated_frame = result.plot(
                    show_labels=False,  # Hide class labels
                    show_conf=False,    # Hide confidence scores
                    show_ids=True       # Show only IDs
                )
        """
        # Visualize the results
        #annotated_frame = results[0].plot()
        annotated_frame = results[0].plot(
                show_labels=False,  # Hide class labels
                show_conf=False,    # Hide confidence scores
                show_ids=True       # Show only IDs
            )
        """
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

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

cap.release()

[carlosjulioph]

I have updated Ultralytics to version 8.2.78 ultralytics-thop-2.0.3, but the following error occurs in the suggested code:

'annotated_frame = result.plot()
TypeError: plot() got an unexpected keyword argument 'show_labels'."

[glenn-jocher]

@carlosjulioph thank you for updating to the latest version. The plot() method does not support the show_labels and show_conf arguments. To customize the display to show only the assigned ID, you can modify the plot() method to exclude the class and score manually. Unfortunately, the current version does not support this directly through plot() arguments. You may need to customize the visualization code to achieve this. For further details, please refer to the Ultralytics documentation.

[carlosjulioph]

I have installed Pytorch with CUDA. I have an RTX 3080 Ti GPU and I would like the processing to be supported by this GPU. Even when I resize the original image to 30% to get a resolution of 640x480, the inference still shows some latency. What tips or recommendations could be considered to increase FPS?

[glenn-jocher]

@carlosjulioph to increase FPS, ensure you are using the latest version of the Ultralytics package. Additionally, consider using the half precision mode and optimizing your model with TensorRT. For more details, please refer to the Ultralytics documentation.

[vivekpayasi]

For running multiple threads, in this documentation, it is mentioned that we can load the models first and then call them from separate threads. (https://docs.ultralytics.com/modes/track/#how-can-i-run-object-tracking-on-multiple-video-streams-simultaneously)

model1 = YOLO("yolov8n.pt")
model2 = YOLO("yolov8n-seg.pt")
video_file1 = "path/to/video1.mp4"
video_file2 = 0  # Path to a second video file, or 0 for a webcam

tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

But in one the documentation for YOLO models, I read that it is recommended to load the model within the thread itself.
(https://docs.ultralytics.com/guides/yolo-thread-safe-inference/#thread-safe-inference)

def thread_safe_predict(image_path):
    """Predict on an image using a new YOLO model instance in a thread-safe manner; takes image path as input."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results

Are YOLO-World models inherently thread-safe that we don't need to load them in separate threads? Which method is the correct one?

[glenn-jocher]

@vivekpayasi for thread safety, it's recommended to load the YOLO model within each thread. This ensures that each thread has its own model instance, preventing potential conflicts. You can find more details in the YOLO Thread-Safe Inference Guide.

[Jordan-Karangala]

Hi,

Can someone help me with the following issue.
I implemented yolov9 model for tracking youtube video. It's working well but the ID's it is creating at the first instance for a particular person is not remaining same over the time in video even the person is there in the frame always.

I want the model to create the ID at first instance and recal the ID when the same person comes into the frame again(same video).
Below is the code i used.

from ultralytics import YOLO
import ssl
import certifi
ssl._create_default_https_context = ssl._create_unverified_context # Not sure why some videos are not working.

model = YOLO('model_weights/yolov9c.pt')

results = model.track(source='https://www.youtube.com/watch?v=1YqVEVbXQ1c', show=True,tracker="detect_track/lib/python3.11/site-packages/ultralytics/cfg/trackers/bytetrack.yaml" )

Thank you in advance for your valuable time.

[glenn-jocher]

@Jordan-Karangala hi,

The issue you're experiencing with ID consistency can be addressed by fine-tuning the tracker settings. Ensure you're using the latest version of the Ultralytics package. You might also want to try the BoT-SORT tracker (tracker="botsort.yaml") as it may offer better performance for your use case. For more details, please refer to the tracking documentation.