Commencer

Comptage d’objets dans des zones avec Ultralytics YOLO26

La solution RegionCounter d’Ultralytics YOLO26 suit les objets d’une image vidéo à l’autre et compte, sur chaque image, les objets dont le centre de la boîte englobante se trouve dans chacune des zones que tu définis. Chaque zone est dessinée sur l’image avec son propre décompte en direct. Tu peux ainsi surveiller plusieurs secteurs, comme les allées d’un magasin, les voies de circulation ou les zones de production, avec un seul appel Python ou une commande CLI.



Regarder : Comptage d’objets dans différentes zones avec Ultralytics YOLO | Solutions Ultralytics

Pourquoi utiliser le comptage par zone ?#

  • Plusieurs zones en un seul passage : Transmets un dictionnaire de polygones nommés ; chaque zone reçoit alors son propre décompte affiché sur l’image, ce qui te permet de couvrir tous les espaces qui t’intéressent avec un seul flux vidéo.
  • Suivi intégré : La solution exécute en interne la détection YOLO26 et le suivi d’objets, sans nécessiter de pipeline de suivi distinct.
  • Décomptes accessibles par programmation : Chaque image traitée renvoie un objet de résultats contenant un dictionnaire des décomptes par zone, prêt à être utilisé dans des tableaux de bord, des alertes ou des journaux.

Applications concrètes#

Commerce de détailRues de marché
Comptage de personnes par Ultralytics YOLO dans des zones polygonales dessinées dans un magasinDécomptes par zone d’Ultralytics YOLO superposés à une rue de marché bondée
Comptage de personnes par zone avec Ultralytics YOLOComptage de foule par zone avec Ultralytics YOLO

Comment compter des objets dans des zones avec Ultralytics YOLO#

Exécute la solution RegionCounter sur une source vidéo depuis la CLI ou Python. Une zone peut être une liste de points (une seule zone) ou un dictionnaire associant des noms de zones à des listes de points. L’exemple Python ci-dessous compte les objets dans deux zones nommées et écrit les images traitées dans un fichier vidéo de sortie :

Comptage par zone avec Ultralytics YOLO
# Run a region counting example
yolo solutions region show=True

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

# Pass a custom region
yolo solutions region region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"

Arguments de RegionCounter()#

Voici un tableau des arguments de RegionCounter :

ArgumentTypeValeur par défautDescription
modelstrNoneChemin vers un fichier de modèle Ultralytics YOLO.
regionlist ou dictNonePoints définissant la région d'intérêt : une liste de tuples (x, y) ou un dictionnaire associant des noms de régions à des listes de points pour plusieurs régions (uniquement RegionCounter). Si None, les solutions qui nécessitent une région utilisent une région par défaut prédéfinie.
line_widthint2Épaisseur des lignes des boîtes, des points clés et des compteurs dessinés par la solution.
verboseboolTrueActive le journal de la solution pour chaque image, qui indique la forme de l'entrée, le nombre d'éléments par classe et la vitesse de traitement. L'appel de suivi reste toujours silencieux.

La solution RegionCounter permet d’utiliser les paramètres de suivi d’objets :

ArgumentTypeValeur par défautDescription
trackerstr'tracktrack.yaml'Indique l'algorithme de suivi à utiliser. Options intégrées : botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml.
conffloat0.25Définit le seuil de confiance des détections ; des valeurs plus faibles permettent de suivre davantage d'objets, mais peuvent inclure des faux positifs.
ioufloat0.5Définit le seuil d'intersection sur l'union (IoU) utilisé pour filtrer les détections qui se chevauchent.
classeslistNoneFiltre les résultats selon l'indice de classe. Par exemple, classes=[0, 2, 3] ne suit que les classes spécifiées.
devicestrNoneIndique le périphérique utilisé pour l'inférence (par exemple, cpu, cuda:0 ou 0). Permet de choisir entre le CPU, un GPU spécifique ou d'autres périphériques de calcul pour l'exécution du modèle.
imgszint or tuple640Taille cible de l'image pour l'inférence : un entier pour une image carrée ou une paire (height, width). Les dimensions sont ajustées au stride du modèle.
max_detint300Nombre maximal de détections conservées par image avant le suivi, ce qui limite le nombre d'objets qu'une solution traite dans les scènes denses.
quantizeint or strNonePrécision d’inférence : 16 (FP16) ou 32/unset (FP32) pour les modèles PyTorch et TorchScript hors CPU ; les autres formats utilisent la précision définie par leur artefact et leur environnement d’exécution. Remplace l’argument half obsolète.

Les paramètres de visualisation suivants sont également pris en charge :

ArgumentTypeValeur par défautDescription
showboolFalseSi True, affiche les images ou vidéos annotées dans une fenêtre. Utile pour obtenir un retour visuel immédiat pendant le développement ou les tests.
show_confboolTrueAffiche le score de confiance de chaque détection à côté de son étiquette. Donne une indication du degré de certitude du modèle pour chaque détection.
show_labelsboolTrueAffiche les étiquettes de chaque détection dans le résultat visuel. Permet d'identifier immédiatement les objets détectés.

Fonctionnement du comptage par zone#

La solution RegionCounter convertit chaque zone transmise en un polygone d’au moins trois points. Une simple liste de points devient une zone unique nommée Region#01, tandis qu’un dictionnaire conserve les noms de zones que tu as définis ; chaque zone est dessinée dans une couleur distincte de la palette Ultralytics. Chaque image est ensuite traitée en trois étapes :

  1. Le suivi YOLO26 détecte et suit chaque objet dans l’image.
  2. Pour chaque objet suivi, la solution calcule le centre de la boîte englobante et vérifie dans quels polygones de zone il se trouve
  3. Le décompte de chaque zone est affiché en son centre, puis les décomptes sont remis à zéro avant l’image suivante

Comme les décomptes redémarrent à chaque image, le nombre affiché dans une zone correspond à son occupation actuelle, c’est-à-dire au nombre d’objets qui s’y trouvent à cet instant, et non à un total cumulé. Pour compter de façon cumulative les objets qui franchissent une limite, utilise plutôt la solution ObjectCounter.

Chaque appel renvoie également un objet de résultats dont l’attribut plot_im contient l’image annotée et dont le dictionnaire region_counts associe les noms de zones à leurs décomptes. Tu peux ainsi intégrer ces valeurs à la logique de ta propre application.

Conclusion#

La solution RegionCounter d’Ultralytics YOLO26 surveille en direct le nombre d’objets dans autant de zones nommées que nécessaire, avec seulement quelques lignes de code. Pour aller plus loin, compte les franchissements de limites avec le comptage d’objets, suis les objets à l’intérieur d’une seule zone avec TrackZone ou découvre les autres solutions Ultralytics.

FAQ#

  • Ultralytics YOLO26 compte les objets par zone en suivant chaque objet de l’image et en vérifiant si le centre de sa boîte englobante se trouve dans chacun des polygones définis par l’utilisateur. Le nombre affiché pour une zone correspond à son occupation actuelle dans cette image, et non à un total cumulé. Les options de configuration sont répertoriées dans la section Arguments de RegionCounter().

  • Transmets l’argument region sous forme de dictionnaire associant les noms de zones à des listes de points, comme dans l’exemple principal :

    from ultralytics import solutions
    
    region_points = {
        "region-01": [(50, 50), (250, 50), (250, 250), (50, 250)],
        "region-02": [(640, 640), (780, 640), (780, 720), (640, 720)],
    }
    regioncounter = solutions.RegionCounter(region=region_points, model="yolo26n.pt", show=True)

    Chaque zone nommée est dessinée dans une couleur distincte et possède son propre décompte.

  • L’objet renvoyé par chaque appel regioncounter(im0) contient un dictionnaire region_counts associant les noms de zones à leurs décomptes, ainsi que plot_im (l’image annotée) et total_tracks (le nombre d’objets suivis). Affiche l’objet de résultats pour examiner tous les champs disponibles.

  • Oui. Passe l’argument classes avec les indices des classes à conserver, par exemple classes=[0] pour compter uniquement les personnes avec un modèle préentraîné sur COCO. La liste complète des arguments liés au suivi se trouve dans la section RegionCounter() Arguments.

  • RegionCounter indique le nombre d’objets présents dans chaque zone polygonale de l’image courante, tandis que ObjectCounter compte les objets de manière cumulative lorsqu’ils franchissent une ligne ou la limite d’une zone, en suivant les totaux des entrées et des sorties. Utilise RegionCounter pour connaître en temps réel le nombre d’objets présents dans une ou plusieurs zones et ObjectCounter pour compter les entrées et les sorties ; seules les régions en forme de ligne sont prises en charge par ObjectCounter.

Commentaires99

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. pedmindsetGitHub

    Been trying to figure this out for a while now. I want to ask, can I use object counting in regions with instance sementation and tracking? You want to count vehicles that cross two specific regions, like so Object 001 crossed region A and region B. Is this possible to do

    1
    1. Glenn JocherUltralytics

      @pedmindset yes, it is possible to count objects crossing multiple regions using Ultralytics YOLO11. You can utilize the RegionCounter class to define multiple regions and track objects across them. The objects' movement through these regions can be tracked using persistent IDs, enabling you to determine which object crossed which regions. For implementation details, refer to the Region Counting Guide.

      1
  2. amulyaamaggididivamiGitHub
    import cv2
    from ultralytics import solutions
    
    # Load video file
    cap = cv2.VideoCapture("retail-store.mp4")
    assert cap.isOpened(), "Error reading video file"
    
    # Define the counting line coordinates (adjust as per your scene)
    region_points = [(1135, 714), (1134, 416)]
    
    # Get video properties
    w, h, fps = (int(cap.get(x)) for x in (
        cv2.CAP_PROP_FRAME_WIDTH,
        cv2.CAP_PROP_FRAME_HEIGHT,
        cv2.CAP_PROP_FPS,
    ))
    
    # Setup video writer for output
    video_writer = cv2.VideoWriter(
        "object_counting_output.mp4",
        cv2.VideoWriter_fourcc(*"mp4v"),
        fps,
        (w, h),
    )
    
    # Initialize the object counter
    counter = solutions.ObjectCounter(
        show=False,                 # Don't show live preview
        region=region_points,       # Line coordinates
        model="yolo11n.pt",         # YOLO model
        classes=[0],                # Class 0 = person
        line_width=3,
    )
    
    # Process video frame by frame
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            print("Video processing complete.")
            break
    
        # Run the counter on the frame
        results = counter(frame)
    
        # Write to output video
        video_writer.write(results.plot_im)
    
    # Cleanup
    cap.release()
    video_writer.release()
    cv2.destroyAllWindows()
    
    print(f"✅ Processing complete. Saved as 'object_counting_output.mp4'")

    I’m getting the count reversed — the number of people entering is shown as OUT, and those exiting are shown as IN. How can I fix this?

    1. RizwanMunawarGitHub

      @amulyaamaggididivami Hi, can you please try reversing the region coordinates, like mentioned? I believe this will work.

      region_points = [(1134, 416), (1135, 714)]
    2. Glenn JocherUltralytics

      @SudhanshuBlaze IN/OUT for line counters is image-axis based, not compass: for a mostly vertical line, IN = motion to the right (+x) and OUT = left; for a mostly horizontal line, IN = down (+y) and OUT = up; you can relabel to N/S/E/W post-process like this:

      def label_dirs(results, p1, p2):
          (x1, y1), (x2, y2) = p1, p2
          vertical = abs(x1 - x2) < abs(y1 - y2)
          return ({"eastbound": results.in_count, "westbound": results.out_count} if vertical
                  else {"southbound": results.in_count, "northbound": results.out_count})

      Details of the IN/OUT logic are in the count_objects method of the ObjectCounter reference.

  3. Forlin12GitHub

    Hello, I would like to know how it works to remove how many objects there are per instant region because I can't extract this information.

  4. SudhanshuBlazeGitHub

    Hi,

    I was wondering in the case of LINE counters, if there's a thumb rule to translate the IN, OUT count to North->South, East-> West, something like this. How do I know which direction is IN and which direction is OUT in the case of LINE counters?

    My coordinates: line_counter1 = [(842, 1434), (640, 2200)]
    line_counter2 = [(1028, 1304), (1094, 1038)]
    line_counter3 = [(1068, 1038), (684, 1048)]
    line_counter4 = [(2498, 546), (3276, 572)]
    line_counter5 = [(3244, 786), (3414, 904)]
    line_counter6 = [(1830, 958), (1668, 710)]

    Thanks in advance

  5. morusskGitHub

    Hey, I am trying to use solutions.RegionCounter() with conf less than 0.25 but it seems to be ignoring it, is that by design? If I use conf > 0.25 it is taken into account and counts only detections with confidence higher than conf in particular region but lower then 0.25 seems to be ignored and those detections have not chance of being counted by solutions.RegionCounter(). Please advice.

    1. RizwanMunawarGitHub

      @morussk Hi, thanks for sharing the details. The counting in region feature relies on object tracking rather than standalone predictions. As a result, detections with a confidence score below 0.25 are ignored by default.

      However, this behaviour can be modified by adjusting the track_high_thresh parameter. Currently, the Solutions class doesn’t support adjusting tracking configuration core options directly, but you can adjust it by cloning the code and modifying the tracker's configurations file.

      Note: We always recommend using the latest version of the Ultralytics Python package. You can update it by running: pip install -U ultralytics.

      Thanks.

      1
    1. Glenn JocherUltralytics

      @dimasfadhila for region-based object counting in the Ultralytics example, we use models pre-trained on the COCO dataset by default, which includes 80 common object classes. You can see the full class list in our COCO dataset documentation. If you need to count custom objects, you'll want to train on your own dataset using YOLO's training mode.

  6. rejensGitHub

    Process video

    while cap.isOpened(): success, im0 = cap.read() # Read the video frame. if not success: break im0 = region.count(im0) # Count the objects in different regions of frame. cv2.imshow("frame", im0) if cv2.waitKey(1) & 0xFF == ord('q'): break

    this successfully did count and display the objects inside the region, how can i retrieve the number of counts, seems region.count(im0) returns the image only.

    thanks

    1. Glenn JocherUltralytics(modifié)

      @rejens RegionCounter returns a results object, so call it on each frame and read the per-region counts from region_counts:

      results = region(im0)
      print(results.region_counts)  # e.g. {'Region#01': 3}
      im0 = results.plot_im

      The counts are for the current frame (they reset on every frame). Let me know if you need further clarification!

  7. DarkbutbrightGitHub

    hi,counter = solutions.ObjectCounter(paras),im0 = counter.count(im0),Can the type information, font size, and position of the count in the video be set?

    1. Glenn JocherUltralytics(modifié)

      @Darkbutbright yes, you can customize the text information, font size and position of the count by modifying the solution source code. For ObjectCounter, the counts are drawn in its display_counts() method (in ultralytics/solutions/object_counter.py) through the SolutionAnnotator, so you can adjust the text rendering there. You can also call the solution and draw your own text on the returned plot_im with cv2.putText(), using results.in_count and results.out_count. Let me know if you need further clarification!

    2. DarkbutbrightGitHub

      Thank you for your patient answer, but I really don't know where to get the detailed instructions (documents) of the solutions class. Could you please tell me how to get it (including more clear instructions for using other classes of yolo)?

    3. Glenn JocherUltralytics

      @Darkbutbright thank you for your question! You can find detailed instructions and documentation for the solutions class and other YOLO functionalities in the Ultralytics Docs. For specific examples, such as region counting or object tracking, check the solutions guide or the respective sections in the repository. Let me know if you need assistance with a particular use case!

  8. kemalfrkGitHub

    Hello, select the area with mouse events how to write the code that counts these classes if it enters a class.Thanks

    1. Glenn JocherUltralytics

      @kemalfrk to implement object counting in specific regions using mouse events, you can modify the region points dynamically by capturing mouse click events and updating the region coordinates in real-time. You can refer to the Ultralytics YOLOv8 region counting example for guidance on how to set up and use the RegionCounter. If you have further questions or need additional customization, feel free to ask!

    1. Glenn JocherUltralytics

      @MuhammedEnesGurkan to count only sheep, use the --classes argument to specify the class index for sheep in your model. For example, if sheep are class 2, run: python yolov8_region_counter.py --source "path/to/video.mp4" --classes 2. Adjust the class index as needed based on your model's class mapping.