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

ultralytics/solutions/distance_calculation.py

@@ -4,8 +4,8 @@ import math
 
 import cv2
 
-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 DistanceCalculation(BaseSolution):
@@ -18,22 +18,17 @@ class DistanceCalculation(BaseSolution):
     Attributes:
         left_mouse_count (int): Counter for left mouse button clicks.
         selected_boxes (Dict[int, List[float]]): Dictionary to store selected bounding boxes and their track IDs.
-        annotator (Annotator): An instance of the Annotator class for drawing on the image.
-        boxes (List[List[float]]): List of bounding boxes for detected objects.
-        track_ids (List[int]): List of track IDs for detected objects.
-        clss (List[int]): List of class indices for detected objects.
-        names (List[str]): List of class names that the model can detect.
         centroids (List[List[int]]): List to store centroids of selected bounding boxes.
 
     Methods:
         mouse_event_for_distance: Handles mouse events for selecting objects in the video stream.
-        calculate: Processes video frames and calculates the distance between selected objects.
+        process: Processes video frames and calculates the distance between selected objects.
 
     Examples:
         >>> distance_calc = DistanceCalculation()
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = distance_calc.calculate(frame)
-        >>> cv2.imshow("Distance Calculation", processed_frame)
+        >>> results = distance_calc.process(frame)
+        >>> cv2.imshow("Distance Calculation", results.plot_im)
         >>> cv2.waitKey(0)
     """
 
@@ -44,8 +39,7 @@ class DistanceCalculation(BaseSolution):
         # Mouse event information
         self.left_mouse_count = 0
         self.selected_boxes = {}
-
-        self.centroids = []  # Initialize empty list to store centroids
+        self.centroids = []  # Store centroids of selected objects
 
     def mouse_event_for_distance(self, event, x, y, flags, param):
         """
@@ -56,7 +50,7 @@ class DistanceCalculation(BaseSolution):
             x (int): X-coordinate of the mouse pointer.
             y (int): Y-coordinate of the mouse pointer.
             flags (int): Flags associated with the event (e.g., cv2.EVENT_FLAG_CTRLKEY, cv2.EVENT_FLAG_SHIFTKEY).
-            param (Dict): Additional parameters passed to the function.
+            param (Any): Additional parameters passed to the function.
 
         Examples:
             >>> # Assuming 'dc' is an instance of DistanceCalculation
@@ -73,7 +67,7 @@ class DistanceCalculation(BaseSolution):
             self.selected_boxes = {}
             self.left_mouse_count = 0
 
-    def calculate(self, im0):
+    def process(self, im0):
         """
         Processes a video frame and calculates the distance between two selected bounding boxes.
 
@@ -84,41 +78,47 @@ class DistanceCalculation(BaseSolution):
             im0 (numpy.ndarray): The input image frame to process.
 
         Returns:
-            (numpy.ndarray): The processed image frame with annotations and distance calculations.
+            (SolutionResults): Contains processed image `plot_im`, `total_tracks` (int) representing the total number
+                of tracked objects, and `pixels_distance` (float) representing the distance between selected objects
+                in pixels.
 
         Examples:
             >>> import numpy as np
             >>> from ultralytics.solutions import DistanceCalculation
             >>> dc = DistanceCalculation()
             >>> frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-            >>> processed_frame = dc.calculate(frame)
+            >>> results = dc.process(frame)
+            >>> print(f"Distance: {results.pixels_distance:.2f} pixels")
         """
-        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
 
+        pixels_distance = 0
         # Iterate over bounding boxes, track ids and classes index
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-            self.annotator.box_label(box, color=colors(int(cls), True), label=self.names[int(cls)])
+            annotator.box_label(box, color=colors(int(cls), True), label=self.names[int(cls)])
 
+            # Update selected boxes if they're being tracked
             if len(self.selected_boxes) == 2:
                 for trk_id in self.selected_boxes.keys():
                     if trk_id == track_id:
                         self.selected_boxes[track_id] = box
 
         if len(self.selected_boxes) == 2:
-            # Store user selected boxes in centroids list
+            # Calculate centroids of selected boxes
             self.centroids.extend(
                 [[int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2)] for box in self.selected_boxes.values()]
             )
-            # Calculate pixels distance
+            # Calculate Euclidean distance between centroids
             pixels_distance = math.sqrt(
                 (self.centroids[0][0] - self.centroids[1][0]) ** 2 + (self.centroids[0][1] - self.centroids[1][1]) ** 2
             )
-            self.annotator.plot_distance_and_line(pixels_distance, self.centroids)
-
-        self.centroids = []
+            annotator.plot_distance_and_line(pixels_distance, self.centroids)
 
-        self.display_output(im0)  # display output with base class function
+        self.centroids = []  # Reset centroids for next frame
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
         cv2.setMouseCallback("Ultralytics Solutions", self.mouse_event_for_distance)
 
-        return im0  # return output image for more usage
+        # Return SolutionResults with processed image and calculated metrics
+        return SolutionResults(plot_im=plot_im, pixels_distance=pixels_distance, total_tracks=len(self.track_ids))

ultralytics/solutions/heatmap.py

@@ -4,7 +4,7 @@ import cv2
 import numpy as np
 
 from ultralytics.solutions.object_counter import ObjectCounter
-from ultralytics.utils.plotting import Annotator
+from ultralytics.solutions.solutions import SolutionAnnotator, SolutionResults
 
 
 class Heatmap(ObjectCounter):
@@ -18,28 +18,33 @@ class Heatmap(ObjectCounter):
         initialized (bool): Flag indicating whether the heatmap has been initialized.
         colormap (int): OpenCV colormap used for heatmap visualization.
         heatmap (np.ndarray): Array storing the cumulative heatmap data.
-        annotator (Annotator): Object for drawing annotations on the image.
+        annotator (SolutionAnnotator): Object for drawing annotations on the image.
 
     Methods:
         heatmap_effect: Calculates and updates the heatmap effect for a given bounding box.
-        generate_heatmap: Generates and applies the heatmap effect to each frame.
+        process: Generates and applies the heatmap effect to each frame.
 
     Examples:
         >>> from ultralytics.solutions import Heatmap
         >>> heatmap = Heatmap(model="yolo11n.pt", colormap=cv2.COLORMAP_JET)
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = heatmap.generate_heatmap(frame)
+        >>> processed_frame = heatmap.process(frame)
     """
 
     def __init__(self, **kwargs):
-        """Initializes the Heatmap class for real-time video stream heatmap generation based on object tracks."""
+        """
+        Initializes the Heatmap class for real-time video stream heatmap generation based on object tracks.
+
+        Args:
+            **kwargs (Any): Keyword arguments passed to the parent ObjectCounter class.
+        """
         super().__init__(**kwargs)
 
-        self.initialized = False  # bool variable for heatmap initialization
-        if self.region is not None:  # check if user provided the region coordinates
+        self.initialized = False  # Flag for heatmap initialization
+        if self.region is not None:  # Check if user provided the region coordinates
             self.initialize_region()
 
-        # store colormap
+        # Store colormap
         self.colormap = cv2.COLORMAP_PARULA if self.CFG["colormap"] is None else self.CFG["colormap"]
         self.heatmap = None
 
@@ -49,11 +54,6 @@ class Heatmap(ObjectCounter):
 
         Args:
             box (List[float]): Bounding box coordinates [x0, y0, x1, y1].
-
-        Examples:
-            >>> heatmap = Heatmap()
-            >>> box = [100, 100, 200, 200]
-            >>> heatmap.heatmap_effect(box)
         """
         x0, y0, x1, y1 = map(int, box)
         radius_squared = (min(x1 - x0, y1 - y0) // 2) ** 2
@@ -70,7 +70,7 @@ class Heatmap(ObjectCounter):
         # Update only the values within the bounding box in a single vectorized operation
         self.heatmap[y0:y1, x0:x1][within_radius] += 2
 
-    def generate_heatmap(self, im0):
+    def process(self, im0):
         """
         Generate heatmap for each frame using Ultralytics.
 
@@ -78,50 +78,52 @@ class Heatmap(ObjectCounter):
             im0 (np.ndarray): Input image array for processing.
 
         Returns:
-            (np.ndarray): Processed image with heatmap overlay and object counts (if region is specified).
-
-        Examples:
-            >>> heatmap = Heatmap()
-            >>> im0 = cv2.imread("image.jpg")
-            >>> result = heatmap.generate_heatmap(im0)
+            (SolutionResults): Contains processed image `plot_im`,
+                '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).
         """
         if not self.initialized:
             self.heatmap = np.zeros_like(im0, dtype=np.float32) * 0.99
-        self.initialized = True  # Initialize heatmap only once
+            self.initialized = True  # Initialize heatmap only once
 
-        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
 
         # Iterate over bounding boxes, track ids and classes index
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-            # Draw bounding box and counting region
+            # Apply heatmap effect for the bounding box
             self.heatmap_effect(box)
 
             if self.region is not None:
                 self.annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
                 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
                 current_centroid = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
-                # Store tracking previous position and perform object counting
+                # Get previous position if available
                 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
 
+        plot_im = self.annotator.result()
         if self.region is not None:
-            self.display_counts(im0)  # Display the counts on the frame
+            self.display_counts(plot_im)  # Display the counts on the frame
 
         # Normalize, apply colormap to heatmap and combine with original image
         if self.track_data.id is not None:
-            im0 = cv2.addWeighted(
-                im0,
-                0.5,
-                cv2.applyColorMap(
-                    cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8), self.colormap
-                ),
-                0.5,
-                0,
-            )
-
-        self.display_output(im0)  # display output with base class function
-        return im0  # return output image for more usage
+            normalized_heatmap = cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+            colored_heatmap = cv2.applyColorMap(normalized_heatmap, self.colormap)
+            plot_im = cv2.addWeighted(plot_im, 0.5, colored_heatmap, 0.5, 0)
+
+        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/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),
+        )