ultralytics 8.3.87__py3-none-any.whl → 8.3.89__py3-none-any.whl

ultralytics/solutions/region_counter.py

@@ -1,33 +1,33 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
-from ultralytics.utils import LOGGER
-from ultralytics.utils.plotting import Annotator, colors
+import numpy as np
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
 
 
 class RegionCounter(BaseSolution):
     """
-    A class designed for real-time counting of objects within user-defined regions in a video stream.
+    A class 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.
+    This class inherits from `BaseSolution` and provides functionality to define polygonal regions in a video frame,
+    track objects, and count those objects that pass through each defined region. Useful for applications requiring
+    counting in specified areas, such as monitoring zones or segmented sections.
 
     Attributes:
-        region_template (dict): A template for creating new counting regions with default attributes including
-                                the name, polygon coordinates, and display colors.
-        counting_regions (list): A list storing all defined regions, where each entry is based on `region_template`
-                                 and includes specific region settings like name, coordinates, and color.
+        region_template (Dict): Template for creating new counting regions with default attributes including name,
+            polygon coordinates, and display colors.
+        counting_regions (List): List storing all defined regions, where each entry is based on `region_template`
+            and includes specific region settings like name, coordinates, and color.
+        region_counts (Dict): Dictionary storing the count of objects for each named region.
 
     Methods:
-        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.
+        add_region: Adds a new counting region with specified attributes.
+        process: Processes video frames to count objects in each region.
     """
 
     def __init__(self, **kwargs):
-        """Initializes the RegionCounter class for real-time counting in different regions of the video streams."""
+        """Initializes the RegionCounter class for real-time counting in different regions of video streams."""
         super().__init__(**kwargs)
         self.region_template = {
             "name": "Default Region",
@@ -37,6 +37,7 @@ class RegionCounter(BaseSolution):
             "region_color": (255, 255, 255),
             "text_color": (0, 0, 0),
         }
+        self.region_counts = {}
         self.counting_regions = []
 
     def add_region(self, name, polygon_points, region_color, text_color):
@@ -45,9 +46,9 @@ class RegionCounter(BaseSolution):
 
         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.
+            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(
@@ -60,57 +61,59 @@ class RegionCounter(BaseSolution):
         )
         self.counting_regions.append(region)
 
-    def count(self, im0):
+    def process(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.
+            im0 (np.ndarray): Input image frame where objects and regions are annotated.
 
         Returns:
-           im0 (numpy.ndarray): Processed image frame with annotated counting information.
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (int, total number of tracked objects),
+                and 'region_counts' (Dict, counts of objects per region).
         """
-        self.annotator = Annotator(im0, line_width=self.line_width)
         self.extract_tracks(im0)
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)
+
+        # Ensure self.region is initialized and structured as a dictionary
+        if not isinstance(self.region, dict):
+            self.region = {"Region#01": self.region or self.initialize_region()}
 
-        # 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):
-            if not isinstance(reg_pts, list) or not all(isinstance(pt, tuple) for pt in reg_pts):
-                LOGGER.warning(f"Invalid region points for {region_name}: {reg_pts}")
-                continue  # Skip invalid entries
+        # Draw only valid regions
+        for idx, (region_name, reg_pts) in enumerate(self.region.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())
+            annotator.draw_region(reg_pts, color, self.line_width * 2)
+            self.add_region(region_name, reg_pts, color, annotator.get_txt_color())
 
-        # Prepare regions for containment check
+        # Prepare regions for containment check (only process valid ones)
         for region in self.counting_regions:
-            region["prepared_polygon"] = self.prep(region["polygon"])
+            if "prepared_polygon" not in region:
+                region["prepared_polygon"] = self.prep(region["polygon"])
+
+        # Convert bounding boxes to NumPy array for center points
+        boxes_np = np.array([((box[0] + box[2]) / 2, (box[1] + box[3]) / 2) for box in self.boxes], dtype=np.float32)
+        points = [self.Point(pt) for pt in boxes_np]  # Convert centers to Point objects
 
-        # 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)
+        # Process bounding boxes & check containment
+        if points:
+            for (point, cls), box in zip(zip(points, self.clss), self.boxes):
+                annotator.box_label(box, label=self.names[cls], color=colors(cls))
 
-            for region in self.counting_regions:
-                if region["prepared_polygon"].contains(self.Point(bbox_center)):
-                    region["counts"] += 1
+                for region in self.counting_regions:
+                    if region["prepared_polygon"].contains(point):
+                        region["counts"] += 1
+                        self.region_counts[region["name"]] = region["counts"]
 
-        # Display counts in each region
+        # Display region counts
         for region in self.counting_regions:
-            self.annotator.text_label(
+            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
+            region["counts"] = 0  # Reset for next frame
+        plot_im = annotator.result()
+        self.display_output(plot_im)
 
-        self.display_output(im0)
-        return im0
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), region_counts=self.region_counts)

ultralytics/solutions/security_alarm.py

@@ -1,36 +1,44 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils import LOGGER
-from ultralytics.utils.plotting import Annotator, colors
+from ultralytics.utils.plotting import colors
 
 
 class SecurityAlarm(BaseSolution):
     """
     A class to manage security alarm functionalities for real-time monitoring.
 
-    This class extends the BaseSolution class and provides features to monitor
-    objects in a frame, send email notifications when specific thresholds are
-    exceeded for total detections, and annotate the output frame for visualization.
+    This class extends the BaseSolution class and provides features to monitor objects in a frame, send email
+    notifications when specific thresholds are exceeded for total detections, and annotate the output frame for
+    visualization.
 
     Attributes:
-       email_sent (bool): Flag to track if an email has already been sent for the current event.
-       records (int): Threshold for the number of detected objects to trigger an alert.
+        email_sent (bool): Flag to track if an email has already been sent for the current event.
+        records (int): Threshold for the number of detected objects to trigger an alert.
+        server (smtplib.SMTP): SMTP server connection for sending email alerts.
+        to_email (str): Recipient's email address for alerts.
+        from_email (str): Sender's email address for alerts.
 
     Methods:
-       authenticate: Sets up email server authentication for sending alerts.
-       send_email: Sends an email notification with details and an image attachment.
-       monitor: Monitors the frame, processes detections, and triggers alerts if thresholds are crossed.
+        authenticate: Sets up email server authentication for sending alerts.
+        send_email: Sends an email notification with details and an image attachment.
+        process: Monitors the frame, processes detections, and triggers alerts if thresholds are crossed.
 
     Examples:
         >>> security = SecurityAlarm()
         >>> security.authenticate("abc@gmail.com", "1111222233334444", "xyz@gmail.com")
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = security.monitor(frame)
+        >>> results = security.process(frame)
     """
 
     def __init__(self, **kwargs):
-        """Initializes the SecurityAlarm class with parameters for real-time object monitoring."""
+        """
+        Initializes the SecurityAlarm class with parameters for real-time object monitoring.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
         super().__init__(**kwargs)
         self.email_sent = False
         self.records = self.CFG["records"]
@@ -47,8 +55,7 @@ class SecurityAlarm(BaseSolution):
             password (str): Password for the sender's email account.
             to_email (str): Recipient's email address.
 
-        This method initializes a secure connection with the SMTP server
-        and logs in using the provided credentials.
+        This method initializes a secure connection with the SMTP server and logs in using the provided credentials.
 
         Examples:
             >>> alarm = SecurityAlarm()
@@ -70,8 +77,8 @@ class SecurityAlarm(BaseSolution):
             im0 (numpy.ndarray): The input image or frame to be attached to the email.
             records (int): The number of detected objects to be included in the email message.
 
-        This method encodes the input image, composes the email message with
-        details about the detection, and sends it to the specified recipient.
+        This method encodes the input image, composes the email message with details about the detection, and sends it
+        to the specified recipient.
 
         Examples:
             >>> alarm = SecurityAlarm()
@@ -105,40 +112,43 @@ class SecurityAlarm(BaseSolution):
             self.server.send_message(message)
             LOGGER.info("✅ Email sent successfully!")
         except Exception as e:
-            print(f"❌ Failed to send email: {e}")
+            LOGGER.error(f"❌ Failed to send email: {e}")
 
-    def monitor(self, im0):
+    def process(self, im0):
         """
         Monitors the frame, processes object detections, and triggers alerts if thresholds are exceeded.
 
         Args:
             im0 (numpy.ndarray): The input image or frame to be processed and annotated.
 
-        This method processes the input frame, extracts detections, annotates the frame
-        with bounding boxes, and sends an email notification if the number of detected objects
-        surpasses the specified threshold and an alert has not already been sent.
-
         Returns:
-            (numpy.ndarray): The processed frame with annotations.
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (total number of tracked objects) and
+                'email_sent' (whether an email alert was triggered).
+
+        This method processes the input frame, extracts detections, annotates the frame with bounding boxes, and sends
+        an email notification if the number of detected objects surpasses the specified threshold and an alert has not
+        already been sent.
 
         Examples:
             >>> alarm = SecurityAlarm()
             >>> frame = cv2.imread("path/to/image.jpg")
-            >>> processed_frame = alarm.monitor(frame)
+            >>> results = alarm.process(frame)
         """
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
         self.extract_tracks(im0)  # Extract tracks
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
-        # Iterate over bounding boxes, track ids and classes index
+        # Iterate over bounding boxes and classes index
         for box, cls in zip(self.boxes, self.clss):
             # Draw bounding box
-            self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
+            annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
 
         total_det = len(self.clss)
-        if total_det > self.records and not self.email_sent:  # Only send email If not sent before
+        if total_det > self.records and not self.email_sent:  # Only send email if not sent before
             self.send_email(im0, total_det)
             self.email_sent = True
 
-        self.display_output(im0)  # display output with base class function
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
 
-        return im0  # return output image for more usage
+        # Return a SolutionResults
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), email_sent=self.email_sent)