ultralytics 8.3.142__py3-none-any.whl → 8.3.144__py3-none-any.whl

ultralytics/solutions/solutions.py

@@ -2,13 +2,14 @@
 
 import math
 from collections import defaultdict
+from typing import Any, Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
 
 from ultralytics import YOLO
 from ultralytics.solutions.config import SolutionConfig
-from ultralytics.utils import ASSETS_URL, LOGGER
+from ultralytics.utils import ASSETS_URL, LOGGER, ops
 from ultralytics.utils.checks import check_imshow, check_requirements
 from ultralytics.utils.plotting import Annotator
 
@@ -18,25 +19,47 @@ class BaseSolution:
     A base class for managing Ultralytics Solutions.
 
     This class provides core functionality for various Ultralytics Solutions, including model loading, object tracking,
-    and region initialization.
+    and region initialization. It serves as the foundation for implementing specific computer vision solutions such as
+    object counting, pose estimation, and analytics.
 
     Attributes:
-        LineString (shapely.geometry.LineString): Class for creating line string geometries.
-        Polygon (shapely.geometry.Polygon): Class for creating polygon geometries.
-        Point (shapely.geometry.Point): Class for creating point geometries.
-        CFG (dict): Configuration dictionary loaded from a YAML file and updated with kwargs.
-        region (List[Tuple[int, int]]): List of coordinate tuples defining a region of interest.
+        LineString: Class for creating line string geometries from shapely.
+        Polygon: Class for creating polygon geometries from shapely.
+        Point: Class for creating point geometries from shapely.
+        prep: Prepared geometry function from shapely for optimized spatial operations.
+        CFG (Dict[str, Any]): Configuration dictionary loaded from YAML file and updated with kwargs.
+        LOGGER: Logger instance for solution-specific logging.
+        annotator: Annotator instance for drawing on images.
+        tracks: YOLO tracking results from the latest inference.
+        track_data: Extracted tracking data (boxes or OBB) from tracks.
+        boxes (List): Bounding box coordinates from tracking results.
+        clss (List[int]): Class indices from tracking results.
+        track_ids (List[int]): Track IDs from tracking results.
+        confs (List[float]): Confidence scores from tracking results.
+        track_line: Current track line for storing tracking history.
+        masks: Segmentation masks from tracking results.
+        r_s: Region or line geometry object for spatial operations.
+        frame_no (int): Current frame number for logging purposes.
+        region (List[Tuple[int, int]]): List of coordinate tuples defining region of interest.
         line_width (int): Width of lines used in visualizations.
-        model (ultralytics.YOLO): Loaded YOLO model instance.
+        model (YOLO): Loaded YOLO model instance.
         names (Dict[int, str]): Dictionary mapping class indices to class names.
-        env_check (bool): Flag indicating whether the environment supports image display.
-        track_history (collections.defaultdict): Dictionary to store tracking history for each object.
+        classes (List[int]): List of class indices to track.
+        show_conf (bool): Flag to show confidence scores in annotations.
+        show_labels (bool): Flag to show class labels in annotations.
+        device (str): Device for model inference.
+        track_add_args (Dict[str, Any]): Additional arguments for tracking configuration.
+        env_check (bool): Flag indicating whether environment supports image display.
+        track_history (defaultdict): Dictionary storing tracking history for each object.
+        profilers (Tuple): Profiler instances for performance monitoring.
 
     Methods:
-        extract_tracks: Apply object tracking and extract tracks from an input image.
-        store_tracking_history: Store object tracking history for a given track ID and bounding box.
-        initialize_region: Initialize the counting region and line segment based on configuration.
-        display_output: Display the results of processing, including showing frames or saving results.
+        adjust_box_label: Generate formatted label for bounding box.
+        extract_tracks: Apply object tracking and extract tracks from input image.
+        store_tracking_history: Store object tracking history for given track ID and bounding box.
+        initialize_region: Initialize counting region and line segment based on configuration.
+        display_output: Display processing results including frames or saved results.
+        process: Process method to be implemented by each Solution subclass.
 
     Examples:
         >>> solution = BaseSolution(model="yolo11n.pt", region=[(0, 0), (100, 0), (100, 100), (0, 100)])
@@ -46,12 +69,12 @@ class BaseSolution:
         >>> solution.display_output(image)
     """
 
-    def __init__(self, is_cli=False, **kwargs):
+    def __init__(self, is_cli: bool = False, **kwargs):
         """
-        Initializes the BaseSolution class with configuration settings and the YOLO model.
+        Initialize the BaseSolution class with configuration settings and YOLO model.
 
         Args:
-            is_cli (bool): Enables CLI mode if set to True.
+            is_cli (bool): Enable CLI mode if set to True.
             **kwargs (Any): Additional configuration parameters that override defaults.
         """
         self.CFG = vars(SolutionConfig().update(**kwargs))
@@ -75,6 +98,7 @@ class BaseSolution:
             self.track_line = None
             self.masks = None
             self.r_s = None
+            self.frame_no = -1  # Only for logging
 
             self.LOGGER.info(f"Ultralytics Solutions: ✅ {self.CFG}")
             self.region = self.CFG["region"]  # Store region data for other classes usage
@@ -88,9 +112,10 @@ class BaseSolution:
             self.classes = self.CFG["classes"]
             self.show_conf = self.CFG["show_conf"]
             self.show_labels = self.CFG["show_labels"]
+            self.device = self.CFG["device"]
 
             self.track_add_args = {  # Tracker additional arguments for advance configuration
-                k: self.CFG[k] for k in ["iou", "conf", "device", "max_det", "half", "tracker", "device", "verbose"]
+                k: self.CFG[k] for k in ["iou", "conf", "device", "max_det", "half", "tracker"]
             }  # verbose must be passed to track method; setting it False in YOLO still logs the track information.
 
             if is_cli and self.CFG["source"] is None:
@@ -105,9 +130,14 @@ class BaseSolution:
             self.env_check = check_imshow(warn=True)
             self.track_history = defaultdict(list)
 
-    def adjust_box_label(self, cls, conf, track_id=None):
+            self.profilers = (
+                ops.Profile(device=self.device),  # track
+                ops.Profile(device=self.device),  # solution
+            )
+
+    def adjust_box_label(self, cls: int, conf: float, track_id: Optional[int] = None) -> Optional[str]:
         """
-        Generates a formatted label for a bounding box.
+        Generate a formatted label for a bounding box.
 
         This method constructs a label string for a bounding box using the class index and confidence score.
         Optionally includes the track ID if provided. The label format adapts based on the display settings
@@ -116,17 +146,17 @@ class BaseSolution:
         Args:
             cls (int): The class index of the detected object.
             conf (float): The confidence score of the detection.
-            track_id (int, optional): The unique identifier for the tracked object. Defaults to None.
+            track_id (int, optional): The unique identifier for the tracked object.
 
         Returns:
-            (str or None): The formatted label string if `self.show_labels` is True; otherwise, None.
+            (str | None): The formatted label string if `self.show_labels` is True; otherwise, None.
         """
         name = ("" if track_id is None else f"{track_id} ") + self.names[cls]
         return (f"{name} {conf:.2f}" if self.show_conf else name) if self.show_labels else None
 
-    def extract_tracks(self, im0):
+    def extract_tracks(self, im0: np.ndarray):
         """
-        Applies object tracking and extracts tracks from an input image or frame.
+        Apply object tracking and extract tracks from an input image or frame.
 
         Args:
             im0 (np.ndarray): The input image or frame.
@@ -136,7 +166,10 @@ class BaseSolution:
             >>> frame = cv2.imread("path/to/image.jpg")
             >>> solution.extract_tracks(frame)
         """
-        self.tracks = self.model.track(source=im0, persist=True, classes=self.classes, **self.track_add_args)
+        with self.profilers[0]:
+            self.tracks = self.model.track(
+                source=im0, persist=True, classes=self.classes, verbose=False, **self.track_add_args
+            )
         self.track_data = self.tracks[0].obb or self.tracks[0].boxes  # Extract tracks for OBB or object detection
 
         if self.track_data and self.track_data.id is not None:
@@ -148,9 +181,9 @@ class BaseSolution:
             self.LOGGER.warning("no tracks found!")
             self.boxes, self.clss, self.track_ids, self.confs = [], [], [], []
 
-    def store_tracking_history(self, track_id, box, is_obb=False):
+    def store_tracking_history(self, track_id: int, box):
         """
-        Stores the tracking history of an object.
+        Store the tracking history of an object.
 
         This method updates the tracking history for a given object by appending the center point of its
         bounding box to the track line. It maintains a maximum of 30 points in the tracking history.
@@ -158,7 +191,6 @@ class BaseSolution:
         Args:
             track_id (int): The unique identifier for the tracked object.
             box (List[float]): The bounding box coordinates of the object in the format [x1, y1, x2, y2].
-            is_obb (bool): True if OBB model is used (applies to object counting only).
 
         Examples:
             >>> solution = BaseSolution()
@@ -166,7 +198,7 @@ class BaseSolution:
         """
         # Store tracking history
         self.track_line = self.track_history[track_id]
-        self.track_line.append(tuple(box.mean(dim=0)) if is_obb else (box[:4:2].mean(), box[1:4:2].mean()))
+        self.track_line.append(tuple(box.mean(dim=0)) if box.numel() > 4 else (box[:4:2].mean(), box[1:4:2].mean()))
         if len(self.track_line) > 30:
             self.track_line.pop(0)
 
@@ -178,7 +210,7 @@ class BaseSolution:
             self.Polygon(self.region) if len(self.region) >= 3 else self.LineString(self.region)
         )  # region or line
 
-    def display_output(self, plot_im):
+    def display_output(self, plot_im: np.ndarray):
         """
         Display the results of the processing, which could involve showing frames, printing counts, or saving results.
 
@@ -186,7 +218,7 @@ class BaseSolution:
         the processed frame with annotations, and allows for user interaction to close the display.
 
         Args:
-            plot_im (numpy.ndarray): The image or frame that has been processed and annotated.
+            plot_im (np.ndarray): The image or frame that has been processed and annotated.
 
         Examples:
             >>> solution = BaseSolution()
@@ -209,9 +241,20 @@ class BaseSolution:
 
     def __call__(self, *args, **kwargs):
         """Allow instances to be called like a function with flexible arguments."""
-        result = self.process(*args, **kwargs)  # Call the subclass-specific process method
-        if self.CFG["verbose"]:  # extract verbose value to display the output logs if True
-            LOGGER.info(f"🚀 Results: {result}")
+        with self.profilers[1]:
+            result = self.process(*args, **kwargs)  # Call the subclass-specific process method
+        track_or_predict = "predict" if type(self).__name__ == "ObjectCropper" else "track"
+        track_or_predict_speed = self.profilers[0].dt * 1e3
+        solution_speed = (self.profilers[1].dt - self.profilers[0].dt) * 1e3  # solution time = process - track
+        result.speed = {track_or_predict: track_or_predict_speed, "solution": solution_speed}
+        if self.CFG["verbose"]:
+            self.frame_no += 1
+            LOGGER.info(
+                f"{self.frame_no}: {result.plot_im.shape[0]}x{result.plot_im.shape[1]} {solution_speed:.1f}ms\n"
+                f"Speed: {track_or_predict_speed:.1f}ms {track_or_predict}, "
+                f"{solution_speed:.1f}ms solution per image at shape "
+                f"(1, {getattr(self.model, 'ch', 3)}, {result.plot_im.shape[0]}, {result.plot_im.shape[1]})\n"
+            )
         return result
 
 
@@ -220,8 +263,8 @@ class SolutionAnnotator(Annotator):
     A specialized annotator class for visualizing and analyzing computer vision tasks.
 
     This class extends the base Annotator class, providing additional methods for drawing regions, centroids, tracking
-    trails, and visual annotations for Ultralytics Solutions: https://docs.ultralytics.com/solutions/.
-    and parking management.
+    trails, and visual annotations for Ultralytics Solutions. It offers comprehensive visualization capabilities for
+    various computer vision applications including object detection, tracking, pose estimation, and analytics.
 
     Attributes:
         im (np.ndarray): The image being annotated.
@@ -232,19 +275,19 @@ class SolutionAnnotator(Annotator):
         example (str): An example attribute for demonstration purposes.
 
     Methods:
-        draw_region: Draws a region using specified points, colors, and thickness.
-        queue_counts_display: Displays queue counts in the specified region.
-        display_analytics: Displays overall statistics for parking lot management.
-        estimate_pose_angle: Calculates the angle between three points in an object pose.
-        draw_specific_points: Draws specific keypoints on the image.
-        plot_workout_information: Draws a labeled text box on the image.
-        plot_angle_and_count_and_stage: Visualizes angle, step count, and stage for workout monitoring.
-        plot_distance_and_line: Displays the distance between centroids and connects them with a line.
-        display_objects_labels: Annotates bounding boxes with object class labels.
-        sweep_annotator: Visualizes a vertical sweep line and optional label.
-        visioneye: Maps and connects object centroids to a visual "eye" point.
-        circle_label: Draws a circular label within a bounding box.
-        text_label: Draws a rectangular label within a bounding box.
+        draw_region: Draw a region using specified points, colors, and thickness.
+        queue_counts_display: Display queue counts in the specified region.
+        display_analytics: Display overall statistics for parking lot management.
+        estimate_pose_angle: Calculate the angle between three points in an object pose.
+        draw_specific_kpts: Draw specific keypoints on the image.
+        plot_workout_information: Draw a labeled text box on the image.
+        plot_angle_and_count_and_stage: Visualize angle, step count, and stage for workout monitoring.
+        plot_distance_and_line: Display the distance between centroids and connect them with a line.
+        display_objects_labels: Annotate bounding boxes with object class labels.
+        sweep_annotator: Visualize a vertical sweep line and optional label.
+        visioneye: Map and connect object centroids to a visual "eye" point.
+        circle_label: Draw a circular label within a bounding box.
+        text_label: Draw a rectangular label within a bounding box.
 
     Examples:
         >>> annotator = SolutionAnnotator(image)
@@ -254,26 +297,39 @@ class SolutionAnnotator(Annotator):
         ... )
     """
 
-    def __init__(self, im, line_width=None, font_size=None, font="Arial.ttf", pil=False, example="abc"):
+    def __init__(
+        self,
+        im: np.ndarray,
+        line_width: Optional[int] = None,
+        font_size: Optional[int] = None,
+        font: str = "Arial.ttf",
+        pil: bool = False,
+        example: str = "abc",
+    ):
         """
-        Initializes the SolutionAnnotator class with an image for annotation.
+        Initialize the SolutionAnnotator class with an image for annotation.
 
         Args:
             im (np.ndarray): The image to be annotated.
             line_width (int, optional): Line thickness for drawing on the image.
             font_size (int, optional): Font size for text annotations.
-            font (str, optional): Path to the font file.
-            pil (bool, optional): Indicates whether to use PIL for rendering text.
-            example (str, optional): An example parameter for demonstration purposes.
+            font (str): Path to the font file.
+            pil (bool): Indicates whether to use PIL for rendering text.
+            example (str): An example parameter for demonstration purposes.
         """
         super().__init__(im, line_width, font_size, font, pil, example)
 
-    def draw_region(self, reg_pts=None, color=(0, 255, 0), thickness=5):
+    def draw_region(
+        self,
+        reg_pts: Optional[List[Tuple[int, int]]] = None,
+        color: Tuple[int, int, int] = (0, 255, 0),
+        thickness: int = 5,
+    ):
         """
         Draw a region or line on the image.
 
         Args:
-            reg_pts (List[Tuple[int, int]]): Region points (for line 2 points, for region 4+ points).
+            reg_pts (List[Tuple[int, int]], optional): Region points (for line 2 points, for region 4+ points).
             color (Tuple[int, int, int]): RGB color value for the region.
             thickness (int): Line thickness for drawing the region.
         """
@@ -283,13 +339,19 @@ class SolutionAnnotator(Annotator):
         for point in reg_pts:
             cv2.circle(self.im, (point[0], point[1]), thickness * 2, color, -1)  # -1 fills the circle
 
-    def queue_counts_display(self, label, points=None, region_color=(255, 255, 255), txt_color=(0, 0, 0)):
+    def queue_counts_display(
+        self,
+        label: str,
+        points: Optional[List[Tuple[int, int]]] = None,
+        region_color: Tuple[int, int, int] = (255, 255, 255),
+        txt_color: Tuple[int, int, int] = (0, 0, 0),
+    ):
         """
-        Displays queue counts on an image centered at the points with customizable font size and colors.
+        Display queue counts on an image centered at the points with customizable font size and colors.
 
         Args:
             label (str): Queue counts label.
-            points (List[Tuple[int, int]]): Region points for center point calculation to display text.
+            points (List[Tuple[int, int]], optional): Region points for center point calculation to display text.
             region_color (Tuple[int, int, int]): RGB queue region color.
             txt_color (Tuple[int, int, int]): RGB text display color.
         """
@@ -323,7 +385,14 @@ class SolutionAnnotator(Annotator):
             lineType=cv2.LINE_AA,
         )
 
-    def display_analytics(self, im0, text, txt_color, bg_color, margin):
+    def display_analytics(
+        self,
+        im0: np.ndarray,
+        text: Dict[str, Any],
+        txt_color: Tuple[int, int, int],
+        bg_color: Tuple[int, int, int],
+        margin: int,
+    ):
         """
         Display the overall statistics for parking lots, object counter etc.
 
@@ -353,7 +422,7 @@ class SolutionAnnotator(Annotator):
             text_y_offset = rect_y2
 
     @staticmethod
-    def estimate_pose_angle(a, b, c):
+    def estimate_pose_angle(a: List[float], b: List[float], c: List[float]) -> float:
         """
         Calculate the angle between three points for workout monitoring.
 
@@ -369,20 +438,26 @@ class SolutionAnnotator(Annotator):
         angle = abs(radians * 180.0 / math.pi)
         return angle if angle <= 180.0 else (360 - angle)
 
-    def draw_specific_kpts(self, keypoints, indices=None, radius=2, conf_thresh=0.25):
+    def draw_specific_kpts(
+        self,
+        keypoints: List[List[float]],
+        indices: Optional[List[int]] = None,
+        radius: int = 2,
+        conf_thresh: float = 0.25,
+    ) -> np.ndarray:
         """
         Draw specific keypoints for gym steps counting.
 
         Args:
             keypoints (List[List[float]]): Keypoints data to be plotted, each in format [x, y, confidence].
             indices (List[int], optional): Keypoint indices to be plotted.
-            radius (int, optional): Keypoint radius.
-            conf_thresh (float, optional): Confidence threshold for keypoints.
+            radius (int): Keypoint radius.
+            conf_thresh (float): Confidence threshold for keypoints.
 
         Returns:
             (np.ndarray): Image with drawn keypoints.
 
-        Note:
+        Notes:
             Keypoint format: [x, y] or [x, y, confidence].
             Modifies self.im in-place.
         """
@@ -399,20 +474,26 @@ class SolutionAnnotator(Annotator):
 
         return self.im
 
-    def plot_workout_information(self, display_text, position, color=(104, 31, 17), txt_color=(255, 255, 255)):
+    def plot_workout_information(
+        self,
+        display_text: str,
+        position: Tuple[int, int],
+        color: Tuple[int, int, int] = (104, 31, 17),
+        txt_color: Tuple[int, int, int] = (255, 255, 255),
+    ) -> int:
         """
         Draw workout text with a background on the image.
 
         Args:
             display_text (str): The text to be displayed.
             position (Tuple[int, int]): Coordinates (x, y) on the image where the text will be placed.
-            color (Tuple[int, int, int], optional): Text background color.
-            txt_color (Tuple[int, int, int], optional): Text foreground color.
+            color (Tuple[int, int, int]): Text background color.
+            txt_color (Tuple[int, int, int]): Text foreground color.
 
         Returns:
             (int): The height of the text.
         """
-        (text_width, text_height), _ = cv2.getTextSize(display_text, 0, self.sf, self.tf)
+        (text_width, text_height), _ = cv2.getTextSize(display_text, 0, fontScale=self.sf, thickness=self.tf)
 
         # Draw background rectangle
         cv2.rectangle(
@@ -428,7 +509,13 @@ class SolutionAnnotator(Annotator):
         return text_height
 
     def plot_angle_and_count_and_stage(
-        self, angle_text, count_text, stage_text, center_kpt, color=(104, 31, 17), txt_color=(255, 255, 255)
+        self,
+        angle_text: str,
+        count_text: str,
+        stage_text: str,
+        center_kpt: List[int],
+        color: Tuple[int, int, int] = (104, 31, 17),
+        txt_color: Tuple[int, int, int] = (255, 255, 255),
     ):
         """
         Plot the pose angle, count value, and step stage for workout monitoring.
@@ -438,8 +525,8 @@ class SolutionAnnotator(Annotator):
             count_text (str): Counts value for workout monitoring.
             stage_text (str): Stage decision for workout monitoring.
             center_kpt (List[int]): Centroid pose index for workout monitoring.
-            color (Tuple[int, int, int], optional): Text background color.
-            txt_color (Tuple[int, int, int], optional): Text foreground color.
+            color (Tuple[int, int, int]): Text background color.
+            txt_color (Tuple[int, int, int]): Text foreground color.
         """
         # Format text
         angle_text, count_text, stage_text = f" {angle_text:.2f}", f"Steps : {count_text}", f" {stage_text}"
@@ -456,7 +543,11 @@ class SolutionAnnotator(Annotator):
         )
 
     def plot_distance_and_line(
-        self, pixels_distance, centroids, line_color=(104, 31, 17), centroid_color=(255, 0, 255)
+        self,
+        pixels_distance: float,
+        centroids: List[Tuple[int, int]],
+        line_color: Tuple[int, int, int] = (104, 31, 17),
+        centroid_color: Tuple[int, int, int] = (255, 0, 255),
     ):
         """
         Plot the distance and line between two centroids on the frame.
@@ -464,8 +555,8 @@ class SolutionAnnotator(Annotator):
         Args:
             pixels_distance (float): Pixels distance between two bbox centroids.
             centroids (List[Tuple[int, int]]): Bounding box centroids data.
-            line_color (Tuple[int, int, int], optional): Distance line color.
-            centroid_color (Tuple[int, int, int], optional): Bounding box centroid color.
+            line_color (Tuple[int, int, int]): Distance line color.
+            centroid_color (Tuple[int, int, int]): Bounding box centroid color.
         """
         # Get the text size
         text = f"Pixels Distance: {pixels_distance:.2f}"
@@ -491,7 +582,16 @@ class SolutionAnnotator(Annotator):
         cv2.circle(self.im, centroids[0], 6, centroid_color, -1)
         cv2.circle(self.im, centroids[1], 6, centroid_color, -1)
 
-    def display_objects_labels(self, im0, text, txt_color, bg_color, x_center, y_center, margin):
+    def display_objects_labels(
+        self,
+        im0: np.ndarray,
+        text: str,
+        txt_color: Tuple[int, int, int],
+        bg_color: Tuple[int, int, int],
+        x_center: float,
+        y_center: float,
+        margin: int,
+    ):
         """
         Display the bounding boxes labels in parking management app.
 
@@ -531,7 +631,14 @@ class SolutionAnnotator(Annotator):
             lineType=cv2.LINE_AA,
         )
 
-    def sweep_annotator(self, line_x=0, line_y=0, label=None, color=(221, 0, 186), txt_color=(255, 255, 255)):
+    def sweep_annotator(
+        self,
+        line_x: int = 0,
+        line_y: int = 0,
+        label: Optional[str] = None,
+        color: Tuple[int, int, int] = (221, 0, 186),
+        txt_color: Tuple[int, int, int] = (255, 255, 255),
+    ):
         """
         Draw a sweep annotation line and an optional label.
 
@@ -565,7 +672,13 @@ class SolutionAnnotator(Annotator):
                 self.tf,
             )
 
-    def visioneye(self, box, center_point, color=(235, 219, 11), pin_color=(255, 0, 255)):
+    def visioneye(
+        self,
+        box: List[float],
+        center_point: Tuple[int, int],
+        color: Tuple[int, int, int] = (235, 219, 11),
+        pin_color: Tuple[int, int, int] = (255, 0, 255),
+    ):
         """
         Perform pinpoint human-vision eye mapping and plotting.
 
@@ -580,7 +693,14 @@ class SolutionAnnotator(Annotator):
         cv2.circle(self.im, center_bbox, self.tf * 2, color, -1)
         cv2.line(self.im, center_point, center_bbox, color, self.tf)
 
-    def circle_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), margin=2):
+    def circle_label(
+        self,
+        box: Tuple[float, float, float, float],
+        label: str = "",
+        color: Tuple[int, int, int] = (128, 128, 128),
+        txt_color: Tuple[int, int, int] = (255, 255, 255),
+        margin: int = 2,
+    ):
         """
         Draw a label with a background circle centered within a given bounding box.
 
@@ -618,7 +738,14 @@ class SolutionAnnotator(Annotator):
             lineType=cv2.LINE_AA,
         )
 
-    def text_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), margin=5):
+    def text_label(
+        self,
+        box: Tuple[float, float, float, float],
+        label: str = "",
+        color: Tuple[int, int, int] = (128, 128, 128),
+        txt_color: Tuple[int, int, int] = (255, 255, 255),
+        margin: int = 5,
+    ):
         """
         Draw a label with a background rectangle centered within a given bounding box.
 
@@ -661,7 +788,8 @@ class SolutionResults:
     A class to encapsulate the results of Ultralytics Solutions.
 
     This class is designed to store and manage various outputs generated by the solution pipeline, including counts,
-    angles, and workout stages.
+    angles, workout stages, and other analytics data. It provides a structured way to access and manipulate results
+    from different computer vision solutions such as object counting, pose estimation, and tracking analytics.
 
     Attributes:
         plot_im (np.ndarray): Processed image with counts, blurred, or other effects from solutions.
@@ -677,9 +805,10 @@ class SolutionResults:
         filled_slots (int): The number of filled slots in a monitored area.
         email_sent (bool): A flag indicating whether an email notification was sent.
         total_tracks (int): The total number of tracked objects.
-        region_counts (dict): The count of objects within a specific region.
+        region_counts (Dict): The count of objects within a specific region.
         speed_dict (Dict[str, float]): A dictionary containing speed information for tracked objects.
         total_crop_objects (int): Total number of cropped objects using ObjectCropper class.
+        speed (Dict): Performance timing information for tracking and solution processing.
     """
 
     def __init__(self, **kwargs):
@@ -703,13 +832,14 @@ class SolutionResults:
         self.email_sent = False
         self.total_tracks = 0
         self.region_counts = {}
-        self.speed_dict = {}
+        self.speed_dict = {}  # for speed estimation
         self.total_crop_objects = 0
+        self.speed = {}
 
         # Override with user-defined values
         self.__dict__.update(kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Return a formatted string representation of the SolutionResults object.
 
@@ -721,4 +851,4 @@ class SolutionResults:
             for k, v in self.__dict__.items()
             if k != "plot_im" and v not in [None, {}, 0, 0.0, False]  # Exclude `plot_im` explicitly
         }
-        return f"SolutionResults({', '.join(f'{k}={v}' for k, v in attrs.items())})"
+        return ", ".join(f"{k}={v}" for k, v in attrs.items())