dgenerate-ultralytics-headless 8.3.237__py3-none-any.whl → 8.3.240__py3-none-any.whl

ultralytics/nn/text_model.py

@@ -196,12 +196,7 @@ class MobileCLIP(TextModel):
             device (torch.device): Device to load the model on.
         """
         try:
-            import warnings
-
-            # Suppress 'timm.models.layers is deprecated, please import via timm.layers' warning from mobileclip usage
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", category=FutureWarning)
-                import mobileclip
+            import mobileclip
         except ImportError:
             # Ultralytics fork preferred since Apple MobileCLIP repo has incorrect version of torchvision
             checks.check_requirements("git+https://github.com/ultralytics/mobileclip.git")
@@ -308,7 +303,7 @@ class MobileCLIPTS(TextModel):
             (torch.Tensor): Tokenized text inputs with shape (batch_size, sequence_length).
 
         Examples:
-            >>> model = MobileCLIPTS("cpu")
+            >>> model = MobileCLIPTS(device=torch.device("cpu"))
             >>> tokens = model.tokenize(["a photo of a cat", "a photo of a dog"])
             >>> strict_tokens = model.tokenize(
             ...     ["a very long caption"], truncate=False

ultralytics/solutions/ai_gym.py

@@ -13,7 +13,7 @@ class AIGym(BaseSolution):
     repetitions of exercises based on predefined angle thresholds for up and down positions.
 
     Attributes:
-        states (dict[float, int, str]): Stores per-track angle, count, and stage for workout monitoring.
+        states (dict[int, dict[str, float | int | str]]): Per-track angle, rep count, and stage for workout monitoring.
         up_angle (float): Angle threshold for considering the 'up' position of an exercise.
         down_angle (float): Angle threshold for considering the 'down' position of an exercise.
         kpts (list[int]): Indices of keypoints used for angle calculation.

ultralytics/solutions/analytics.py

@@ -56,7 +56,7 @@ class Analytics(BaseSolution):
         from matplotlib.backends.backend_agg import FigureCanvasAgg
         from matplotlib.figure import Figure
 
-        self.type = self.CFG["analytics_type"]  # type of analytics i.e "line", "pie", "bar" or "area" charts.
+        self.type = self.CFG["analytics_type"]  # Chart type: "line", "pie", "bar", or "area".
         self.x_label = "Classes" if self.type in {"bar", "pie"} else "Frame#"
         self.y_label = "Total Counts"
 
@@ -66,10 +66,10 @@ class Analytics(BaseSolution):
         self.title = "Ultralytics Solutions"  # window name
         self.max_points = 45  # maximum points to be drawn on window
         self.fontsize = 25  # text font size for display
-        figsize = self.CFG["figsize"]  # set output image size i.e (12.8, 7.2) -> w = 1280, h = 720
+        figsize = self.CFG["figsize"]  # Output size, e.g. (12.8, 7.2) -> 1280x720.
         self.color_cycle = cycle(["#DD00BA", "#042AFF", "#FF4447", "#7D24FF", "#BD00FF"])
 
-        self.total_counts = 0  # count variable for storing total counts i.e. for line
+        self.total_counts = 0  # Stores total counts for line charts.
         self.clswise_count = {}  # dictionary for class-wise counts
         self.update_every = kwargs.get("update_every", 30)  # Only update graph every 30 frames by default
         self.last_plot_im = None  # Cache of the last rendered chart
@@ -104,7 +104,7 @@ class Analytics(BaseSolution):
                 and 'classwise_count' (dict, per-class object count).
 
         Raises:
-            ModuleNotFoundError: If an unsupported chart type is specified.
+            ValueError: If an unsupported chart type is specified.
 
         Examples:
             >>> analytics = Analytics(analytics_type="line")
@@ -131,9 +131,9 @@ class Analytics(BaseSolution):
                 )
             plot_im = self.last_plot_im
         else:
-            raise ModuleNotFoundError(f"{self.type} chart is not supported ❌")
+            raise ValueError(f"Unsupported analytics_type='{self.type}'. Supported types: line, bar, pie, area.")
 
-        # return output dictionary with summary for more usage
+        # Return results for downstream use.
         return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), classwise_count=self.clswise_count)
 
     def update_graph(

ultralytics/solutions/config.py

@@ -35,7 +35,7 @@ class SolutionConfig:
         vision_point (tuple[int, int]): Reference point for directional tracking or perspective drawing.
         crop_dir (str): Directory path to save cropped detection images.
         json_file (str): Path to a JSON file containing data for parking areas.
-        line_width (int): Width for visual display i.e. bounding boxes, keypoints, counts.
+        line_width (int): Width for visual display, e.g. bounding boxes, keypoints, and counts.
         records (int): Number of detection records to send email alerts.
         fps (float): Frame rate (Frames Per Second) for speed estimation calculation.
         max_hist (int): Maximum number of historical points or states stored per tracked object for speed estimation.

ultralytics/solutions/distance_calculation.py

@@ -17,7 +17,7 @@ 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.
+        selected_boxes (dict[int, Any]): Dictionary to store selected bounding boxes keyed by track ID.
         centroids (list[list[int]]): List to store centroids of selected bounding boxes.
 
     Methods:

ultralytics/solutions/object_counter.py

@@ -19,7 +19,7 @@ class ObjectCounter(BaseSolution):
         in_count (int): Counter for objects moving inward.
         out_count (int): Counter for objects moving outward.
         counted_ids (list[int]): List of IDs of objects that have been counted.
-        classwise_counts (dict[str, dict[str, int]]): Dictionary for counts, categorized by object class.
+        classwise_count (dict[str, dict[str, int]]): Dictionary for counts, categorized by object class.
         region_initialized (bool): Flag indicating whether the counting region has been initialized.
         show_in (bool): Flag to control display of inward count.
         show_out (bool): Flag to control display of outward count.

ultralytics/solutions/object_cropper.py

@@ -1,6 +1,5 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-import os
 from pathlib import Path
 from typing import Any
 
@@ -40,12 +39,10 @@ class ObjectCropper(BaseSolution):
         super().__init__(**kwargs)
 
         self.crop_dir = self.CFG["crop_dir"]  # 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
+        Path(self.crop_dir).mkdir(parents=True, exist_ok=True)
         if self.CFG["show"]:
-            self.LOGGER.warning(
-                f"show=True disabled for crop solution, results will be saved in the directory named: {self.crop_dir}"
-            )
+            self.LOGGER.warning(f"show=True is not supported for ObjectCropper; saving crops to '{self.crop_dir}'.")
+            self.CFG["show"] = False
         self.crop_idx = 0  # Initialize counter for total cropped objects
         self.iou = self.CFG["iou"]
         self.conf = self.CFG["conf"]

ultralytics/solutions/parking_management.py

@@ -92,7 +92,7 @@ class ParkingPtsSelection:
 
         for text, cmd in [
             ("Upload Image", self.upload_image),
-            ("Remove Last BBox", self.remove_last_bounding_box),
+            ("Remove Last Bounding Box", self.remove_last_bounding_box),
             ("Save", self.save_to_json),
         ]:
             self.tk.Button(button_frame, text=text, command=cmd).pack(side=self.tk.LEFT)
@@ -186,9 +186,9 @@ class ParkingManagement(BaseSolution):
         json_file (str): Path to the JSON file containing parking region details.
         json (list[dict]): Loaded JSON data containing parking region information.
         pr_info (dict[str, int]): Dictionary storing parking information (Occupancy and Available spaces).
-        arc (tuple[int, int, int]): RGB color tuple for available region visualization.
-        occ (tuple[int, int, int]): RGB color tuple for occupied region visualization.
-        dc (tuple[int, int, int]): RGB color tuple for centroid visualization of detected objects.
+        arc (tuple[int, int, int]): BGR color tuple for available region visualization.
+        occ (tuple[int, int, int]): BGR color tuple for occupied region visualization.
+        dc (tuple[int, int, int]): BGR color tuple for centroid visualization of detected objects.
 
     Methods:
         process: Process the input image for parking lot management and visualization.
@@ -205,11 +205,11 @@ class ParkingManagement(BaseSolution):
         super().__init__(**kwargs)
 
         self.json_file = self.CFG["json_file"]  # Load parking regions JSON data
-        if self.json_file is None:
-            LOGGER.warning("json_file argument missing. Parking region details required.")
-            raise ValueError("❌ Json file path can not be empty")
+        if not self.json_file:
+            LOGGER.warning("ParkingManagement requires `json_file` with parking region coordinates.")
+            raise ValueError("❌ JSON file path cannot be empty.")
 
-        with open(self.json_file) as f:
+        with open(self.json_file, encoding="utf-8") as f:
             self.json = json.load(f)
 
         self.pr_info = {"Occupancy": 0, "Available": 0}  # Dictionary for parking information
@@ -239,28 +239,32 @@ class ParkingManagement(BaseSolution):
             >>> results = parking_manager.process(image)
         """
         self.extract_tracks(im0)  # Extract tracks from im0
-        es, fs = len(self.json), 0  # Empty slots, filled slots
+        available_slots, occupied_slots = len(self.json), 0
         annotator = SolutionAnnotator(im0, self.line_width)  # Initialize annotator
 
         for region in self.json:
             # Convert points to a NumPy array with the correct dtype and reshape properly
-            pts_array = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
-            rg_occupied = False  # Occupied region initialization
+            region_polygon = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
+            region_occupied = False
             for box, cls in zip(self.boxes, self.clss):
                 xc, yc = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-                dist = cv2.pointPolygonTest(pts_array, (xc, yc), False)
-                if dist >= 0:
+                inside_distance = cv2.pointPolygonTest(region_polygon, (xc, yc), False)
+                if inside_distance >= 0:
                     # cv2.circle(im0, (xc, yc), radius=self.line_width * 4, color=self.dc, thickness=-1)
                     annotator.display_objects_labels(
                         im0, self.model.names[int(cls)], (104, 31, 17), (255, 255, 255), xc, yc, 10
                     )
-                    rg_occupied = True
+                    region_occupied = True
                     break
-            fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
+            if region_occupied:
+                occupied_slots += 1
+                available_slots -= 1
             # Plot regions
-            cv2.polylines(im0, [pts_array], isClosed=True, color=self.occ if rg_occupied else self.arc, thickness=2)
+            cv2.polylines(
+                im0, [region_polygon], isClosed=True, color=self.occ if region_occupied else self.arc, thickness=2
+            )
 
-        self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
+        self.pr_info["Occupancy"], self.pr_info["Available"] = occupied_slots, available_slots
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
 

ultralytics/solutions/queue_management.py

@@ -14,7 +14,7 @@ class QueueManager(BaseSolution):
 
     Attributes:
         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.
+        rect_color (tuple[int, int, int]): BGR color tuple for drawing the queue region rectangle.
         region_length (int): The number of points defining the queue region.
         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.
@@ -30,10 +30,10 @@ class QueueManager(BaseSolution):
         >>> cap = cv2.VideoCapture("path/to/video.mp4")
         >>> queue_manager = QueueManager(region=[100, 100, 200, 200, 300, 300])
         >>> while cap.isOpened():
-        >>>     success, im0 = cap.read()
-        >>>     if not success:
-        >>>         break
-        >>>     results = queue_manager.process(im0)
+        ...     success, im0 = cap.read()
+        ...     if not success:
+        ...         break
+        ...     results = queue_manager.process(im0)
     """
 
     def __init__(self, **kwargs: Any) -> None:

ultralytics/solutions/region_counter.py

@@ -67,7 +67,7 @@ class RegionCounter(BaseSolution):
             text_color (tuple[int, int, int]): BGR color for the text within the region.
 
         Returns:
-            (dict[str, any]): Returns a dictionary including the region information i.e. name, region_color etc.
+            (dict[str, Any]): Region information including name, polygon, and display colors.
         """
         region = self.region_template.copy()
         region.update(
@@ -82,7 +82,7 @@ class RegionCounter(BaseSolution):
         return region
 
     def initialize_regions(self):
-        """Initialize regions only once."""
+        """Initialize regions from `self.region` only once."""
         if self.region is None:
             self.initialize_region()
         if not isinstance(self.region, dict):  # Ensure self.region is initialized and structured as a dictionary

ultralytics/solutions/security_alarm.py

@@ -98,7 +98,7 @@ class SecurityAlarm(BaseSolution):
         message["Subject"] = "Security Alert"
 
         # Add the text message body
-        message_body = f"Ultralytics ALERT!!! {records} objects have been detected!!"
+        message_body = f"Ultralytics alert: {records} object(s) detected."
         message.attach(MIMEText(message_body))
 
         # Attach the image

ultralytics/solutions/solutions.py

@@ -177,7 +177,7 @@ class BaseSolution:
             self.track_ids = self.track_data.id.int().cpu().tolist()
             self.confs = self.track_data.conf.cpu().tolist()
         else:
-            self.LOGGER.warning("no tracks found!")
+            self.LOGGER.warning("No tracks found.")
             self.boxes, self.clss, self.track_ids, self.confs = [], [], [], []
 
     def store_tracking_history(self, track_id: int, box) -> None:
@@ -271,7 +271,7 @@ class SolutionAnnotator(Annotator):
         font_size (int): Size of the font used for text annotations.
         font (str): Path to the font file used for text rendering.
         pil (bool): Whether to use PIL for text rendering.
-        example (str): An example attribute for demonstration purposes.
+        example (str): Example text used to detect non-ASCII labels for PIL rendering.
 
     Methods:
         draw_region: Draw a region using specified points, colors, and thickness.
@@ -312,7 +312,7 @@ class SolutionAnnotator(Annotator):
             font_size (int, optional): Font size for text annotations.
             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.
+            example (str): Example text used to detect non-ASCII labels for PIL rendering.
         """
         super().__init__(im, line_width, font_size, font, pil, example)
 
@@ -326,7 +326,7 @@ class SolutionAnnotator(Annotator):
 
         Args:
             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.
+            color (tuple[int, int, int]): BGR color value for the region (OpenCV format).
             thickness (int): Line thickness for drawing the region.
         """
         cv2.polylines(self.im, [np.array(reg_pts, dtype=np.int32)], isClosed=True, color=color, thickness=thickness)
@@ -347,8 +347,8 @@ class SolutionAnnotator(Annotator):
         Args:
             label (str): Queue counts label.
             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.
+            region_color (tuple[int, int, int]): BGR queue region color (OpenCV format).
+            txt_color (tuple[int, int, int]): BGR text color (OpenCV format).
         """
         x_values = [point[0] for point in points]
         y_values = [point[1] for point in points]
@@ -388,13 +388,13 @@ class SolutionAnnotator(Annotator):
         bg_color: tuple[int, int, int],
         margin: int,
     ):
-        """Display the overall statistics for parking lots, object counter etc.
+        """Display overall statistics for Solutions (e.g., parking management and object counting).
 
         Args:
             im0 (np.ndarray): Inference image.
             text (dict[str, Any]): Labels dictionary.
-            txt_color (tuple[int, int, int]): Display color for text foreground.
-            bg_color (tuple[int, int, int]): Display color for text background.
+            txt_color (tuple[int, int, int]): Text color (BGR, OpenCV format).
+            bg_color (tuple[int, int, int]): Background color (BGR, OpenCV format).
             margin (int): Gap between text and rectangle for better display.
         """
         horizontal_gap = int(im0.shape[1] * 0.02)
@@ -415,22 +415,45 @@ class SolutionAnnotator(Annotator):
             cv2.putText(im0, txt, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
             text_y_offset = rect_y2
 
+    @staticmethod
+    def _point_xy(point: Any) -> tuple[float, float]:
+        """Convert a keypoint-like object to an (x, y) tuple of floats."""
+        if hasattr(point, "detach"):  # torch.Tensor
+            point = point.detach()
+        if hasattr(point, "cpu"):  # torch.Tensor
+            point = point.cpu()
+        if hasattr(point, "numpy"):  # torch.Tensor
+            point = point.numpy()
+        if hasattr(point, "tolist"):  # numpy / torch
+            point = point.tolist()
+        return float(point[0]), float(point[1])
+
     @staticmethod
     @lru_cache(maxsize=256)
-    def estimate_pose_angle(a: list[float], b: list[float], c: list[float]) -> float:
+    def _estimate_pose_angle_cached(a: tuple[float, float], b: tuple[float, float], c: tuple[float, float]) -> float:
+        """Calculate the angle between three points for workout monitoring (cached)."""
+        radians = math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0])
+        angle = abs(radians * 180.0 / math.pi)
+        return angle if angle <= 180.0 else (360 - angle)
+
+    @staticmethod
+    def estimate_pose_angle(a: Any, b: Any, c: Any) -> float:
         """Calculate the angle between three points for workout monitoring.
 
         Args:
-            a (list[float]): The coordinates of the first point.
-            b (list[float]): The coordinates of the second point (vertex).
-            c (list[float]): The coordinates of the third point.
+            a (Any): The coordinates of the first point (e.g. list/tuple/NumPy array/torch tensor).
+            b (Any): The coordinates of the second point (vertex).
+            c (Any): The coordinates of the third point.
 
         Returns:
             (float): The angle in degrees between the three points.
         """
-        radians = math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0])
-        angle = abs(radians * 180.0 / math.pi)
-        return angle if angle <= 180.0 else (360 - angle)
+        a_xy, b_xy, c_xy = (
+            SolutionAnnotator._point_xy(a),
+            SolutionAnnotator._point_xy(b),
+            SolutionAnnotator._point_xy(c),
+        )
+        return SolutionAnnotator._estimate_pose_angle_cached(a_xy, b_xy, c_xy)
 
     def draw_specific_kpts(
         self,
@@ -543,7 +566,7 @@ class SolutionAnnotator(Annotator):
         """Plot the distance and line between two centroids on the frame.
 
         Args:
-            pixels_distance (float): Pixels distance between two bbox centroids.
+            pixels_distance (float): Pixel distance between two bounding-box centroids.
             centroids (list[tuple[int, int]]): Bounding box centroids data.
             line_color (tuple[int, int, int]): Distance line color.
             centroid_color (tuple[int, int, int]): Bounding box centroid color.
@@ -634,8 +657,8 @@ class SolutionAnnotator(Annotator):
             line_x (int): The x-coordinate of the sweep line.
             line_y (int): The y-coordinate limit of the sweep line.
             label (str, optional): Text label to be drawn in center of sweep line. If None, no label is drawn.
-            color (tuple[int, int, int]): RGB color for the line and label background.
-            txt_color (tuple[int, int, int]): RGB color for the label text.
+            color (tuple[int, int, int]): BGR color for the line and label background (OpenCV format).
+            txt_color (tuple[int, int, int]): BGR color for the label text (OpenCV format).
         """
         # Draw the sweep line
         cv2.line(self.im, (line_x, 0), (line_x, line_y), color, self.tf * 2)
@@ -695,15 +718,15 @@ class SolutionAnnotator(Annotator):
             box (tuple[float, float, float, float]): The bounding box coordinates (x1, y1, x2, y2).
             label (str): The text label to be displayed.
             color (tuple[int, int, int]): The background color of the rectangle (B, G, R).
-            txt_color (tuple[int, int, int]): The color of the text (R, G, B).
-            shape (str): The shape of the label i.e "circle" or "rect"
+            txt_color (tuple[int, int, int]): The color of the text (B, G, R).
+            shape (str): Label shape. Options: "circle" or "rect".
             margin (int): The margin between the text and the rectangle border.
         """
         if shape == "circle" and len(label) > 3:
             LOGGER.warning(f"Length of label is {len(label)}, only first 3 letters will be used for circle annotation.")
             label = label[:3]
 
-        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)  # Calculate center of the bbox
+        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)  # Bounding-box center
         text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, self.sf - 0.15, self.tf)[0]  # Get size of the text
         text_x, text_y = x_center - text_size[0] // 2, y_center + text_size[1] // 2  # Calculate top-left corner of text
 

ultralytics/solutions/speed_estimation.py

@@ -62,7 +62,7 @@ class SpeedEstimator(BaseSolution):
         """Process an input frame to estimate object speeds based on tracking data.
 
         Args:
-            im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
+            im0 (np.ndarray): Input image for processing with shape (H, W, C) in OpenCV BGR format.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).

ultralytics/trackers/basetrack.py

@@ -19,7 +19,7 @@ class TrackState:
     Examples:
         >>> state = TrackState.New
         >>> if state == TrackState.New:
-        >>>     print("Object is newly detected.")
+        ...     print("Object is newly detected.")
     """
 
     New = 0

ultralytics/trackers/bot_sort.py

@@ -45,9 +45,9 @@ class BOTrack(STrack):
 
     Examples:
         Create a BOTrack instance and update its features
-        >>> bo_track = BOTrack(tlwh=[100, 50, 80, 40], score=0.9, cls=1, feat=np.random.rand(128))
+        >>> bo_track = BOTrack(xywh=np.array([100, 50, 80, 40, 0]), score=0.9, cls=1, feat=np.random.rand(128))
         >>> bo_track.predict()
-        >>> new_track = BOTrack(tlwh=[110, 60, 80, 40], score=0.85, cls=1, feat=np.random.rand(128))
+        >>> new_track = BOTrack(xywh=np.array([110, 60, 80, 40, 0]), score=0.85, cls=1, feat=np.random.rand(128))
         >>> bo_track.update(new_track, frame_id=2)
     """
 
@@ -59,7 +59,8 @@ class BOTrack(STrack):
         """Initialize a BOTrack object with temporal parameters, such as feature history, alpha, and current features.
 
         Args:
-            xywh (np.ndarray): Bounding box coordinates in xywh format (center x, center y, width, height).
+            xywh (np.ndarray): Bounding box in `(x, y, w, h, idx)` or `(x, y, w, h, angle, idx)` format, where (x, y) is
+                the center, (w, h) are width and height, and `idx` is the detection index.
             score (float): Confidence score of the detection.
             cls (int): Class ID of the detected object.
             feat (np.ndarray, optional): Feature vector associated with the detection.

ultralytics/trackers/byte_tracker.py

@@ -56,8 +56,8 @@ class STrack(BaseTrack):
         """Initialize a new STrack instance.
 
         Args:
-            xywh (list[float]): Bounding box coordinates and dimensions in the format (x, y, w, h, [a], idx), where (x,
-                y) is the center, (w, h) are width and height, [a] is optional aspect ratio, and idx is the id.
+            xywh (list[float]): Bounding box in `(x, y, w, h, idx)` or `(x, y, w, h, angle, idx)` format, where (x, y)
+                is the center, (w, h) are width and height, and `idx` is the detection index.
             score (float): Confidence score of the detection.
             cls (Any): Class label for the detected object.
         """
@@ -338,7 +338,7 @@ class BYTETracker:
         # Step 3: Second association, with low score detection boxes association the untrack to the low score detections
         detections_second = self.init_track(results_second, feats_second)
         r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
-        # TODO
+        # TODO: consider fusing scores or appearance features for second association.
         dists = matching.iou_distance(r_tracked_stracks, detections_second)
         matches, u_track, _u_detection_second = matching.linear_assignment(dists, thresh=0.5)
         for itracked, idet in matches:
@@ -389,7 +389,7 @@ class BYTETracker:
         self.tracked_stracks, self.lost_stracks = self.remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
         self.removed_stracks.extend(removed_stracks)
         if len(self.removed_stracks) > 1000:
-            self.removed_stracks = self.removed_stracks[-999:]  # clip remove stracks to 1000 maximum
+            self.removed_stracks = self.removed_stracks[-1000:]  # clip removed stracks to 1000 maximum
 
         return np.asarray([x.result for x in self.tracked_stracks if x.is_activated], dtype=np.float32)
 

ultralytics/trackers/utils/gmc.py

@@ -34,11 +34,10 @@ class GMC:
     Examples:
         Create a GMC object and apply it to a frame
         >>> gmc = GMC(method="sparseOptFlow", downscale=2)
-        >>> frame = np.array([[1, 2, 3], [4, 5, 6]])
-        >>> processed_frame = gmc.apply(frame)
-        >>> print(processed_frame)
-        array([[1, 2, 3],
-               [4, 5, 6]])
+        >>> frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
+        >>> warp = gmc.apply(frame)
+        >>> print(warp.shape)
+        (2, 3)
     """
 
     def __init__(self, method: str = "sparseOptFlow", downscale: int = 2) -> None:
@@ -85,7 +84,7 @@ class GMC:
         self.initializedFirstFrame = False
 
     def apply(self, raw_frame: np.ndarray, detections: list | None = None) -> np.ndarray:
-        """Apply object detection on a raw frame using the specified method.
+        """Estimate a 2×3 motion compensation warp for a frame.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).
@@ -145,7 +144,7 @@ class GMC:
         try:
             (_, H) = cv2.findTransformECC(self.prevFrame, frame, H, self.warp_mode, self.criteria, None, 1)
         except Exception as e:
-            LOGGER.warning(f"find transform failed. Set warp as identity {e}")
+            LOGGER.warning(f"findTransformECC failed; using identity warp. {e}")
 
         return H
 

ultralytics/trackers/utils/kalman_filter.py

@@ -167,9 +167,10 @@ class KalmanFilterXYAH:
             covariance (np.ndarray): Covariance matrix of the predicted states with shape (N, 8, 8).
 
         Examples:
+            >>> kf = KalmanFilterXYAH()
             >>> mean = np.random.rand(10, 8)  # 10 object states
             >>> covariance = np.random.rand(10, 8, 8)  # Covariance matrices for 10 object states
-            >>> predicted_mean, predicted_covariance = kalman_filter.multi_predict(mean, covariance)
+            >>> predicted_mean, predicted_covariance = kf.multi_predict(mean, covariance)
         """
         std_pos = [
             self._std_weight_position * mean[:, 3],

ultralytics/trackers/utils/matching.py

@@ -26,9 +26,10 @@ def linear_assignment(cost_matrix: np.ndarray, thresh: float, use_lap: bool = Tr
         use_lap (bool): Use lap.lapjv for the assignment. If False, scipy.optimize.linear_sum_assignment is used.
 
     Returns:
-        matched_indices (np.ndarray): Array of matched indices of shape (K, 2), where K is the number of matches.
-        unmatched_a (np.ndarray): Array of unmatched indices from the first set, with shape (L,).
-        unmatched_b (np.ndarray): Array of unmatched indices from the second set, with shape (M,).
+        matched_indices (list[list[int]] | np.ndarray): Matched indices of shape (K, 2), where K is the number of
+            matches.
+        unmatched_a (np.ndarray): Unmatched indices from the first set, with shape (L,).
+        unmatched_b (np.ndarray): Unmatched indices from the second set, with shape (M,).
 
     Examples:
         >>> cost_matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

ultralytics/utils/__init__.py

@@ -14,6 +14,7 @@ import socket
 import sys
 import threading
 import time
+import warnings
 from functools import lru_cache
 from pathlib import Path
 from threading import Lock
@@ -132,6 +133,14 @@ os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # suppress verbose TF compiler warning
 os.environ["TORCH_CPP_LOG_LEVEL"] = "ERROR"  # suppress "NNPACK.cpp could not initialize NNPACK" warnings
 os.environ["KINETO_LOG_LEVEL"] = "5"  # suppress verbose PyTorch profiler output when computing FLOPs
 
+# Centralized warning suppression
+warnings.filterwarnings("ignore", message="torch.distributed.reduce_op is deprecated")  # PyTorch deprecation
+warnings.filterwarnings("ignore", message="The figure layout has changed to tight")  # matplotlib>=3.7.2
+warnings.filterwarnings("ignore", category=FutureWarning, module="timm")  # mobileclip timm.layers deprecation
+warnings.filterwarnings("ignore", category=torch.jit.TracerWarning)  # ONNX/TorchScript export tracer warnings
+warnings.filterwarnings("ignore", category=UserWarning, message=".*prim::Constant.*")  # ONNX shape warning
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="coremltools")  # CoreML np.bool deprecation
+
 # Precompiled type tuples for faster isinstance() checks
 FLOAT_OR_INT = (float, int)
 STR_OR_PATH = (str, Path)
@@ -142,7 +151,7 @@ class DataExportMixin:
 
     This class provides utilities to export performance metrics (e.g., mAP, precision, recall) or prediction results
     from classification, object detection, segmentation, or pose estimation tasks into various formats: Polars
-    DataFrame, CSV and JSON.
+    DataFrame, CSV, and JSON.
 
     Methods:
         to_df: Convert summary to a Polars DataFrame.
@@ -159,14 +168,14 @@ class DataExportMixin:
     """
 
     def to_df(self, normalize=False, decimals=5):
-        """Create a polars DataFrame from the prediction results summary or validation metrics.
+        """Create a Polars DataFrame from the prediction results summary or validation metrics.
 
         Args:
             normalize (bool, optional): Normalize numerical values for easier comparison.
             decimals (int, optional): Decimal places to round floats.
 
         Returns:
-            (DataFrame): DataFrame containing the summary data.
+            (polars.DataFrame): Polars DataFrame containing the summary data.
         """
         import polars as pl  # scope for faster 'import ultralytics'
 

ultralytics/utils/benchmarks.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 """
-Benchmark a YOLO model formats for speed and accuracy.
+Benchmark YOLO model formats for speed and accuracy.
 
 Usage:
     from ultralytics.utils.benchmarks import ProfileModels, benchmark
@@ -78,7 +78,7 @@ def benchmark(
         **kwargs (Any): Additional keyword arguments for exporter.
 
     Returns:
-        (polars.DataFrame): A polars DataFrame with benchmark results for each format, including file size, metric, and
+        (polars.DataFrame): A Polars DataFrame with benchmark results for each format, including file size, metric, and
             inference time.
 
     Examples: