ultralytics 8.0.237__py3-none-any.whl → 8.0.239__py3-none-any.whl

ultralytics/solutions/speed_estimation.py

@@ -66,7 +66,7 @@ class SpeedEstimator:
             spdl_dist_thresh (int): Euclidean distance threshold for speed line
         """
         if reg_pts is None:
-            print('Region points not provided, using default values')
+            print("Region points not provided, using default values")
         else:
             self.reg_pts = reg_pts
         self.names = names
@@ -114,8 +114,9 @@ class SpeedEstimator:
             cls (str): object class name
             track (list): tracking history for tracks path drawing
         """
-        speed_label = str(int(
-            self.dist_data[track_id])) + 'km/ph' if track_id in self.dist_data else self.names[int(cls)]
+        speed_label = (
+            str(int(self.dist_data[track_id])) + "km/ph" if track_id in self.dist_data else self.names[int(cls)]
+        )
         bbox_color = colors(int(track_id)) if track_id in self.dist_data else (255, 0, 255)
 
         self.annotator.box_label(box, speed_label, bbox_color)
@@ -132,19 +133,16 @@ class SpeedEstimator:
         """
 
         if self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
+            if self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh:
+                direction = "known"
 
-            if (self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh):
-                direction = 'known'
-
-            elif (self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] <
-                  self.reg_pts[0][1] + self.spdl_dist_thresh):
-                direction = 'known'
+            elif self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[0][1] + self.spdl_dist_thresh:
+                direction = "known"
 
             else:
-                direction = 'unknown'
-
-            if self.trk_previous_times[trk_id] != 0 and direction != 'unknown':
+                direction = "unknown"
 
+            if self.trk_previous_times[trk_id] != 0 and direction != "unknown":
                 if trk_id not in self.trk_idslist:
                     self.trk_idslist.append(trk_id)
 
@@ -178,7 +176,6 @@ class SpeedEstimator:
         self.annotator.draw_region(reg_pts=self.reg_pts, color=(255, 0, 0), thickness=self.region_thickness)
 
         for box, trk_id, cls in zip(self.boxes, self.trk_ids, self.clss):
-
             track = self.store_track_info(trk_id, box)
 
             if trk_id not in self.trk_previous_times:
@@ -194,10 +191,10 @@ class SpeedEstimator:
 
     def display_frames(self):
         """Display frame."""
-        cv2.imshow('Ultralytics Speed Estimation', self.im0)
-        if cv2.waitKey(1) & 0xFF == ord('q'):
+        cv2.imshow("Ultralytics Speed Estimation", self.im0)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
             return
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     SpeedEstimator()

ultralytics/trackers/__init__.py

@@ -4,4 +4,4 @@ from .bot_sort import BOTSORT
 from .byte_tracker import BYTETracker
 from .track import register_tracker
 
-__all__ = 'register_tracker', 'BOTSORT', 'BYTETracker'  # allow simpler import
+__all__ = "register_tracker", "BOTSORT", "BYTETracker"  # allow simpler import

ultralytics/trackers/basetrack.py

@@ -55,6 +55,7 @@ class BaseTrack:
     _count = 0
 
     def __init__(self):
+        """Initializes a new track with unique ID and foundational tracking attributes."""
         self.track_id = 0
         self.is_activated = False
         self.state = TrackState.New

ultralytics/trackers/bot_sort.py

@@ -39,6 +39,7 @@ class BOTrack(STrack):
         bo_track.predict()
         bo_track.update(new_track, frame_id)
     """
+
     shared_kalman = KalmanFilterXYWH()
 
     def __init__(self, tlwh, score, cls, feat=None, feat_history=50):
@@ -176,7 +177,7 @@ class BOTSORT(BYTETracker):
     def get_dists(self, tracks, detections):
         """Get distances between tracks and detections using IoU and (optionally) ReID embeddings."""
         dists = matching.iou_distance(tracks, detections)
-        dists_mask = (dists > self.proximity_thresh)
+        dists_mask = dists > self.proximity_thresh
 
         # TODO: mot20
         # if not self.args.mot20:

ultralytics/trackers/byte_tracker.py

@@ -112,8 +112,9 @@ class STrack(BaseTrack):
 
     def re_activate(self, new_track, frame_id, new_id=False):
         """Reactivates a previously lost track with a new detection."""
-        self.mean, self.covariance = self.kalman_filter.update(self.mean, self.covariance,
-                                                               self.convert_coords(new_track.tlwh))
+        self.mean, self.covariance = self.kalman_filter.update(
+            self.mean, self.covariance, self.convert_coords(new_track.tlwh)
+        )
         self.tracklet_len = 0
         self.state = TrackState.Tracked
         self.is_activated = True
@@ -136,8 +137,9 @@ class STrack(BaseTrack):
         self.tracklet_len += 1
 
         new_tlwh = new_track.tlwh
-        self.mean, self.covariance = self.kalman_filter.update(self.mean, self.covariance,
-                                                               self.convert_coords(new_tlwh))
+        self.mean, self.covariance = self.kalman_filter.update(
+            self.mean, self.covariance, self.convert_coords(new_tlwh)
+        )
         self.state = TrackState.Tracked
         self.is_activated = True
 
@@ -192,7 +194,7 @@ class STrack(BaseTrack):
 
     def __repr__(self):
         """Return a string representation of the BYTETracker object with start and end frames and track ID."""
-        return f'OT_{self.track_id}_({self.start_frame}-{self.end_frame})'
+        return f"OT_{self.track_id}_({self.start_frame}-{self.end_frame})"
 
 
 class BYTETracker:
@@ -275,7 +277,7 @@ class BYTETracker:
         strack_pool = self.joint_stracks(tracked_stracks, self.lost_stracks)
         # Predict the current location with KF
         self.multi_predict(strack_pool)
-        if hasattr(self, 'gmc') and img is not None:
+        if hasattr(self, "gmc") and img is not None:
             warp = self.gmc.apply(img, dets)
             STrack.multi_gmc(strack_pool, warp)
             STrack.multi_gmc(unconfirmed, warp)
@@ -349,7 +351,8 @@ class BYTETracker:
             self.removed_stracks = self.removed_stracks[-999:]  # clip remove stracks to 1000 maximum
         return np.asarray(
             [x.tlbr.tolist() + [x.track_id, x.score, x.cls, x.idx] for x in self.tracked_stracks if x.is_activated],
-            dtype=np.float32)
+            dtype=np.float32,
+        )
 
     def get_kalmanfilter(self):
         """Returns a Kalman filter object for tracking bounding boxes."""

ultralytics/trackers/track.py

@@ -10,7 +10,7 @@ from .bot_sort import BOTSORT
 from .byte_tracker import BYTETracker
 
 # A mapping of tracker types to corresponding tracker classes
-TRACKER_MAP = {'bytetrack': BYTETracker, 'botsort': BOTSORT}
+TRACKER_MAP = {"bytetrack": BYTETracker, "botsort": BOTSORT}
 
 
 def on_predict_start(predictor: object, persist: bool = False) -> None:
@@ -24,15 +24,15 @@ def on_predict_start(predictor: object, persist: bool = False) -> None:
     Raises:
         AssertionError: If the tracker_type is not 'bytetrack' or 'botsort'.
     """
-    if predictor.args.task == 'obb':
-        raise NotImplementedError('ERROR ❌ OBB task does not support track mode!')
-    if hasattr(predictor, 'trackers') and persist:
+    if predictor.args.task == "obb":
+        raise NotImplementedError("ERROR ❌ OBB task does not support track mode!")
+    if hasattr(predictor, "trackers") and persist:
         return
 
     tracker = check_yaml(predictor.args.tracker)
     cfg = IterableSimpleNamespace(**yaml_load(tracker))
 
-    if cfg.tracker_type not in ['bytetrack', 'botsort']:
+    if cfg.tracker_type not in ["bytetrack", "botsort"]:
         raise AssertionError(f"Only 'bytetrack' and 'botsort' are supported for now, but got '{cfg.tracker_type}'")
 
     trackers = []
@@ -76,5 +76,5 @@ def register_tracker(model: object, persist: bool) -> None:
         model (object): The model object to register tracking callbacks for.
         persist (bool): Whether to persist the trackers if they already exist.
     """
-    model.add_callback('on_predict_start', partial(on_predict_start, persist=persist))
-    model.add_callback('on_predict_postprocess_end', partial(on_predict_postprocess_end, persist=persist))
+    model.add_callback("on_predict_start", partial(on_predict_start, persist=persist))
+    model.add_callback("on_predict_postprocess_end", partial(on_predict_postprocess_end, persist=persist))

ultralytics/trackers/utils/gmc.py

@@ -33,7 +33,7 @@ class GMC:
         applySparseOptFlow(self, raw_frame, detections=None): Applies the Sparse Optical Flow method to a raw frame.
     """
 
-    def __init__(self, method: str = 'sparseOptFlow', downscale: int = 2) -> None:
+    def __init__(self, method: str = "sparseOptFlow", downscale: int = 2) -> None:
         """
         Initialize a video tracker with specified parameters.
 
@@ -46,34 +46,31 @@ class GMC:
         self.method = method
         self.downscale = max(1, int(downscale))
 
-        if self.method == 'orb':
+        if self.method == "orb":
             self.detector = cv2.FastFeatureDetector_create(20)
             self.extractor = cv2.ORB_create()
             self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING)
 
-        elif self.method == 'sift':
+        elif self.method == "sift":
             self.detector = cv2.SIFT_create(nOctaveLayers=3, contrastThreshold=0.02, edgeThreshold=20)
             self.extractor = cv2.SIFT_create(nOctaveLayers=3, contrastThreshold=0.02, edgeThreshold=20)
             self.matcher = cv2.BFMatcher(cv2.NORM_L2)
 
-        elif self.method == 'ecc':
+        elif self.method == "ecc":
             number_of_iterations = 5000
             termination_eps = 1e-6
             self.warp_mode = cv2.MOTION_EUCLIDEAN
             self.criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, number_of_iterations, termination_eps)
 
-        elif self.method == 'sparseOptFlow':
-            self.feature_params = dict(maxCorners=1000,
-                                       qualityLevel=0.01,
-                                       minDistance=1,
-                                       blockSize=3,
-                                       useHarrisDetector=False,
-                                       k=0.04)
+        elif self.method == "sparseOptFlow":
+            self.feature_params = dict(
+                maxCorners=1000, qualityLevel=0.01, minDistance=1, blockSize=3, useHarrisDetector=False, k=0.04
+            )
 
-        elif self.method in ['none', 'None', None]:
+        elif self.method in ["none", "None", None]:
             self.method = None
         else:
-            raise ValueError(f'Error: Unknown GMC method:{method}')
+            raise ValueError(f"Error: Unknown GMC method:{method}")
 
         self.prevFrame = None
         self.prevKeyPoints = None
@@ -97,11 +94,11 @@ class GMC:
             array([[1, 2, 3],
                    [4, 5, 6]])
         """
-        if self.method in ['orb', 'sift']:
+        if self.method in ["orb", "sift"]:
             return self.applyFeatures(raw_frame, detections)
-        elif self.method == 'ecc':
+        elif self.method == "ecc":
             return self.applyEcc(raw_frame, detections)
-        elif self.method == 'sparseOptFlow':
+        elif self.method == "sparseOptFlow":
             return self.applySparseOptFlow(raw_frame, detections)
         else:
             return np.eye(2, 3)
@@ -149,7 +146,7 @@ class GMC:
         try:
             (cc, H) = cv2.findTransformECC(self.prevFrame, frame, H, self.warp_mode, self.criteria, None, 1)
         except Exception as e:
-            LOGGER.warning(f'WARNING: find transform failed. Set warp as identity {e}')
+            LOGGER.warning(f"WARNING: find transform failed. Set warp as identity {e}")
 
         return H
 
@@ -182,11 +179,11 @@ class GMC:
 
         # Find the keypoints
         mask = np.zeros_like(frame)
-        mask[int(0.02 * height):int(0.98 * height), int(0.02 * width):int(0.98 * width)] = 255
+        mask[int(0.02 * height) : int(0.98 * height), int(0.02 * width) : int(0.98 * width)] = 255
         if detections is not None:
             for det in detections:
                 tlbr = (det[:4] / self.downscale).astype(np.int_)
-                mask[tlbr[1]:tlbr[3], tlbr[0]:tlbr[2]] = 0
+                mask[tlbr[1] : tlbr[3], tlbr[0] : tlbr[2]] = 0
 
         keypoints = self.detector.detect(frame, mask)
 
@@ -228,11 +225,14 @@ class GMC:
                 prevKeyPointLocation = self.prevKeyPoints[m.queryIdx].pt
                 currKeyPointLocation = keypoints[m.trainIdx].pt
 
-                spatialDistance = (prevKeyPointLocation[0] - currKeyPointLocation[0],
-                                   prevKeyPointLocation[1] - currKeyPointLocation[1])
+                spatialDistance = (
+                    prevKeyPointLocation[0] - currKeyPointLocation[0],
+                    prevKeyPointLocation[1] - currKeyPointLocation[1],
+                )
 
-                if (np.abs(spatialDistance[0]) < maxSpatialDistance[0]) and \
-                        (np.abs(spatialDistance[1]) < maxSpatialDistance[1]):
+                if (np.abs(spatialDistance[0]) < maxSpatialDistance[0]) and (
+                    np.abs(spatialDistance[1]) < maxSpatialDistance[1]
+                ):
                     spatialDistances.append(spatialDistance)
                     matches.append(m)
 
@@ -283,7 +283,7 @@ class GMC:
                 H[0, 2] *= self.downscale
                 H[1, 2] *= self.downscale
         else:
-            LOGGER.warning('WARNING: not enough matching points')
+            LOGGER.warning("WARNING: not enough matching points")
 
         # Store to next iteration
         self.prevFrame = frame.copy()
@@ -350,7 +350,7 @@ class GMC:
                 H[0, 2] *= self.downscale
                 H[1, 2] *= self.downscale
         else:
-            LOGGER.warning('WARNING: not enough matching points')
+            LOGGER.warning("WARNING: not enough matching points")
 
         self.prevFrame = frame.copy()
         self.prevKeyPoints = copy.copy(keypoints)

ultralytics/trackers/utils/kalman_filter.py

@@ -17,7 +17,7 @@ class KalmanFilterXYAH:
 
     def __init__(self):
         """Initialize Kalman filter model matrices with motion and observation uncertainty weights."""
-        ndim, dt = 4, 1.
+        ndim, dt = 4, 1.0
 
         # Create Kalman filter model matrices
         self._motion_mat = np.eye(2 * ndim, 2 * ndim)
@@ -27,8 +27,8 @@ class KalmanFilterXYAH:
 
         # Motion and observation uncertainty are chosen relative to the current state estimate. These weights control
         # the amount of uncertainty in the model.
-        self._std_weight_position = 1. / 20
-        self._std_weight_velocity = 1. / 160
+        self._std_weight_position = 1.0 / 20
+        self._std_weight_velocity = 1.0 / 160
 
     def initiate(self, measurement: np.ndarray) -> tuple:
         """
@@ -47,9 +47,15 @@ class KalmanFilterXYAH:
         mean = np.r_[mean_pos, mean_vel]
 
         std = [
-            2 * self._std_weight_position * measurement[3], 2 * self._std_weight_position * measurement[3], 1e-2,
-            2 * self._std_weight_position * measurement[3], 10 * self._std_weight_velocity * measurement[3],
-            10 * self._std_weight_velocity * measurement[3], 1e-5, 10 * self._std_weight_velocity * measurement[3]]
+            2 * self._std_weight_position * measurement[3],
+            2 * self._std_weight_position * measurement[3],
+            1e-2,
+            2 * self._std_weight_position * measurement[3],
+            10 * self._std_weight_velocity * measurement[3],
+            10 * self._std_weight_velocity * measurement[3],
+            1e-5,
+            10 * self._std_weight_velocity * measurement[3],
+        ]
         covariance = np.diag(np.square(std))
         return mean, covariance
 
@@ -66,11 +72,17 @@ class KalmanFilterXYAH:
                 velocities are initialized to 0 mean.
         """
         std_pos = [
-            self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-2,
-            self._std_weight_position * mean[3]]
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3],
+            1e-2,
+            self._std_weight_position * mean[3],
+        ]
         std_vel = [
-            self._std_weight_velocity * mean[3], self._std_weight_velocity * mean[3], 1e-5,
-            self._std_weight_velocity * mean[3]]
+            self._std_weight_velocity * mean[3],
+            self._std_weight_velocity * mean[3],
+            1e-5,
+            self._std_weight_velocity * mean[3],
+        ]
         motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
 
         mean = np.dot(mean, self._motion_mat.T)
@@ -90,8 +102,11 @@ class KalmanFilterXYAH:
             (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
         """
         std = [
-            self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-1,
-            self._std_weight_position * mean[3]]
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3],
+            1e-1,
+            self._std_weight_position * mean[3],
+        ]
         innovation_cov = np.diag(np.square(std))
 
         mean = np.dot(self._update_mat, mean)
@@ -111,11 +126,17 @@ class KalmanFilterXYAH:
                 velocities are initialized to 0 mean.
         """
         std_pos = [
-            self._std_weight_position * mean[:, 3], self._std_weight_position * mean[:, 3],
-            1e-2 * np.ones_like(mean[:, 3]), self._std_weight_position * mean[:, 3]]
+            self._std_weight_position * mean[:, 3],
+            self._std_weight_position * mean[:, 3],
+            1e-2 * np.ones_like(mean[:, 3]),
+            self._std_weight_position * mean[:, 3],
+        ]
         std_vel = [
-            self._std_weight_velocity * mean[:, 3], self._std_weight_velocity * mean[:, 3],
-            1e-5 * np.ones_like(mean[:, 3]), self._std_weight_velocity * mean[:, 3]]
+            self._std_weight_velocity * mean[:, 3],
+            self._std_weight_velocity * mean[:, 3],
+            1e-5 * np.ones_like(mean[:, 3]),
+            self._std_weight_velocity * mean[:, 3],
+        ]
         sqr = np.square(np.r_[std_pos, std_vel]).T
 
         motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
@@ -143,21 +164,23 @@ class KalmanFilterXYAH:
         projected_mean, projected_cov = self.project(mean, covariance)
 
         chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
-        kalman_gain = scipy.linalg.cho_solve((chol_factor, lower),
-                                             np.dot(covariance, self._update_mat.T).T,
-                                             check_finite=False).T
+        kalman_gain = scipy.linalg.cho_solve(
+            (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, check_finite=False
+        ).T
         innovation = measurement - projected_mean
 
         new_mean = mean + np.dot(innovation, kalman_gain.T)
         new_covariance = covariance - np.linalg.multi_dot((kalman_gain, projected_cov, kalman_gain.T))
         return new_mean, new_covariance
 
-    def gating_distance(self,
-                        mean: np.ndarray,
-                        covariance: np.ndarray,
-                        measurements: np.ndarray,
-                        only_position: bool = False,
-                        metric: str = 'maha') -> np.ndarray:
+    def gating_distance(
+        self,
+        mean: np.ndarray,
+        covariance: np.ndarray,
+        measurements: np.ndarray,
+        only_position: bool = False,
+        metric: str = "maha",
+    ) -> np.ndarray:
         """
         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,
@@ -183,14 +206,14 @@ class KalmanFilterXYAH:
             measurements = measurements[:, :2]
 
         d = measurements - mean
-        if metric == 'gaussian':
+        if metric == "gaussian":
             return np.sum(d * d, axis=1)
-        elif metric == 'maha':
+        elif metric == "maha":
             cholesky_factor = np.linalg.cholesky(covariance)
             z = scipy.linalg.solve_triangular(cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True)
             return np.sum(z * z, axis=0)  # square maha
         else:
-            raise ValueError('Invalid distance metric')
+            raise ValueError("Invalid distance metric")
 
 
 class KalmanFilterXYWH(KalmanFilterXYAH):
@@ -220,10 +243,15 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         mean = np.r_[mean_pos, mean_vel]
 
         std = [
-            2 * self._std_weight_position * measurement[2], 2 * self._std_weight_position * measurement[3],
-            2 * self._std_weight_position * measurement[2], 2 * self._std_weight_position * measurement[3],
-            10 * self._std_weight_velocity * measurement[2], 10 * self._std_weight_velocity * measurement[3],
-            10 * self._std_weight_velocity * measurement[2], 10 * self._std_weight_velocity * measurement[3]]
+            2 * self._std_weight_position * measurement[2],
+            2 * self._std_weight_position * measurement[3],
+            2 * self._std_weight_position * measurement[2],
+            2 * self._std_weight_position * measurement[3],
+            10 * self._std_weight_velocity * measurement[2],
+            10 * self._std_weight_velocity * measurement[3],
+            10 * self._std_weight_velocity * measurement[2],
+            10 * self._std_weight_velocity * measurement[3],
+        ]
         covariance = np.diag(np.square(std))
         return mean, covariance
 
@@ -240,11 +268,17 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
                 velocities are initialized to 0 mean.
         """
         std_pos = [
-            self._std_weight_position * mean[2], self._std_weight_position * mean[3],
-            self._std_weight_position * mean[2], self._std_weight_position * mean[3]]
+            self._std_weight_position * mean[2],
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[2],
+            self._std_weight_position * mean[3],
+        ]
         std_vel = [
-            self._std_weight_velocity * mean[2], self._std_weight_velocity * mean[3],
-            self._std_weight_velocity * mean[2], self._std_weight_velocity * mean[3]]
+            self._std_weight_velocity * mean[2],
+            self._std_weight_velocity * mean[3],
+            self._std_weight_velocity * mean[2],
+            self._std_weight_velocity * mean[3],
+        ]
         motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
 
         mean = np.dot(mean, self._motion_mat.T)
@@ -264,8 +298,11 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
             (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
         """
         std = [
-            self._std_weight_position * mean[2], self._std_weight_position * mean[3],
-            self._std_weight_position * mean[2], self._std_weight_position * mean[3]]
+            self._std_weight_position * mean[2],
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[2],
+            self._std_weight_position * mean[3],
+        ]
         innovation_cov = np.diag(np.square(std))
 
         mean = np.dot(self._update_mat, mean)
@@ -285,11 +322,17 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
                 velocities are initialized to 0 mean.
         """
         std_pos = [
-            self._std_weight_position * mean[:, 2], self._std_weight_position * mean[:, 3],
-            self._std_weight_position * mean[:, 2], self._std_weight_position * mean[:, 3]]
+            self._std_weight_position * mean[:, 2],
+            self._std_weight_position * mean[:, 3],
+            self._std_weight_position * mean[:, 2],
+            self._std_weight_position * mean[:, 3],
+        ]
         std_vel = [
-            self._std_weight_velocity * mean[:, 2], self._std_weight_velocity * mean[:, 3],
-            self._std_weight_velocity * mean[:, 2], self._std_weight_velocity * mean[:, 3]]
+            self._std_weight_velocity * mean[:, 2],
+            self._std_weight_velocity * mean[:, 3],
+            self._std_weight_velocity * mean[:, 2],
+            self._std_weight_velocity * mean[:, 3],
+        ]
         sqr = np.square(np.r_[std_pos, std_vel]).T
 
         motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]

ultralytics/trackers/utils/matching.py

@@ -13,7 +13,7 @@ try:
 except (ImportError, AssertionError, AttributeError):
     from ultralytics.utils.checks import check_requirements
 
-    check_requirements('lapx>=0.5.2')  # update to lap package from https://github.com/rathaROG/lapx
+    check_requirements("lapx>=0.5.2")  # update to lap package from https://github.com/rathaROG/lapx
     import lap
 
 
@@ -70,8 +70,9 @@ def iou_distance(atracks: list, btracks: list) -> np.ndarray:
         (np.ndarray): Cost matrix computed based on IoU.
     """
 
-    if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) \
-            or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
+    if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) or (
+        len(btracks) > 0 and isinstance(btracks[0], np.ndarray)
+    ):
         atlbrs = atracks
         btlbrs = btracks
     else:
@@ -80,13 +81,13 @@ def iou_distance(atracks: list, btracks: list) -> np.ndarray:
 
     ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float32)
     if len(atlbrs) and len(btlbrs):
-        ious = bbox_ioa(np.ascontiguousarray(atlbrs, dtype=np.float32),
-                        np.ascontiguousarray(btlbrs, dtype=np.float32),
-                        iou=True)
+        ious = bbox_ioa(
+            np.ascontiguousarray(atlbrs, dtype=np.float32), np.ascontiguousarray(btlbrs, dtype=np.float32), iou=True
+        )
     return 1 - ious  # cost matrix
 
 
-def embedding_distance(tracks: list, detections: list, metric: str = 'cosine') -> np.ndarray:
+def embedding_distance(tracks: list, detections: list, metric: str = "cosine") -> np.ndarray:
     """
     Compute distance between tracks and detections based on embeddings.