def calc_accuracy(gt_trajectory, pred_trajectory, burnin=10, ignore_unknown=True, video_wh=None): """Calculate accuracy over the sequence. Args: gt_trajectory (list[list]): list of bboxes pred_trajectory (list[ndarray]): The outer list contains the tracking results of each frame in one video. The ndarray has two cases: - bbox: denotes the normal tracking box in [x1, y1, w, h] format. - special tracking state: [0] denotes the unknown state, namely the skipping frame after failure, [1] denotes the initialized state, and [2] denotes the failed state. burnin: number of frames that have to be ignored after the re-initialization when calculating accuracy. Default is 10. ignore_unknown (bool): whether ignore the skipping frames after failures when calculating accuracy. Default is True. video_wh: bounding region (width, height) Return: Float: accuracy over the sequence. """ pred_traj_region = trajectory2region(pred_trajectory) gt_traj_region = trajectory2region(gt_trajectory) overlaps = np.array( calculate_region_overlaps(pred_traj_region, gt_traj_region, video_wh)) mask = np.ones(len(overlaps), dtype=bool) for i, region in enumerate(pred_traj_region): if is_special(region, Special.UNKNOWN) and ignore_unknown: mask[i] = False elif is_special(region, Special.INITIALIZATION): for j in range(i, min(len(pred_traj_region), i + burnin)): mask[j] = False elif is_special(region, Special.FAILURE): mask[i] = False return np.mean(overlaps[mask]) if any(mask) else 0.
def compute_accuracy(trajectory: List[Region], sequence: Sequence, burnin: int = 10, ignore_unknown: bool = True, bounded: bool = True) -> float: overlaps = np.array( calculate_overlaps(trajectory, sequence.groundtruth(), (sequence.size) if bounded else None)) mask = np.ones(len(overlaps), dtype=bool) for i, region in enumerate(trajectory): if is_special(region, Special.UNKNOWN) and ignore_unknown: mask[i] = False elif is_special(region, Special.INITIALIZATION): for j in range(i, min(len(trajectory), i + burnin)): mask[j] = False elif is_special(region, Special.FAILURE): mask[i] = False return np.mean(overlaps[mask]), np.sum(mask)
def locate_failures_inits(trajectory: List[Region]) -> Tuple[int, int]: return [i for i, region in enumerate(trajectory) if is_special(region, Special.FAILURE)], \ [i for i, region in enumerate(trajectory) if is_special(region, Special.INITIALIZATION)]
def count_failures(trajectory: List[Region]) -> Tuple[int, int]: return len([ region for region in trajectory if is_special(region, Special.FAILURE) ]), len(trajectory)