Skip to content

Reference for ultralytics/solutions/region_counter.py

Note

This file is available at https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/region_counter.py. If you spot a problem please help fix it by contributing a Pull Request 🛠️. Thank you 🙏!


ultralytics.solutions.region_counter.RegionCounter

RegionCounter(**kwargs)

Bases: BaseSolution

A class designed for real-time counting of objects within user-defined regions in a video stream.

This class inherits from BaseSolution and offers functionalities to define polygonal regions in a video frame, track objects, and count those objects that pass through each defined region. This makes it useful for applications that require counting in specified areas, such as monitoring zones or segmented sections.

Attributes:

NameTypeDescription
region_templatedict

A template for creating new counting regions with default attributes including the name, polygon coordinates, and display colors.

counting_regionslist

A list storing all defined regions, where each entry is based on region_template and includes specific region settings like name, coordinates, and color.

Methods:

NameDescription
add_region

Adds a new counting region with specified attributes, such as the region's name, polygon points, region color, and text color.

count

Processes video frames to count objects in each region, drawing regions and displaying counts on the frame. Handles object detection, region definition, and containment checks.

Source code in ultralytics/solutions/region_counter.py 
28
29
30
31
32
33
34
35
36
37
38
39
def __init__(self, **kwargs):
    """Initializes the RegionCounter class for real-time counting in different regions of the video streams."""
    super().__init__(**kwargs)
    self.region_template = {
        "name": "Default Region",
        "polygon": None,
        "counts": 0,
        "dragging": False,
        "region_color": (255, 255, 255),
        "text_color": (0, 0, 0),
    }
    self.counting_regions = []

add_region

add_region(name, polygon_points, region_color, text_color)

Adds a new region to the counting list based on the provided template with specific attributes.

Parameters:

NameTypeDescriptionDefault
namestr

Name assigned to the new region.

required
polygon_pointslist[tuple]

List of (x, y) coordinates defining the region's polygon.

required
region_colortuple

BGR color for region visualization.

required
text_colortuple

BGR color for the text within the region.

required
Source code in ultralytics/solutions/region_counter.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
def add_region(self, name, polygon_points, region_color, text_color):
    """
    Adds a new region to the counting list based on the provided template with specific attributes.

    Args:
        name (str): Name assigned to the new region.
        polygon_points (list[tuple]): List of (x, y) coordinates defining the region's polygon.
        region_color (tuple): BGR color for region visualization.
        text_color (tuple): BGR color for the text within the region.
    """
    region = self.region_template.copy()
    region.update(
        {
            "name": name,
            "polygon": self.Polygon(polygon_points),
            "region_color": region_color,
            "text_color": text_color,
        }
    )
    self.counting_regions.append(region)

count

count(im0)

Processes the input frame to detect and count objects within each defined region.

Parameters:

NameTypeDescriptionDefault
im0ndarray

Input image frame where objects and regions are annotated.

required

Returns:

NameTypeDescription
im0ndarray

Processed image frame with annotated counting information.

Source code in ultralytics/solutions/region_counter.py 
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def count(self, im0):
    """
    Processes the input frame to detect and count objects within each defined region.

    Args:
        im0 (numpy.ndarray): Input image frame where objects and regions are annotated.

    Returns:
       im0 (numpy.ndarray): Processed image frame with annotated counting information.
    """
    self.annotator = Annotator(im0, line_width=self.line_width)
    self.extract_tracks(im0)

    # Region initialization and conversion
    if self.region is None:
        self.initialize_region()
        regions = {"Region#01": self.region}
    else:
        regions = self.region if isinstance(self.region, dict) else {"Region#01": self.region}

    # Draw regions and process counts for each defined area
    for idx, (region_name, reg_pts) in enumerate(regions.items(), start=1):
        color = colors(idx, True)
        self.annotator.draw_region(reg_pts=reg_pts, color=color, thickness=self.line_width * 2)
        self.add_region(region_name, reg_pts, color, self.annotator.get_txt_color())

    # Prepare regions for containment check
    for region in self.counting_regions:
        region["prepared_polygon"] = self.prep(region["polygon"])

    # Process bounding boxes and count objects within each region
    for box, cls in zip(self.boxes, self.clss):
        self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
        bbox_center = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)

        for region in self.counting_regions:
            if region["prepared_polygon"].contains(self.Point(bbox_center)):
                region["counts"] += 1

    # Display counts in each region
    for region in self.counting_regions:
        self.annotator.text_label(
            region["polygon"].bounds,
            label=str(region["counts"]),
            color=region["region_color"],
            txt_color=region["text_color"],
        )
        region["counts"] = 0  # Reset count for next frame

    self.display_output(im0)
    return im0



📅 Created 4 days ago ✏️ Updated 4 days ago
RizwanMunawar