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

ultralytics/solutions/speed_estimation.py

@@ -4,8 +4,8 @@ from time import time
 
 import numpy as np
 
-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 SpeedEstimator(BaseSolution):
@@ -20,14 +20,13 @@ class SpeedEstimator(BaseSolution):
         trkd_ids (List[int]): List of tracked object IDs that have already been speed-estimated.
         trk_pt (Dict[int, float]): Dictionary storing previous timestamps for tracked objects.
         trk_pp (Dict[int, Tuple[float, float]]): Dictionary storing previous positions for tracked objects.
-        annotator (Annotator): Annotator object for drawing on images.
         region (List[Tuple[int, int]]): List of points defining the speed estimation region.
         track_line (List[Tuple[float, float]]): List of points representing the object's track.
         r_s (LineString): LineString object representing the speed estimation region.
 
     Methods:
         initialize_region: Initializes the speed estimation region.
-        estimate_speed: Estimates the speed of objects based on tracking data.
+        process: Processes input frames to estimate object speeds.
         store_tracking_history: Stores the tracking history for an object.
         extract_tracks: Extracts tracks from the current frame.
         display_output: Displays the output with annotations.
@@ -35,76 +34,80 @@ class SpeedEstimator(BaseSolution):
     Examples:
         >>> estimator = SpeedEstimator()
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = estimator.estimate_speed(frame)
-        >>> cv2.imshow("Speed Estimation", processed_frame)
+        >>> results = estimator.process(frame)
+        >>> cv2.imshow("Speed Estimation", results.plot_im)
     """
 
     def __init__(self, **kwargs):
-        """Initializes the SpeedEstimator object with speed estimation parameters and data structures."""
+        """
+        Initializes the SpeedEstimator object with speed estimation parameters and data structures.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
         super().__init__(**kwargs)
 
         self.initialize_region()  # Initialize speed region
 
-        self.spd = {}  # set for speed data
-        self.trkd_ids = []  # list for already speed_estimated and tracked ID's
-        self.trk_pt = {}  # set for tracks previous time
-        self.trk_pp = {}  # set for tracks previous point
+        self.spd = {}  # Dictionary for speed data
+        self.trkd_ids = []  # List for already speed-estimated and tracked IDs
+        self.trk_pt = {}  # Dictionary for tracks' previous timestamps
+        self.trk_pp = {}  # Dictionary for tracks' previous positions
 
-    def estimate_speed(self, im0):
+    def process(self, im0):
         """
-        Estimates the speed of objects based on tracking data.
+        Processes an input frame to estimate object speeds based on tracking data.
 
         Args:
-            im0 (np.ndarray): Input image for processing. Shape is typically (H, W, C) for RGB images.
+            im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
 
         Returns:
-            (np.ndarray): Processed image with speed estimations and annotations.
+            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
 
         Examples:
             >>> estimator = SpeedEstimator()
             >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-            >>> processed_image = estimator.estimate_speed(image)
+            >>> results = estimator.process(image)
         """
-        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
 
-        self.annotator.draw_region(
-            reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
-        )  # Draw region
+        # Draw speed estimation region
+        annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
 
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
             self.store_tracking_history(track_id, box)  # Store track history
 
-            # Check if track_id is already in self.trk_pp or trk_pt initialize if not
+            # Initialize tracking data for new objects
             if track_id not in self.trk_pt:
                 self.trk_pt[track_id] = 0
             if track_id not in self.trk_pp:
                 self.trk_pp[track_id] = self.track_line[-1]
 
+            # Prepare label with speed if available, otherwise use class name
             speed_label = f"{int(self.spd[track_id])} km/h" if track_id in self.spd else self.names[int(cls)]
-            self.annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
-
-            # Draw tracks of objects
-            self.annotator.draw_centroid_and_tracks(
-                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
-            )
+            annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
 
-            # Calculate object speed and direction based on region intersection
+            # Determine if object is crossing the speed estimation region
             if self.LineString([self.trk_pp[track_id], self.track_line[-1]]).intersects(self.r_s):
                 direction = "known"
             else:
                 direction = "unknown"
 
-            # Perform speed calculation and tracking updates if direction is valid
+            # Calculate speed for objects crossing the region for the first time
             if direction == "known" and track_id not in self.trkd_ids:
                 self.trkd_ids.append(track_id)
                 time_difference = time() - self.trk_pt[track_id]
                 if time_difference > 0:
+                    # Calculate speed based on vertical displacement and time
                     self.spd[track_id] = np.abs(self.track_line[-1][1] - self.trk_pp[track_id][1]) / time_difference
 
+            # Update tracking data for next frame
             self.trk_pt[track_id] = time()
             self.trk_pp[track_id] = self.track_line[-1]
 
-        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 results with processed image and tracking summary
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/solutions/streamlit_inference.py

@@ -13,21 +13,24 @@ from ultralytics.utils.downloads import GITHUB_ASSETS_STEMS
 
 class Inference:
     """
-    A class to perform object detection, image classification, image segmentation and pose estimation inference using
-    Streamlit and Ultralytics YOLO models. It provides the functionalities such as loading models, configuring settings,
-    uploading video files, and performing real-time inference.
+    A class to perform object detection, image classification, image segmentation and pose estimation inference.
+
+    This class provides functionalities for loading models, configuring settings, uploading video files, and performing
+    real-time inference using Streamlit and Ultralytics YOLO models.
 
     Attributes:
         st (module): Streamlit module for UI creation.
-        temp_dict (dict): Temporary dictionary to store the model path.
+        temp_dict (Dict): Temporary dictionary to store the model path and other configuration.
         model_path (str): Path to the loaded model.
         model (YOLO): The YOLO model instance.
-        source (str): Selected video source.
-        enable_trk (str): Enable tracking option.
-        conf (float): Confidence threshold.
-        iou (float): IoU threshold for non-max suppression.
-        vid_file_name (str): Name of the uploaded video file.
-        selected_ind (list): List of selected class indices.
+        source (str): Selected video source (webcam or video file).
+        enable_trk (str): Enable tracking option ("Yes" or "No").
+        conf (float): Confidence threshold for detection.
+        iou (float): IoU threshold for non-maximum suppression.
+        org_frame (Any): Container for the original frame to be displayed.
+        ann_frame (Any): Container for the annotated frame to be displayed.
+        vid_file_name (Union[str, int]): Name of the uploaded video file or webcam index.
+        selected_ind (List[int]): List of selected class indices for detection.
 
     Methods:
         web_ui: Sets up the Streamlit web interface with custom HTML elements.
@@ -37,7 +40,7 @@ class Inference:
         inference: Performs real-time object detection inference.
 
     Examples:
-        >>> inf = solutions.Inference(model="path/to/model.pt")  # Model is not necessary argument.
+        >>> inf = Inference(model="path/to/model.pt")  # Model is an optional argument
         >>> inf.inference()
     """
 
@@ -51,19 +54,19 @@ class Inference:
         check_requirements("streamlit>=1.29.0")  # scope imports for faster ultralytics package load speeds
         import streamlit as st
 
-        self.st = st  # Reference to the Streamlit class instance
-        self.source = None  # Placeholder for video or webcam source details
+        self.st = st  # Reference to the Streamlit module
+        self.source = None  # Video source selection (webcam or video file)
         self.enable_trk = False  # Flag to toggle object tracking
         self.conf = 0.25  # Confidence threshold for detection
         self.iou = 0.45  # Intersection-over-Union (IoU) threshold for non-maximum suppression
-        self.org_frame = None  # Container for the original frame to be displayed
-        self.ann_frame = None  # Container for the annotated frame to be displayed
-        self.vid_file_name = None  # Holds the name of the video file
-        self.selected_ind = []  # List of selected classes for detection or tracking
-        self.model = None  # Container for the loaded model instance
+        self.org_frame = None  # Container for the original frame display
+        self.ann_frame = None  # Container for the annotated frame display
+        self.vid_file_name = None  # Video file name or webcam index
+        self.selected_ind = []  # List of selected class indices for detection
+        self.model = None  # YOLO model instance
 
         self.temp_dict = {"model": None, **kwargs}
-        self.model_path = None  # Store model file name with path
+        self.model_path = None  # Model file path
         if self.temp_dict["model"] is not None:
             self.model_path = self.temp_dict["model"]
 
@@ -105,9 +108,9 @@ class Inference:
         )  # Slider for confidence
         self.iou = float(self.st.sidebar.slider("IoU Threshold", 0.0, 1.0, self.iou, 0.01))  # Slider for NMS threshold
 
-        col1, col2 = self.st.columns(2)
-        self.org_frame = col1.empty()
-        self.ann_frame = col2.empty()
+        col1, col2 = self.st.columns(2)  # Create two columns for displaying frames
+        self.org_frame = col1.empty()  # Container for original frame
+        self.ann_frame = col2.empty()  # Container for annotated frame
 
     def source_upload(self):
         """Handles video file uploads through the Streamlit interface."""
@@ -120,7 +123,7 @@ class Inference:
                     out.write(g.read())  # Read bytes into file
                 self.vid_file_name = "ultralytics.mp4"
         elif self.source == "webcam":
-            self.vid_file_name = 0
+            self.vid_file_name = 0  # Use webcam index 0
 
     def configure(self):
         """Configures the model and loads selected classes for inference."""
@@ -143,7 +146,7 @@ class Inference:
             self.selected_ind = list(self.selected_ind)
 
     def inference(self):
-        """Performs real-time object detection inference."""
+        """Performs real-time object detection inference on video or webcam feed."""
         self.web_ui()  # Initialize the web interface
         self.sidebar()  # Create the sidebar
         self.source_upload()  # Upload the video source
@@ -153,20 +156,23 @@ class Inference:
             stop_button = self.st.button("Stop")  # Button to stop the inference
             cap = cv2.VideoCapture(self.vid_file_name)  # Capture the video
             if not cap.isOpened():
-                self.st.error("Could not open webcam.")
+                self.st.error("Could not open webcam or video source.")
+                return
+
             while cap.isOpened():
                 success, frame = cap.read()
                 if not success:
                     self.st.warning("Failed to read frame from webcam. Please verify the webcam is connected properly.")
                     break
 
-                # Store model predictions
+                # Process frame with model
                 if self.enable_trk == "Yes":
                     results = self.model.track(
                         frame, conf=self.conf, iou=self.iou, classes=self.selected_ind, persist=True
                     )
                 else:
                     results = self.model(frame, conf=self.conf, iou=self.iou, classes=self.selected_ind)
+
                 annotated_frame = results[0].plot()  # Add annotations on frame
 
                 if stop_button:
@@ -177,7 +183,7 @@ class Inference:
                 self.ann_frame.image(annotated_frame, channels="BGR")  # Display processed frame
 
             cap.release()  # Release the capture
-        cv2.destroyAllWindows()  # Destroy window
+        cv2.destroyAllWindows()  # Destroy all OpenCV windows
 
 
 if __name__ == "__main__":
@@ -185,6 +191,6 @@ if __name__ == "__main__":
 
     # Check if a model name is provided as a command-line argument
     args = len(sys.argv)
-    model = sys.argv[1] if args > 1 else None  # assign first argument as the model name
+    model = sys.argv[1] if args > 1 else None  # Assign first argument as the model name if provided
     # Create an instance of the Inference class and run inference
     Inference(model=model).inference()

ultralytics/solutions/trackzone.py

@@ -3,8 +3,8 @@
 import cv2
 import numpy as np
 
-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 TrackZone(BaseSolution):
@@ -12,29 +12,33 @@ class TrackZone(BaseSolution):
     A class to manage region-based object tracking in a video stream.
 
     This class extends the BaseSolution class and provides functionality for tracking objects within a specific region
-    defined by a polygonal area. Objects outside the region are excluded from tracking. It supports dynamic initialization
-    of the region, allowing either a default region or a user-specified polygon.
+    defined by a polygonal area. Objects outside the region are excluded from tracking.
 
     Attributes:
-        region (ndarray): The polygonal region for tracking, represented as a convex hull.
+        region (np.ndarray): The polygonal region for tracking, represented as a convex hull of points.
 
     Methods:
-        trackzone: Processes each frame of the video, applying region-based tracking.
+        process: Processes each frame of the video, applying region-based tracking.
 
     Examples:
         >>> tracker = TrackZone()
         >>> frame = cv2.imread("frame.jpg")
-        >>> processed_frame = tracker.trackzone(frame)
-        >>> cv2.imshow("Tracked Frame", processed_frame)
+        >>> results = tracker.process(frame)
+        >>> cv2.imshow("Tracked Frame", results.plot_im)
     """
 
     def __init__(self, **kwargs):
-        """Initializes the TrackZone class for tracking objects within a defined region in video streams."""
+        """
+        Initializes the TrackZone class for tracking objects within a defined region in video streams.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
         super().__init__(**kwargs)
         default_region = [(150, 150), (1130, 150), (1130, 570), (150, 570)]
         self.region = cv2.convexHull(np.array(self.region or default_region, dtype=np.int32))
 
-    def trackzone(self, im0):
+    def process(self, im0):
         """
         Processes the input frame to track objects within a defined region.
 
@@ -42,27 +46,34 @@ class TrackZone(BaseSolution):
         only from the masked area, and updates tracking information. Objects outside the region are ignored.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to be processed.
+            im0 (np.ndarray): The input image or frame to be processed.
 
         Returns:
-            (numpy.ndarray): The processed image with tracking id and bounding boxes annotations.
+            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (int) representing the
+                               total number of tracked objects within the defined region.
 
         Examples:
             >>> tracker = TrackZone()
             >>> frame = cv2.imread("path/to/image.jpg")
-            >>> tracker.trackzone(frame)
+            >>> results = tracker.process(frame)
         """
-        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
+
         # Create a mask for the region and extract tracks from the masked image
-        masked_frame = cv2.bitwise_and(im0, im0, mask=cv2.fillPoly(np.zeros_like(im0[:, :, 0]), [self.region], 255))
+        mask = np.zeros_like(im0[:, :, 0])
+        mask = cv2.fillPoly(mask, [self.region], 255)
+        masked_frame = cv2.bitwise_and(im0, im0, mask=mask)
         self.extract_tracks(masked_frame)
 
+        # Draw the region boundary
         cv2.polylines(im0, [self.region], isClosed=True, color=(255, 255, 255), thickness=self.line_width * 2)
 
         # Iterate over boxes, track ids, classes indexes list and draw bounding boxes
         for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-            self.annotator.box_label(box, label=f"{self.names[cls]}:{track_id}", color=colors(track_id, True))
+            annotator.box_label(box, label=f"{self.names[cls]}:{track_id}", color=colors(track_id, 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))

ultralytics/solutions/vision_eye.py

@@ -0,0 +1,69 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
+
+
+class VisionEye(BaseSolution):
+    """
+    A class to manage object detection and vision mapping in images or video streams.
+
+    This class extends the BaseSolution class and provides functionality for detecting objects,
+    mapping vision points, and annotating results with bounding boxes and labels.
+
+    Attributes:
+        vision_point (Tuple[int, int]): Coordinates where vision will view objects and draw tracks, default is (30, 30).
+
+    Methods:
+        process: Processes the input image to detect objects, annotate them, and apply vision mapping.
+
+    Examples:
+        >>> vision_eye = VisionEye()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> results = vision_eye.process(frame)
+        >>> print(f"Total detected instances: {results.total_tracks}")
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the VisionEye class for detecting objects and applying vision mapping.
+
+        Args:
+            **kwargs (Any): Keyword arguments passed to the parent class and for configuring vision_point.
+        """
+        super().__init__(**kwargs)
+        # Set the vision point where the system will view objects and draw tracks
+        self.vision_point = kwargs.get("vision_point", (30, 30))
+
+    def process(self, im0):
+        """
+        Performs object detection, vision mapping, and annotation on the input image.
+
+        Args:
+            im0 (numpy.ndarray): The input image for detection and annotation.
+
+        Returns:
+            (SolutionResults): Object containing the annotated image and tracking statistics.
+                - plot_im: Annotated output image with bounding boxes and vision mapping
+                - total_tracks: Number of tracked objects in the frame
+
+        Examples:
+            >>> vision_eye = VisionEye()
+            >>> frame = cv2.imread("image.jpg")
+            >>> results = vision_eye.process(frame)
+            >>> print(f"Detected {results.total_tracks} objects")
+        """
+        self.extract_tracks(im0)  # Extract tracks (bounding boxes, classes, and masks)
+        annotator = SolutionAnnotator(im0, self.line_width)
+
+        for cls, t_id, box in zip(self.clss, self.track_ids, self.boxes):
+            # Annotate the image with bounding boxes, labels, and vision mapping
+            annotator.box_label(box, label=self.names[cls], color=colors(int(t_id), True))
+            annotator.visioneye(box, self.vision_point)
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display the annotated output using the base class function
+
+        # Return a SolutionResults object with the annotated image and tracking statistics
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/trackers/utils/kalman_filter.py

@@ -67,7 +67,7 @@ class KalmanFilterXYAH:
         Create a track from an unassociated measurement.
 
         Args:
-            measurement (ndarray): Bounding box coordinates (x, y, a, h) with center position (x, y), aspect ratio a,
+            measurement (np.ndarray): Bounding box coordinates (x, y, a, h) with center position (x, y), aspect ratio a,
                 and height h.
 
         Returns:
@@ -101,8 +101,8 @@ class KalmanFilterXYAH:
         Run Kalman filter prediction step.
 
         Args:
-            mean (ndarray): The 8-dimensional mean vector of the object state at the previous time step.
-            covariance (ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time step.
+            mean (np.ndarray): The 8-dimensional mean vector of the object state at the previous time step.
+            covariance (np.ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time step.
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
@@ -138,8 +138,8 @@ class KalmanFilterXYAH:
         Project state distribution to measurement space.
 
         Args:
-            mean (ndarray): The state's mean vector (8 dimensional array).
-            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
+            mean (np.ndarray): The state's mean vector (8 dimensional array).
+            covariance (np.ndarray): The state's covariance matrix (8x8 dimensional).
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
@@ -167,8 +167,8 @@ class KalmanFilterXYAH:
         Run Kalman filter prediction step for multiple object states (Vectorized version).
 
         Args:
-            mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
-            covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.
+            mean (np.ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
+            covariance (np.ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the mean matrix and covariance matrix of the predicted states.
@@ -208,9 +208,9 @@ class KalmanFilterXYAH:
         Run Kalman filter correction step.
 
         Args:
-            mean (ndarray): The predicted state's mean vector (8 dimensional).
-            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
-            measurement (ndarray): The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center
+            mean (np.ndarray): The predicted state's mean vector (8 dimensional).
+            covariance (np.ndarray): The state's covariance matrix (8x8 dimensional).
+            measurement (np.ndarray): The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center
                 position, a the aspect ratio, and h the height of the bounding box.
 
         Returns:
@@ -250,9 +250,9 @@ class KalmanFilterXYAH:
         distribution has 4 degrees of freedom, otherwise 2.
 
         Args:
-            mean (ndarray): Mean vector over the state distribution (8 dimensional).
-            covariance (ndarray): Covariance of the state distribution (8x8 dimensional).
-            measurements (ndarray): An (N, 4) matrix of N measurements, each in format (x, y, a, h) where (x, y) is the
+            mean (np.ndarray): Mean vector over the state distribution (8 dimensional).
+            covariance (np.ndarray): Covariance of the state distribution (8x8 dimensional).
+            measurements (np.ndarray): An (N, 4) matrix of N measurements, each in format (x, y, a, h) where (x, y) is the
                 bounding box center position, a the aspect ratio, and h the height.
             only_position (bool): If True, distance computation is done with respect to box center position only.
             metric (str): The metric to use for calculating the distance. Options are 'gaussian' for the squared
@@ -322,7 +322,7 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Create track from unassociated measurement.
 
         Args:
-            measurement (ndarray): Bounding box coordinates (x, y, w, h) with center position (x, y), width, and height.
+            measurement (np.ndarray): Bounding box coordinates (x, y, w, h) with center position (x, y), width, and height.
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional)
@@ -366,8 +366,8 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Run Kalman filter prediction step.
 
         Args:
-            mean (ndarray): The 8-dimensional mean vector of the object state at the previous time step.
-            covariance (ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time step.
+            mean (np.ndarray): The 8-dimensional mean vector of the object state at the previous time step.
+            covariance (np.ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time step.
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
@@ -403,8 +403,8 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Project state distribution to measurement space.
 
         Args:
-            mean (ndarray): The state's mean vector (8 dimensional array).
-            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
+            mean (np.ndarray): The state's mean vector (8 dimensional array).
+            covariance (np.ndarray): The state's covariance matrix (8x8 dimensional).
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
@@ -432,8 +432,8 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Run Kalman filter prediction step (Vectorized version).
 
         Args:
-            mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
-            covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.
+            mean (np.ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
+            covariance (np.ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.
 
         Returns:
             (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
@@ -473,9 +473,9 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Run Kalman filter correction step.
 
         Args:
-            mean (ndarray): The predicted state's mean vector (8 dimensional).
-            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
-            measurement (ndarray): The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center
+            mean (np.ndarray): The predicted state's mean vector (8 dimensional).
+            covariance (np.ndarray): The state's covariance matrix (8x8 dimensional).
+            measurement (np.ndarray): The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center
                 position, w the width, and h the height of the bounding box.
 
         Returns:

ultralytics/utils/__init__.py

@@ -427,14 +427,11 @@ class ThreadingLocked:
     Attributes:
         lock (threading.Lock): A lock object used to manage access to the decorated function.
 
-    Example:
-        ```python
-        from ultralytics.utils import ThreadingLocked
-
-        @ThreadingLocked()
-        def my_function():
-            # Your code here
-        ```
+    Examples:
+        >>> from ultralytics.utils import ThreadingLocked
+        >>> @ThreadingLocked()
+        >>> def my_function():
+        ...    # Your code here
     """
 
     def __init__(self):