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

ultralytics/solutions/instance_segmentation.py

@@ -0,0 +1,69 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
+
+
+class InstanceSegmentation(BaseSolution):
+    """
+    A class to manage instance segmentation in images or video streams.
+
+    This class extends the BaseSolution class and provides functionality for performing instance segmentation, including
+    drawing segmented masks with bounding boxes and labels.
+
+    Attributes:
+        model (str): The segmentation model to use for inference.
+
+    Methods:
+        process: Processes the input image to perform instance segmentation and annotate results.
+
+    Examples:
+        >>> segmenter = InstanceSegmentation()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> results = segmenter.segment(frame)
+        >>> print(f"Total segmented instances: {results['total_tracks']}")
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the InstanceSegmentation class for detecting and annotating segmented instances.
+
+        Args:
+            **kwargs (Any): Keyword arguments passed to the BaseSolution parent class.
+                model (str): Model name or path, defaults to "yolo11n-seg.pt".
+        """
+        kwargs["model"] = kwargs.get("model", "yolo11n-seg.pt")
+        super().__init__(**kwargs)
+
+    def process(self, im0):
+        """
+        Performs instance segmentation on the input image and annotates the results.
+
+        Args:
+            im0 (numpy.ndarray): The input image for segmentation.
+
+        Returns:
+            (SolutionResults): Object containing the annotated image and total number of tracked instances.
+
+        Examples:
+            >>> segmenter = InstanceSegmentation()
+            >>> frame = cv2.imread("image.jpg")
+            >>> summary = segmenter.segment(frame)
+            >>> print(summary)
+        """
+        self.extract_tracks(im0)  # Extract tracks (bounding boxes, classes, and masks)
+        annotator = SolutionAnnotator(im0, self.line_width)
+
+        # Iterate over detected classes, track IDs, and segmentation masks
+        if self.masks is None:
+            self.LOGGER.warning("⚠️ No masks detected! Ensure you're using a supported Ultralytics segmentation model.")
+        else:
+            for cls, t_id, mask in zip(self.clss, self.track_ids, self.masks):
+                # Annotate the image with segmentation mask, mask color, and label
+                annotator.segmentation_mask(mask=mask, mask_color=colors(t_id, True), label=self.names[cls])
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display the annotated output using the base class function
+
+        # Return SolutionResults
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/solutions/object_blurrer.py

@@ -0,0 +1,89 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+
+import cv2
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils import LOGGER
+from ultralytics.utils.plotting import colors
+
+
+class ObjectBlurrer(BaseSolution):
+    """
+    A class to manage the blurring of detected objects in a real-time video stream.
+
+    This class extends the BaseSolution class and provides functionality for blurring objects based on detected bounding
+    boxes. The blurred areas are updated directly in the input image, allowing for privacy preservation or other effects.
+
+    Attributes:
+        blur_ratio (int): The intensity of the blur effect applied to detected objects (higher values create more blur).
+        iou (float): Intersection over Union threshold for object detection.
+        conf (float): Confidence threshold for object detection.
+
+    Methods:
+        process: Applies a blurring effect to detected objects in the input image.
+        extract_tracks: Extracts tracking information from detected objects.
+        display_output: Displays the processed output image.
+
+    Examples:
+        >>> blurrer = ObjectBlurrer()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> processed_results = blurrer.process(frame)
+        >>> print(f"Total blurred objects: {processed_results.total_tracks}")
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the ObjectBlurrer class for applying a blur effect to objects detected in video streams or images.
+
+        Args:
+            **kwargs (Any): Keyword arguments passed to the parent class and for configuration.
+                blur_ratio (float): Intensity of the blur effect (0.1-1.0, default=0.5).
+        """
+        super().__init__(**kwargs)
+        blur_ratio = kwargs.get("blur_ratio", 0.5)
+        if blur_ratio < 0.1:
+            LOGGER.warning("⚠️ blur ratio cannot be less than 0.1, updating it to default value 0.5")
+            blur_ratio = 0.5
+        self.blur_ratio = int(blur_ratio * 100)
+
+    def process(self, im0):
+        """
+        Applies a blurring effect to detected objects in the input image.
+
+        This method extracts tracking information, applies blur to regions corresponding to detected objects,
+        and annotates the image with bounding boxes.
+
+        Args:
+            im0 (numpy.ndarray): The input image containing detected objects.
+
+        Returns:
+            (SolutionResults): Object containing the processed image and number of tracked objects.
+                - plot_im (numpy.ndarray): The annotated output image with blurred objects.
+                - total_tracks (int): The total number of tracked objects in the frame.
+
+        Examples:
+            >>> blurrer = ObjectBlurrer()
+            >>> frame = cv2.imread("image.jpg")
+            >>> results = blurrer.process(frame)
+            >>> print(f"Blurred {results.total_tracks} objects")
+        """
+        self.extract_tracks(im0)  # Extract tracks
+        annotator = SolutionAnnotator(im0, self.line_width)
+
+        # Iterate over bounding boxes and classes
+        for box, cls in zip(self.boxes, self.clss):
+            # Crop and blur the detected object
+            blur_obj = cv2.blur(
+                im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])],
+                (self.blur_ratio, self.blur_ratio),
+            )
+            # Update the blurred area in the original image
+            im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] = blur_obj
+            annotator.box_label(box, label=self.names[cls], color=colors(cls, True))  # Annotate bounding box
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display the output using the base class function
+
+        # Return a SolutionResults
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/solutions/object_counter.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
-from ultralytics.utils.plotting import Annotator, colors
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
 
 
 class ObjectCounter(BaseSolution):
@@ -24,12 +24,12 @@ class ObjectCounter(BaseSolution):
         count_objects: Counts objects within a polygonal or linear region.
         store_classwise_counts: Initializes class-wise counts if not already present.
         display_counts: Displays object counts on the frame.
-        count: Processes input data (frames or object tracks) and updates counts.
+        process: Processes input data (frames or object tracks) and updates counts.
 
     Examples:
         >>> counter = ObjectCounter()
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = counter.count(frame)
+        >>> results = counter.process(frame)
         >>> print(f"Inward count: {counter.in_count}, Outward count: {counter.out_count}")
     """
 
@@ -41,7 +41,7 @@ class ObjectCounter(BaseSolution):
         self.out_count = 0  # Counter for objects moving outward
         self.counted_ids = []  # List of IDs of objects that have been counted
         self.classwise_counts = {}  # Dictionary for counts, categorized by object class
-        self.region_initialized = False  # Bool variable for region initialization
+        self.region_initialized = False  # Flag indicating whether the region has been initialized
 
         self.show_in = self.CFG["show_in"]
         self.show_out = self.CFG["show_out"]
@@ -51,7 +51,7 @@ class ObjectCounter(BaseSolution):
         Counts objects within a polygonal or linear region based on their tracks.
 
         Args:
-            current_centroid (Tuple[float, float]): Current centroid values in the current frame.
+            current_centroid (Tuple[float, float]): Current centroid coordinates (x, y) in the current frame.
             track_id (int): Unique identifier for the tracked object.
             prev_position (Tuple[float, float]): Last frame position coordinates (x, y) of the track.
             cls (int): Class index for classwise count updates.
@@ -60,10 +60,10 @@ class ObjectCounter(BaseSolution):
             >>> counter = ObjectCounter()
             >>> track_line = {1: [100, 200], 2: [110, 210], 3: [120, 220]}
             >>> box = [130, 230, 150, 250]
-            >>> track_id = 1
-            >>> prev_position = (120, 220)
-            >>> cls = 0
-            >>> counter.count_objects(current_centroid, track_id, prev_position, cls)
+            >>> track_id_num = 1
+            >>> previous_position = (120, 220)
+            >>> class_to_count = 0  # In COCO model, class 0 = person
+            >>> counter.count_objects((140, 240), track_id_num, previous_position, class_to_count)
         """
         if prev_position is None or track_id in self.counted_ids:
             return
@@ -101,10 +101,10 @@ class ObjectCounter(BaseSolution):
                     and current_centroid[0] > prev_position[0]
                     or region_width >= region_height
                     and current_centroid[1] > prev_position[1]
-                ):  # Moving right
+                ):  # Moving right or downward
                     self.in_count += 1
                     self.classwise_counts[self.names[cls]]["IN"] += 1
-                else:  # Moving left
+                else:  # Moving left or upward
                     self.out_count += 1
                     self.classwise_counts[self.names[cls]]["OUT"] += 1
                 self.counted_ids.append(track_id)
@@ -116,9 +116,6 @@ class ObjectCounter(BaseSolution):
         Args:
             cls (int): Class index for classwise count updates.
 
-        This method ensures that the 'classwise_counts' dictionary contains an entry for the specified class,
-        initializing 'IN' and 'OUT' counts to zero if the class is not already present.
-
         Examples:
             >>> counter = ObjectCounter()
             >>> counter.store_classwise_counts(0)  # Initialize counts for class index 0
@@ -128,12 +125,12 @@ class ObjectCounter(BaseSolution):
         if self.names[cls] not in self.classwise_counts:
             self.classwise_counts[self.names[cls]] = {"IN": 0, "OUT": 0}
 
-    def display_counts(self, im0):
+    def display_counts(self, plot_im):
         """
         Displays object counts on the input image or frame.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to display counts on.
+            plot_im (numpy.ndarray): The image or frame to display counts on.
 
         Examples:
             >>> counter = ObjectCounter()
@@ -146,11 +143,10 @@ class ObjectCounter(BaseSolution):
             for key, value in self.classwise_counts.items()
             if value["IN"] != 0 or value["OUT"] != 0
         }
-
         if labels_dict:
-            self.annotator.display_analytics(im0, labels_dict, (104, 31, 17), (255, 255, 255), 10)
+            self.annotator.display_analytics(plot_im, labels_dict, (104, 31, 17), (255, 255, 255), 10)
 
-    def count(self, im0):
+    def process(self, im0):
         """
         Processes input data (frames or object tracks) and updates object counts.
 
@@ -161,19 +157,21 @@ class ObjectCounter(BaseSolution):
             im0 (numpy.ndarray): The input image or frame to be processed.
 
         Returns:
-            (numpy.ndarray): The processed image with annotations and count information.
+            (SolutionResults): Contains processed image `im0`, 'in_count' (int, count of objects entering the region),
+                'out_count' (int, count of objects exiting the region), 'classwise_count' (Dict, per-class object count),
+                and 'total_tracks' (int, total number of tracked objects).
 
         Examples:
             >>> counter = ObjectCounter()
             >>> frame = cv2.imread("path/to/image.jpg")
-            >>> processed_frame = counter.count(frame)
+            >>> results = counter.process(frame)
         """
         if not self.region_initialized:
             self.initialize_region()
             self.region_initialized = True
 
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
         self.extract_tracks(im0)  # Extract tracks
+        self.annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
         self.annotator.draw_region(
             reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
@@ -184,20 +182,24 @@ class ObjectCounter(BaseSolution):
             # Draw bounding box and counting region
             self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
             self.store_tracking_history(track_id, box)  # Store track history
-            self.store_classwise_counts(cls)  # store classwise counts in dict
+            self.store_classwise_counts(cls)  # Store classwise counts in dict
 
-            # Draw tracks of objects
-            self.annotator.draw_centroid_and_tracks(
-                self.track_line, color=colors(int(cls), True), track_thickness=self.line_width
-            )
             current_centroid = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
-            # store previous position of track for object counting
+            # Store previous position of track for object counting
             prev_position = None
             if len(self.track_history[track_id]) > 1:
                 prev_position = self.track_history[track_id][-2]
             self.count_objects(current_centroid, track_id, prev_position, cls)  # Perform object counting
 
-        self.display_counts(im0)  # Display the counts on the frame
-        self.display_output(im0)  # display output with base class function
-
-        return im0  # return output image for more usage
+        plot_im = self.annotator.result()
+        self.display_counts(plot_im)  # Display the counts on the frame
+        self.display_output(plot_im)  # Display output with base class function
+
+        # Return SolutionResults
+        return SolutionResults(
+            plot_im=plot_im,
+            in_count=self.in_count,
+            out_count=self.out_count,
+            classwise_count=self.classwise_counts,
+            total_tracks=len(self.track_ids),
+        )

ultralytics/solutions/object_cropper.py

@@ -0,0 +1,84 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+from pathlib import Path
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionResults
+from ultralytics.utils.plotting import save_one_box
+
+
+class ObjectCropper(BaseSolution):
+    """
+    A class to manage the cropping of detected objects in a real-time video stream or images.
+
+    This class extends the BaseSolution class and provides functionality for cropping objects based on detected bounding
+    boxes. The cropped images are saved to a specified directory for further analysis or usage.
+
+    Attributes:
+        crop_dir (str): Directory where cropped object images are stored.
+        crop_idx (int): Counter for the total number of cropped objects.
+        iou (float): IoU (Intersection over Union) threshold for non-maximum suppression.
+        conf (float): Confidence threshold for filtering detections.
+
+    Methods:
+        process: Crops detected objects from the input image and saves them to the output directory.
+
+    Examples:
+        >>> cropper = ObjectCropper()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> processed_results = cropper.process(frame)
+        >>> print(f"Total cropped objects: {cropper.crop_idx}")
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the ObjectCropper class for cropping objects from detected bounding boxes.
+
+        Args:
+            **kwargs (Any): Keyword arguments passed to the parent class and used for configuration.
+                crop_dir (str): Path to the directory for saving cropped object images.
+        """
+        super().__init__(**kwargs)
+
+        self.crop_dir = kwargs.get("crop_dir", "cropped-detections")  # Directory for storing cropped detections
+        if not os.path.exists(self.crop_dir):
+            os.mkdir(self.crop_dir)  # Create directory if it does not exist
+        if self.CFG["show"]:
+            self.LOGGER.info(
+                f"⚠️ show=True disabled for crop solution, results will be saved in the directory named: {self.crop_dir}"
+            )
+        self.crop_idx = 0  # Initialize counter for total cropped objects
+        self.iou = self.CFG["iou"]
+        self.conf = self.CFG["conf"] if self.CFG["conf"] is not None else 0.25
+
+    def process(self, im0):
+        """
+        Crops detected objects from the input image and saves them as separate images.
+
+        Args:
+            im0 (numpy.ndarray): The input image containing detected objects.
+
+        Returns:
+            (SolutionResults): A SolutionResults object containing the total number of cropped objects and processed image.
+
+        Examples:
+            >>> cropper = ObjectCropper()
+            >>> frame = cv2.imread("image.jpg")
+            >>> results = cropper.process(frame)
+            >>> print(f"Total cropped objects: {results.total_crop_objects}")
+        """
+        results = self.model.predict(
+            im0, classes=self.classes, conf=self.conf, iou=self.iou, device=self.CFG["device"]
+        )[0]
+
+        for box in results.boxes:
+            self.crop_idx += 1
+            save_one_box(
+                box.xyxy,
+                im0,
+                file=Path(self.crop_dir) / f"crop_{self.crop_idx}.jpg",
+                BGR=True,
+            )
+
+        # Return SolutionResults
+        return SolutionResults(plot_im=im0, total_crop_objects=self.crop_idx)

ultralytics/solutions/parking_management.py

@@ -5,10 +5,9 @@ import json
 import cv2
 import numpy as np
 
-from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils import LOGGER
 from ultralytics.utils.checks import check_imshow
-from ultralytics.utils.plotting import Annotator
 
 
 class ParkingPtsSelection:
@@ -189,7 +188,7 @@ class ParkingManagement(BaseSolution):
         dc (Tuple[int, int, int]): RGB color tuple for centroid visualization of detected objects.
 
     Methods:
-        process_data: Processes model data for parking lot management and visualization.
+        process: Processes the input image for parking lot management and visualization.
 
     Examples:
         >>> from ultralytics.solutions import ParkingManagement
@@ -216,9 +215,9 @@ class ParkingManagement(BaseSolution):
         self.occ = (0, 255, 0)  # occupied region color
         self.dc = (255, 0, 189)  # centroid color for each box
 
-    def process_data(self, im0):
+    def process(self, im0):
         """
-        Processes the model data for parking lot management.
+        Processes the input image for parking lot management and visualization.
 
         This function analyzes the input image, extracts tracks, and determines the occupancy status of parking
         regions defined in the JSON file. It annotates the image with occupied and available parking spots,
@@ -227,14 +226,18 @@ class ParkingManagement(BaseSolution):
         Args:
             im0 (np.ndarray): The input inference image.
 
+        Returns:
+            (SolutionResults): Contains processed image `plot_im`, 'filled_slots' (number of occupied parking slots),
+                'available_slots' (number of available parking slots), and 'total_tracks' (total number of tracked objects).
+
         Examples:
             >>> parking_manager = ParkingManagement(json_file="parking_regions.json")
             >>> image = cv2.imread("parking_lot.jpg")
-            >>> parking_manager.process_data(image)
+            >>> results = parking_manager.process(image)
         """
         self.extract_tracks(im0)  # extract tracks from im0
         es, fs = len(self.json), 0  # empty slots, filled slots
-        annotator = Annotator(im0, self.line_width)  # init annotator
+        annotator = SolutionAnnotator(im0, self.line_width)  # init annotator
 
         for region in self.json:
             # Convert points to a NumPy array with the correct dtype and reshape properly
@@ -257,5 +260,14 @@ class ParkingManagement(BaseSolution):
         self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
-        self.display_output(im0)  # display output with base class function
-        return im0  # return output image for more usage
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # display output with base class function
+
+        # Return SolutionResults
+        return SolutionResults(
+            plot_im=plot_im,
+            filled_slots=self.pr_info["Occupancy"],
+            available_slots=self.pr_info["Available"],
+            total_tracks=len(self.track_ids),
+        )

ultralytics/solutions/queue_management.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.solutions.solutions import BaseSolution
-from ultralytics.utils.plotting import Annotator, colors
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
 
 
 class QueueManager(BaseSolution):
@@ -15,13 +15,12 @@ class QueueManager(BaseSolution):
         counts (int): The current count of objects in the queue.
         rect_color (Tuple[int, int, int]): RGB color tuple for drawing the queue region rectangle.
         region_length (int): The number of points defining the queue region.
-        annotator (Annotator): An instance of the Annotator class for drawing on frames.
         track_line (List[Tuple[int, int]]): List of track line coordinates.
         track_history (Dict[int, List[Tuple[int, int]]]): Dictionary storing tracking history for each object.
 
     Methods:
         initialize_region: Initializes the queue region.
-        process_queue: Processes a single frame for queue management.
+        process: Processes a single frame for queue management.
         extract_tracks: Extracts object tracks from the current frame.
         store_tracking_history: Stores the tracking history for an object.
         display_output: Displays the processed output.
@@ -33,18 +32,18 @@ class QueueManager(BaseSolution):
         >>>     success, im0 = cap.read()
         >>>     if not success:
         >>>         break
-        >>>     out = queue.process_queue(im0)
+        >>>     results = queue_manager.process(im0)
     """
 
     def __init__(self, **kwargs):
         """Initializes the QueueManager with parameters for tracking and counting objects in a video stream."""
         super().__init__(**kwargs)
         self.initialize_region()
-        self.counts = 0  # Queue counts Information
-        self.rect_color = (255, 255, 255)  # Rectangle color
+        self.counts = 0  # Queue counts information
+        self.rect_color = (255, 255, 255)  # Rectangle color for visualization
         self.region_length = len(self.region)  # Store region length for further usage
 
-    def process_queue(self, im0):
+    def process(self, im0):
         """
         Processes the queue management for a single frame of video.
 
@@ -52,48 +51,28 @@ class QueueManager(BaseSolution):
             im0 (numpy.ndarray): Input image for processing, typically a frame from a video stream.
 
         Returns:
-            (numpy.ndarray): Processed image with annotations, bounding boxes, and queue counts.
-
-        This method performs the following steps:
-        1. Resets the queue count for the current frame.
-        2. Initializes an Annotator object for drawing on the image.
-        3. Extracts tracks from the image.
-        4. Draws the counting region on the image.
-        5. For each detected object:
-           - Draws bounding boxes and labels.
-           - Stores tracking history.
-           - Draws centroids and tracks.
-           - Checks if the object is inside the counting region and updates the count.
-        6. Displays the queue count on the image.
-        7. Displays the processed output.
+            (SolutionResults): Contains processed image `im0`, 'queue_count' (int, number of objects in the queue) and
+                'total_tracks' (int, total number of tracked objects).
 
         Examples:
             >>> queue_manager = QueueManager()
             >>> frame = cv2.imread("frame.jpg")
-            >>> processed_frame = queue_manager.process_queue(frame)
+            >>> results = queue_manager.process(frame)
         """
         self.counts = 0  # Reset counts every frame
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
-        self.extract_tracks(im0)  # Extract tracks
-
-        self.annotator.draw_region(
-            reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2
-        )  # Draw region
+        self.extract_tracks(im0)  # Extract tracks from the current frame
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
+        annotator.draw_region(reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2)  # Draw region
 
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
             # Draw bounding box and counting region
-            self.annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+            annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
             self.store_tracking_history(track_id, box)  # Store track history
 
-            # Draw tracks of objects
-            self.annotator.draw_centroid_and_tracks(
-                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
-            )
-
             # Cache frequently accessed attributes
             track_history = self.track_history.get(track_id, [])
 
-            # store previous position of track and check if the object is inside the counting region
+            # Store previous position of track and check if the object is inside the counting region
             prev_position = None
             if len(track_history) > 1:
                 prev_position = track_history[-2]
@@ -101,12 +80,14 @@ class QueueManager(BaseSolution):
                 self.counts += 1
 
         # Display queue counts
-        self.annotator.queue_counts_display(
+        annotator.queue_counts_display(
             f"Queue Counts : {str(self.counts)}",
             points=self.region,
             region_color=self.rect_color,
             txt_color=(104, 31, 17),
         )
-        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 object with processed data
+        return SolutionResults(plot_im=plot_im, queue_count=self.counts, total_tracks=len(self.track_ids))