Comptage d'objets à l'aide de Ultralytics YOLO11

Qu'est-ce que le comptage d'objets ?

Le comptage d'objets avec Ultralytics YOLO11 implique l'identification et le comptage précis d'objets spécifiques dans les vidéos et les flux de caméras. YOLO11 excelle dans les applications en temps réel, en fournissant un comptage d'objets efficace et précis pour divers scénarios tels que l'analyse des foules et la surveillance, grâce à ses algorithmes de pointe et à ses capacités d' apprentissage profond.

Avantages du comptage d'objets ?

• Optimisation des ressources : Le comptage d'objets facilite la gestion efficace des ressources en fournissant des comptages précis et en optimisant l'allocation des ressources dans des applications telles que la gestion des stocks.
• Sécurité renforcée : Le comptage d'objets améliore la sécurité et la surveillance en suivant et en comptant avec précision les entités, ce qui permet une détection proactive des menaces.
• Prise de décision éclairée : Le comptage d'objets offre des informations précieuses pour la prise de décision, l'optimisation des processus dans le commerce de détail, la gestion du trafic et divers autres domaines.

Applications dans le monde réel

Logistique	Aquaculture
Comptage de paquets de bandes transporteuses à l'aide de Ultralytics YOLO11	Compte les poissons dans la mer en utilisant Ultralytics YOLO11

# Run a counting example
yolo solutions count show=True

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

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

import cv2

from ultralytics import solutions

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

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

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

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

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

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

Argument ObjectCounter

Voici un tableau avec les ObjectCounter arguments :

Arguments model.track

FAQ

Comment compter les objets dans une vidéo à l'aide de Ultralytics YOLO11 ?

Pour compter les objets dans une vidéo à l'aide de Ultralytics YOLO11, tu peux suivre les étapes suivantes :

1. Importe les bibliothèques nécessaires (cv2, ultralytics).
2. Définis la région de comptage (par exemple, un polygone, une ligne, etc.).
3. Configure la capture vidéo et initialise le compteur d'objets.
4. Traite chaque image pour suivre les objets et les compter dans la région définie.

Voici un exemple simple pour compter dans une région :

import cv2

from ultralytics import solutions


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

    region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
    counter = solutions.ObjectCounter(show=True, region=region_points, model=model_path)

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

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


count_objects_in_region("path/to/video.mp4", "output_video.avi", "yolo11n.pt")

Explore d'autres configurations et options dans la section Comptage d'objets.

Quels sont les avantages de l'utilisation de Ultralytics YOLO11 pour le comptage d'objets ?

L'utilisation de Ultralytics YOLO11 pour le comptage d'objets offre plusieurs avantages :

1. Optimisation des ressources : Il facilite la gestion efficace des ressources en fournissant des comptages précis, ce qui permet d'optimiser l'affectation des ressources dans des secteurs tels que la gestion des stocks.
2. Sécurité renforcée : Il améliore la sécurité et la surveillance en suivant et en comptant les entités avec précision, ce qui facilite la détection proactive des menaces.
3. Prise de décision éclairée : Il offre des informations précieuses pour la prise de décision, l'optimisation des processus dans des domaines tels que la vente au détail, la gestion du trafic, et plus encore.

Pour des applications concrètes et des exemples de code, visite la section Avantages du comptage d'objets.

Comment puis-je compter des classes d'objets spécifiques en utilisant Ultralytics YOLO11 ?

Pour compter des classes d'objets spécifiques à l'aide de Ultralytics YOLO11, tu dois spécifier les classes qui t'intéressent pendant la phase de suivi. Tu trouveras ci-dessous un exemple de Python :

import cv2

from ultralytics import solutions


def count_specific_classes(video_path, output_video_path, model_path, classes_to_count):
    """Count specific classes of objects in a video."""
    cap = cv2.VideoCapture(video_path)
    assert cap.isOpened(), "Error reading video file"
    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
    video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

    line_points = [(20, 400), (1080, 400)]
    counter = solutions.ObjectCounter(show=True, region=line_points, model=model_path, classes=classes_to_count)

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

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


count_specific_classes("path/to/video.mp4", "output_specific_classes.avi", "yolo11n.pt", [0, 2])

Dans cet exemple, classes_to_count=[0, 2]ce qui signifie qu'il compte les objets de la classe 0 et 2 (par exemple, personne et voiture).

Pourquoi devrais-je utiliser YOLO11 plutôt que d'autres modèles de détection d'objets pour les applications en temps réel ?

Ultralytics YOLO11 offre plusieurs avantages par rapport à d'autres modèles de détection d'objets comme Faster R-CNN, SSD et les versions précédentes de YOLO :

1. Vitesse et efficacité : YOLO11 offre des capacités de traitement en temps réel, ce qui le rend idéal pour les applications nécessitant une inférence à grande vitesse, telles que la surveillance et la conduite autonome.
2. Précision: il offre une précision de pointe pour les tâches de détection et de suivi des objets, ce qui permet de réduire le nombre de faux positifs et d'améliorer la fiabilité globale du système.
3. Facilité d'intégration : YOLO11 offre une intégration transparente avec diverses plateformes et appareils, y compris les appareils mobiles et périphériques, ce qui est crucial pour les applications modernes d'IA.
4. Flexibilité : Prend en charge diverses tâches telles que la détection, la segmentation et le suivi d'objets avec des modèles configurables pour répondre aux exigences de cas d'utilisation spécifiques.

Consulte lesite Ultralytics YOLO11Documentation pour en savoir plus sur ses caractéristiques et comparer ses performances.

Puis-je utiliser YOLO11 pour des applications avancées comme l'analyse des foules et la gestion du trafic ?

Oui, Ultralytics YOLO11 est parfaitement adapté aux applications avancées telles que l'analyse des foules et la gestion du trafic, grâce à ses capacités de détection en temps réel, à son évolutivité et à sa souplesse d'intégration. Ses fonctions avancées permettent le suivi, le comptage et la classification d'objets avec une grande précision dans des environnements dynamiques. Les exemples de cas d'utilisation comprennent :

• Analyse des foules : Surveille et gère les grands rassemblements, en assurant la sécurité et en optimisant le flux de la foule.
• Gestion du trafic : Suit et compte les véhicules, analyse les schémas de circulation et gère les embouteillages en temps réel.

Pour plus d'informations et de détails sur la mise en œuvre, reporte-toi au guide sur les applications réelles du comptage d'objets avec YOLO11.

📅 C réé il y a 11 mois ✏️ Mis à jour il y a 9 jours

Commentaires