zh/modes/track/

[giscus[bot]]

zh/modes/track/

了解如何使用Ultralytics YOLO 在视频流中进行物体跟踪。使用不同跟踪器和自定义跟踪器配置的指南。

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

[Eric5619]

[glenn-jocher]

Hey there! 😊 To access the tracking ID of each object when using Ultralytics YOLO for object tracking, you can simply refer to the id attribute of the boxes object in your results. Here's a quick example using Python:

from ultralytics import YOLO

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

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

# Access tracking IDs
for result in results:
    track_ids = result.boxes.id
    print(track_ids)

This will print out the tracking IDs for the objects detected in each frame of your video. Hope this helps! Let me know if you have any more questions.

[YongerZhu]

Can I use YOLO V8 to track the same object on different surveillance screens, and if so, how?

[pderrenger]

Absolutely! You can use YOLOv8 for tracking objects across different surveillance screens. Here's a quick guide on how to do it:

1. Load Your Model: First, load your YOLOv8 model. You can use a pre-trained model or your custom-trained model.

   from ultralytics import YOLO
   model = YOLO('yolov8n.pt')  # or your custom model

2. Run the Tracker: Use the track method on your model and specify the source as your video or stream URL. You can choose from different trackers like BoT-SORT or ByteTrack by specifying the tracker argument.

   results = model.track(source="path/to/your/video.mp4", tracker="bytetrack.yaml")

3. Process Results: The results object will contain the tracked objects with unique IDs that persist across frames.

Remember, for tracking across different screens, you'll need to run the tracker separately for each video source and then correlate the tracking IDs based on your specific requirements, such as appearance similarity or spatial proximity.

Happy tracking! 🚀

[YongerZhu]

Thank you for your reply. What I would like to know further is that if a vehicle passes through a stretch of road, and there are multiple cameras along this road, and each camera is able to capture the vehicle's movement within its field of view separately, how do I match correlate that vehicle from different cameras?

Can I do this with just YOLO V8, or do I need to use some feature matching algorithm to associate the same vehicle from different cameras based on its appearance?

[pderrenger]

@YongerZhu hey there! 🌟 For tracking the same vehicle across multiple cameras, YOLOv8 can detect and track the vehicle within each camera's view. However, to correlate the vehicle across different cameras, you'd typically need an additional step involving a feature matching algorithm or a multi-camera tracking system. This step would compare features or tracking IDs to associate the same vehicle across different camera feeds based on its appearance, trajectory, or other distinguishing features.

While YOLOv8 excels in detection and tracking within individual video streams, integrating these detections across multiple streams for consistent tracking of an object involves more complex logic and potentially additional tools or algorithms focused on multi-camera tracking scenarios. 🚗💨

For a start, you could use YOLOv8 to extract features or bounding boxes and then apply algorithms like cosine similarity for feature matching or use spatial and temporal information for cross-camera correlation. Happy coding!

[YongerZhu]

thank you for your help

[pderrenger]

Hey there! 🌟 Thanks for reaching out. To track a vehicle across multiple cameras, you'll indeed need a bit more than just YOLOv8's detection and tracking capabilities. After using YOLOv8 to detect and track the vehicle within each camera's view, you'd typically employ a feature matching algorithm or a multi-camera tracking system to correlate the vehicle's appearance across different cameras. This could involve comparing features like color histograms, shape, or even using more advanced techniques like deep learning-based re-identification (Re-ID) models that can generate a unique fingerprint for each vehicle.

Here's a simplified example of how you might approach this with YOLOv8 detections:

# Assume you have detections from YOLOv8 for each camera
detections_cam1 = yolo_model.detect(cam1_frame)
detections_cam2 = yolo_model.detect(cam2_frame)

# Extract features for each detection (simplified)
features_cam1 = extract_features(detections_cam1)
features_cam2 = extract_features(detections_cam2)

# Match features across cameras
matches = match_features(features_cam1, features_cam2)

This is a high-level overview, and the actual implementation can get quite complex, especially in handling varying angles, lighting conditions, and occlusions across cameras. Tools like OpenCV can be helpful for feature extraction and matching, and there are several research papers and projects on multi-camera tracking and vehicle re-identification that might offer deeper insights and methodologies. Happy coding! 🚀

[Fancyhzw]

How can I use YOLO to show the center point in the window?

[glenn-jocher]

Hey there! 😊 To show the center point of detected objects using YOLO, you can modify the plotting function to include the center points. Here's a quick example assuming you're using the Python API:

from ultralytics import YOLO
import cv2

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

# Run inference
results = model('path/to/your/image.jpg')

# Extract boxes
boxes = results[0].boxes.xyxy.cpu().numpy()

# Calculate and plot center points
for box in boxes:
    center_x = int((box[0] + box[2]) / 2)
    center_y = int((box[1] + box[3]) / 2)
    cv2.circle(results[0].orig_img, (center_x, center_y), radius=5, color=(0, 255, 0), thickness=-1)

# Display the image with center points
cv2.imshow('YOLO Centers', results[0].orig_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code snippet will draw a green dot at the center of each detected object in your image. Hope this helps! Let me know if you have any other questions.

[Daniel-lucifer]

After accessing the tracking ID of each object when using Ultratics YOLO for object tracking, if I use several images I have collected myself, such as three images, how can I match the features detected in the three images I provide? Because some features may appear repeatedly

[pderrenger]

Hello! It's great to see you exploring object tracking with YOLO and using custom datasets. 😊 When it comes to matching detected features across multiple images, especially where the same features might appear in each, there are a few strategies you might consider:

1. Feature Matching Approaches: You can utilize feature matching algorithms like SIFT (Scale-Invariant Feature Transform) or ORB (Oriented FAST and Rotated BRIEF) to find similarities between features extracted from your images. Here’s a simple snippet using ORB with OpenCV for matching features between two images:

import cv2

# Load images
img1 = cv2.imread('image1.jpg', 0)  # Query image
img2 = cv2.imread('image2.jpg', 0)  # Train image

# Initialize ORB detector
orb = cv2.ORB_create()

# Find the keypoints and descriptors
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)

# Create BFMatcher object and match descriptors
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)

# Sort them in ascending order of their distances so that best matches come to front
matches = sorted(matches, key=lambda x: x.distance)

# Draw first 10 matches.
img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:10], None, flags=2)
cv2.imshow('Matches', img3)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. Tracking Across Frames: If your images are frames from a video or a sequence where objects move slightly between frames, you might employ tracking algorithms like the ones already integrated into YOLO's tracking features (e.g., BoT-SORT, ByteTrack) which you have seen in the Ultralytics documentation. These trackers inherently handle feature matching across frames to maintain consistent IDs for each object.

3. Custom Solutions: Depending on the specificity of your task (for example, matching unique objects across different scene conditions), training a neural network to recognize specific features or objects across your dataset might provide more tailored results.

Matching features reliably across multiple images can be challenging, especially in varied conditions. It's often a combination of techniques and some fine-tuning that leads to the best results.

Hope this helps! If you have further questions or need more detailed assistance, feel free to ask. Happy coding! 😄

[Daniel-lucifer]

How can I determine my position in this scene based on three images collected at a fixed location after accessing the tracking ID of each object when using Ultratics YOLO for object tracking

[glenn-jocher]

确定场景中的位置基于三张在固定位置收集的图像以及物体的跟踪ID时，可以通过比较物体的相对位置和运动轨迹在连续的帧中变化来实现。若您能够获取每个物体在这三张图像中的坐标或者位置信息，就可以利用这些数据来估计您相对于这些物体的位置变化。下面是一个简单的例子，说明如何使用Ultralytics YOLO进行物体跟踪，并获取每个追踪物体的坐标。

from ultralytics import YOLO

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

# Perform tracking
results = model.track("path/to/your/video.mp4")

for frame in results:
    boxes = frame.boxes.xyxy  # xyxy format
    track_ids = frame.boxes.id
    for track_id, box in zip(track_ids, boxes):
        x1, y1, x2, y2 = box
        print(f"Track ID: {track_id} is at position: [({x1}, {y1}), ({x2}, {y2})]")

这段代码运行后，您将能看到每一个追踪物体在每一帧中的位置。根据这些位置信息，您可以分析物体随时间的移动轨迹，进而推断出您的位置。希望这对您有所帮助！🚀

[GKYoffice]

I want to get some performance indicators about trackers, such as MOTA, IDF1, etc. How should I do it?

[glenn-jocher]

To evaluate trackers using metrics such as MOTA, IDF1, etc., you would typically use specialized tracking evaluation tools that are capable of computing these metrics based on the tracker's output.

At present, direct support for these evaluation metrics isn't built into the Ultralytics YOLO platform. However, you can integrate tracking output with evaluation frameworks like MOTChallenge which provide tools to evaluate multiple object tracking performance using these metrics.

Here is a general approach on how you might proceed:

1. Export your tracking results in a format compatible with the evaluation tool (e.g., .txt or .csv with frame ID, track ID, bounding boxes, etc.).
2. Use the evaluation tool to read these results and the corresponding ground truth.
3. Compute the metrics.

For specific implementation, you might refer to the documentation or forums associated with the chosen evaluation tool for detailed steps and code examples. If integrating new evaluation measures directly into your workflows is of interest, consider contributing to the Ultralytics repository to include these features.

[zhaozhaotnl]

Hello! I am so glad to use yolov8,but I have a question that which tracking method the under code use.Bytetrack or Botsort?
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()

[pderrenger]

Hello! I'm glad you're enjoying using YOLOv8! In your script, the specific tracking method used (ByteTrack or BoT-SORT) depends on the configuration you've set when initializing the YOLO() object or the default settings if none is specified explicitly.

By default, YOLOv8 uses BoT-SORT as the tracker unless overriden by specifying a different tracker configuration. If you want to explicitly use ByteTrack or any other tracker, you can set the tracker argument like this:

from ultralytics import YOLO

# Load a YOLOv8 model with ByteTrack
model = YOLO('yolov8n.pt', tracker='bytetrack.yaml')

# Now proceed with your tracking code

Feel free to swap 'bytetrack.yaml' with the specific tracker config file you are interested in using. Enjoy tracking! 🚀

[zhaozhaotnl]

Thanks for answering!It works. Thanks again!

[pderrenger]

I'm thrilled to hear that the solution worked for you! If you have any more questions or need further assistance as you continue exploring YOLOv8, feel free to reach out. Happy coding! 😊🚀

[XiaoMingWM]

Can YOLOV8 do object tracking on the image to distinguish between different ids？

[pderrenger]

@XiaoMingWM yes, YOLOv8 can perform object tracking and distinguish between different IDs. It supports multiple tracking algorithms like BoT-SORT and ByteTrack, which can be enabled using specific YAML configuration files. This allows the model to track objects across video frames and maintain unique IDs for each detected object, making it suitable for applications such as surveillance, sports analytics, and more.

For more details on how to implement and customize tracking with YOLOv8, you can refer to our comprehensive guide on multi-object tracking available in the documentation. If you have any more questions or need further assistance, feel free to ask! 🚀