dgenerate-ultralytics-headless 8.3.143__py3-none-any.whl → 8.3.144__py3-none-any.whl

ultralytics/solutions/streamlit_inference.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 import io
-from typing import Any
+from typing import Any, List
 
 import cv2
 
@@ -24,7 +24,7 @@ class Inference:
         model_path (str): Path to the loaded model.
         model (YOLO): The YOLO model instance.
         source (str): Selected video source (webcam or video file).
-        enable_trk (str): Enable tracking option ("Yes" or "No").
+        enable_trk (bool): Enable tracking option.
         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.
@@ -33,14 +33,19 @@ class Inference:
         selected_ind (List[int]): List of selected class indices for detection.
 
     Methods:
-        web_ui: Sets up the Streamlit web interface with custom HTML elements.
-        sidebar: Configures the Streamlit sidebar for model and inference settings.
-        source_upload: Handles video file uploads through the Streamlit interface.
-        configure: Configures the model and loads selected classes for inference.
-        inference: Performs real-time object detection inference.
+        web_ui: Set up the Streamlit web interface with custom HTML elements.
+        sidebar: Configure the Streamlit sidebar for model and inference settings.
+        source_upload: Handle video file uploads through the Streamlit interface.
+        configure: Configure the model and load selected classes for inference.
+        inference: Perform real-time object detection inference.
 
     Examples:
-        >>> inf = Inference(model="path/to/model.pt")  # Model is an optional argument
+        Create an Inference instance with a custom model
+        >>> inf = Inference(model="path/to/model.pt")
+        >>> inf.inference()
+
+        Create an Inference instance with default settings
+        >>> inf = Inference()
         >>> inf.inference()
     """
 
@@ -62,7 +67,7 @@ class Inference:
         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.selected_ind: List[int] = []  # List of selected class indices for detection
         self.model = None  # YOLO model instance
 
         self.temp_dict = {"model": None, **kwargs}
@@ -73,7 +78,7 @@ class Inference:
         LOGGER.info(f"Ultralytics Solutions: ✅ {self.temp_dict}")
 
     def web_ui(self):
-        """Sets up the Streamlit web interface with custom HTML elements."""
+        """Set up the Streamlit web interface with custom HTML elements."""
         menu_style_cfg = """<style>MainMenu {visibility: hidden;}</style>"""  # Hide main menu style
 
         # Main title of streamlit application
@@ -102,7 +107,7 @@ class Inference:
             "Video",
             ("webcam", "video"),
         )  # Add source selection dropdown
-        self.enable_trk = self.st.sidebar.radio("Enable Tracking", ("Yes", "No"))  # Enable object tracking
+        self.enable_trk = self.st.sidebar.radio("Enable Tracking", ("Yes", "No")) == "Yes"  # Enable object tracking
         self.conf = float(
             self.st.sidebar.slider("Confidence Threshold", 0.0, 1.0, self.conf, 0.01)
         )  # Slider for confidence
@@ -166,7 +171,7 @@ class Inference:
                     break
 
                 # Process frame with model
-                if self.enable_trk == "Yes":
+                if self.enable_trk:
                     results = self.model.track(
                         frame, conf=self.conf, iou=self.iou, classes=self.selected_ind, persist=True
                     )

ultralytics/solutions/trackzone.py

@@ -23,9 +23,9 @@ class TrackZone(BaseSolution):
         clss (List[int]): Class indices of tracked objects.
 
     Methods:
-        process: Processes each frame of the video, applying region-based tracking.
-        extract_tracks: Extracts tracking information from the input frame.
-        display_output: Displays the processed output.
+        process: Process each frame of the video, applying region-based tracking.
+        extract_tracks: Extract tracking information from the input frame.
+        display_output: Display the processed output.
 
     Examples:
         >>> tracker = TrackZone()
@@ -82,7 +82,7 @@ class TrackZone(BaseSolution):
             )
 
         plot_im = annotator.result()
-        self.display_output(plot_im)  # display output with base class function
+        self.display_output(plot_im)  # Display output with base class function
 
         # Return a SolutionResults
         return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/trackers/basetrack.py

@@ -2,6 +2,7 @@
 """Module defines the base classes and structures for object tracking in YOLO."""
 
 from collections import OrderedDict
+from typing import Any
 
 import numpy as np
 
@@ -66,15 +67,7 @@ class BaseTrack:
     _count = 0
 
     def __init__(self):
-        """
-        Initialize a new track with a unique ID and foundational tracking attributes.
-
-        Examples:
-            Initialize a new track
-            >>> track = BaseTrack()
-            >>> print(track.track_id)
-            0
-        """
+        """Initialize a new track with a unique ID and foundational tracking attributes."""
         self.track_id = 0
         self.is_activated = False
         self.state = TrackState.New
@@ -88,37 +81,37 @@ class BaseTrack:
         self.location = (np.inf, np.inf)
 
     @property
-    def end_frame(self):
-        """Returns the ID of the most recent frame where the object was tracked."""
+    def end_frame(self) -> int:
+        """Return the ID of the most recent frame where the object was tracked."""
         return self.frame_id
 
     @staticmethod
-    def next_id():
+    def next_id() -> int:
         """Increment and return the next unique global track ID for object tracking."""
         BaseTrack._count += 1
         return BaseTrack._count
 
-    def activate(self, *args):
-        """Activates the track with provided arguments, initializing necessary attributes for tracking."""
+    def activate(self, *args: Any) -> None:
+        """Activate the track with provided arguments, initializing necessary attributes for tracking."""
         raise NotImplementedError
 
-    def predict(self):
-        """Predicts the next state of the track based on the current state and tracking model."""
+    def predict(self) -> None:
+        """Predict the next state of the track based on the current state and tracking model."""
         raise NotImplementedError
 
-    def update(self, *args, **kwargs):
-        """Updates the track with new observations and data, modifying its state and attributes accordingly."""
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        """Update the track with new observations and data, modifying its state and attributes accordingly."""
         raise NotImplementedError
 
-    def mark_lost(self):
-        """Marks the track as lost by updating its state to TrackState.Lost."""
+    def mark_lost(self) -> None:
+        """Mark the track as lost by updating its state to TrackState.Lost."""
         self.state = TrackState.Lost
 
-    def mark_removed(self):
-        """Marks the track as removed by setting its state to TrackState.Removed."""
+    def mark_removed(self) -> None:
+        """Mark the track as removed by setting its state to TrackState.Removed."""
         self.state = TrackState.Removed
 
     @staticmethod
-    def reset_id():
+    def reset_id() -> None:
         """Reset the global track ID counter to its initial value."""
         BaseTrack._count = 0

ultralytics/trackers/bot_sort.py

@@ -1,6 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 from collections import deque
+from typing import Any, List, Optional
 
 import numpy as np
 import torch
@@ -51,7 +52,9 @@ class BOTrack(STrack):
 
     shared_kalman = KalmanFilterXYWH()
 
-    def __init__(self, tlwh, score, cls, feat=None, feat_history=50):
+    def __init__(
+        self, tlwh: np.ndarray, score: float, cls: int, feat: Optional[np.ndarray] = None, feat_history: int = 50
+    ):
         """
         Initialize a BOTrack object with temporal parameters, such as feature history, alpha, and current features.
 
@@ -59,7 +62,7 @@ class BOTrack(STrack):
             tlwh (np.ndarray): Bounding box coordinates in tlwh format (top left x, top left y, width, height).
             score (float): Confidence score of the detection.
             cls (int): Class ID of the detected object.
-            feat (np.ndarray | None): Feature vector associated with the detection.
+            feat (np.ndarray, optional): Feature vector associated with the detection.
             feat_history (int): Maximum length of the feature history deque.
 
         Examples:
@@ -79,7 +82,7 @@ class BOTrack(STrack):
         self.features = deque([], maxlen=feat_history)
         self.alpha = 0.9
 
-    def update_features(self, feat):
+    def update_features(self, feat: np.ndarray) -> None:
         """Update the feature vector and apply exponential moving average smoothing."""
         feat /= np.linalg.norm(feat)
         self.curr_feat = feat
@@ -90,7 +93,7 @@ class BOTrack(STrack):
         self.features.append(feat)
         self.smooth_feat /= np.linalg.norm(self.smooth_feat)
 
-    def predict(self):
+    def predict(self) -> None:
         """Predict the object's future state using the Kalman filter to update its mean and covariance."""
         mean_state = self.mean.copy()
         if self.state != TrackState.Tracked:
@@ -99,20 +102,20 @@ class BOTrack(STrack):
 
         self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
 
-    def re_activate(self, new_track, frame_id, new_id=False):
+    def re_activate(self, new_track: "BOTrack", frame_id: int, new_id: bool = False) -> None:
         """Reactivate a track with updated features and optionally assign a new ID."""
         if new_track.curr_feat is not None:
             self.update_features(new_track.curr_feat)
         super().re_activate(new_track, frame_id, new_id)
 
-    def update(self, new_track, frame_id):
+    def update(self, new_track: "BOTrack", frame_id: int) -> None:
         """Update the track with new detection information and the current frame ID."""
         if new_track.curr_feat is not None:
             self.update_features(new_track.curr_feat)
         super().update(new_track, frame_id)
 
     @property
-    def tlwh(self):
+    def tlwh(self) -> np.ndarray:
         """Return the current bounding box position in `(top left x, top left y, width, height)` format."""
         if self.mean is None:
             return self._tlwh.copy()
@@ -121,7 +124,7 @@ class BOTrack(STrack):
         return ret
 
     @staticmethod
-    def multi_predict(stracks):
+    def multi_predict(stracks: List["BOTrack"]) -> None:
         """Predict the mean and covariance for multiple object tracks using a shared Kalman filter."""
         if len(stracks) <= 0:
             return
@@ -136,12 +139,12 @@ class BOTrack(STrack):
             stracks[i].mean = mean
             stracks[i].covariance = cov
 
-    def convert_coords(self, tlwh):
+    def convert_coords(self, tlwh: np.ndarray) -> np.ndarray:
         """Convert tlwh bounding box coordinates to xywh format."""
         return self.tlwh_to_xywh(tlwh)
 
     @staticmethod
-    def tlwh_to_xywh(tlwh):
+    def tlwh_to_xywh(tlwh: np.ndarray) -> np.ndarray:
         """Convert bounding box from tlwh (top-left-width-height) to xywh (center-x-center-y-width-height) format."""
         ret = np.asarray(tlwh).copy()
         ret[:2] += ret[2:] / 2
@@ -176,12 +179,12 @@ class BOTSORT(BYTETracker):
         The class is designed to work with a YOLO object detection model and supports ReID only if enabled via args.
     """
 
-    def __init__(self, args, frame_rate=30):
+    def __init__(self, args: Any, frame_rate: int = 30):
         """
         Initialize BOTSORT object with ReID module and GMC algorithm.
 
         Args:
-            args (object): Parsed command-line arguments containing tracking parameters.
+            args (Any): Parsed command-line arguments containing tracking parameters.
             frame_rate (int): Frame rate of the video being processed.
 
         Examples:
@@ -203,11 +206,13 @@ class BOTSORT(BYTETracker):
             else None
         )
 
-    def get_kalmanfilter(self):
+    def get_kalmanfilter(self) -> KalmanFilterXYWH:
         """Return an instance of KalmanFilterXYWH for predicting and updating object states in the tracking process."""
         return KalmanFilterXYWH()
 
-    def init_track(self, dets, scores, cls, img=None):
+    def init_track(
+        self, dets: np.ndarray, scores: np.ndarray, cls: np.ndarray, img: Optional[np.ndarray] = None
+    ) -> List[BOTrack]:
         """Initialize object tracks using detection bounding boxes, scores, class labels, and optional ReID features."""
         if len(dets) == 0:
             return []
@@ -217,7 +222,7 @@ class BOTSORT(BYTETracker):
         else:
             return [BOTrack(xyxy, s, c) for (xyxy, s, c) in zip(dets, scores, cls)]  # detections
 
-    def get_dists(self, tracks, detections):
+    def get_dists(self, tracks: List[BOTrack], detections: List[BOTrack]) -> np.ndarray:
         """Calculate distances between tracks and detections using IoU and optionally ReID embeddings."""
         dists = matching.iou_distance(tracks, detections)
         dists_mask = dists > (1 - self.proximity_thresh)
@@ -232,11 +237,11 @@ class BOTSORT(BYTETracker):
             dists = np.minimum(dists, emb_dists)
         return dists
 
-    def multi_predict(self, tracks):
+    def multi_predict(self, tracks: List[BOTrack]) -> None:
         """Predict the mean and covariance of multiple object tracks using a shared Kalman filter."""
         BOTrack.multi_predict(tracks)
 
-    def reset(self):
+    def reset(self) -> None:
         """Reset the BOTSORT tracker to its initial state, clearing all tracked objects and internal states."""
         super().reset()
         self.gmc.reset_params()
@@ -245,14 +250,19 @@ class BOTSORT(BYTETracker):
 class ReID:
     """YOLO model as encoder for re-identification."""
 
-    def __init__(self, model):
-        """Initialize encoder for re-identification."""
+    def __init__(self, model: str):
+        """
+        Initialize encoder for re-identification.
+
+        Args:
+            model (str): Path to the YOLO model for re-identification.
+        """
         from ultralytics import YOLO
 
         self.model = YOLO(model)
         self.model(embed=[len(self.model.model.model) - 2 if ".pt" in model else -1], verbose=False)  # initialize
 
-    def __call__(self, img, dets):
+    def __call__(self, img: np.ndarray, dets: np.ndarray) -> List[np.ndarray]:
         """Extract embeddings for detected objects."""
         feats = self.model([save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))])
         if len(feats) != dets.shape[0] and feats[0].shape[0] == dets.shape[0]:

ultralytics/trackers/byte_tracker.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from typing import Any, List, Optional, Tuple
+
 import numpy as np
 
 from ..utils import LOGGER
@@ -29,16 +31,17 @@ class STrack(BaseTrack):
         idx (int): Index or identifier for the object.
         frame_id (int): Current frame ID.
         start_frame (int): Frame where the object was first detected.
+        angle (float | None): Optional angle information for oriented bounding boxes.
 
     Methods:
-        predict(): Predict the next state of the object using Kalman filter.
-        multi_predict(stracks): Predict the next states for multiple tracks.
-        multi_gmc(stracks, H): Update multiple track states using a homography matrix.
-        activate(kalman_filter, frame_id): Activate a new tracklet.
-        re_activate(new_track, frame_id, new_id): Reactivate a previously lost tracklet.
-        update(new_track, frame_id): Update the state of a matched track.
-        convert_coords(tlwh): Convert bounding box to x-y-aspect-height format.
-        tlwh_to_xyah(tlwh): Convert tlwh bounding box to xyah format.
+        predict: Predict the next state of the object using Kalman filter.
+        multi_predict: Predict the next states for multiple tracks.
+        multi_gmc: Update multiple track states using a homography matrix.
+        activate: Activate a new tracklet.
+        re_activate: Reactivate a previously lost tracklet.
+        update: Update the state of a matched track.
+        convert_coords: Convert bounding box to x-y-aspect-height format.
+        tlwh_to_xyah: Convert tlwh bounding box to xyah format.
 
     Examples:
         Initialize and activate a new track
@@ -48,7 +51,7 @@ class STrack(BaseTrack):
 
     shared_kalman = KalmanFilterXYAH()
 
-    def __init__(self, xywh, score, cls):
+    def __init__(self, xywh: List[float], score: float, cls: Any):
         """
         Initialize a new STrack instance.
 
@@ -79,14 +82,14 @@ class STrack(BaseTrack):
         self.angle = xywh[4] if len(xywh) == 6 else None
 
     def predict(self):
-        """Predicts the next state (mean and covariance) of the object using the Kalman filter."""
+        """Predict the next state (mean and covariance) of the object using the Kalman filter."""
         mean_state = self.mean.copy()
         if self.state != TrackState.Tracked:
             mean_state[7] = 0
         self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
 
     @staticmethod
-    def multi_predict(stracks):
+    def multi_predict(stracks: List["STrack"]):
         """Perform multi-object predictive tracking using Kalman filter for the provided list of STrack instances."""
         if len(stracks) <= 0:
             return
@@ -101,7 +104,7 @@ class STrack(BaseTrack):
             stracks[i].covariance = cov
 
     @staticmethod
-    def multi_gmc(stracks, H=np.eye(2, 3)):
+    def multi_gmc(stracks: List["STrack"], H: np.ndarray = np.eye(2, 3)):
         """Update state tracks positions and covariances using a homography matrix for multiple tracks."""
         if len(stracks) > 0:
             multi_mean = np.asarray([st.mean.copy() for st in stracks])
@@ -119,7 +122,7 @@ class STrack(BaseTrack):
                 stracks[i].mean = mean
                 stracks[i].covariance = cov
 
-    def activate(self, kalman_filter, frame_id):
+    def activate(self, kalman_filter: KalmanFilterXYAH, frame_id: int):
         """Activate a new tracklet using the provided Kalman filter and initialize its state and covariance."""
         self.kalman_filter = kalman_filter
         self.track_id = self.next_id()
@@ -132,8 +135,8 @@ class STrack(BaseTrack):
         self.frame_id = frame_id
         self.start_frame = frame_id
 
-    def re_activate(self, new_track, frame_id, new_id=False):
-        """Reactivates a previously lost track using new detection data and updates its state and attributes."""
+    def re_activate(self, new_track: "STrack", frame_id: int, new_id: bool = False):
+        """Reactivate a previously lost track using new detection data and update its state and attributes."""
         self.mean, self.covariance = self.kalman_filter.update(
             self.mean, self.covariance, self.convert_coords(new_track.tlwh)
         )
@@ -148,7 +151,7 @@ class STrack(BaseTrack):
         self.angle = new_track.angle
         self.idx = new_track.idx
 
-    def update(self, new_track, frame_id):
+    def update(self, new_track: "STrack", frame_id: int):
         """
         Update the state of a matched track.
 
@@ -177,13 +180,13 @@ class STrack(BaseTrack):
         self.angle = new_track.angle
         self.idx = new_track.idx
 
-    def convert_coords(self, tlwh):
+    def convert_coords(self, tlwh: np.ndarray) -> np.ndarray:
         """Convert a bounding box's top-left-width-height format to its x-y-aspect-height equivalent."""
         return self.tlwh_to_xyah(tlwh)
 
     @property
-    def tlwh(self):
-        """Returns the bounding box in top-left-width-height format from the current state estimate."""
+    def tlwh(self) -> np.ndarray:
+        """Get the bounding box in top-left-width-height format from the current state estimate."""
         if self.mean is None:
             return self._tlwh.copy()
         ret = self.mean[:4].copy()
@@ -192,14 +195,14 @@ class STrack(BaseTrack):
         return ret
 
     @property
-    def xyxy(self):
-        """Converts bounding box from (top left x, top left y, width, height) to (min x, min y, max x, max y) format."""
+    def xyxy(self) -> np.ndarray:
+        """Convert bounding box from (top left x, top left y, width, height) to (min x, min y, max x, max y) format."""
         ret = self.tlwh.copy()
         ret[2:] += ret[:2]
         return ret
 
     @staticmethod
-    def tlwh_to_xyah(tlwh):
+    def tlwh_to_xyah(tlwh: np.ndarray) -> np.ndarray:
         """Convert bounding box from tlwh format to center-x-center-y-aspect-height (xyah) format."""
         ret = np.asarray(tlwh).copy()
         ret[:2] += ret[2:] / 2
@@ -207,28 +210,28 @@ class STrack(BaseTrack):
         return ret
 
     @property
-    def xywh(self):
-        """Returns the current position of the bounding box in (center x, center y, width, height) format."""
+    def xywh(self) -> np.ndarray:
+        """Get the current position of the bounding box in (center x, center y, width, height) format."""
         ret = np.asarray(self.tlwh).copy()
         ret[:2] += ret[2:] / 2
         return ret
 
     @property
-    def xywha(self):
-        """Returns position in (center x, center y, width, height, angle) format, warning if angle is missing."""
+    def xywha(self) -> np.ndarray:
+        """Get position in (center x, center y, width, height, angle) format, warning if angle is missing."""
         if self.angle is None:
             LOGGER.warning("`angle` attr not found, returning `xywh` instead.")
             return self.xywh
         return np.concatenate([self.xywh, self.angle[None]])
 
     @property
-    def result(self):
-        """Returns the current tracking results in the appropriate bounding box format."""
+    def result(self) -> List[float]:
+        """Get the current tracking results in the appropriate bounding box format."""
         coords = self.xyxy if self.angle is None else self.xywha
         return coords.tolist() + [self.track_id, self.score, self.cls, self.idx]
 
-    def __repr__(self):
-        """Returns a string representation of the STrack object including start frame, end frame, and track ID."""
+    def __repr__(self) -> str:
+        """Return a string representation of the STrack object including start frame, end frame, and track ID."""
         return f"OT_{self.track_id}_({self.start_frame}-{self.end_frame})"
 
 
@@ -250,15 +253,16 @@ class BYTETracker:
         kalman_filter (KalmanFilterXYAH): Kalman Filter object.
 
     Methods:
-        update(results, img=None): Updates object tracker with new detections.
-        get_kalmanfilter(): Returns a Kalman filter object for tracking bounding boxes.
-        init_track(dets, scores, cls, img=None): Initialize object tracking with detections.
-        get_dists(tracks, detections): Calculates the distance between tracks and detections.
-        multi_predict(tracks): Predicts the location of tracks.
-        reset_id(): Resets the ID counter of STrack.
-        joint_stracks(tlista, tlistb): Combines two lists of stracks.
-        sub_stracks(tlista, tlistb): Filters out the stracks present in the second list from the first list.
-        remove_duplicate_stracks(stracksa, stracksb): Removes duplicate stracks based on IoU.
+        update: Update object tracker with new detections.
+        get_kalmanfilter: Return a Kalman filter object for tracking bounding boxes.
+        init_track: Initialize object tracking with detections.
+        get_dists: Calculate the distance between tracks and detections.
+        multi_predict: Predict the location of tracks.
+        reset_id: Reset the ID counter of STrack.
+        reset: Reset the tracker by clearing all tracks.
+        joint_stracks: Combine two lists of stracks.
+        sub_stracks: Filter out the stracks present in the second list from the first list.
+        remove_duplicate_stracks: Remove duplicate stracks based on IoU.
 
     Examples:
         Initialize BYTETracker and update with detection results
@@ -267,7 +271,7 @@ class BYTETracker:
         >>> tracked_objects = tracker.update(results)
     """
 
-    def __init__(self, args, frame_rate=30):
+    def __init__(self, args, frame_rate: int = 30):
         """
         Initialize a BYTETracker instance for object tracking.
 
@@ -280,9 +284,9 @@ class BYTETracker:
             >>> args = Namespace(track_buffer=30)
             >>> tracker = BYTETracker(args, frame_rate=30)
         """
-        self.tracked_stracks = []  # type: list[STrack]
-        self.lost_stracks = []  # type: list[STrack]
-        self.removed_stracks = []  # type: list[STrack]
+        self.tracked_stracks = []  # type: List[STrack]
+        self.lost_stracks = []  # type: List[STrack]
+        self.removed_stracks = []  # type: List[STrack]
 
         self.frame_id = 0
         self.args = args
@@ -290,8 +294,8 @@ class BYTETracker:
         self.kalman_filter = self.get_kalmanfilter()
         self.reset_id()
 
-    def update(self, results, img=None, feats=None):
-        """Updates the tracker with new detections and returns the current list of tracked objects."""
+    def update(self, results, img: Optional[np.ndarray] = None, feats: Optional[np.ndarray] = None) -> np.ndarray:
+        """Update the tracker with new detections and return the current list of tracked objects."""
         self.frame_id += 1
         activated_stracks = []
         refind_stracks = []
@@ -319,7 +323,7 @@ class BYTETracker:
         detections = self.init_track(dets, scores_keep, cls_keep, img if feats is None else feats)
         # Add newly detected tracklets to tracked_stracks
         unconfirmed = []
-        tracked_stracks = []  # type: list[STrack]
+        tracked_stracks = []  # type: List[STrack]
         for track in self.tracked_stracks:
             if not track.is_activated:
                 unconfirmed.append(track)
@@ -408,42 +412,44 @@ class BYTETracker:
 
         return np.asarray([x.result for x in self.tracked_stracks if x.is_activated], dtype=np.float32)
 
-    def get_kalmanfilter(self):
-        """Returns a Kalman filter object for tracking bounding boxes using KalmanFilterXYAH."""
+    def get_kalmanfilter(self) -> KalmanFilterXYAH:
+        """Return a Kalman filter object for tracking bounding boxes using KalmanFilterXYAH."""
         return KalmanFilterXYAH()
 
-    def init_track(self, dets, scores, cls, img=None):
-        """Initializes object tracking with given detections, scores, and class labels using the STrack algorithm."""
+    def init_track(
+        self, dets: np.ndarray, scores: np.ndarray, cls: np.ndarray, img: Optional[np.ndarray] = None
+    ) -> List[STrack]:
+        """Initialize object tracking with given detections, scores, and class labels using the STrack algorithm."""
         return [STrack(xyxy, s, c) for (xyxy, s, c) in zip(dets, scores, cls)] if len(dets) else []  # detections
 
-    def get_dists(self, tracks, detections):
-        """Calculates the distance between tracks and detections using IoU and optionally fuses scores."""
+    def get_dists(self, tracks: List[STrack], detections: List[STrack]) -> np.ndarray:
+        """Calculate the distance between tracks and detections using IoU and optionally fuse scores."""
         dists = matching.iou_distance(tracks, detections)
         if self.args.fuse_score:
             dists = matching.fuse_score(dists, detections)
         return dists
 
-    def multi_predict(self, tracks):
+    def multi_predict(self, tracks: List[STrack]):
         """Predict the next states for multiple tracks using Kalman filter."""
         STrack.multi_predict(tracks)
 
     @staticmethod
     def reset_id():
-        """Resets the ID counter for STrack instances to ensure unique track IDs across tracking sessions."""
+        """Reset the ID counter for STrack instances to ensure unique track IDs across tracking sessions."""
         STrack.reset_id()
 
     def reset(self):
-        """Resets the tracker by clearing all tracked, lost, and removed tracks and reinitializing the Kalman filter."""
-        self.tracked_stracks = []  # type: list[STrack]
-        self.lost_stracks = []  # type: list[STrack]
-        self.removed_stracks = []  # type: list[STrack]
+        """Reset the tracker by clearing all tracked, lost, and removed tracks and reinitializing the Kalman filter."""
+        self.tracked_stracks = []  # type: List[STrack]
+        self.lost_stracks = []  # type: List[STrack]
+        self.removed_stracks = []  # type: List[STrack]
         self.frame_id = 0
         self.kalman_filter = self.get_kalmanfilter()
         self.reset_id()
 
     @staticmethod
-    def joint_stracks(tlista, tlistb):
-        """Combines two lists of STrack objects into a single list, ensuring no duplicates based on track IDs."""
+    def joint_stracks(tlista: List[STrack], tlistb: List[STrack]) -> List[STrack]:
+        """Combine two lists of STrack objects into a single list, ensuring no duplicates based on track IDs."""
         exists = {}
         res = []
         for t in tlista:
@@ -457,14 +463,14 @@ class BYTETracker:
         return res
 
     @staticmethod
-    def sub_stracks(tlista, tlistb):
-        """Filters out the stracks present in the second list from the first list."""
+    def sub_stracks(tlista: List[STrack], tlistb: List[STrack]) -> List[STrack]:
+        """Filter out the stracks present in the second list from the first list."""
         track_ids_b = {t.track_id for t in tlistb}
         return [t for t in tlista if t.track_id not in track_ids_b]
 
     @staticmethod
-    def remove_duplicate_stracks(stracksa, stracksb):
-        """Removes duplicate stracks from two lists based on Intersection over Union (IoU) distance."""
+    def remove_duplicate_stracks(stracksa: List[STrack], stracksb: List[STrack]) -> Tuple[List[STrack], List[STrack]]:
+        """Remove duplicate stracks from two lists based on Intersection over Union (IoU) distance."""
         pdist = matching.iou_distance(stracksa, stracksb)
         pairs = np.where(pdist < 0.15)
         dupa, dupb = [], []