SYMBOL INDEX (1226 symbols across 117 files)

FILE: boxmot/detectors/__init__.py
  function _check_model (line 13) | def _check_model(name, markers):
  function is_ultralytics_model (line 18) | def is_ultralytics_model(yolo_name):
  function is_yolox_model (line 22) | def is_yolox_model(yolo_name):
  function is_rtdetr_model (line 26) | def is_rtdetr_model(yolo_name):
  function default_imgsz (line 30) | def default_imgsz(yolo_name):
  function get_yolo_inferer (line 39) | def get_yolo_inferer(yolo_model):

FILE: boxmot/detectors/detector.py
  function resolve_image (line 9) | def resolve_image(image: Union[np.ndarray, str]) -> np.ndarray:
  function load_weights (line 24) | def load_weights(path: str) -> Any:
  class Detector (line 35) | class Detector:
    method __init__ (line 36) | def __init__(self, path: str):
    method _load_model (line 40) | def _load_model(self, path: str):
    method preprocess (line 43) | def preprocess(self, frame: np.ndarray, **kwargs):
    method process (line 46) | def process(self, frame, **kwargs):
    method postprocess (line 49) | def postprocess(self, boxes, **kwargs):
    method __call__ (line 52) | def __call__(self, image: Union[np.ndarray, str], **kwargs):

FILE: boxmot/detectors/rtdetr.py
  class RTDetrStrategy (line 16) | class RTDetrStrategy:
    method __init__ (line 23) | def __init__(self, model, device, args):
    method __call__ (line 43) | def __call__(self, im, augment, visualize, embed):
    method warmup (line 76) | def warmup(self, imgsz):
    method update_im_paths (line 79) | def update_im_paths(self, predictor: DetectionPredictor):
    method preprocess (line 89) | def preprocess(self, im) -> torch.Tensor:
    method postprocess (line 95) | def postprocess(self, preds, im, im0s):

FILE: boxmot/detectors/ultralytics.py
  class Ultralytics (line 10) | class Ultralytics(Detector):
    method __init__ (line 11) | def __init__(self, path: str, device='cpu', conf=0.25, iou=0.45, imgsz...
    method _load_model (line 21) | def _load_model(self, path: str):
    method preprocess (line 25) | def preprocess(self, image: np.ndarray, **kwargs):
    method process (line 31) | def process(self, frame, **kwargs):
    method postprocess (line 45) | def postprocess(self, results, **kwargs):
    method __call__ (line 57) | def __call__(self, image, **kwargs):

FILE: boxmot/detectors/yolox.py
  function _coerce_torch_dtype (line 31) | def _coerce_torch_dtype(dtype, fallback: torch.Tensor) -> torch.dtype:
  function _patch_yolox_head_decode_outputs_for_mps (line 45) | def _patch_yolox_head_decode_outputs_for_mps() -> None:
  class YoloXStrategy (line 86) | class YoloXStrategy:
    method __init__ (line 176) | def __init__(self, model, device, args):
    method get_model_from_weigths (line 237) | def get_model_from_weigths(self, model_names, weight_path):
    method __call__ (line 244) | def __call__(self, im, augment, visualize, embed):
    method warmup (line 259) | def warmup(self, imgsz):
    method update_im_paths (line 262) | def update_im_paths(self, predictor: DetectionPredictor):
    method yolox_preprocess (line 274) | def yolox_preprocess(
    method preprocess (line 305) | def preprocess(self, im) -> torch.Tensor:
    method postprocess (line 320) | def postprocess(self, preds, im, im0s):

FILE: boxmot/engine/cli.py
  function load_dataset_cfg (line 21) | def load_dataset_cfg(name: str) -> dict:
  function ensure_model_extension (line 28) | def ensure_model_extension(model_path):
  function core_options (line 50) | def core_options(func):
  function parse_classes (line 121) | def parse_classes(classes_input):
  function singular_model_options (line 144) | def singular_model_options(func):
  function plural_model_options (line 160) | def plural_model_options(func):
  function export_options (line 176) | def export_options(func):
  function tune_options (line 212) | def tune_options(func):
  class CommandFirstGroup (line 229) | class CommandFirstGroup(click.Group):
    method format_help (line 232) | def format_help(self, ctx, formatter):
  function boxmot (line 303) | def boxmot(ctx):
  function track (line 317) | def track(ctx, detector, reid, tracker, yolo_model, reid_model, classes,...
  function generate (line 378) | def generate(ctx, detector, reid, yolo_model, reid_model, classes, **kwa...
  function eval (line 412) | def eval(ctx, detector, reid, tracker, yolo_model, reid_model, classes, ...
  function tune (line 450) | def tune(ctx, detector, reid, tracker, yolo_model, reid_model, classes, ...
  function export (line 482) | def export(ctx, **kwargs):
  function version (line 494) | def version():
  function help (line 502) | def help(ctx):

FILE: boxmot/engine/evaluator.py
  function load_dataset_cfg (line 53) | def load_dataset_cfg(name: str) -> dict:
  function eval_init (line 60) | def eval_init(args,
  function parse_mot_results (line 109) | def parse_mot_results(results: str) -> dict:
  function _sequence_img_dir (line 186) | def _sequence_img_dir(seq_dir: Path) -> Path:
  function _list_sequence_frames (line 191) | def _list_sequence_frames(img_dir: Path) -> list[Path]:
  function _sequence_name_from_img_dir (line 195) | def _sequence_name_from_img_dir(img_dir: Path) -> str:
  function _read_image_cv2 (line 199) | def _read_image_cv2(p: Path):
  function _collect_seq_info (line 206) | def _collect_seq_info(source: Path) -> tuple[list[Path], dict[str, int]]:
  function _autotune_batch_size (line 219) | def _autotune_batch_size(yolo, device: str, imgsz, requested: int) -> int:
  function _clear_device_cache (line 261) | def _clear_device_cache(device: str) -> None:
  function _count_data_lines (line 272) | def _count_data_lines(path: Path, skip_header: bool = False) -> int:
  function _max_frame_id (line 283) | def _max_frame_id(path: Path) -> int:
  function generate_dets_embs_batched (line 307) | def generate_dets_embs_batched(args: argparse.Namespace, y: Path, source...
  function run_generate_dets_embs (line 609) | def run_generate_dets_embs(args: argparse.Namespace, timing_stats: Optio...
  function build_dataset_eval_settings (line 631) | def build_dataset_eval_settings(
  function trackeval (line 714) | def trackeval(
  function process_sequence (line 785) | def process_sequence(seq_name: str,
  function _worker_init (line 874) | def _worker_init():
  function run_generate_mot_results (line 878) | def run_generate_mot_results(args: argparse.Namespace, evolve_config: di...
  function run_trackeval (line 972) | def run_trackeval(args: argparse.Namespace, verbose: bool = True) -> dict:
  function main (line 1118) | def main(args):

FILE: boxmot/engine/export.py
  function validate_export_formats (line 15) | def validate_export_formats(include):
  function setup_model (line 26) | def setup_model(args):
  function create_export_tasks (line 70) | def create_export_tasks(args, model, dummy_input):
  function perform_exports (line 119) | def perform_exports(export_tasks):
  function main (line 131) | def main(args):

FILE: boxmot/engine/inference.py
  function resolve_yolo_model_path (line 37) | def resolve_yolo_model_path(yolo_model_path: Union[str, Path]) -> Path:
  class TimedReIDModel (line 47) | class TimedReIDModel:
    method __init__ (line 55) | def __init__(self, model, timing_stats: Optional[TimingStats] = None):
    method get_features (line 66) | def get_features(self, xyxys: np.ndarray, img: np.ndarray) -> np.ndarray:
    method __getattr__ (line 86) | def __getattr__(self, name):
  class DetectorReIDPipeline (line 91) | class DetectorReIDPipeline:
    method __init__ (line 110) | def __init__(
    method _init_reid_models (line 171) | def _init_reid_models(self, reid_model_paths: Union[str, Path, List[Un...
    method _setup_yolo_callbacks (line 197) | def _setup_yolo_callbacks(self):
    method _setup_custom_model (line 211) | def _setup_custom_model(self, predictor):
    method _update_custom_paths (line 236) | def _update_custom_paths(self, predictor):
    method _on_frame_start (line 241) | def _on_frame_start(self, predictor):
    method add_callback (line 245) | def add_callback(self, event: str, callback: Callable):
    method get_reid_features (line 260) | def get_reid_features(
    method get_all_reid_features (line 285) | def get_all_reid_features(
    method predict (line 305) | def predict(
    method predict_batch (line 355) | def predict_batch(
    method warmup (line 404) | def warmup(self):
    method autotune_batch_size (line 426) | def autotune_batch_size(self, requested_batch_size: int) -> int:
    method print_timing_summary (line 481) | def print_timing_summary(self):
    method custom_model (line 486) | def custom_model(self):
  function extract_detections (line 495) | def extract_detections(result) -> np.ndarray:
  function filter_detections (line 521) | def filter_detections(

FILE: boxmot/engine/results.py
  class Tracks (line 14) | class Tracks:
    method __init__ (line 15) | def __init__(self, frame: np.ndarray, tracks: np.ndarray, get_drawer: ...
    method show (line 20) | def show(self) -> bool:
    method _default_draw (line 34) | def _default_draw(self, frame, tracks):
  class Results (line 52) | class Results:
    method __init__ (line 53) | def __init__(self, source: Union[str, int, Path], detector: Any, reid:...
    method __iter__ (line 72) | def __iter__(self) -> Iterator[Tracks]:
    method __next__ (line 77) | def __next__(self) -> Tracks:
    method _log_frame_timings (line 84) | def _log_frame_timings(self, frame_num: int, det_time: float, reid_tim...
    method _print_summary (line 102) | def _print_summary(self):
    method _get_frames (line 124) | def _get_frames(self):
    method _process (line 165) | def _process(self):
    method show (line 202) | def show(self):
  function track (line 209) | def track(source, detector, reid, tracker, verbose: bool = True) -> Resu...

FILE: boxmot/engine/tracker.py
  class VideoWriter (line 19) | class VideoWriter:
    method __init__ (line 22) | def __init__(self, output_path, fps=30):
    method write (line 29) | def write(self, frame):
    method release (line 42) | def release(self):
  function on_predict_start (line 49) | def on_predict_start(predictor, args, timing_stats=None):
  function plot_trajectories (line 88) | def plot_trajectories(predictor, timing_stats=None, video_writer=None):
  function main (line 174) | def main(args):

FILE: boxmot/engine/tuner.py
  function load_yaml_config (line 20) | def load_yaml_config(tracking_method: str) -> dict:
  function yaml_to_search_space (line 29) | def yaml_to_search_space(config: dict, tune) -> dict:
  class Tracker (line 57) | class Tracker:
    method __init__ (line 61) | def __init__(self, opt):
    method objective_function (line 64) | def objective_function(self, config: dict) -> dict:
  function main (line 97) | def main(args):

FILE: boxmot/motion/cmc/__init__.py
  function _normalize (line 12) | def _normalize(name: str) -> str:
  class _LazyLoader (line 18) | class _LazyLoader:
    method __call__ (line 23) | def __call__(self) -> Type[BaseCMC]:
  function available_cmc_methods (line 41) | def available_cmc_methods() -> tuple[str, ...]:
  function get_cmc_method (line 46) | def get_cmc_method(name: Optional[str]) -> Optional[Type[BaseCMC]]:
  function create_cmc (line 66) | def create_cmc(name: Optional[str], /, **kwargs) -> Optional[BaseCMC]:

FILE: boxmot/motion/cmc/base_cmc.py
  class BaseCMC (line 15) | class BaseCMC(ABC):
    method apply (line 29) | def apply(self, img: np.ndarray, dets: Optional[np.ndarray] = None) ->...
    method preprocess (line 32) | def preprocess(self, img: np.ndarray) -> np.ndarray:
    method generate_mask (line 65) | def generate_mask(self, img_gray: np.ndarray, dets: Optional[np.ndarra...

FILE: boxmot/motion/cmc/ecc.py
  class ECC (line 14) | class ECC(BaseCMC):
    method __init__ (line 22) | def __init__(
    method apply (line 45) | def apply(self, img: np.ndarray, dets: Optional[np.ndarray] = None) ->...

FILE: boxmot/motion/cmc/orb.py
  class ORB (line 14) | class ORB(BaseCMC):
    method __init__ (line 19) | def __init__(
    method apply (line 46) | def apply(self, img: np.ndarray, dets: Optional[np.ndarray] = None) ->...
    method _store_state (line 149) | def _store_state(self, img_p: np.ndarray, keypoints, descriptors, dets...
    method _draw_matches (line 156) | def _draw_matches(prev_img: np.ndarray, curr_img: np.ndarray, prev_kp,...

FILE: boxmot/motion/cmc/sift.py
  class SIFT (line 14) | class SIFT(BaseCMC):
    method __init__ (line 19) | def __init__(
    method apply (line 48) | def apply(self, img: np.ndarray, dets: Optional[np.ndarray] = None) ->...
    method _store_state (line 142) | def _store_state(self, img_p: np.ndarray, keypoints, descriptors, dets...
  class ORBLikeDraw (line 149) | class ORBLikeDraw:
    method draw (line 151) | def draw(prev: np.ndarray, curr: np.ndarray, prev_kp, curr_kp, matches...

FILE: boxmot/motion/cmc/sof.py
  class SOF (line 14) | class SOF(BaseCMC):
    method __init__ (line 23) | def __init__(self, scale: float = 0.15) -> None:
    method apply (line 46) | def apply(self, img: np.ndarray, dets: Optional[np.ndarray] = None) ->...
    method _reset (line 110) | def _reset(self, frame_gray: np.ndarray) -> None:

FILE: boxmot/motion/kalman_filters/base.py
  class BaseKalmanFilter (line 25) | class BaseKalmanFilter:
    method __init__ (line 30) | def __init__(
    method _default_motion_matrix (line 91) | def _default_motion_matrix(dim_x: int, dim_z: int) -> np.ndarray:
    method _resolve_matrix (line 99) | def _resolve_matrix(self, matrix: Optional[np.ndarray], fallback: np.n...
    method _reshape_measurement (line 103) | def _reshape_measurement(z: np.ndarray, dim_z: int) -> np.ndarray:
    method _wrap_angle (line 112) | def _wrap_angle(angle: Union[np.ndarray, float]) -> Union[np.ndarray, ...
    method _align_angle_to_reference (line 119) | def _align_angle_to_reference(cls, angle: float, reference_angle: floa...
    method _theta_velocity_index (line 123) | def _theta_velocity_index(dim_x: int) -> int:
    method _select_obb_candidate (line 127) | def _select_obb_candidate(
    method _enforce_state_geometry (line 156) | def _enforce_state_geometry(
    method _prepare_gating_inputs (line 179) | def _prepare_gating_inputs(
    method _gating_from_residuals (line 193) | def _gating_from_residuals(
    method _zero_theta_velocity (line 210) | def _zero_theta_velocity(self, mean: np.ndarray) -> np.ndarray:
    method _damp_theta_velocity (line 218) | def _damp_theta_velocity(
    method initiate (line 230) | def initiate(self, measurement: np.ndarray) -> Tuple[np.ndarray, np.nd...
    method _get_initial_covariance_std (line 242) | def _get_initial_covariance_std(self, measurement: np.ndarray) -> np.n...
    method predict (line 249) | def predict(
    method _get_process_noise_std (line 266) | def _get_process_noise_std(self, mean: np.ndarray) -> Tuple[np.ndarray...
    method _get_measurement_noise_std (line 273) | def _get_measurement_noise_std(
    method project (line 282) | def project(
    method multi_predict (line 307) | def multi_predict(
    method update (line 325) | def update(
    method _get_multi_process_noise_std (line 353) | def _get_multi_process_noise_std(
    method predict_state (line 362) | def predict_state(
    method project_state (line 389) | def project_state(
    method update_state (line 410) | def update_state(
    method mahalanobis_distance (line 448) | def mahalanobis_distance(
    method gating_distance (line 469) | def gating_distance(

FILE: boxmot/motion/kalman_filters/xyah.py
  class KalmanFilterXYAH (line 8) | class KalmanFilterXYAH(BaseKalmanFilter):
    method __init__ (line 16) | def __init__(self, ndim: int = 4):
    method _get_initial_covariance_std (line 22) | def _get_initial_covariance_std(self, measurement: np.ndarray) -> np.n...
    method _get_process_noise_std (line 39) | def _get_process_noise_std(self, mean: np.ndarray) -> Tuple[np.ndarray...
    method _get_measurement_noise_std (line 57) | def _get_measurement_noise_std(
    method _get_multi_process_noise_std (line 70) | def _get_multi_process_noise_std(
    method _enforce_xyah_constraints (line 91) | def _enforce_xyah_constraints(cls, mean: np.ndarray, is_obb: bool) -> ...
    method initiate (line 99) | def initiate(self, measurement: np.ndarray) -> Tuple[np.ndarray, np.nd...
    method predict (line 107) | def predict(self, mean: np.ndarray, covariance: np.ndarray) -> Tuple[n...
    method multi_predict (line 112) | def multi_predict(
    method update (line 122) | def update(
    method gating_distance (line 149) | def gating_distance(

FILE: boxmot/motion/kalman_filters/xyhr.py
  class ConstantNoiseXYHR (line 10) | class ConstantNoiseXYHR:
    method __init__ (line 13) | def __init__(self, dim_x: int, dim_z: int = 4):
    method get_init_state_cov (line 17) | def get_init_state_cov(self) -> np.ndarray:
    method get_r (line 23) | def get_r(self) -> np.ndarray:
    method get_q (line 28) | def get_q(self) -> np.ndarray:
  class KalmanFilterXYHR (line 36) | class KalmanFilterXYHR(BaseKalmanFilter):
    method __init__ (line 47) | def __init__(
    method covariance (line 98) | def covariance(self) -> np.ndarray:
    method covariance (line 102) | def covariance(self, value: np.ndarray) -> None:
    method _reshape_measurement_vector (line 105) | def _reshape_measurement_vector(self, z: np.ndarray) -> np.ndarray:
    method _enforce_state_constraints (line 122) | def _enforce_state_constraints(self) -> None:
    method _get_initial_covariance_std (line 131) | def _get_initial_covariance_std(self, measurement: np.ndarray) -> np.n...
    method _get_process_noise_std (line 135) | def _get_process_noise_std(self, mean: np.ndarray) -> Tuple[np.ndarray...
    method _get_measurement_noise_std (line 143) | def _get_measurement_noise_std(
    method _get_multi_process_noise_std (line 149) | def _get_multi_process_noise_std(
    method initiate (line 160) | def initiate(self, measurement: np.ndarray) -> Tuple[np.ndarray, np.nd...
    method predict (line 168) | def predict(
    method project (line 193) | def project(
    method update (line 211) | def update(self, z: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: boxmot/motion/kalman_filters/xysr.py
  class KalmanFilterXYSR (line 10) | class KalmanFilterXYSR(BaseKalmanFilter):
    method __init__ (line 18) | def __init__(self, dim_x: int = 7, dim_z: int = 4, dim_u: int = 0, max...
    method _build_motion_matrix (line 54) | def _build_motion_matrix(dim_x: int, dim_z: int) -> np.ndarray:
    method _scale_from_measurement (line 79) | def _scale_from_measurement(z: np.ndarray) -> float:
    method _measurement_reference_state (line 90) | def _measurement_reference_state(self) -> Optional[np.ndarray]:
    method _align_obb_measurement (line 96) | def _align_obb_measurement(
    method _prepare_measurement (line 138) | def _prepare_measurement(
    method _enforce_state_constraints (line 154) | def _enforce_state_constraints(self) -> None:
    method _affine_components (line 164) | def _affine_components(m: np.ndarray) -> Tuple[float, float, float]:
    method _get_initial_covariance_std (line 175) | def _get_initial_covariance_std(self, measurement: np.ndarray) -> np.n...
    method _get_process_noise_std (line 205) | def _get_process_noise_std(self, mean: np.ndarray) -> Tuple[np.ndarray...
    method _get_measurement_noise_std (line 236) | def _get_measurement_noise_std(self, mean: np.ndarray, confidence: flo...
    method _get_multi_process_noise_std (line 259) | def _get_multi_process_noise_std(
    method initiate (line 295) | def initiate(self, measurement: np.ndarray) -> Tuple[np.ndarray, np.nd...
    method apply_affine_correction (line 311) | def apply_affine_correction(self, m: np.ndarray, t: np.ndarray) -> None:
    method predict (line 368) | def predict(
    method freeze (line 379) | def freeze(self) -> None:
    method unfreeze (line 383) | def unfreeze(self) -> None:
    method update (line 440) | def update(
    method md_for_measurement (line 478) | def md_for_measurement(self, z: np.ndarray) -> float:

FILE: boxmot/motion/kalman_filters/xywh.py
  class KalmanFilterXYWH (line 8) | class KalmanFilterXYWH(BaseKalmanFilter):
    method __init__ (line 16) | def __init__(self, ndim: int = 4):
    method _get_initial_covariance_std (line 22) | def _get_initial_covariance_std(self, measurement: np.ndarray) -> np.n...
    method _get_process_noise_std (line 38) | def _get_process_noise_std(self, mean: np.ndarray) -> Tuple[np.ndarray...
    method _get_measurement_noise_std (line 56) | def _get_measurement_noise_std(self, mean: np.ndarray, confidence: flo...
    method _get_multi_process_noise_std (line 67) | def _get_multi_process_noise_std(
    method _align_obb_measurement (line 88) | def _align_obb_measurement(
    method _enforce_xywh_constraints (line 128) | def _enforce_xywh_constraints(cls, mean: np.ndarray, is_obb: bool) -> ...
    method initiate (line 136) | def initiate(self, measurement: np.ndarray) -> Tuple[np.ndarray, np.nd...
    method predict (line 144) | def predict(self, mean: np.ndarray, covariance: np.ndarray) -> Tuple[n...
    method multi_predict (line 149) | def multi_predict(
    method update (line 162) | def update(
    method gating_distance (line 188) | def gating_distance(

FILE: boxmot/postprocessing/gbrc.py
  function linear_interpolation (line 12) | def linear_interpolation(data: np.ndarray, interval: int) -> np.ndarray:
  function _fit_predict_1d (line 52) | def _fit_predict_1d(regr: GradientBoostingRegressor, t: np.ndarray, y: n...
  function gradient_boosting_smooth (line 58) | def gradient_boosting_smooth(
  function process_file (line 99) | def process_file(
  function gbrc (line 136) | def gbrc(
  function main (line 175) | def main():

FILE: boxmot/postprocessing/gsi.py
  function linear_interpolation (line 13) | def linear_interpolation(data: np.ndarray, interval: int) -> np.ndarray:
  function gaussian_smooth (line 57) | def gaussian_smooth(data: np.ndarray, tau: float) -> np.ndarray:
  function process_file (line 96) | def process_file(file_path: Path, interval: int, tau: float):
  function gsi (line 115) | def gsi(mot_results_folder: Path, interval: int = 20, tau: float = 10):
  function main (line 145) | def main():

FILE: boxmot/reid/backbones/clip/clip/clip.py
  function _download (line 39) | def _download(url: str, root: str = os.path.expanduser("~/.cache/clip")):
  function _transform (line 86) | def _transform(n_px):
  function available_models (line 101) | def available_models() -> List[str]:
  function load (line 106) | def load(
  function tokenize (line 223) | def tokenize(

FILE: boxmot/reid/backbones/clip/clip/model.py
  class Bottleneck (line 12) | class Bottleneck(nn.Module):
    method __init__ (line 15) | def __init__(self, inplanes, planes, stride=1):
    method forward (line 42) | def forward(self, x: torch.Tensor):
  class AttentionPool2d (line 58) | class AttentionPool2d(nn.Module):
    method __init__ (line 59) | def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, o...
    method forward (line 70) | def forward(self, x):
  class ModifiedResNet (line 100) | class ModifiedResNet(nn.Module):
    method __init__ (line 108) | def __init__(self, layers, output_dim, heads, input_resolution=224, wi...
    method _make_layer (line 136) | def _make_layer(self, planes, blocks, stride=1):
    method forward (line 145) | def forward(self, x):
  class LayerNorm (line 167) | class LayerNorm(nn.LayerNorm):
    method forward (line 170) | def forward(self, x: torch.Tensor):
  class QuickGELU (line 179) | class QuickGELU(nn.Module):
    method forward (line 180) | def forward(self, x: torch.Tensor):
  class ResidualAttentionBlock (line 184) | class ResidualAttentionBlock(nn.Module):
    method __init__ (line 185) | def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor ...
    method attention (line 198) | def attention(self, x: torch.Tensor):
    method forward (line 206) | def forward(self, x: torch.Tensor):
  class Transformer (line 212) | class Transformer(nn.Module):
    method __init__ (line 213) | def __init__(
    method forward (line 223) | def forward(self, x: torch.Tensor):
  class VisionTransformer (line 227) | class VisionTransformer(nn.Module):
    method __init__ (line 228) | def __init__(
    method forward (line 263) | def forward(self, x: torch.Tensor, cv_emb=None):
  class CLIP (line 296) | class CLIP(nn.Module):
    method __init__ (line 297) | def __init__(self,
    method initialize_parameters (line 359) | def initialize_parameters(self):
    method build_attention_mask (line 395) | def build_attention_mask(self):
    method dtype (line 404) | def dtype(self):
    method encode_image (line 407) | def encode_image(self, image):
    method encode_text (line 410) | def encode_text(self, text):
    method forward (line 423) | def forward(self, image, text):
  function convert_weights (line 440) | def convert_weights(model: nn.Module):
  function build_model (line 469) | def build_model(
  function resize_pos_embed (line 565) | def resize_pos_embed(posemb, posemb_new, hight, width):

FILE: boxmot/reid/backbones/clip/clip/simple_tokenizer.py
  function default_bpe (line 14) | def default_bpe():
  function bytes_to_unicode (line 19) | def bytes_to_unicode():
  function get_pairs (line 45) | def get_pairs(word):
  function basic_clean (line 57) | def basic_clean(text):
  function whitespace_clean (line 63) | def whitespace_clean(text):
  class SimpleTokenizer (line 69) | class SimpleTokenizer(object):
    method __init__ (line 70) | def __init__(self, bpe_path: str = default_bpe()):
    method bpe (line 93) | def bpe(self, token):
    method encode (line 135) | def encode(self, text):
    method decode (line 145) | def decode(self, tokens):

FILE: boxmot/reid/backbones/clip/make_model.py
  function weights_init_kaiming (line 11) | def weights_init_kaiming(m):
  function weights_init_classifier (line 27) | def weights_init_classifier(m):
  class build_transformer (line 35) | class build_transformer(nn.Module):
    method __init__ (line 36) | def __init__(self, num_classes, camera_num, view_num, cfg):
    method forward (line 90) | def forward(self, x, label=None, cam_label=None, view_label=None):
    method load_param (line 141) | def load_param(self, trained_path):
    method load_param_finetune (line 147) | def load_param_finetune(self, model_path):
  function make_model (line 154) | def make_model(cfg, num_class, camera_num, view_num):
  function load_clip_to_cpu (line 162) | def load_clip_to_cpu(backbone_name, h_resolution, w_resolution, vision_s...

FILE: boxmot/reid/backbones/clip/make_model_clipreid.py
  function weights_init_kaiming (line 11) | def weights_init_kaiming(m):
  function weights_init_classifier (line 27) | def weights_init_classifier(m):
  class TextEncoder (line 35) | class TextEncoder(nn.Module):
    method __init__ (line 36) | def __init__(self, clip_model):
    method forward (line 44) | def forward(self, prompts, tokenized_prompts):
  class build_transformer (line 57) | class build_transformer(nn.Module):
    method __init__ (line 58) | def __init__(self, num_classes, camera_num, view_num, cfg):
    method forward (line 120) | def forward(
    method load_param (line 190) | def load_param(self, trained_path):
    method load_param_finetune (line 196) | def load_param_finetune(self, model_path):
  function make_model (line 203) | def make_model(cfg, num_class, camera_num, view_num):
  function load_clip_to_cpu (line 211) | def load_clip_to_cpu(backbone_name, h_resolution, w_resolution, vision_s...
  class PromptLearner (line 230) | class PromptLearner(nn.Module):
    method __init__ (line 231) | def __init__(self, num_class, dataset_name, dtype, token_embedding):
    method forward (line 261) | def forward(self, label):

FILE: boxmot/reid/backbones/hacnn.py
  class ConvBlock (line 12) | class ConvBlock(nn.Module):
    method __init__ (line 25) | def __init__(self, in_c, out_c, k, s=1, p=0):
    method forward (line 30) | def forward(self, x):
  class InceptionA (line 34) | class InceptionA(nn.Module):
    method __init__ (line 35) | def __init__(self, in_channels, out_channels):
    method forward (line 56) | def forward(self, x):
  class InceptionB (line 65) | class InceptionB(nn.Module):
    method __init__ (line 66) | def __init__(self, in_channels, out_channels):
    method forward (line 84) | def forward(self, x):
  class SpatialAttn (line 92) | class SpatialAttn(nn.Module):
    method __init__ (line 95) | def __init__(self):
    method forward (line 100) | def forward(self, x):
  class ChannelAttn (line 114) | class ChannelAttn(nn.Module):
    method __init__ (line 117) | def __init__(self, in_channels, reduction_rate=16):
    method forward (line 123) | def forward(self, x):
  class SoftAttn (line 132) | class SoftAttn(nn.Module):
    method __init__ (line 140) | def __init__(self, in_channels):
    method forward (line 146) | def forward(self, x):
  class HardAttn (line 154) | class HardAttn(nn.Module):
    method __init__ (line 157) | def __init__(self, in_channels):
    method init_params (line 162) | def init_params(self):
    method forward (line 168) | def forward(self, x):
  class HarmAttn (line 177) | class HarmAttn(nn.Module):
    method __init__ (line 180) | def __init__(self, in_channels):
    method forward (line 185) | def forward(self, x):
  class HACNN (line 191) | class HACNN(nn.Module):
    method __init__ (line 207) | def __init__(
    method init_scale_factors (line 268) | def init_scale_factors(self):
    method stn (line 276) | def stn(self, x, theta):
    method transform_theta (line 286) | def transform_theta(self, theta_i, region_idx):
    method forward (line 296) | def forward(self, x):

FILE: boxmot/reid/backbones/lmbn/attention.py
  class BatchRandomErasing (line 24) | class BatchRandomErasing(nn.Module):
    method __init__ (line 25) | def __init__(
    method forward (line 36) | def forward(self, img):
  class BatchDrop (line 64) | class BatchDrop(nn.Module):
    method __init__ (line 71) | def __init__(self, h_ratio, w_ratio):
    method forward (line 76) | def forward(self, x):
  class BatchDropTop (line 89) | class BatchDropTop(nn.Module):
    method __init__ (line 97) | def __init__(self, h_ratio):
    method forward (line 101) | def forward(self, x, visdrop=False):
  class BatchFeatureErase_Top (line 128) | class BatchFeatureErase_Top(nn.Module):
    method __init__ (line 136) | def __init__(
    method forward (line 151) | def forward(self, x, drop_top=True, bottleneck_features=True, visdrop=...
  class SE_Module (line 166) | class SE_Module(Module):
    method __init__ (line 167) | def __init__(self, channels, reduction=4):
    method forward (line 174) | def forward(self, x):
  class PAM_Module (line 183) | class PAM_Module(Module):
    method __init__ (line 188) | def __init__(self, in_dim):
    method forward (line 203) | def forward(self, x):
  class CAM_Module (line 227) | class CAM_Module(Module):
    method __init__ (line 230) | def __init__(self, in_dim):
    method forward (line 237) | def forward(self, x):
  class Dual_Module (line 261) | class Dual_Module(Module):
    method __init__ (line 272) | def __init__(self, in_dim):
    method forward (line 278) | def forward(self, x):

FILE: boxmot/reid/backbones/lmbn/bnneck.py
  class BNNeck (line 6) | class BNNeck(nn.Module):
    method __init__ (line 7) | def __init__(self, input_dim, class_num, return_f=False):
    method forward (line 16) | def forward(self, x):
    method weights_init_kaiming (line 27) | def weights_init_kaiming(self, m):
    method weights_init_classifier (line 41) | def weights_init_classifier(self, m):
  class BNNeck3 (line 49) | class BNNeck3(nn.Module):
    method __init__ (line 50) | def __init__(self, input_dim, class_num, feat_dim, return_f=False):
    method forward (line 64) | def forward(self, x):
    method weights_init_kaiming (line 77) | def weights_init_kaiming(self, m):
    method weights_init_classifier (line 91) | def weights_init_classifier(self, m):
  class ClassBlock (line 103) | class ClassBlock(nn.Module):
    method __init__ (line 104) | def __init__(
    method forward (line 139) | def forward(self, x):
    method weights_init_kaiming (line 149) | def weights_init_kaiming(self, m):
    method weights_init_classifier (line 162) | def weights_init_classifier(self, m):

FILE: boxmot/reid/backbones/lmbn/lmbn_n.py
  class LMBN_n (line 13) | class LMBN_n(nn.Module):
    method __init__ (line 14) | def __init__(self, num_classes, loss, pretrained, use_gpu):
    method forward (line 71) | def forward(self, x):
    method weights_init_kaiming (line 144) | def weights_init_kaiming(self, m):

FILE: boxmot/reid/backbones/mlfn.py
  class MLFNBlock (line 18) | class MLFNBlock(nn.Module):
    method __init__ (line 19) | def __init__(self, in_channels, out_channels, stride, fsm_channels, gr...
    method forward (line 61) | def forward(self, x):
  class MLFN (line 95) | class MLFN(nn.Module):
    method __init__ (line 106) | def __init__(
    method init_params (line 167) | def init_params(self):
    method forward (line 181) | def forward(self, x):
  function init_pretrained_weights (line 213) | def init_pretrained_weights(model, model_url):
  function mlfn (line 229) | def mlfn(num_classes, loss="softmax", pretrained=True, **kwargs):

FILE: boxmot/reid/backbones/mobilenetv2.py
  class ConvBlock (line 19) | class ConvBlock(nn.Module):
    method __init__ (line 34) | def __init__(self, in_c, out_c, k, s=1, p=0, g=1):
    method forward (line 39) | def forward(self, x):
  class Bottleneck (line 43) | class Bottleneck(nn.Module):
    method __init__ (line 44) | def __init__(self, in_channels, out_channels, expansion_factor, stride...
    method forward (line 57) | def forward(self, x):
  class MobileNetV2 (line 67) | class MobileNetV2(nn.Module):
    method __init__ (line 79) | def __init__(
    method _make_layer (line 110) | def _make_layer(self, block, t, c, n, s):
    method _construct_fc_layer (line 122) | def _construct_fc_layer(self, fc_dims, input_dim, dropout_p=None):
    method _init_params (line 151) | def _init_params(self):
    method featuremaps (line 168) | def featuremaps(self, x):
    method forward (line 180) | def forward(self, x):
  function init_pretrained_weights (line 201) | def init_pretrained_weights(model, model_url):
  function mobilenetv2_x1_0 (line 217) | def mobilenetv2_x1_0(num_classes, loss, pretrained=True, **kwargs):
  function mobilenetv2_x1_4 (line 233) | def mobilenetv2_x1_4(num_classes, loss, pretrained=True, **kwargs):

FILE: boxmot/reid/backbones/osnet.py
  class ConvLayer (line 25) | class ConvLayer(nn.Module):
    method __init__ (line 28) | def __init__(
    method forward (line 54) | def forward(self, x):
  class Conv1x1 (line 61) | class Conv1x1(nn.Module):
    method __init__ (line 64) | def __init__(self, in_channels, out_channels, stride=1, groups=1):
    method forward (line 78) | def forward(self, x):
  class Conv1x1Linear (line 85) | class Conv1x1Linear(nn.Module):
    method __init__ (line 88) | def __init__(self, in_channels, out_channels, stride=1):
    method forward (line 95) | def forward(self, x):
  class Conv3x3 (line 101) | class Conv3x3(nn.Module):
    method __init__ (line 104) | def __init__(self, in_channels, out_channels, stride=1, groups=1):
    method forward (line 118) | def forward(self, x):
  class LightConv3x3 (line 125) | class LightConv3x3(nn.Module):
    method __init__ (line 131) | def __init__(self, in_channels, out_channels):
    method forward (line 148) | def forward(self, x):
  class ChannelGate (line 159) | class ChannelGate(nn.Module):
    method __init__ (line 162) | def __init__(
    method forward (line 195) | def forward(self, x):
  class OSBlock (line 210) | class OSBlock(nn.Module):
    method __init__ (line 213) | def __init__(
    method forward (line 244) | def forward(self, x):
  class OSNet (line 264) | class OSNet(nn.Module):
    method __init__ (line 273) | def __init__(
    method _make_layer (line 319) | def _make_layer(
    method _construct_fc_layer (line 337) | def _construct_fc_layer(self, fc_dims, input_dim, dropout_p=None):
    method _init_params (line 358) | def _init_params(self):
    method featuremaps (line 378) | def featuremaps(self, x):
    method forward (line 387) | def forward(self, x, return_featuremaps=False):
  function init_pretrained_weights (line 406) | def init_pretrained_weights(model, key=""):
  function osnet_x1_0 (line 486) | def osnet_x1_0(num_classes=1000, pretrained=True, loss="softmax", **kwar...
  function osnet_x0_75 (line 501) | def osnet_x0_75(num_classes=1000, pretrained=True, loss="softmax", **kwa...
  function osnet_x0_5 (line 516) | def osnet_x0_5(num_classes=1000, pretrained=True, loss="softmax", **kwar...
  function osnet_x0_25 (line 531) | def osnet_x0_25(num_classes=1000, pretrained=True, loss="softmax", **kwa...
  function osnet_ibn_x1_0 (line 546) | def osnet_ibn_x1_0(num_classes=1000, pretrained=True, loss="softmax", **...

FILE: boxmot/reid/backbones/osnet_ain.py
  class ConvLayer (line 24) | class ConvLayer(nn.Module):
    method __init__ (line 27) | def __init__(
    method forward (line 53) | def forward(self, x):
  class Conv1x1 (line 59) | class Conv1x1(nn.Module):
    method __init__ (line 62) | def __init__(self, in_channels, out_channels, stride=1, groups=1):
    method forward (line 76) | def forward(self, x):
  class Conv1x1Linear (line 82) | class Conv1x1Linear(nn.Module):
    method __init__ (line 85) | def __init__(self, in_channels, out_channels, stride=1, bn=True):
    method forward (line 94) | def forward(self, x):
  class Conv3x3 (line 101) | class Conv3x3(nn.Module):
    method __init__ (line 104) | def __init__(self, in_channels, out_channels, stride=1, groups=1):
    method forward (line 118) | def forward(self, x):
  class LightConv3x3 (line 124) | class LightConv3x3(nn.Module):
    method __init__ (line 130) | def __init__(self, in_channels, out_channels):
    method forward (line 147) | def forward(self, x):
  class LightConvStream (line 154) | class LightConvStream(nn.Module):
    method __init__ (line 157) | def __init__(self, in_channels, out_channels, depth):
    method forward (line 168) | def forward(self, x):
  class ChannelGate (line 175) | class ChannelGate(nn.Module):
    method __init__ (line 178) | def __init__(
    method forward (line 211) | def forward(self, x):
  class OSBlock (line 226) | class OSBlock(nn.Module):
    method __init__ (line 229) | def __init__(self, in_channels, out_channels, reduction=4, T=4, **kwar...
    method forward (line 245) | def forward(self, x):
  class OSBlockINin (line 259) | class OSBlockINin(nn.Module):
    method __init__ (line 262) | def __init__(self, in_channels, out_channels, reduction=4, T=4, **kwar...
    method forward (line 279) | def forward(self, x):
  class OSNet (line 297) | class OSNet(nn.Module):
    method __init__ (line 306) | def __init__(
    method _make_layer (line 347) | def _make_layer(self, blocks, layer, in_channels, out_channels):
    method _construct_fc_layer (line 354) | def _construct_fc_layer(self, fc_dims, input_dim, dropout_p=None):
    method _init_params (line 375) | def _init_params(self):
    method featuremaps (line 399) | def featuremaps(self, x):
    method forward (line 410) | def forward(self, x, return_featuremaps=False):
  function init_pretrained_weights (line 429) | def init_pretrained_weights(model, key=""):
  function osnet_ain_x1_0 (line 509) | def osnet_ain_x1_0(num_classes=1000, pretrained=True, loss="softmax", **...
  function osnet_ain_x0_75 (line 528) | def osnet_ain_x0_75(num_classes=1000, pretrained=True, loss="softmax", *...
  function osnet_ain_x0_5 (line 547) | def osnet_ain_x0_5(num_classes=1000, pretrained=True, loss="softmax", **...
  function osnet_ain_x0_25 (line 566) | def osnet_ain_x0_25(num_classes=1000, pretrained=True, loss="softmax", *...

FILE: boxmot/reid/backbones/resnet.py
  function conv3x3 (line 33) | def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
  function conv1x1 (line 47) | def conv1x1(in_planes, out_planes, stride=1):
  class BasicBlock (line 52) | class BasicBlock(nn.Module):
    method __init__ (line 55) | def __init__(
    method forward (line 82) | def forward(self, x):
  class Bottleneck (line 101) | class Bottleneck(nn.Module):
    method __init__ (line 104) | def __init__(
    method forward (line 130) | def forward(self, x):
  class ResNet (line 153) | class ResNet(nn.Module):
    method __init__ (line 171) | def __init__(
    method _make_layer (line 242) | def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
    method _construct_fc_layer (line 283) | def _construct_fc_layer(self, fc_dims, input_dim, dropout_p=None):
    method _init_params (line 312) | def _init_params(self):
    method featuremaps (line 329) | def featuremaps(self, x):
    method forward (line 340) | def forward(self, x):
  function init_pretrained_weights (line 361) | def init_pretrained_weights(model, model_url):
  function resnet18 (line 380) | def resnet18(num_classes, loss="softmax", pretrained=True, **kwargs):
  function resnet34 (line 396) | def resnet34(num_classes, loss="softmax", pretrained=True, **kwargs):
  function resnet50 (line 412) | def resnet50(num_classes, loss="softmax", pretrained=True, **kwargs):
  function resnet101 (line 428) | def resnet101(num_classes, loss="softmax", pretrained=True, **kwargs):
  function resnet152 (line 444) | def resnet152(num_classes, loss="softmax", pretrained=True, **kwargs):
  function resnext50_32x4d (line 463) | def resnext50_32x4d(num_classes, loss="softmax", pretrained=True, **kwar...
  function resnext101_32x8d (line 481) | def resnext101_32x8d(num_classes, loss="softmax", pretrained=True, **kwa...
  function resnet50_fc512 (line 504) | def resnet50_fc512(num_classes, loss="softmax", pretrained=True, **kwargs):

FILE: boxmot/reid/backends/base_backend.py
  class BaseModelBackend (line 17) | class BaseModelBackend:
    method __init__ (line 18) | def __init__(self, weights, device, half):
    method _obb_to_xyxy (line 60) | def _obb_to_xyxy(box: np.ndarray) -> np.ndarray:
    method _order_corners (line 71) | def _order_corners(corners: np.ndarray) -> np.ndarray:
    method _crop_obb (line 84) | def _crop_obb(box: np.ndarray, img: np.ndarray) -> np.ndarray:
    method _is_obb_box (line 107) | def _is_obb_box(box: np.ndarray) -> bool:
    method _boxes_to_xyxy (line 112) | def _boxes_to_xyxy(cls, boxes: np.ndarray) -> np.ndarray:
    method get_crops (line 135) | def get_crops(self, xyxys, img):
    method get_features (line 191) | def get_features(self, xyxys, img):
    method warmup (line 202) | def warmup(self, imgsz=[(256, 128, 3)]):
    method to_numpy (line 212) | def to_numpy(self, x):
    method inference_preprocess (line 215) | def inference_preprocess(self, x):
    method inference_postprocess (line 231) | def inference_postprocess(self, features):
    method forward (line 240) | def forward(self, im_batch):
    method load_model (line 244) | def load_model(self, w):
    method download_model (line 248) | def download_model(self, w):

FILE: boxmot/reid/backends/onnx_backend.py
  class ONNXBackend (line 4) | class ONNXBackend(BaseModelBackend):
    method __init__ (line 6) | def __init__(self, weights, device, half):
    method load_model (line 11) | def load_model(self, w):
    method forward (line 30) | def forward(self, im_batch):

FILE: boxmot/reid/backends/openvino_backend.py
  class OpenVinoBackend (line 7) | class OpenVinoBackend(BaseModelBackend):
    method __init__ (line 9) | def __init__(self, weights, device, half):
    method load_model (line 14) | def load_model(self, w):
    method forward (line 45) | def forward(self, im_batch):

FILE: boxmot/reid/backends/pytorch_backend.py
  class PyTorchBackend (line 5) | class PyTorchBackend(BaseModelBackend):
    method __init__ (line 7) | def __init__(self, weights, device, half):
    method load_model (line 12) | def load_model(self, w):
    method forward (line 19) | def forward(self, im_batch):

FILE: boxmot/reid/backends/tensorrt_backend.py
  class TensorRTBackend (line 10) | class TensorRTBackend(BaseModelBackend):
    method __init__ (line 11) | def __init__(self, weights, device, half):
    method load_model (line 21) | def load_model(self, w):
    method forward (line 102) | def forward(self, im_batch):

FILE: boxmot/reid/backends/tflite_backend.py
  class TFLiteBackend (line 12) | class TFLiteBackend(BaseModelBackend):
    method __init__ (line 23) | def __init__(self, weights: Path, device: str, half: bool):
    method _get_interpreter_class (line 38) | def _get_interpreter_class(self) -> type[Any]:
    method load_model (line 47) | def load_model(self, w):
    method forward (line 63) | def forward(self, im_batch: torch.Tensor) -> np.ndarray:

FILE: boxmot/reid/backends/torchscript_backend.py
  class TorchscriptBackend (line 7) | class TorchscriptBackend(BaseModelBackend):
    method __init__ (line 9) | def __init__(self, weights, device, half):
    method load_model (line 14) | def load_model(self, w):
    method forward (line 20) | def forward(self, im_batch):

FILE: boxmot/reid/core/__init__.py
  function export_formats (line 6) | def export_formats():

FILE: boxmot/reid/core/auto_backend.py
  class ReidAutoBackend (line 18) | class ReidAutoBackend:
    method __init__ (line 19) | def __init__(
    method get_backend (line 49) | def get_backend(
    method check_suffix (line 88) | def check_suffix(
    method model_type (line 113) | def model_type(self, p: Path) -> Tuple[bool, ...]:

FILE: boxmot/reid/core/registry.py
  class ReIDModelRegistry (line 11) | class ReIDModelRegistry:
    method show_downloadable_models (line 15) | def show_downloadable_models():
    method get_model_name (line 20) | def get_model_name(model):
    method get_model_url (line 27) | def get_model_url(model):
    method load_pretrained_weights (line 31) | def load_pretrained_weights(model, weight_path):
    method show_available_models (line 75) | def show_available_models():
    method get_nr_classes (line 80) | def get_nr_classes(weights):
    method build_model (line 86) | def build_model(name, weights, num_classes, loss="softmax", pretrained...

FILE: boxmot/reid/core/reid_handler.py
  class ReID (line 9) | class ReID:
    method __init__ (line 10) | def __init__(self, weights: Union[str, Path], device='cpu', half=False):
    method __call__ (line 20) | def __call__(self, frame: np.ndarray, dets: np.ndarray) -> np.ndarray:

FILE: boxmot/reid/exporters/base_exporter.py
  function export_decorator (line 7) | def export_decorator(export_func):
  class BaseExporter (line 37) | class BaseExporter:
    method __init__ (line 38) | def __init__(self, model, im, file, optimize=True, dynamic=True, half=...
    method file_size (line 50) | def file_size(path):
    method export (line 59) | def export(self):
    method __init_subclass__ (line 62) | def __init_subclass__(cls, **kwargs):

FILE: boxmot/reid/exporters/onnx_exporter.py
  class ONNXExporter (line 9) | class ONNXExporter(BaseExporter):
    method __init__ (line 12) | def __init__(self, model, im, file, opset=None, dynamic=False, half=Fa...
    method export (line 17) | def export(self):
    method simplify_model (line 102) | def simplify_model(self, model_onnx):
    method _best_onnx_opset (line 115) | def _best_onnx_opset(self, onnx, cuda: bool = False) -> int:
    method _infer_output_names (line 149) | def _infer_output_names(self):
    method _build_dynamic_axes (line 162) | def _build_dynamic_axes(self, output_names):
    method _try_fp16_convert_cpu (line 187) | def _try_fp16_convert_cpu(self, model_onnx):

FILE: boxmot/reid/exporters/openvino_exporter.py
  class OpenVINOExporter (line 6) | class OpenVINOExporter(BaseExporter):
    method export (line 9) | def export(self) -> str:

FILE: boxmot/reid/exporters/tensorrt_exporter.py
  class EngineExporter (line 6) | class EngineExporter(BaseExporter):
    method export (line 10) | def export(self):
    method export_onnx (line 79) | def export_onnx(self):

FILE: boxmot/reid/exporters/tflite_exporter.py
  class TFLiteExporter (line 13) | class TFLiteExporter(BaseExporter):
    method __init__ (line 16) | def __init__(self, model, im, file, opset=None, dynamic=False, half=Fa...
    method export (line 20) | def export(self) -> str:
    method _ensure_onnx_file (line 48) | def _ensure_onnx_file(self) -> Path:
    method _build_convert_kwargs (line 68) | def _build_convert_kwargs(self, onnx2tf_module, onnx_path: Path, outpu...
    method _set_if_supported (line 86) | def _set_if_supported(kwargs: dict, sig, name: str, value) -> None:
    method _select_tflite_artifact (line 90) | def _select_tflite_artifact(self, export_dir: Path) -> Optional[Path]:
    method _matches_any_token (line 109) | def _matches_any_token(path: Path, tokens: Tuple[str, ...]) -> bool:

FILE: boxmot/reid/exporters/torchscript_exporter.py
  class TorchScriptExporter (line 6) | class TorchScriptExporter(BaseExporter):
    method export (line 7) | def export(self):

FILE: boxmot/trackers/basetracker.py
  class BaseTracker (line 15) | class BaseTracker(VisualizationMixin):
    method __init__ (line 18) | def __init__(
    method update (line 118) | def update(
    method get_class_dets_n_embs (line 137) | def get_class_dets_n_embs(self, dets, embs, cls_id):
    method _set_detection_mode (line 168) | def _set_detection_mode(self, is_obb: bool) -> None:
    method empty_detections (line 181) | def empty_detections(self, dtype=np.float32) -> np.ndarray:
    method empty_output (line 184) | def empty_output(self, dtype=float) -> np.ndarray:
    method setup_decorator (line 188) | def setup_decorator(method):
    method per_class_decorator (line 234) | def per_class_decorator(update_method):
    method check_inputs (line 287) | def check_inputs(self, dets, img, embs=None):
    method reset (line 305) | def reset(self):

FILE: boxmot/trackers/boosttrack/assoc.py
  function shape_similarity (line 9) | def shape_similarity(detects: np.ndarray, tracks: np.ndarray, s_sim_corr...
  function shape_similarity_v1 (line 15) | def shape_similarity_v1(detects: np.ndarray, tracks: np.ndarray) -> np.n...
  function shape_similarity_v2 (line 26) | def shape_similarity_v2(detects: np.ndarray, tracks: np.ndarray) -> np.n...
  function MhDist_similarity (line 37) | def MhDist_similarity(mahalanobis_distance: np.ndarray, softmax_temp: fl...
  function iou_batch (line 50) | def iou_batch(bboxes1, bboxes2):
  function soft_biou_batch (line 69) | def soft_biou_batch(bboxes1, bboxes2):
  function match (line 106) | def match(cost_matrix: np.ndarray, threshold: float) -> np.ndarray:
  function linear_assignment (line 117) | def linear_assignment(
  function associate (line 156) | def associate(

FILE: boxmot/trackers/boosttrack/boosttrack.py
  function convert_bbox_to_z (line 15) | def convert_bbox_to_z(bbox):
  function convert_x_to_bbox (line 27) | def convert_x_to_bbox(x, score=None):
  class KalmanBoxTracker (line 41) | class KalmanBoxTracker:
    method __init__ (line 48) | def __init__(self, det, max_obs, emb: Optional[np.ndarray] = None):
    method get_confidence (line 62) | def get_confidence(self, coef: float = 0.9) -> float:
    method update (line 68) | def update(self, det: np.ndarray):
    method camera_update (line 77) | def camera_update(self, transform: np.ndarray):
    method predict (line 101) | def predict(self):
    method get_state (line 109) | def get_state(self):
    method update_emb (line 112) | def update_emb(self, emb, alpha=0.9):
    method get_emb (line 116) | def get_emb(self):
  class BoostTrack (line 120) | class BoostTrack(BaseTracker):
    method __init__ (line 163) | def __init__(
    method update (line 230) | def update(self, dets: np.ndarray, img: np.ndarray, embs: Optional[np....
    method filter_outputs (line 345) | def filter_outputs(self, outputs: np.ndarray) -> np.ndarray:
    method get_iou_matrix (line 355) | def get_iou_matrix(self, detections: np.ndarray, buffered: bool = Fals...
    method get_mh_dist_matrix (line 363) | def get_mh_dist_matrix(self, detections: np.ndarray, n_dims: int = 4) ...
    method duo_confidence_boost (line 379) | def duo_confidence_boost(self, detections: np.ndarray) -> np.ndarray:
    method dlo_confidence_boost (line 421) | def dlo_confidence_boost(self, detections: np.ndarray) -> np.ndarray:

FILE: boxmot/trackers/botsort/basetrack.py
  class TrackState (line 6) | class TrackState:
  class BaseTrack (line 25) | class BaseTrack:
    method end_frame (line 62) | def end_frame(self) -> int:
    method next_id (line 72) | def next_id() -> int:
    method activate (line 82) | def activate(self, *args):
    method predict (line 94) | def predict(self):
    method update (line 103) | def update(self, *args, **kwargs):
    method mark_lost (line 116) | def mark_lost(self):
    method mark_long_lost (line 122) | def mark_long_lost(self):
    method mark_removed (line 128) | def mark_removed(self):
    method clear_count (line 135) | def clear_count():

FILE: boxmot/trackers/botsort/botsort.py
  class BotSort (line 21) | class BotSort(BaseTracker):
    method __init__ (line 64) | def __init__(
    method _kalman_ndim (line 112) | def _kalman_ndim(self) -> int:
    method _detection_boxes (line 115) | def _detection_boxes(self, dets: np.ndarray) -> np.ndarray:
    method update (line 120) | def update(
    method _split_detections (line 195) | def _split_detections(self, dets, embs):
    method _create_detections (line 207) | def _create_detections(self, dets_first, features_high):
    method _separate_tracks (line 220) | def _separate_tracks(self):
    method _first_association (line 229) | def _first_association(
    method _second_association (line 280) | def _second_association(
    method _handle_unconfirmed_tracks (line 323) | def _handle_unconfirmed_tracks(
    method _initialize_new_tracks (line 372) | def _initialize_new_tracks(self, u_detections, activated_stracks, dete...
    method _update_tracks (line 381) | def _update_tracks(
    method _update_track_states (line 411) | def _update_track_states(self, removed_stracks):
    method _prepare_output (line 417) | def _prepare_output(

FILE: boxmot/trackers/botsort/botsort_track.py
  class STrack (line 11) | class STrack(BaseTrack):
    method __init__ (line 15) | def __init__(self, det, feat=None, feat_history=50, max_obs=50, is_obb...
    method _init_from_aabb_detection (line 45) | def _init_from_aabb_detection(self, det: np.ndarray) -> None:
    method _init_from_obb_detection (line 51) | def _init_from_obb_detection(self, det: np.ndarray) -> None:
    method update_features (line 57) | def update_features(self, feat):
    method update_cls (line 68) | def update_cls(self, cls, conf):
    method predict (line 83) | def predict(self):
    method multi_predict (line 96) | def multi_predict(stracks):
    method multi_gmc (line 117) | def multi_gmc(stracks, H=np.eye(2, 3)):
    method activate (line 133) | def activate(self, kalman_filter, frame_id):
    method re_activate (line 145) | def re_activate(self, new_track, frame_id, new_id=False):
    method update (line 163) | def update(self, new_track, frame_id):
    method _wrap_pi_periodic (line 186) | def _wrap_pi_periodic(delta: float) -> float:
    method _state_obb_for_plot (line 189) | def _state_obb_for_plot(self) -> np.ndarray:
    method xyxy (line 212) | def xyxy(self):
    method xywha (line 225) | def xywha(self):

FILE: boxmot/trackers/botsort/botsort_utils.py
  function joint_stracks (line 10) | def joint_stracks(tlista: List["STrack"], tlistb: List["STrack"]) -> Lis...
  function sub_stracks (line 34) | def sub_stracks(tlista: List["STrack"], tlistb: List["STrack"]) -> List[...
  function remove_duplicate_stracks (line 53) | def remove_duplicate_stracks(

FILE: boxmot/trackers/bytetrack/basetrack.py
  class TrackState (line 8) | class TrackState(object):
  class BaseTrack (line 15) | class BaseTrack(object):
    method end_frame (line 34) | def end_frame(self):
    method next_id (line 38) | def next_id():
    method activate (line 42) | def activate(self, *args):
    method predict (line 45) | def predict(self):
    method update (line 48) | def update(self, *args, **kwargs):
    method mark_lost (line 51) | def mark_lost(self):
    method mark_removed (line 54) | def mark_removed(self):
    method clear_count (line 58) | def clear_count():

FILE: boxmot/trackers/bytetrack/bytetrack.py
  class STrack (line 16) | class STrack(BaseTrack):
    method __init__ (line 20) | def __init__(self, det, max_obs, is_obb: bool = False):
    method _init_from_aabb_detection (line 36) | def _init_from_aabb_detection(self, det: np.ndarray) -> None:
    method _init_from_obb_detection (line 44) | def _init_from_obb_detection(self, det: np.ndarray) -> None:
    method predict (line 52) | def predict(self):
    method multi_predict (line 64) | def multi_predict(stracks):
    method activate (line 83) | def activate(self, kalman_filter, frame_id):
    method re_activate (line 99) | def re_activate(self, new_track, frame_id, new_id=False):
    method update (line 115) | def update(self, new_track, frame_id):
    method _wrap_pi_periodic (line 143) | def _wrap_pi_periodic(delta: float) -> float:
    method _state_obb_for_plot (line 146) | def _state_obb_for_plot(self) -> np.ndarray:
    method xyxy (line 169) | def xyxy(self):
    method xywha (line 189) | def xywha(self):
  class ByteTrack (line 197) | class ByteTrack(BaseTracker):
    method __init__ (line 231) | def __init__(
    method update (line 266) | def update(
  function joint_stracks (line 415) | def joint_stracks(tlista, tlistb):
  function sub_stracks (line 429) | def sub_stracks(tlista, tlistb):
  function remove_duplicate_stracks (line 440) | def remove_duplicate_stracks(stracksa, stracksb):

FILE: boxmot/trackers/deepocsort/deepocsort.py
  function k_previous_obs (line 17) | def k_previous_obs(observations, cur_age, k):
  function convert_x_to_bbox (line 28) | def convert_x_to_bbox(x, score=None):
  function speed_direction (line 43) | def speed_direction(bbox1, bbox2):
  class KalmanBoxTracker (line 51) | class KalmanBoxTracker:
    method __init__ (line 58) | def __init__(
    method update (line 143) | def update(self, det):
    method update_emb (line 182) | def update_emb(self, emb, alpha=0.9):
    method get_emb (line 186) | def get_emb(self):
    method apply_affine_correction (line 189) | def apply_affine_correction(self, affine):
    method predict (line 208) | def predict(self):
    method get_state (line 225) | def get_state(self):
    method mahalanobis (line 231) | def mahalanobis(self, bbox):
  class DeepOcSort (line 236) | class DeepOcSort(BaseTracker):
    method __init__ (line 274) | def __init__(
    method update (line 319) | def update(

FILE: boxmot/trackers/detection_layout.py
  class DetectionLayout (line 9) | class DetectionLayout:
    method box_with_conf_cols (line 21) | def box_with_conf_cols(self) -> int:
    method association_mode_name (line 24) | def association_mode_name(self, base_name: str) -> str:
    method empty_dets (line 27) | def empty_dets(self, dtype=np.float32) -> np.ndarray:
    method empty_output (line 30) | def empty_output(self, dtype=float) -> np.ndarray:
    method boxes (line 33) | def boxes(self, dets: np.ndarray) -> np.ndarray:
    method confidences (line 38) | def confidences(self, dets: np.ndarray) -> np.ndarray:
    method classes (line 43) | def classes(self, dets: np.ndarray) -> np.ndarray:
    method with_detection_indices (line 48) | def with_detection_indices(self, dets: np.ndarray) -> np.ndarray:
    method validate_dets (line 54) | def validate_dets(self, dets: np.ndarray) -> None:
  class AxisAlignedDetections (line 61) | class AxisAlignedDetections(DetectionLayout):
    method __init__ (line 62) | def __init__(self) -> None:
  class OrientedDetections (line 74) | class OrientedDetections(DetectionLayout):
    method __init__ (line 75) | def __init__(self) -> None:
  function get_detection_layout (line 91) | def get_detection_layout(is_obb: bool) -> DetectionLayout:
  function infer_detection_layout (line 95) | def infer_detection_layout(dets: np.ndarray) -> DetectionLayout | None:

FILE: boxmot/trackers/hybridsort/association.py
  function intersection_batch (line 5) | def intersection_batch(bboxes1, bboxes2):
  function box_area (line 18) | def box_area(bbox):
  function iou_batch (line 22) | def iou_batch(bboxes1, bboxes2):
  function cal_score_dif_batch (line 41) | def cal_score_dif_batch(bboxes1, bboxes2):
  function cal_score_dif_batch_two_score (line 53) | def cal_score_dif_batch_two_score(bboxes1, bboxes2):
  function hmiou (line 65) | def hmiou(bboxes1, bboxes2):
  function giou_batch (line 90) | def giou_batch(bboxes1, bboxes2):
  function giou_batch_true (line 123) | def giou_batch_true(bboxes1, bboxes2):
  function diou_batch (line 157) | def diou_batch(bboxes1, bboxes2):
  function ciou_batch (line 196) | def ciou_batch(bboxes1, bboxes2):
  function ct_dist (line 249) | def ct_dist(bboxes1, bboxes2):
  function speed_direction_batch (line 273) | def speed_direction_batch(dets, tracks):
  function linear_assignment (line 291) | def linear_assignment(cost_matrix, thresh=0.):
  function associate_detections_to_trackers (line 305) | def associate_detections_to_trackers(detections,trackers,iou_threshold =...
  function associate (line 349) | def associate(detections, trackers, iou_threshold, velocities, previous_...
  function cost_vel (line 408) | def cost_vel(Y, X, trackers, velocities, detections, previous_obs, vdc_w...
  function speed_direction_batch_lt (line 431) | def speed_direction_batch_lt(dets, tracks):
  function speed_direction_batch_rt (line 442) | def speed_direction_batch_rt(dets, tracks):
  function speed_direction_batch_lb (line 453) | def speed_direction_batch_lb(dets, tracks):
  function speed_direction_batch_rb (line 464) | def speed_direction_batch_rb(dets, tracks):
  function associate_4_points (line 475) | def associate_4_points(detections, trackers, iou_threshold, lt, rt, lb, ...
  function associate_4_points_with_score (line 525) | def associate_4_points_with_score(detections, trackers, iou_threshold, l...
  function associate_4_points_with_score_with_reid (line 578) | def associate_4_points_with_score_with_reid(detections, trackers, iou_th...
  function associate_kitti (line 658) | def associate_kitti(detections, trackers, det_cates, iou_threshold,
  function embedding_distance (line 740) | def embedding_distance(tracks_feat, detections_feat, metric='cosine'):
  function fuse_motion (line 770) | def fuse_motion(cost_matrix, tracks, detections, only_position=False, la...
  function linear_assignment_appearance (line 785) | def linear_assignment_appearance(cost_matrix, thresh):
  function fuse_score (line 798) | def fuse_score(cost_matrix, det_scores):

FILE: boxmot/trackers/hybridsort/hybridsort.py
  function k_previous_obs (line 26) | def k_previous_obs(observations, cur_age, k):
  function convert_bbox_to_z (line 37) | def convert_bbox_to_z(bbox):
  function convert_x_to_bbox (line 52) | def convert_x_to_bbox(x, score=None):
  function speed_direction_lt (line 63) | def speed_direction_lt(bbox1, bbox2):
  function speed_direction_rt (line 71) | def speed_direction_rt(bbox1, bbox2):
  function speed_direction_lb (line 79) | def speed_direction_lb(bbox1, bbox2):
  function speed_direction_rb (line 87) | def speed_direction_rb(bbox1, bbox2):
  class KalmanBoxTracker (line 95) | class KalmanBoxTracker(object):
    method __init__ (line 103) | def __init__(
    method update_features (line 217) | def update_features(self, feat, score: float = -1.0):
    method camera_update (line 238) | def camera_update(self, warp_matrix):
    method update (line 262) | def update(self, bbox, id_feature, update_feature: bool = True, *, cls...
    method predict (line 318) | def predict(self):
  class HybridSort (line 356) | class HybridSort(BaseTracker):
    method __init__ (line 367) | def __init__(
    method update (line 455) | def update(self, dets: np.ndarray, img: np.ndarray, embs: np.ndarray =...

FILE: boxmot/trackers/hybridsort/kalmanfilter_score.py
  class KalmanFilterNew_score (line 111) | class KalmanFilterNew_score(object):
    method __init__ (line 285) | def __init__(self, dim_x, dim_z, dim_u=0, args=None):
    method predict (line 342) | def predict(self, u=None, B=None, F=None, Q=None):
    method freeze (line 385) | def freeze(self):
    method unfreeze (line 392) | def unfreeze(self):
    method update (line 443) | def update(self, z, R=None, H=None, confidence=0.0):
    method predict_steadystate (line 537) | def predict_steadystate(self, u=0, B=None):
    method update_steadystate (line 566) | def update_steadystate(self, z):
    method update_correlated (line 633) | def update_correlated(self, z, R=None, H=None):
    method batch_filter (line 710) | def batch_filter(self, zs, Fs=None, Qs=None, Hs=None,
    method rts_smoother (line 846) | def rts_smoother(self, Xs, Ps, Fs=None, Qs=None, inv=np.linalg.inv):
    method get_prediction (line 910) | def get_prediction(self, u=None, B=None, F=None, Q=None):
    method get_update (line 953) | def get_update(self, z=None):
    method residual_of (line 998) | def residual_of(self, z):
    method measurement_of_state (line 1006) | def measurement_of_state(self, x):
    method log_likelihood (line 1023) | def log_likelihood(self):
    method likelihood (line 1032) | def likelihood(self):
    method mahalanobis (line 1047) | def mahalanobis(self):
    method alpha (line 1060) | def alpha(self):
    method log_likelihood_of (line 1070) | def log_likelihood_of(self, z):
    method alpha (line 1081) | def alpha(self, value):
    method __repr__ (line 1087) | def __repr__(self):
    method test_matrix_dimensions (line 1117) | def test_matrix_dimensions(self, z=None, H=None, R=None, F=None, Q=None):
  function update (line 1217) | def update(x, P, z, R, H=None, return_all=False):
  function update_steadystate (line 1309) | def update_steadystate(x, z, K, H=None):
  function predict (line 1357) | def predict(x, P, F=1, Q=0, u=0, B=1, alpha=1.):
  function predict_steadystate (line 1398) | def predict_steadystate(x, F=1, u=0, B=1):
  function batch_filter (line 1430) | def batch_filter(x, P, zs, Fs, Qs, Hs, Rs, Bs=None, us=None,
  function rts_smoother (line 1538) | def rts_smoother(Xs, Ps, Fs, Qs):

FILE: boxmot/trackers/hybridsort/kalmanfilter_score_new.py
  class KalmanFilterNew_score_new (line 110) | class KalmanFilterNew_score_new(object):
    method __init__ (line 284) | def __init__(self, dim_x, dim_z, dim_u=0, args=None):
    method predict (line 341) | def predict(self, u=None, B=None, F=None, Q=None):
    method freeze (line 385) | def freeze(self):
    method unfreeze (line 392) | def unfreeze(self):
    method update (line 450) | def update(self, z, R=None, H=None):
    method predict_steadystate (line 547) | def predict_steadystate(self, u=0, B=None):
    method update_steadystate (line 576) | def update_steadystate(self, z):
    method update_correlated (line 643) | def update_correlated(self, z, R=None, H=None):
    method batch_filter (line 720) | def batch_filter(self, zs, Fs=None, Qs=None, Hs=None,
    method rts_smoother (line 856) | def rts_smoother(self, Xs, Ps, Fs=None, Qs=None, inv=np.linalg.inv):
    method get_prediction (line 920) | def get_prediction(self, u=None, B=None, F=None, Q=None):
    method get_update (line 963) | def get_update(self, z=None):
    method residual_of (line 1008) | def residual_of(self, z):
    method measurement_of_state (line 1016) | def measurement_of_state(self, x):
    method log_likelihood (line 1033) | def log_likelihood(self):
    method likelihood (line 1042) | def likelihood(self):
    method mahalanobis (line 1057) | def mahalanobis(self):
    method alpha (line 1070) | def alpha(self):
    method log_likelihood_of (line 1080) | def log_likelihood_of(self, z):
    method alpha (line 1091) | def alpha(self, value):
    method __repr__ (line 1097) | def __repr__(self):
    method test_matrix_dimensions (line 1127) | def test_matrix_dimensions(self, z=None, H=None, R=None, F=None, Q=None):
  function update (line 1227) | def update(x, P, z, R, H=None, return_all=False):
  function update_steadystate (line 1319) | def update_steadystate(x, z, K, H=None):
  function predict (line 1367) | def predict(x, P, F=1, Q=0, u=0, B=1, alpha=1.):
  function predict_steadystate (line 1408) | def predict_steadystate(x, F=1, u=0, B=1):
  function batch_filter (line 1440) | def batch_filter(x, P, zs, Fs, Qs, Hs, Rs, Bs=None, us=None,
  function rts_smoother (line 1548) | def rts_smoother(Xs, Ps, Fs, Qs):

FILE: boxmot/trackers/ocsort/ocsort.py
  function k_previous_obs (line 17) | def k_previous_obs(observations, cur_age, k, is_obb=False):
  function convert_x_to_bbox (line 31) | def convert_x_to_bbox(x, score=None):
  function convert_obb_to_z (line 48) | def convert_obb_to_z(obb):
  function convert_x_to_obb (line 61) | def convert_x_to_obb(x, score=None):
  function speed_direction (line 73) | def speed_direction(bbox1, bbox2):
  function speed_direction_obb (line 81) | def speed_direction_obb(bbox1, bbox2):
  class KalmanBoxTracker (line 89) | class KalmanBoxTracker(object):
    method __init__ (line 96) | def __init__(
    method _wrap_pi_periodic (line 213) | def _wrap_pi_periodic(delta: float) -> float:
    method _state_obb_for_plot (line 216) | def _state_obb_for_plot(self) -> np.ndarray:
    method update (line 237) | def update(self, bbox, cls, det_ind):
    method predict (line 278) | def predict(self):
    method get_state (line 300) | def get_state(self):
  class OcSort (line 309) | class OcSort(BaseTracker):
    method __init__ (line 340) | def __init__(
    method update (line 371) | def update(

FILE: boxmot/trackers/sfsort/sfsort.py
  class TrackState (line 18) | class TrackState:
  class Track (line 27) | class Track:
    method __post_init__ (line 43) | def __post_init__(self) -> None:
    method id (line 57) | def id(self) -> int:
    method _wrap_pi_periodic (line 61) | def _wrap_pi_periodic(delta: float) -> float:
    method _wrap_angle (line 65) | def _wrap_angle(angle: float) -> float:
    method _align_obb_measurement (line 69) | def _align_obb_measurement(
    method _state_obb_for_plot (line 107) | def _state_obb_for_plot(self) -> np.ndarray:
    method update (line 128) | def update(self, box: np.ndarray, frame_id: int, conf: float, cls: int...
  class SFSORT (line 157) | class SFSORT(BaseTracker):
    method __init__ (line 194) | def __init__(
    method update (line 258) | def update(self, dets: np.ndarray, img: np.ndarray, embs: np.ndarray |...
    method _split_detections (line 367) | def _split_detections(self, dets: np.ndarray) -> tuple[np.ndarray, np....
    method _split_aabb_detections (line 372) | def _split_aabb_detections(self, dets: np.ndarray) -> tuple[np.ndarray...
    method _split_obb_detections (line 381) | def _split_obb_detections(self, dets: np.ndarray) -> tuple[np.ndarray,...
    method _dynamic_thresholds (line 390) | def _dynamic_thresholds(self, scores: np.ndarray) -> tuple[float, floa...
    method _purge_stale_lost_tracks (line 404) | def _purge_stale_lost_tracks(self) -> None:
    method _update_lost_tracks (line 413) | def _update_lost_tracks(self, next_lost_tracks: Iterable[Track]) -> None:
    method _maybe_set_margins (line 428) | def _maybe_set_margins(self, frame_width: int | None, frame_height: in...
    method _new_track (line 450) | def _new_track(self, box: np.ndarray, frame_id: int, conf: float, cls:...
    method _format_track (line 464) | def _format_track(track: Track) -> list[float]:
    method clamp (line 474) | def clamp(value: float, min_value: float, max_value: float) -> float:
    method _resolve_or_default (line 478) | def _resolve_or_default(
    method _obb_to_xyxy (line 485) | def _obb_to_xyxy(box: np.ndarray) -> np.ndarray:
    method calculate_cost (line 495) | def calculate_cost(
    method _calculate_cost_obb (line 514) | def _calculate_cost_obb(
    method _calculate_cost_aabb (line 554) | def _calculate_cost_aabb(
    method _combine_cost_terms (line 607) | def _combine_cost_terms(

FILE: boxmot/trackers/strongsort/sort/detection.py
  class Detection (line 4) | class Detection(object):
    method __init__ (line 28) | def __init__(self, tlwh, conf, cls, det_ind, feat):
    method to_xyah (line 35) | def to_xyah(self):

FILE: boxmot/trackers/strongsort/sort/iou_matching.py
  function iou (line 10) | def iou(bbox, candidates):
  function iou_cost (line 49) | def iou_cost(tracks, detections, track_indices=None, detection_indices=N...

FILE: boxmot/trackers/strongsort/sort/linear_assignment.py
  function min_cost_matching (line 14) | def min_cost_matching(
  function matching_cascade (line 82) | def matching_cascade(
  function gate_cost_matrix (line 145) | def gate_cost_matrix(
  function _cosine_distance (line 201) | def _cosine_distance(a, b, data_is_normalized=False):
  function _pdist (line 223) | def _pdist(a, b):
  function _nn_euclidean_distance (line 246) | def _nn_euclidean_distance(x, y):
  function _nn_cosine_distance (line 266) | def _nn_cosine_distance(x, y):
  class NearestNeighborDistanceMetric (line 286) | class NearestNeighborDistanceMetric(object):
    method __init__ (line 307) | def __init__(self, metric, matching_threshold, budget=None):
    method partial_fit (line 318) | def partial_fit(self, features, targets, active_targets):
    method distance (line 335) | def distance(self, features, targets):

FILE: boxmot/trackers/strongsort/sort/track.py
  class TrackState (line 10) | class TrackState:
  class Track (line 25) | class Track:
    method __init__ (line 72) | def __init__(
    method to_tlwh (line 110) | def to_tlwh(self):
    method to_tlbr (line 125) | def to_tlbr(self):
    method camera_update (line 139) | def camera_update(self, warp_matrix):
    method increment_age (line 150) | def increment_age(self):
    method predict (line 154) | def predict(self):
    method update (line 162) | def update(self, detection):
    method mark_missed (line 191) | def mark_missed(self):
    method is_tentative (line 198) | def is_tentative(self):
    method is_confirmed (line 202) | def is_confirmed(self):
    method is_deleted (line 206) | def is_deleted(self):

FILE: boxmot/trackers/strongsort/sort/tracker.py
  class Tracker (line 13) | class Tracker:
    method __init__ (line 40) | def __init__(
    method predict (line 62) | def predict(self):
    method increment_ages (line 70) | def increment_ages(self):
    method update (line 75) | def update(self, detections):
    method _match (line 108) | def _match(self, detections):
    method _initiate_track (line 159) | def _initiate_track(self, detection):

FILE: boxmot/trackers/strongsort/strongsort.py
  class StrongSort (line 18) | class StrongSort(BaseTracker):
    method __init__ (line 51) | def __init__(
    method update (line 92) | def update(
    method reset (line 166) | def reset(self):

FILE: boxmot/trackers/strongsort/strongsort_kf.py
  class KalmanFilter (line 23) | class KalmanFilter(object):
    method __init__ (line 40) | def __init__(self):
    method initiate (line 56) | def initiate(self, measurement):
    method predict (line 90) | def predict(self, mean, covariance):
    method project (line 129) | def project(self, mean, covariance, confidence=0.0):
    method update (line 163) | def update(self, mean, covariance, measurement, confidence=0.0):
    method gating_distance (line 201) | def gating_distance(self, mean, covariance, measurements, only_positio...

FILE: boxmot/trackers/tracker_zoo.py
  function get_tracker_config (line 22) | def get_tracker_config(tracker_type):
  function create_tracker (line 27) | def create_tracker(

FILE: boxmot/utils/__init__.py
  function _is_main_process (line 36) | def _is_main_process(record):
  function configure_logging (line 40) | def configure_logging(main_only: bool = True):

FILE: boxmot/utils/analysis/mot_ds_kf_tuning.py
  function load_gt_data (line 12) | def load_gt_data(seq_dir: Path, annotations_dir: Path = None, use_temp_g...
  function build_tracks_from_sequence (line 37) | def build_tracks_from_sequence(
  function main (line 93) | def main(

FILE: boxmot/utils/analysis/mot_seq_bb_plot.py
  function plot_gt_boxes_with_trajectories (line 14) | def plot_gt_boxes_with_trajectories(

FILE: boxmot/utils/analysis/ray_results.py
  function is_pareto_efficient (line 20) | def is_pareto_efficient(points: np.ndarray) -> np.ndarray:
  function plot_metrics_by_trial (line 42) | def plot_metrics_by_trial(df, metrics=("HOTA", "MOTA", "IDF1"), exp_path...
  function main (line 82) | def main():

FILE: boxmot/utils/association.py
  function speed_direction_batch (line 8) | def speed_direction_batch(dets, tracks):
  function linear_assignment (line 20) | def linear_assignment(cost_matrix):
  function compute_aw_max_metric (line 35) | def compute_aw_max_metric(emb_cost, w_association_emb, bottom=0.5):
  function associate (line 67) | def associate(
  function associate_kitti (line 161) | def associate_kitti(

FILE: boxmot/utils/checks.py
  class RequirementsChecker (line 16) | class RequirementsChecker:
    method __init__ (line 28) | def __init__(
    method check_packages (line 40) | def check_packages(
    method sync_extra (line 78) | def sync_extra(
    method _install_packages (line 119) | def _install_packages(

FILE: boxmot/utils/clean.py
  function cleanup_mot17 (line 5) | def cleanup_mot17(data_dir, keep_detection='FRCNN'):

FILE: boxmot/utils/custom_mot_challenge_2d_box.py
  class CustomMotChallenge2DBox (line 18) | class CustomMotChallenge2DBox(MotChallenge2DBox):
    method get_default_dataset_config (line 22) | def get_default_dataset_config():
    method __init__ (line 30) | def __init__(self, config=None):
    method get_preprocessed_seq_data (line 65) | def get_preprocessed_seq_data(self, raw_data, cls):

FILE: boxmot/utils/dataloaders/dataset.py
  function read_seq_fps (line 78) | def read_seq_fps(seq_dir: Path) -> int:
  function compute_fps_mask (line 98) | def compute_fps_mask(frames: np.ndarray, orig_fps: int, target_fps: int)...
  class MOTDataset (line 115) | class MOTDataset:
    method __init__ (line 132) | def __init__(
    method _index_sequences (line 153) | def _index_sequences(self) -> None:
    method sequence_names (line 184) | def sequence_names(self) -> List[str]:
    method get_sequence (line 188) | def get_sequence(self, name: str) -> "MOTSequence":
  class MOTSequence (line 202) | class MOTSequence:
    method __init__ (line 225) | def __init__(self, name: str, meta: Dict, target_fps: Optional[int]):
    method _prepare (line 235) | def _prepare(self) -> None:
    method __iter__ (line 284) | def __iter__(self) -> Generator[Dict[str, Union[int, np.ndarray]], Non...
  function process_sequences_lazily (line 316) | def process_sequences_lazily(dataset: MOTDataset) -> None:

FILE: boxmot/utils/dataloaders/video.py
  class LazyDataLoader (line 11) | class LazyDataLoader:
    method __init__ (line 12) | def __init__(self, source: Union[str, int, Path]):
    method __iter__ (line 16) | def __iter__(self):
    method _get_generator (line 19) | def _get_generator(self) -> Generator:
    method _load_from_csv (line 46) | def _load_from_csv(self, csv_path: str) -> Generator:
    method _load_from_video (line 53) | def _load_from_video(self, video_path: str) -> Generator:
    method _load_from_directory (line 65) | def _load_from_directory(self, path: str) -> Generator:
    method _load_from_glob (line 70) | def _load_from_glob(self, pattern: str) -> Generator:
    method _load_from_youtube (line 74) | def _load_from_youtube(self, url: str) -> Generator:
    method _load_from_stream (line 85) | def _load_from_stream(self, url: str) -> Generator:
    method _load_from_stream_list (line 97) | def _load_from_stream_list(self, file_path: str) -> Generator[List[np....
    method _load_from_webcam (line 118) | def _load_from_webcam(self, index: int) -> Generator:

FILE: boxmot/utils/download.py
  function get_http_session (line 24) | def get_http_session(retries: int = 3, backoff_factor: float = 0.3) -> r...
  function download_file (line 39) | def download_file(url: str, dest: Path, chunk_size: int = 8192, overwrit...
  function extract_zip (line 81) | def extract_zip(zip_path: Path, extract_to: Path, overwrite: bool = Fals...
  function patch_deprecated_types (line 116) | def patch_deprecated_types(root: Path, deprecated: dict = DEPRECATED_TYP...
  function download_trackeval (line 130) | def download_trackeval(dest: Path, branch: str = "master", overwrite: bo...
  function download_hf_dataset (line 180) | def download_hf_dataset(repo_id: str, dest: Path, overwrite: bool = Fals...
  function download_eval_data (line 249) | def download_eval_data(

FILE: boxmot/utils/iou.py
  function iou_obb_pair (line 5) | def iou_obb_pair(i, j, bboxes1, bboxes2):
  class AssociationFunction (line 38) | class AssociationFunction:
    method __init__ (line 39) | def __init__(self, w, h, asso_mode="iou"):
    method iou_batch (line 54) | def iou_batch(bboxes1, bboxes2) -> np.ndarray:
    method iou_batch_obb (line 73) | def iou_batch_obb(bboxes1, bboxes2) -> np.ndarray:
    method hmiou_batch (line 83) | def hmiou_batch(bboxes1, bboxes2):
    method giou_batch (line 133) | def giou_batch(bboxes1, bboxes2) -> np.ndarray:
    method centroid_batch (line 174) | def centroid_batch(self, bboxes1, bboxes2) -> np.ndarray:
    method centroid_batch_obb (line 189) | def centroid_batch_obb(self, bboxes1, bboxes2) -> np.ndarray:
    method ciou_batch (line 203) | def ciou_batch(bboxes1, bboxes2) -> np.ndarray:
    method diou_batch (line 270) | def diou_batch(bboxes1, bboxes2) -> np.ndarray:
    method run_asso_func (line 313) | def run_asso_func(self, bboxes1, bboxes2):
    method _get_asso_func (line 323) | def _get_asso_func(self, asso_mode):

FILE: boxmot/utils/matching.py
  function linear_assignment (line 28) | def linear_assignment(cost_matrix, thresh):
  function iou_distance (line 46) | def iou_distance(atracks, btracks, is_obb: bool = False):
  function embedding_distance (line 85) | def embedding_distance(tracks, detections, metric="cosine"):
  function fuse_motion (line 110) | def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False...
  function fuse_iou (line 125) | def fuse_iou(cost_matrix, tracks, detections):
  function fuse_score (line 139) | def fuse_score(cost_matrix, detections):

FILE: boxmot/utils/misc.py
  function parse_imgsz (line 10) | def parse_imgsz(ctx, param, value):
  function resolve_model_path (line 41) | def resolve_model_path(model_path, default_dir: Path = WEIGHTS) -> Path:
  function increment_path (line 57) | def increment_path(path, exist_ok=False, sep="", mkdir=False):
  function prompt_overwrite (line 90) | def prompt_overwrite(path_type: str, path: Path, ci: bool = True) -> bool:

FILE: boxmot/utils/mot_utils.py
  function split_dataset (line 16) | def split_dataset(src_fldr: Path, percent_to_delete: float = 0.5) -> Tup...
  function convert_to_mot_format (line 92) | def convert_to_mot_format(
  function write_mot_results (line 143) | def write_mot_results(txt_path: Path, mot_results: np.ndarray) -> None:

FILE: boxmot/utils/ops.py
  function xyxy2xywh (line 10) | def xyxy2xywh(x):
  function xywh2xyxy (line 27) | def xywh2xyxy(x):
  function xywh2tlwh (line 46) | def xywh2tlwh(x):
  function tlwh2xyxy (line 64) | def tlwh2xyxy(x):
  function xyxy2tlwh (line 77) | def xyxy2tlwh(x):
  function tlwh2xyah (line 90) | def tlwh2xyah(x):
  function xyxy2xysr (line 103) | def xyxy2xysr(x):
  function letterbox (line 127) | def letterbox(

FILE: boxmot/utils/plots.py
  class MetricsPlotter (line 7) | class MetricsPlotter:
    method __init__ (line 32) | def __init__(self, root_folder: str = '.'):
    method plot_radar_chart (line 46) | def plot_radar_chart(self,
    method plot_fps_metrics (line 127) | def plot_fps_metrics(self,

FILE: boxmot/utils/timing.py
  class TimingStats (line 8) | class TimingStats:
    method __init__ (line 11) | def __init__(self):
    method reset (line 14) | def reset(self):
    method start_frame (line 29) | def start_frame(self):
    method start_tracking (line 33) | def start_tracking(self):
    method end_tracking (line 37) | def end_tracking(self):
    method get_last_track_time (line 45) | def get_last_track_time(self):
    method get_last_reid_time (line 49) | def get_last_reid_time(self):
    method reset_frame_reid (line 53) | def reset_frame_reid(self):
    method start_plot (line 57) | def start_plot(self):
    method end_plot (line 61) | def end_plot(self):
    method add_reid_time (line 67) | def add_reid_time(self, time_ms):
    method record_ultralytics_times (line 73) | def record_ultralytics_times(self, predictor):
    method end_frame (line 84) | def end_frame(self):
    method print_summary (line 91) | def print_summary(self):
  class TimedReIDWrapper (line 209) | class TimedReIDWrapper:
    method __init__ (line 212) | def __init__(self, model, timing_stats):
    method get_features (line 216) | def get_features(self, *args, **kwargs):
    method __getattr__ (line 224) | def __getattr__(self, name):
  function wrap_tracker_reid (line 229) | def wrap_tracker_reid(tracker, timing_stats):

FILE: boxmot/utils/torch_utils.py
  function get_system_info (line 12) | def get_system_info():
  function parse_device (line 16) | def parse_device(device):
  function assert_cuda_available (line 32) | def assert_cuda_available(device):
  function select_device (line 50) | def select_device(device="", batch=0):

FILE: boxmot/utils/visualization.py
  class BaseVisualization (line 9) | class BaseVisualization(ABC):
    method id_to_color (line 14) | def id_to_color(
    method _draw_dashed_rect (line 40) | def _draw_dashed_rect(self, img, x1, y1, x2, y2, color, thickness, das...
    method _obb_to_polygon (line 53) | def _obb_to_polygon(box: tuple) -> np.ndarray:
    method plot_box_on_img (line 61) | def plot_box_on_img(
    method plot_trackers_trajectories (line 126) | def plot_trackers_trajectories(
    method _all_active_tracks (line 155) | def _all_active_tracks(self):
    method _infer_state (line 164) | def _infer_state(self, a):
    method _display_groups (line 196) | def _display_groups(self):
    method _draw_track (line 199) | def _draw_track(self, img, a, forced_state, style, thickness, fontscal...
    method plot_results (line 245) | def plot_results(
  class ExplicitStateVisualization (line 278) | class ExplicitStateVisualization(BaseVisualization):
    method _display_groups (line 283) | def _display_groups(self):
  class InferredStateVisualization (line 334) | class InferredStateVisualization(BaseVisualization):
    method _display_groups (line 339) | def _display_groups(self):
  class VisualizationMixin (line 349) | class VisualizationMixin(BaseVisualization):
    method _display_groups (line 354) | def _display_groups(self):

FILE: tests/performance/test_cmcs_p.py
  function cmc_object (line 16) | def cmc_object(request):
  function test_cmc_apply (line 23) | def test_cmc_apply(cmc_object):

FILE: tests/performance/test_tracking_p.py
  function test_motion_tracker_update_time (line 16) | def test_motion_tracker_update_time(tracker_type):
  function test_motion_n_appearance_tracker_update_time (line 62) | def test_motion_n_appearance_tracker_update_time(tracker_type):

FILE: tests/unit/test_base_backend.py
  class DummyBackend (line 10) | class DummyBackend(BaseModelBackend):
    method __init__ (line 11) | def __init__(self):
    method forward (line 19) | def forward(self, im_batch):
    method load_model (line 22) | def load_model(self, w):
  class InitOnlyBackend (line 26) | class InitOnlyBackend(BaseModelBackend):
    method forward (line 27) | def forward(self, im_batch):
    method load_model (line 30) | def load_model(self, w):
  function test_boxes_to_xyxy_keeps_aabb_boxes (line 34) | def test_boxes_to_xyxy_keeps_aabb_boxes():
  function test_boxes_to_xyxy_converts_obb_detections (line 43) | def test_boxes_to_xyxy_converts_obb_detections():
  function test_boxes_to_xyxy_converts_obb_track_outputs (line 52) | def test_boxes_to_xyxy_converts_obb_track_outputs():
  function test_get_crops_accepts_obb_boxes (line 61) | def test_get_crops_accepts_obb_boxes():
  function test_get_crops_rectifies_rotated_obb_boxes (line 73) | def test_get_crops_rectifies_rotated_obb_boxes():
  function test_base_backend_preserves_explicit_export_paths (line 88) | def test_base_backend_preserves_explicit_export_paths(monkeypatch):

FILE: tests/unit/test_cmcs_u.py
  function cmc_object (line 12) | def cmc_object(request):
  function test_cmc_apply (line 19) | def test_cmc_apply(cmc_object):
  function test_cmc_preprocess (line 31) | def test_cmc_preprocess(cmc_object):
  function test_cmc_apply_empty_detections (line 41) | def test_cmc_apply_empty_detections(cmc_object):

FILE: tests/unit/test_cuda.py
  function test_reidbackend_device (line 14) | def test_reidbackend_device(reid_model):
  function test_reidbackend_half (line 28) | def test_reidbackend_half(reid_model):

FILE: tests/unit/test_dataloader.py
  function test_read_seq_fps (line 14) | def test_read_seq_fps(tmp_path):
  function test_compute_fps_mask (line 30) | def test_compute_fps_mask():
  function simple_sequence (line 39) | def simple_sequence(tmp_path):
  function test_dataset_indexing_and_iteration (line 96) | def test_dataset_indexing_and_iteration(simple_sequence):
  function test_unknown_sequence_raises (line 119) | def test_unknown_sequence_raises(simple_sequence):
  function test_mismatched_dets_embs_raise (line 125) | def test_mismatched_dets_embs_raise(tmp_path, simple_sequence):
  function test_fps_downsampling_and_gt_temp (line 148) | def test_fps_downsampling_and_gt_temp(tmp_path):

FILE: tests/unit/test_exporters_dynamic.py
  function _load_existing_osnet_model_and_input (line 14) | def _load_existing_osnet_model_and_input(batch_size=2):
  function _install_fake_onnx (line 29) | def _install_fake_onnx(monkeypatch):
  function _disable_dep_sync (line 41) | def _disable_dep_sync(monkeypatch):
  function test_onnx_export_dynamic_uses_dynamic_shapes (line 46) | def test_onnx_export_dynamic_uses_dynamic_shapes(monkeypatch, tmp_path, ...
  function test_onnx_export_dynamic_fallback_uses_dynamic_axes (line 73) | def test_onnx_export_dynamic_fallback_uses_dynamic_axes(monkeypatch, tmp...
  function test_onnx_export_static_has_no_dynamic_shapes (line 104) | def test_onnx_export_static_has_no_dynamic_shapes(monkeypatch, tmp_path,...

FILE: tests/unit/test_inference.py
  class _TensorWrapper (line 14) | class _TensorWrapper:
    method __init__ (line 15) | def __init__(self, array: np.ndarray):
    method cpu (line 18) | def cpu(self):
    method numpy (line 21) | def numpy(self):
    method shape (line 25) | def shape(self):
  class _PredictionWrapper (line 29) | class _PredictionWrapper:
    method __init__ (line 30) | def __init__(self, array: np.ndarray):
    method __len__ (line 33) | def __len__(self):
  class _Result (line 37) | class _Result:
    method __init__ (line 38) | def __init__(self, boxes=None, obb=None):
  class _DummyTracker (line 43) | class _DummyTracker(BaseTracker):
    method update (line 46) | def update(self, dets: np.ndarray, img: np.ndarray, embs: np.ndarray =...
    method _display_groups (line 50) | def _display_groups(self):
  class _DummyOBBTracker (line 54) | class _DummyOBBTracker(_DummyTracker):
  function test_extract_detections_reads_aabb_results (line 58) | def test_extract_detections_reads_aabb_results():
  function test_extract_detections_reads_obb_results (line 68) | def test_extract_detections_reads_obb_results():
  function test_extract_detections_preserves_empty_obb_width (line 81) | def test_extract_detections_preserves_empty_obb_width():
  function test_filter_detections_keeps_valid_obb_boxes (line 89) | def test_filter_detections_keeps_valid_obb_boxes():
  function test_tracker_infers_obb_mode_on_empty_followup_frame (line 104) | def test_tracker_infers_obb_mode_on_empty_followup_frame():
  function test_tracker_layout_helpers_switch_with_detection_mode (line 117) | def test_tracker_layout_helpers_switch_with_detection_mode():
  function test_tracker_rejects_obb_when_not_supported (line 131) | def test_tracker_rejects_obb_when_not_supported():
  function test_ocsort_obb_state_roundtrip_handles_column_vectors (line 147) | def test_ocsort_obb_state_roundtrip_handles_column_vectors():
  function test_iou_obb_pair_accepts_column_like_inputs_and_radians (line 157) | def test_iou_obb_pair_accepts_column_like_inputs_and_radians():
  function test_resolve_yolo_model_path_routes_non_rtdetr_to_weights_dir (line 166) | def test_resolve_yolo_model_path_routes_non_rtdetr_to_weights_dir():
  function test_resolve_yolo_model_path_keeps_rtdetr_name_without_path_prefix (line 172) | def test_resolve_yolo_model_path_keeps_rtdetr_name_without_path_prefix():
  function test_ensure_model_extension_preserves_explicit_export_paths (line 179) | def test_ensure_model_extension_preserves_explicit_export_paths():
  function test_ensure_model_extension_keeps_bare_reid_names_in_weights_dir (line 187) | def test_ensure_model_extension_keeps_bare_reid_names_in_weights_dir():

FILE: tests/unit/test_kalman_filters_modes.py
  function _angle_diff (line 10) | def _angle_diff(a: float, b: float) -> float:
  function test_xywh_xyah_support_aabb_mode (line 29) | def test_xywh_xyah_support_aabb_mode(kf_cls, init_measurement, update_me...
  function test_xywh_xyah_support_obb_mode (line 60) | def test_xywh_xyah_support_obb_mode(kf_cls, init_measurement, update_mea...
  function test_xysr_supports_aabb_mode (line 76) | def test_xysr_supports_aabb_mode():
  function test_xysr_supports_obb_mode (line 95) | def test_xysr_supports_obb_mode():
  function test_xysr_obb_aligns_equivalent_ratio_angle_forms (line 116) | def test_xysr_obb_aligns_equivalent_ratio_angle_forms():
  function test_xysr_obb_unfreeze_handles_angle_wrap (line 140) | def test_xysr_obb_unfreeze_handles_angle_wrap():
  function test_xysr_unfreeze_with_column_vectors (line 164) | def test_xysr_unfreeze_with_column_vectors():
  function test_xysr_unfreeze_insufficient_history (line 196) | def test_xysr_unfreeze_insufficient_history():
  function test_xyhr_supports_aabb_mode_and_column_measurement (line 223) | def test_xyhr_supports_aabb_mode_and_column_measurement():
  function test_xyhr_supports_obb_mode_and_inference (line 237) | def test_xyhr_supports_obb_mode_and_inference():

FILE: tests/unit/test_postprocessing.py
  function test_gsi (line 8) | def test_gsi():
  function test_gbrc (line 22) | def test_gbrc():

FILE: tests/unit/test_reidbackend.py
  function get_backend (line 23) | def get_backend(weights: Path, requires_export: bool):
  function test_reidbackend_output (line 33) | def test_reidbackend_output(reid_model, _, requires_export):
  function test_reidbackend_type (line 48) | def test_reidbackend_type(reid_model, backend, requires_export):

FILE: tests/unit/test_tflite_backend.py
  class DummyChecker (line 7) | class DummyChecker:
    method __init__ (line 8) | def __init__(self):
    method check_packages (line 11) | def check_packages(self, requirements):
  function make_backend (line 15) | def make_backend() -> TFLiteBackend:
  function test_tflite_backend_prefers_litert_interpreter (line 21) | def test_tflite_backend_prefers_litert_interpreter(monkeypatch):
  function test_tflite_backend_installs_litert_when_no_runtime_is_available (line 38) | def test_tflite_backend_installs_litert_when_no_runtime_is_available(mon...

FILE: tests/unit/test_tflite_exporter.py
  function _disable_dep_sync (line 14) | def _disable_dep_sync(monkeypatch):
  function _install_fake_tflite_stack (line 18) | def _install_fake_tflite_stack(monkeypatch, convert_impl):
  function test_tflite_export_uses_flatbuffer_direct_and_prefers_float32 (line 28) | def test_tflite_export_uses_flatbuffer_direct_and_prefers_float32(monkey...
  function test_tflite_export_generates_onnx_when_missing (line 71) | def test_tflite_export_generates_onnx_when_missing(monkeypatch, tmp_path):
  function test_create_export_tasks_passes_tflite_export_settings (line 128) | def test_create_export_tasks_passes_tflite_export_settings():

FILE: tests/unit/test_trackers.py
  function test_motion_n_appearance_trackers_instantiation (line 34) | def test_motion_n_appearance_trackers_instantiation(Tracker):
  function test_motion_only_trackers_instantiation (line 43) | def test_motion_only_trackers_instantiation(Tracker):
  function test_tracker_output_size (line 48) | def test_tracker_output_size(tracker_type):
  function test_dynamic_max_obs_based_on_max_age (line 66) | def test_dynamic_max_obs_based_on_max_age():
  function create_kalman_box_tracker_ocsort (line 72) | def create_kalman_box_tracker_ocsort(bbox, cls, det_ind, tracker):
  function create_kalman_box_tracker_deepocsort (line 82) | def create_kalman_box_tracker_deepocsort(bbox, cls, det_ind, tracker):
  function test_Q_matrix_scaling (line 109) | def test_Q_matrix_scaling(Tracker, init_args):
  function test_per_class_tracker_output_size (line 126) | def test_per_class_tracker_output_size(tracker_type):
  function test_per_class_tracker_active_tracks (line 150) | def test_per_class_tracker_active_tracks(tracker_type):
  function test_botsort_supports_obb_without_reid (line 173) | def test_botsort_supports_obb_without_reid():
  function test_botsort_obb_matching_uses_oriented_geometry (line 192) | def test_botsort_obb_matching_uses_oriented_geometry():
  function test_botsort_obb_state_history_follows_rotation_without_flips (line 203) | def test_botsort_obb_state_history_follows_rotation_without_flips():
  function test_bytetrack_supports_obb_outputs (line 225) | def test_bytetrack_supports_obb_outputs():
  function test_bytetrack_obb_matching_uses_oriented_geometry (line 238) | def test_bytetrack_obb_matching_uses_oriented_geometry():
  function test_bytetrack_obb_state_history_follows_rotation_without_flips (line 249) | def test_bytetrack_obb_state_history_follows_rotation_without_flips():
  function test_ocsort_obb_state_history_uses_state_corners (line 266) | def test_ocsort_obb_state_history_uses_state_corners():
  function test_ocsort_obb_state_history_uses_post_update_state_center (line 281) | def test_ocsort_obb_state_history_uses_post_update_state_center():
  function test_sfsort_obb_state_history_uses_state_corners (line 302) | def test_sfsort_obb_state_history_uses_state_corners():
  function test_sfsort_supports_obb_outputs (line 317) | def test_sfsort_supports_obb_outputs():
  function test_sfsort_obb_angle_update_uses_damping (line 330) | def test_sfsort_obb_angle_update_uses_damping():
  function test_sfsort_obb_plotting_draws_tracks (line 349) | def test_sfsort_obb_plotting_draws_tracks():
  function test_tracker_with_no_detections (line 362) | def test_tracker_with_no_detections(tracker_type, dets):
  function test_per_class_isolation (line 381) | def test_per_class_isolation(tracker_type):
  function test_emb_trackers_requires_embeddings (line 404) | def test_emb_trackers_requires_embeddings(tracker_type):
  function test_invalid_det_array_shape (line 421) | def test_invalid_det_array_shape(tracker_type):
  function test_track_id_stable_over_frames (line 444) | def test_track_id_stable_over_frames(tracker_type):
  function test_create_tracker_invalid_tracker_name (line 476) | def test_create_tracker_invalid_tracker_name():

FILE: tests/unit/test_visualization.py
  class MockTracker (line 7) | class MockTracker(VisualizationMixin):
    method __init__ (line 8) | def __init__(self):
  class MockTrack (line 20) | class MockTrack:
    method __init__ (line 21) | def __init__(self, id, history, state="confirmed", conf=0.9, cls=0):
    method get_state (line 32) | def get_state(self):
  class TestVisualization (line 35) | class TestVisualization(unittest.TestCase):
    method setUp (line 36) | def setUp(self):
    method test_plot_results_regular (line 40) | def test_plot_results_regular(self):
    method test_plot_results_show_lost (line 57) | def test_plot_results_show_lost(self):
    method test_plot_results_hide_lost (line 75) | def test_plot_results_hide_lost(self):
    method test_dashed_rect (line 92) | def test_dashed_rect(self):

FILE: tests/unit/test_yolox_batch.py
  function test_get_yolo_inferer_routes_yolox_model (line 6) | def test_get_yolo_inferer_routes_yolox_model():
  function test_get_yolo_inferer_returns_callable_strategy_for_yolox (line 11) | def test_get_yolo_inferer_returns_callable_strategy_for_yolox():
  function test_get_yolo_inferer_accepts_common_yolox_names (line 17) | def test_get_yolo_inferer_accepts_common_yolox_names(name):