dgenerate-ultralytics-headless 8.3.222__py3-none-any.whl → 8.3.225__py3-none-any.whl

ultralytics/trackers/byte_tracker.py

@@ -14,8 +14,7 @@ from .utils.kalman_filter import KalmanFilterXYAH
 
 
 class STrack(BaseTrack):
-    """
-    Single object tracking representation that uses Kalman filtering for state estimation.
+    """Single object tracking representation that uses Kalman filtering for state estimation.
 
     This class is responsible for storing all the information regarding individual tracklets and performs state updates
     and predictions based on Kalman filter.
@@ -54,12 +53,11 @@ class STrack(BaseTrack):
     shared_kalman = KalmanFilterXYAH()
 
     def __init__(self, xywh: list[float], score: float, cls: Any):
-        """
-        Initialize a new STrack instance.
+        """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 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.
             score (float): Confidence score of the detection.
             cls (Any): Class label for the detected object.
 
@@ -154,8 +152,7 @@ class STrack(BaseTrack):
         self.idx = new_track.idx
 
     def update(self, new_track: STrack, frame_id: int):
-        """
-        Update the state of a matched track.
+        """Update the state of a matched track.
 
         Args:
             new_track (STrack): The new track containing updated information.
@@ -238,12 +235,11 @@ class STrack(BaseTrack):
 
 
 class BYTETracker:
-    """
-    BYTETracker: A tracking algorithm built on top of YOLOv8 for object detection and tracking.
+    """BYTETracker: A tracking algorithm built on top of YOLOv8 for object detection and tracking.
 
-    This class encapsulates the functionality for initializing, updating, and managing the tracks for detected objects in a
-    video sequence. It maintains the state of tracked, lost, and removed tracks over frames, utilizes Kalman filtering for
-    predicting the new object locations, and performs data association.
+    This class encapsulates the functionality for initializing, updating, and managing the tracks for detected objects
+    in a video sequence. It maintains the state of tracked, lost, and removed tracks over frames, utilizes Kalman
+    filtering for predicting the new object locations, and performs data association.
 
     Attributes:
         tracked_stracks (list[STrack]): List of successfully activated tracks.
@@ -274,8 +270,7 @@ class BYTETracker:
     """
 
     def __init__(self, args, frame_rate: int = 30):
-        """
-        Initialize a BYTETracker instance for object tracking.
+        """Initialize a BYTETracker instance for object tracking.
 
         Args:
             args (Namespace): Command-line arguments containing tracking parameters.

ultralytics/trackers/track.py

@@ -16,8 +16,7 @@ TRACKER_MAP = {"bytetrack": BYTETracker, "botsort": BOTSORT}
 
 
 def on_predict_start(predictor: object, persist: bool = False) -> None:
-    """
-    Initialize trackers for object tracking during prediction.
+    """Initialize trackers for object tracking during prediction.
 
     Args:
         predictor (ultralytics.engine.predictor.BasePredictor): The predictor object to initialize trackers for.
@@ -70,8 +69,7 @@ def on_predict_start(predictor: object, persist: bool = False) -> None:
 
 
 def on_predict_postprocess_end(predictor: object, persist: bool = False) -> None:
-    """
-    Postprocess detected boxes and update with object tracking.
+    """Postprocess detected boxes and update with object tracking.
 
     Args:
         predictor (object): The predictor object containing the predictions.
@@ -103,8 +101,7 @@ def on_predict_postprocess_end(predictor: object, persist: bool = False) -> None
 
 
 def register_tracker(model: object, persist: bool) -> None:
-    """
-    Register tracking callbacks to the model for object tracking during prediction.
+    """Register tracking callbacks to the model for object tracking during prediction.
 
     Args:
         model (object): The model object to register tracking callbacks for.

ultralytics/trackers/utils/gmc.py

@@ -11,8 +11,7 @@ from ultralytics.utils import LOGGER
 
 
 class GMC:
-    """
-    Generalized Motion Compensation (GMC) class for tracking and object detection in video frames.
+    """Generalized Motion Compensation (GMC) class for tracking and object detection in video frames.
 
     This class provides methods for tracking and detecting objects based on several tracking algorithms including ORB,
     SIFT, ECC, and Sparse Optical Flow. It also supports downscaling of frames for computational efficiency.
@@ -43,8 +42,7 @@ class GMC:
     """
 
     def __init__(self, method: str = "sparseOptFlow", downscale: int = 2) -> None:
-        """
-        Initialize a Generalized Motion Compensation (GMC) object with tracking method and downscale factor.
+        """Initialize a Generalized Motion Compensation (GMC) object with tracking method and downscale factor.
 
         Args:
             method (str): The tracking method to use. Options include 'orb', 'sift', 'ecc', 'sparseOptFlow', 'none'.
@@ -91,8 +89,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.
+        """Apply object detection on a raw frame using the specified method.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).
@@ -118,8 +115,7 @@ class GMC:
             return np.eye(2, 3)
 
     def apply_ecc(self, raw_frame: np.ndarray) -> np.ndarray:
-        """
-        Apply the ECC (Enhanced Correlation Coefficient) algorithm to a raw frame for motion compensation.
+        """Apply the ECC (Enhanced Correlation Coefficient) algorithm to a raw frame for motion compensation.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).
@@ -158,8 +154,7 @@ class GMC:
         return H
 
     def apply_features(self, raw_frame: np.ndarray, detections: list | None = None) -> np.ndarray:
-        """
-        Apply feature-based methods like ORB or SIFT to a raw frame.
+        """Apply feature-based methods like ORB or SIFT to a raw frame.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).
@@ -276,8 +271,7 @@ class GMC:
         return H
 
     def apply_sparseoptflow(self, raw_frame: np.ndarray) -> np.ndarray:
-        """
-        Apply Sparse Optical Flow method to a raw frame.
+        """Apply Sparse Optical Flow method to a raw frame.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).

ultralytics/trackers/utils/kalman_filter.py

@@ -5,11 +5,10 @@ import scipy.linalg
 
 
 class KalmanFilterXYAH:
-    """
-    A KalmanFilterXYAH class for tracking bounding boxes in image space using a Kalman filter.
+    """A KalmanFilterXYAH class for tracking bounding boxes in image space using a Kalman filter.
 
-    Implements a simple Kalman filter for tracking bounding boxes in image space. The 8-dimensional state space
-    (x, y, a, h, vx, vy, va, vh) contains the bounding box center position (x, y), aspect ratio a, height h, and their
+    Implements a simple Kalman filter for tracking bounding boxes in image space. The 8-dimensional state space (x, y,
+    a, h, vx, vy, va, vh) contains the bounding box center position (x, y), aspect ratio a, height h, and their
     respective velocities. Object motion follows a constant velocity model, and bounding box location (x, y, a, h) is
     taken as a direct observation of the state space (linear observation model).
 
@@ -37,8 +36,7 @@ class KalmanFilterXYAH:
     """
 
     def __init__(self):
-        """
-        Initialize Kalman filter model matrices with motion and observation uncertainty weights.
+        """Initialize Kalman filter model matrices with motion and observation uncertainty weights.
 
         The Kalman filter is initialized with an 8-dimensional state space (x, y, a, h, vx, vy, va, vh), where (x, y)
         represents the bounding box center position, 'a' is the aspect ratio, 'h' is the height, and their respective
@@ -62,15 +60,15 @@ class KalmanFilterXYAH:
         self._std_weight_velocity = 1.0 / 160
 
     def initiate(self, measurement: np.ndarray):
-        """
-        Create a track from an unassociated measurement.
+        """Create a track from an unassociated measurement.
 
         Args:
             measurement (np.ndarray): Bounding box coordinates (x, y, a, h) with center position (x, y), aspect ratio a,
                 and height h.
 
         Returns:
-            mean (np.ndarray): Mean vector (8-dimensional) of the new track. Unobserved velocities are initialized to 0 mean.
+            mean (np.ndarray): Mean vector (8-dimensional) of the new track. Unobserved velocities are initialized to 0
+                mean.
             covariance (np.ndarray): Covariance matrix (8x8 dimensional) of the new track.
 
         Examples:
@@ -96,12 +94,12 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def predict(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Run Kalman filter prediction step.
+        """Run Kalman filter prediction step.
 
         Args:
             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.
+            covariance (np.ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time
+                step.
 
         Returns:
             mean (np.ndarray): Mean vector of the predicted state. Unobserved velocities are initialized to 0 mean.
@@ -133,8 +131,7 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def project(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Project state distribution to measurement space.
+        """Project state distribution to measurement space.
 
         Args:
             mean (np.ndarray): The state's mean vector (8 dimensional array).
@@ -163,8 +160,7 @@ class KalmanFilterXYAH:
         return mean, covariance + innovation_cov
 
     def multi_predict(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Run Kalman filter prediction step for multiple object states (Vectorized version).
+        """Run Kalman filter prediction step for multiple object states (Vectorized version).
 
         Args:
             mean (np.ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
@@ -203,8 +199,7 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def update(self, mean: np.ndarray, covariance: np.ndarray, measurement: np.ndarray):
-        """
-        Run Kalman filter correction step.
+        """Run Kalman filter correction step.
 
         Args:
             mean (np.ndarray): The predicted state's mean vector (8 dimensional).
@@ -243,8 +238,7 @@ class KalmanFilterXYAH:
         only_position: bool = False,
         metric: str = "maha",
     ) -> np.ndarray:
-        """
-        Compute gating distance between state distribution and measurements.
+        """Compute gating distance between state distribution and measurements.
 
         A suitable distance threshold can be obtained from `chi2inv95`. If `only_position` is False, the chi-square
         distribution has 4 degrees of freedom, otherwise 2.
@@ -252,11 +246,12 @@ class KalmanFilterXYAH:
         Args:
             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, optional): If True, distance computation is done with respect to box center position only.
-            metric (str, optional): The metric to use for calculating the distance. Options are 'gaussian' for the squared
-                Euclidean distance and 'maha' for the squared Mahalanobis distance.
+            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, optional): If True, distance computation is done with respect to box center position
+                only.
+            metric (str, optional): The metric to use for calculating the distance. Options are 'gaussian' for the
+                squared Euclidean distance and 'maha' for the squared Mahalanobis distance.
 
         Returns:
             (np.ndarray): Returns an array of length N, where the i-th element contains the squared distance between
@@ -287,12 +282,11 @@ class KalmanFilterXYAH:
 
 
 class KalmanFilterXYWH(KalmanFilterXYAH):
-    """
-    A KalmanFilterXYWH class for tracking bounding boxes in image space using a Kalman filter.
+    """A KalmanFilterXYWH class for tracking bounding boxes in image space using a Kalman filter.
 
-    Implements a Kalman filter for tracking bounding boxes with state space (x, y, w, h, vx, vy, vw, vh), where
-    (x, y) is the center position, w is the width, h is the height, and vx, vy, vw, vh are their respective velocities.
-    The object motion follows a constant velocity model, and the bounding box location (x, y, w, h) is taken as a direct
+    Implements a Kalman filter for tracking bounding boxes with state space (x, y, w, h, vx, vy, vw, vh), where (x, y)
+    is the center position, w is the width, h is the height, and vx, vy, vw, vh are their respective velocities. The
+    object motion follows a constant velocity model, and the bounding box location (x, y, w, h) is taken as a direct
     observation of the state space (linear observation model).
 
     Attributes:
@@ -318,14 +312,15 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
     """
 
     def initiate(self, measurement: np.ndarray):
-        """
-        Create track from unassociated measurement.
+        """Create track from unassociated measurement.
 
         Args:
-            measurement (np.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:
-            mean (np.ndarray): Mean vector (8 dimensional) of the new track. Unobserved velocities are initialized to 0 mean.
+            mean (np.ndarray): Mean vector (8 dimensional) of the new track. Unobserved velocities are initialized to 0
+                mean.
             covariance (np.ndarray): Covariance matrix (8x8 dimensional) of the new track.
 
         Examples:
@@ -362,12 +357,12 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def predict(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Run Kalman filter prediction step.
+        """Run Kalman filter prediction step.
 
         Args:
             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.
+            covariance (np.ndarray): The 8x8-dimensional covariance matrix of the object state at the previous time
+                step.
 
         Returns:
             mean (np.ndarray): Mean vector of the predicted state. Unobserved velocities are initialized to 0 mean.
@@ -399,8 +394,7 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def project(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Project state distribution to measurement space.
+        """Project state distribution to measurement space.
 
         Args:
             mean (np.ndarray): The state's mean vector (8 dimensional array).
@@ -429,8 +423,7 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance + innovation_cov
 
     def multi_predict(self, mean: np.ndarray, covariance: np.ndarray):
-        """
-        Run Kalman filter prediction step (Vectorized version).
+        """Run Kalman filter prediction step (Vectorized version).
 
         Args:
             mean (np.ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
@@ -470,8 +463,7 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def update(self, mean: np.ndarray, covariance: np.ndarray, measurement: np.ndarray):
-        """
-        Run Kalman filter correction step.
+        """Run Kalman filter correction step.
 
         Args:
             mean (np.ndarray): The predicted state's mean vector (8 dimensional).

ultralytics/trackers/utils/matching.py

@@ -18,8 +18,7 @@ except (ImportError, AssertionError, AttributeError):
 
 
 def linear_assignment(cost_matrix: np.ndarray, thresh: float, use_lap: bool = True):
-    """
-    Perform linear assignment using either the scipy or lap.lapjv method.
+    """Perform linear assignment using either the scipy or lap.lapjv method.
 
     Args:
         cost_matrix (np.ndarray): The matrix containing cost values for assignments, with shape (N, M).
@@ -62,8 +61,7 @@ def linear_assignment(cost_matrix: np.ndarray, thresh: float, use_lap: bool = Tr
 
 
 def iou_distance(atracks: list, btracks: list) -> np.ndarray:
-    """
-    Compute cost based on Intersection over Union (IoU) between tracks.
+    """Compute cost based on Intersection over Union (IoU) between tracks.
 
     Args:
         atracks (list[STrack] | list[np.ndarray]): List of tracks 'a' or bounding boxes.
@@ -102,8 +100,7 @@ def iou_distance(atracks: list, btracks: list) -> np.ndarray:
 
 
 def embedding_distance(tracks: list, detections: list, metric: str = "cosine") -> np.ndarray:
-    """
-    Compute distance between tracks and detections based on embeddings.
+    """Compute distance between tracks and detections based on embeddings.
 
     Args:
         tracks (list[STrack]): List of tracks, where each track contains embedding features.
@@ -111,8 +108,8 @@ def embedding_distance(tracks: list, detections: list, metric: str = "cosine") -
         metric (str): Metric for distance computation. Supported metrics include 'cosine', 'euclidean', etc.
 
     Returns:
-        (np.ndarray): Cost matrix computed based on embeddings with shape (N, M), where N is the number of tracks
-            and M is the number of detections.
+        (np.ndarray): Cost matrix computed based on embeddings with shape (N, M), where N is the number of tracks and M
+            is the number of detections.
 
     Examples:
         Compute the embedding distance between tracks and detections using cosine metric
@@ -132,8 +129,7 @@ def embedding_distance(tracks: list, detections: list, metric: str = "cosine") -
 
 
 def fuse_score(cost_matrix: np.ndarray, detections: list) -> np.ndarray:
-    """
-    Fuse cost matrix with detection scores to produce a single similarity matrix.
+    """Fuse cost matrix with detection scores to produce a single similarity matrix.
 
     Args:
         cost_matrix (np.ndarray): The matrix containing cost values for assignments, with shape (N, M).