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, 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 renforce 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 sur bande transporteuse Utilisation Ultralytics YOLO11	Compter 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, 400), (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, 400), (1080, 360), (20, 360)]  # For rectangle region counting
# region_points = [(20, 400), (1080, 400), (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 en utilisant Ultralytics YOLO11 ?

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

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

Voici un exemple simple de comptage 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, 400), (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")

Pour en savoir plus sur les configurations et les options, consultez 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 présente 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 permet de détecter les menaces de manière proactive.
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, etc.

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

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

Pour compter des classes d'objets spécifiques à l'aide de Ultralytics YOLO11 , vous devez spécifier les classes qui vous intéressent pendant la phase de suivi. Vous trouverez 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 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 tels que Faster R-CNN, SSD et les versions précédentes de YOLO :

1. Rapidité 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, en réduisant le nombre de faux positifs et en améliorant 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é : Prise en charge de diverses tâches telles que la détection, la segmentation et le suivi d'objets à l'aide de modèles configurables pour répondre aux exigences de cas d'utilisation spécifiques.

Consultez lesite Ultralytics YOLO11 Documentation pour en savoir plus sur les caractéristiques et les comparaisons de performances.

Puis-je utiliser YOLO11 pour des applications avancées telles que 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 flexibilité d'intégration. Ses fonctionnalités avancées permettent le suivi, le comptage et la classification d'objets avec une grande précision dans des environnements dynamiques. Voici quelques exemples de cas d'utilisation :

• Analyse des foules : Surveillez et gérez les grands rassemblements, en assurant la sécurité et en optimisant le flux de la foule.
• Gestion du trafic : Suivre et compter les véhicules, analyser les schémas de circulation et gérer les embouteillages en temps réel.

Pour plus d'informations et de détails sur la mise en œuvre, consultez le guide Real World Applications of object counting with YOLO11.

📅C réé il y a 1 an ✏️ Mis à jour il y a 17 jours

Commentaires