SYMBOL INDEX (1308 symbols across 167 files)

FILE: EgoTracks/tools/eval_datasets/build.py
  function build_eval_function (line 13) | def build_eval_function(dataset_name):
  function build_calculate_metrics_function (line 17) | def build_calculate_metrics_function(dataset_name):

FILE: EgoTracks/tools/eval_datasets/eval_ego4d_lt_tracking.py
  function trivial_batch_collator (line 28) | def trivial_batch_collator(batch):
  function eval_ego4d_lt_tracking (line 35) | def eval_ego4d_lt_tracking(model, cfg):
  function gather_ego4d_lt_tracking_result (line 168) | def gather_ego4d_lt_tracking_result(result):

FILE: EgoTracks/tools/eval_net.py
  function modify_STARK_cfg_by_dataset (line 27) | def modify_STARK_cfg_by_dataset(cfg, dataset_name):
  function eval_main (line 40) | def eval_main(args, cfg=None):
  function calculate_metrics (line 69) | def calculate_metrics(args):

FILE: EgoTracks/tools/preprocess/extract_ego4d_clip_frames.py
  class ExtractFramesWorkflowParams (line 20) | class ExtractFramesWorkflowParams(NamedTuple):
  function run_single_process (line 29) | def run_single_process(clip_uid: str, params: ExtractFramesWorkflowParams):
  function extract_clip_ids (line 62) | def extract_clip_ids(file_path: str):
  function remove_finished_clip_uids (line 73) | def remove_finished_clip_uids(clip_uids: List, params: ExtractFramesWork...
  function read_csv (line 86) | def read_csv(path: str):
  function combine_clip_info (line 94) | def combine_clip_info(params):
  function main (line 110) | def main():

FILE: EgoTracks/tools/train_net.py
  function train_main (line 89) | def train_main(args):
  function run_train (line 162) | def run_train(
  function result2submission (line 192) | def result2submission(args):
  function main (line 224) | def main():

FILE: EgoTracks/tools/trainers/base_trainer.py
  function build_loss_function (line 25) | def build_loss_function(cfg):
  class BaseTrainer (line 36) | class BaseTrainer:
    method __init__ (line 40) | def __init__(self, cfg):
    method train (line 89) | def train(
    method train_epoch (line 139) | def train_epoch(self):
    method save_checkpoint (line 142) | def save_checkpoint(self):
    method load_checkpoint (line 169) | def load_checkpoint(
  class StatValue (line 281) | class StatValue:
    method __init__ (line 282) | def __init__(self):
    method reset (line 285) | def reset(self):
    method clear (line 288) | def clear(self):
    method update (line 292) | def update(self, val):
  class AverageMeter (line 297) | class AverageMeter(object):
    method __init__ (line 300) | def __init__(self):
    method reset (line 304) | def reset(self):
    method clear (line 310) | def clear(self):
    method update (line 314) | def update(self, val, n=1):
    method new_epoch (line 320) | def new_epoch(self):

FILE: EgoTracks/tools/trainers/starkst_trainer.py
  class STARKSTrainer (line 19) | class STARKSTrainer(BaseTrainer):
    method __init__ (line 20) | def __init__(self, cfg):
    method _set_default_settings (line 32) | def _set_default_settings(self):
    method cycle_dataset (line 40) | def cycle_dataset(self, loader):
    method forward_and_compute_loss (line 76) | def forward_and_compute_loss(self, data):
    method forward_pass (line 90) | def forward_pass(self, data, run_box_head, run_cls_head):
    method compute_losses (line 128) | def compute_losses(self, pred_dict, gt_bbox, return_status=True):
    method train_epoch (line 178) | def train_epoch(self):
    method _init_timing (line 191) | def _init_timing(self):
    method _update_stats (line 196) | def _update_stats(self, new_stats: OrderedDict, batch_size, loader):
    method _print_stats (line 208) | def _print_stats(self, i, loader, batch_size):
    method _stats_new_epoch (line 233) | def _stats_new_epoch(self):
  class STARKSTTrainer (line 255) | class STARKSTTrainer(STARKSTrainer):
    method __init__ (line 256) | def __init__(self, cfg):
    method compute_losses (line 263) | def compute_losses(self, pred_dict, labels, return_status=True):
    method forward_and_compute_loss (line 279) | def forward_and_compute_loss(self, data):

FILE: EgoTracks/tracking/config/config.py
  function get_cfg (line 7) | def get_cfg(model_type):

FILE: EgoTracks/tracking/dataset/base_image_dataset.py
  class BaseImageDataset (line 5) | class BaseImageDataset(torch.utils.data.Dataset):
    method __init__ (line 8) | def __init__(self, name, root, image_loader=opencv_loader):
    method __len__ (line 22) | def __len__(self):
    method __getitem__ (line 29) | def __getitem__(self, index):
    method get_name (line 33) | def get_name(self):
    method get_num_images (line 41) | def get_num_images(self):
    method has_class_info (line 48) | def has_class_info(self):
    method get_class_name (line 51) | def get_class_name(self, image_id):
    method get_num_classes (line 54) | def get_num_classes(self):
    method get_class_list (line 57) | def get_class_list(self):
    method get_images_in_class (line 60) | def get_images_in_class(self, class_name):
    method has_segmentation_info (line 63) | def has_segmentation_info(self):
    method get_image_info (line 66) | def get_image_info(self, seq_id):
    method get_image (line 77) | def get_image(self, image_id, anno=None):

FILE: EgoTracks/tracking/dataset/base_video_dataset.py
  class BaseVideoDataset (line 5) | class BaseVideoDataset(torch.utils.data.Dataset):
    method __init__ (line 8) | def __init__(self, name, root, image_loader=opencv_loader):
    method __len__ (line 22) | def __len__(self):
    method __getitem__ (line 29) | def __getitem__(self, index):
    method is_video_sequence (line 33) | def is_video_sequence(self):
    method is_synthetic_video_dataset (line 41) | def is_synthetic_video_dataset(self):
    method get_name (line 49) | def get_name(self):
    method get_num_sequences (line 57) | def get_num_sequences(self):
    method has_class_info (line 64) | def has_class_info(self):
    method has_occlusion_info (line 67) | def has_occlusion_info(self):
    method get_num_classes (line 70) | def get_num_classes(self):
    method get_class_list (line 73) | def get_class_list(self):
    method get_sequences_in_class (line 76) | def get_sequences_in_class(self, class_name):
    method has_segmentation_info (line 79) | def has_segmentation_info(self):
    method get_sequence_info (line 82) | def get_sequence_info(self, seq_id):
    method get_frames (line 93) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/build.py
  function names2datasets (line 21) | def names2datasets(name_list: List, cfg, image_loader=opencv_loader):
  function build_dataloaders (line 124) | def build_dataloaders(cfg, local_rank=-1):

FILE: EgoTracks/tracking/dataset/dataloader.py
  function _check_use_shared_memory (line 13) | def _check_use_shared_memory():
  function ltr_collate (line 22) | def ltr_collate(batch):
  function ltr_collate_stack1 (line 83) | def ltr_collate_stack1(batch):
  class LTRLoader (line 144) | class LTRLoader(torch.utils.data.dataloader.DataLoader):
    method __init__ (line 196) | def __init__(

FILE: EgoTracks/tracking/dataset/eval_datasets/base_dataset.py
  class BaseDataset (line 10) | class BaseDataset:
    method __init__ (line 13) | def __init__(self):
    method __len__ (line 16) | def __len__(self):
    method get_sequence_list (line 20) | def get_sequence_list(self):
  class Sequence (line 25) | class Sequence:
    method __init__ (line 28) | def __init__(
    method _ensure_start_frame (line 53) | def _ensure_start_frame(self):
    method _construct_init_data (line 74) | def _construct_init_data(self, init_data):
    method init_info (line 124) | def init_info(self):
    method frame_info (line 128) | def frame_info(self, frame_num):
    method init_bbox (line 132) | def init_bbox(self, frame_num=0):
    method init_mask (line 135) | def init_mask(self, frame_num=0):
    method get_info (line 138) | def get_info(self, keys, frame_num=None):
    method object_init_data (line 146) | def object_init_data(self, frame_num=None) -> Dict:
    method target_class (line 171) | def target_class(self, frame_num=None):
    method get (line 174) | def get(self, name, frame_num=None):
    method __repr__ (line 177) | def __repr__(self):
  class SequenceList (line 183) | class SequenceList(list):
    method __getitem__ (line 186) | def __getitem__(self, item):
    method __add__ (line 201) | def __add__(self, other):
    method copy (line 204) | def copy(self):
  function imread_indexed (line 208) | def imread_indexed(filename):

FILE: EgoTracks/tracking/dataset/eval_datasets/ego4d_lt_tracking_dataset.py
  class _EGO4DLTTrackingDataset (line 14) | class _EGO4DLTTrackingDataset(BaseDataset):
    method __init__ (line 17) | def __init__(self, data_dir, annotation_path, split=None):
    method get_sequences (line 29) | def get_sequences(self):
    method load_clip_info (line 52) | def load_clip_info(self, clip_info_path):
    method get_lt_track (line 58) | def get_lt_track(
    method __len__ (line 143) | def __len__(self):
  class EGO4DLTTrackingDataset (line 147) | class EGO4DLTTrackingDataset(torch.utils.data.Dataset):
    method __init__ (line 150) | def __init__(self, data_dir, annotation_path, ratio=1.0, split=None):
    method __getitem__ (line 163) | def __getitem__(self, index):
    method __len__ (line 168) | def __len__(self):

FILE: EgoTracks/tracking/dataset/processing/base_processing.py
  class BaseProcessing (line 5) | class BaseProcessing:
    method __init__ (line 10) | def __init__(
    method __call__ (line 34) | def __call__(self, data: TensorDict):

FILE: EgoTracks/tracking/dataset/processing/processing_utils.py
  function sample_target (line 13) | def sample_target(im, target_bb, search_area_factor, output_sz=None, mas...
  function transform_image_to_crop (line 91) | def transform_image_to_crop(
  function jittered_center_crop (line 124) | def jittered_center_crop(
  function transform_box_to_crop (line 170) | def transform_box_to_crop(

FILE: EgoTracks/tracking/dataset/processing/stark_processing.py
  function stack_tensors (line 8) | def stack_tensors(x):
  class STARKProcessing (line 14) | class STARKProcessing(BaseProcessing):
    method __init__ (line 24) | def __init__(
    method _get_jittered_box (line 52) | def _get_jittered_box(self, box, mode):
    method __call__ (line 73) | def __call__(self, data: TensorDict):

FILE: EgoTracks/tracking/dataset/trackingdataset.py
  function no_processing (line 7) | def no_processing(data):
  class TrackingDataset (line 11) | class TrackingDataset(torch.utils.data.Dataset):
    method __init__ (line 23) | def __init__(
    method __len__ (line 67) | def __len__(self):
    method _sample_visible_ids (line 70) | def _sample_visible_ids(
    method __getitem__ (line 111) | def __getitem__(self, index):
    method getitem (line 117) | def getitem(self):
    method getitem_cls (line 226) | def getitem_cls(self):
    method get_center_box (line 351) | def get_center_box(self, H, W, ratio=1 / 8):
    method sample_seq_from_dataset (line 355) | def sample_seq_from_dataset(self, dataset, is_video_dataset):
    method get_one_search (line 376) | def get_one_search(self):
    method get_frame_ids_trident (line 404) | def get_frame_ids_trident(self, visible):
    method get_frame_ids_stark (line 442) | def get_frame_ids_stark(self, visible, valid):

FILE: EgoTracks/tracking/dataset/train_datasets/coco_seq.py
  class MSCOCOSeq (line 13) | class MSCOCOSeq(BaseVideoDataset):
    method __init__ (line 36) | def __init__(
    method _get_sequence_list (line 84) | def _get_sequence_list(self):
    method is_video_sequence (line 90) | def is_video_sequence(self):
    method get_num_classes (line 93) | def get_num_classes(self):
    method get_name (line 96) | def get_name(self):
    method has_class_info (line 99) | def has_class_info(self):
    method get_class_list (line 102) | def get_class_list(self):
    method has_segmentation_info (line 108) | def has_segmentation_info(self):
    method get_num_sequences (line 111) | def get_num_sequences(self):
    method _build_seq_per_class (line 114) | def _build_seq_per_class(self):
    method get_sequences_in_class (line 125) | def get_sequences_in_class(self, class_name):
    method get_sequence_info (line 128) | def get_sequence_info(self, seq_id):
    method _get_anno (line 142) | def _get_anno(self, seq_id):
    method _get_frames (line 147) | def _get_frames(self, seq_id):
    method get_meta_info (line 154) | def get_meta_info(self, seq_id):
    method get_class_name (line 180) | def get_class_name(self, seq_id):
    method get_frames (line 186) | def get_frames(self, seq_id=None, frame_ids=None, anno=None):

FILE: EgoTracks/tracking/dataset/train_datasets/ego4d_lt_tracking.py
  class EGO4DLTT (line 14) | class EGO4DLTT(BaseVideoDataset):
    method __init__ (line 17) | def __init__(
    method get_sequence_info (line 38) | def get_sequence_info(self, seq_id):
    method get_name (line 50) | def get_name(self):
    method _get_bbox_from_lt_tracking (line 53) | def _get_bbox_from_lt_tracking(self, seq_id):
    method _get_frame (line 63) | def _get_frame(self, frame_path):
    method get_frames (line 66) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/train_datasets/ego4d_vq.py
  class Ego4DVQ (line 12) | class Ego4DVQ(BaseVideoDataset):
    method __init__ (line 15) | def __init__(
    method get_sequence_info (line 38) | def get_sequence_info(self, seq_id):
    method get_name (line 50) | def get_name(self):
    method _get_sequence_path (line 53) | def _get_sequence_path(self, seq_id):
    method _get_bbox_from_response_track (line 64) | def _get_bbox_from_response_track(self, seq_id):
    method _get_frame_path (line 83) | def _get_frame_path(self, seq_path, frame_id):
    method _get_frame (line 88) | def _get_frame(self, seq_path, frame_id):
    method get_frames (line 91) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/train_datasets/got10k.py
  class Got10k (line 16) | class Got10k(BaseVideoDataset):
    method __init__ (line 28) | def __init__(
    method get_name (line 111) | def get_name(self):
    method has_class_info (line 114) | def has_class_info(self):
    method has_occlusion_info (line 117) | def has_occlusion_info(self):
    method _load_meta_info (line 120) | def _load_meta_info(self):
    method _read_meta (line 126) | def _read_meta(self, seq_path):
    method _build_seq_per_class (line 151) | def _build_seq_per_class(self):
    method get_sequences_in_class (line 163) | def get_sequences_in_class(self, class_name):
    method _get_sequence_list (line 166) | def _get_sequence_list(self):
    method _read_bb_anno (line 172) | def _read_bb_anno(self, seq_path):
    method _read_target_visible (line 185) | def _read_target_visible(self, seq_path):
    method _get_sequence_path (line 200) | def _get_sequence_path(self, seq_id):
    method get_sequence_info (line 203) | def get_sequence_info(self, seq_id):
    method _get_frame_path (line 218) | def _get_frame_path(self, seq_path, frame_id):
    method _get_frame (line 223) | def _get_frame(self, seq_path, frame_id):
    method get_class_name (line 226) | def get_class_name(self, seq_id):
    method get_frames (line 231) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/train_datasets/lasot.py
  class Lasot (line 15) | class Lasot(BaseVideoDataset):
    method __init__ (line 27) | def __init__(
    method _build_sequence_list (line 63) | def _build_sequence_list(self, vid_ids=None, split=None):
    method _build_class_list (line 84) | def _build_class_list(self):
    method get_name (line 95) | def get_name(self):
    method has_class_info (line 98) | def has_class_info(self):
    method has_occlusion_info (line 101) | def has_occlusion_info(self):
    method get_num_sequences (line 104) | def get_num_sequences(self):
    method get_num_classes (line 107) | def get_num_classes(self):
    method get_sequences_in_class (line 110) | def get_sequences_in_class(self, class_name):
    method _read_bb_anno (line 113) | def _read_bb_anno(self, seq_path):
    method _read_target_visible (line 125) | def _read_target_visible(self, seq_path):
    method _get_sequence_path (line 139) | def _get_sequence_path(self, seq_id):
    method get_sequence_info (line 146) | def get_sequence_info(self, seq_id):
    method _get_frame_path (line 155) | def _get_frame_path(self, seq_path, frame_id):
    method _get_frame (line 160) | def _get_frame(self, seq_path, frame_id):
    method _get_class (line 163) | def _get_class(self, seq_path):
    method get_class_name (line 167) | def get_class_name(self, seq_id):
    method get_frames (line 173) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/train_datasets/tracking_net.py
  function list_sequences (line 15) | def list_sequences(root, set_ids):
  class TrackingNet (line 40) | class TrackingNet(BaseVideoDataset):
    method __init__ (line 52) | def __init__(
    method _load_class_info (line 103) | def _load_class_info(self):
    method get_name (line 125) | def get_name(self):
    method has_class_info (line 128) | def has_class_info(self):
    method get_sequences_in_class (line 131) | def get_sequences_in_class(self, class_name):
    method _read_bb_anno (line 134) | def _read_bb_anno(self, seq_id):
    method get_sequence_info (line 151) | def get_sequence_info(self, seq_id):
    method _get_frame (line 158) | def _get_frame(self, seq_id, frame_id):
    method _get_class (line 170) | def _get_class(self, seq_id):
    method get_class_name (line 174) | def get_class_name(self, seq_id):
    method get_frames (line 179) | def get_frames(self, seq_id, frame_ids, anno=None):

FILE: EgoTracks/tracking/dataset/transforms.py
  class Transform (line 9) | class Transform:
    method __init__ (line 34) | def __init__(self, *transforms):
    method __call__ (line 42) | def __call__(self, **inputs):
    method _split_inputs (line 68) | def _split_inputs(self, inputs):
    method __repr__ (line 85) | def __repr__(self):
  class TransformBase (line 94) | class TransformBase:
    method __init__ (line 97) | def __init__(self):
    method __call__ (line 104) | def __call__(self, **inputs):
    method _get_image_size (line 132) | def _get_image_size(self, inputs):
    method roll (line 148) | def roll(self):
    method transform_image (line 151) | def transform_image(self, image, *rand_params):
    method transform_coords (line 155) | def transform_coords(self, coords, image_shape, *rand_params):
    method transform_bbox (line 159) | def transform_bbox(self, bbox, image_shape, *rand_params):
    method transform_mask (line 183) | def transform_mask(self, mask, *rand_params):
    method transform_att (line 187) | def transform_att(self, att, *rand_params):
  class ToTensor (line 192) | class ToTensor(TransformBase):
    method transform_image (line 195) | def transform_image(self, image):
    method transfrom_mask (line 207) | def transfrom_mask(self, mask):
    method transform_att (line 211) | def transform_att(self, att):
  class ToTensorAndJitter (line 220) | class ToTensorAndJitter(TransformBase):
    method __init__ (line 223) | def __init__(self, brightness_jitter=0.0, normalize=True):
    method roll (line 228) | def roll(self):
    method transform_image (line 233) | def transform_image(self, image, brightness_factor):
    method transform_mask (line 243) | def transform_mask(self, mask, brightness_factor):
    method transform_att (line 249) | def transform_att(self, att, brightness_factor):
  class Normalize (line 258) | class Normalize(TransformBase):
    method __init__ (line 261) | def __init__(self, mean, std, inplace=False):
    method transform_image (line 267) | def transform_image(self, image):
  class ToGrayscale (line 271) | class ToGrayscale(TransformBase):
    method __init__ (line 274) | def __init__(self, probability=0.5):
    method roll (line 279) | def roll(self):
    method transform_image (line 282) | def transform_image(self, image, do_grayscale):
  class ToBGR (line 292) | class ToBGR(TransformBase):
    method transform_image (line 295) | def transform_image(self, image):
  class RandomHorizontalFlip (line 302) | class RandomHorizontalFlip(TransformBase):
    method __init__ (line 305) | def __init__(self, probability=0.5):
    method roll (line 309) | def roll(self):
    method transform_image (line 312) | def transform_image(self, image, do_flip):
    method transform_coords (line 319) | def transform_coords(self, coords, image_shape, do_flip):
    method transform_mask (line 326) | def transform_mask(self, mask, do_flip):
    method transform_att (line 333) | def transform_att(self, att, do_flip):
  class RandomHorizontalFlip_Norm (line 341) | class RandomHorizontalFlip_Norm(RandomHorizontalFlip):
    method __init__ (line 345) | def __init__(self, probability=0.5):
    method transform_coords (line 349) | def transform_coords(self, coords, image_shape, do_flip):

FILE: EgoTracks/tracking/metrics/miou.py
  function compute_overlaps (line 5) | def compute_overlaps(y_pred, y_gt):
  function mIoU (line 19) | def mIoU(y_pred, y_gt):

FILE: EgoTracks/tracking/models/multiple_object_tracker.py
  class MultipleObjectTracker (line 6) | class MultipleObjectTracker(Tracker):
    method __init__ (line 13) | def __init__(self, model):
    method inference (line 17) | def inference(self, video, meta_data):
    method run_model (line 21) | def run_model(self, img):
    method update_tracker (line 25) | def update_tracker(self, res):
    method init_tracker (line 29) | def init_tracker(self, img, meta):

FILE: EgoTracks/tracking/models/single_object_tracker.py
  class SingleObjectTracker (line 15) | class SingleObjectTracker(Tracker):
    method __init__ (line 22) | def __init__(self, model, verbose: bool = False):
    method inference_video_handler (line 31) | def inference_video_handler(
    method inference_sequence (line 36) | def inference_sequence(self, video: Sequence, meta_data: Dict = None) ...
    method inference_img_sequence (line 118) | def inference_img_sequence(
    method run_model (line 202) | def run_model(self, image: torch.Tensor) -> Dict:
    method update_tracker (line 217) | def update_tracker(self, result: Dict) -> None:
    method init_tracker (line 231) | def init_tracker(self, image: torch.Tensor, meta: Dict) -> None:
    method reset_tracker (line 243) | def reset_tracker(self) -> None:

FILE: EgoTracks/tracking/models/stark_tracker/backbone.py
  class FrozenBatchNorm2d (line 16) | class FrozenBatchNorm2d(torch.nn.Module):
    method __init__ (line 24) | def __init__(self, n):
    method _load_from_state_dict (line 31) | def _load_from_state_dict(
    method forward (line 55) | def forward(self, x):
  class BackboneBase (line 68) | class BackboneBase(nn.Module):
    method __init__ (line 69) | def __init__(
    method forward (line 107) | def forward(self, tensor_list: NestedTensor):
  class Backbone (line 118) | class Backbone(BackboneBase):
    method __init__ (line 121) | def __init__(
  class Joiner (line 152) | class Joiner(nn.Sequential):
    method __init__ (line 153) | def __init__(self, backbone, position_embedding):
    method forward (line 156) | def forward(self, tensor_list: NestedTensor, mode=None):
  function build_backbone (line 168) | def build_backbone(cfg):

FILE: EgoTracks/tracking/models/stark_tracker/config/stark_st2/config.py
  class _DATA_TEMPLATE (line 117) | class _DATA_TEMPLATE:
  class _DATA_SEARCH (line 126) | class _DATA_SEARCH:
  class _DATA_VAL (line 135) | class _DATA_VAL:
  class _DATA_TRAIN (line 142) | class _DATA_TRAIN:
  class _DATA (line 151) | class _DATA:
  class _SCHEDULER (line 177) | class _SCHEDULER:
  class _TRAIN (line 183) | class _TRAIN:
  class _MODEL_BACKBONE (line 209) | class _MODEL_BACKBONE:
  class _MODEL_TRANSFORMER (line 217) | class _MODEL_TRANSFORMER:
  class _MODEL (line 228) | class _MODEL:
  class _UPDATE_INTERVALS (line 240) | class _UPDATE_INTERVALS:
  class _TEST (line 250) | class _TEST:
  class STARKParams (line 261) | class STARKParams:
  function _edict2dict (line 268) | def _edict2dict(dest_dict, src_edict):
  function gen_config (line 280) | def gen_config(config_file):
  function _update_config (line 287) | def _update_config(base_cfg, exp_cfg):
  function update_config_from_file (line 301) | def update_config_from_file(filename):

FILE: EgoTracks/tracking/models/stark_tracker/head.py
  function conv (line 7) | def conv(
  class Corner_Predictor (line 46) | class Corner_Predictor(nn.Module):
    method __init__ (line 49) | def __init__(
    method forward (line 85) | def forward(self, x, return_dist=False, softmax=True):
    method get_score_map (line 109) | def get_score_map(self, x):
    method soft_argmax (line 125) | def soft_argmax(self, score_map, return_dist=False, softmax=True):
  class Corner_Predictor_Lite (line 142) | class Corner_Predictor_Lite(nn.Module):
    method __init__ (line 145) | def __init__(self, inplanes=64, channel=256, feat_sz=20, stride=16):
    method forward (line 176) | def forward(self, x, return_dist=False, softmax=True):
    method get_score_map (line 200) | def get_score_map(self, x):
    method soft_argmax (line 204) | def soft_argmax(self, score_map, return_dist=False, softmax=True):
  class MLP (line 221) | class MLP(nn.Module):
    method __init__ (line 224) | def __init__(self, input_dim, hidden_dim, output_dim, num_layers, BN=F...
    method forward (line 238) | def forward(self, x):
  function build_box_head (line 244) | def build_box_head(cfg):

FILE: EgoTracks/tracking/models/stark_tracker/params.py
  class TrackerParams (line 6) | class TrackerParams:
    method set_default_values (line 9) | def set_default_values(self, default_vals: Dict):
    method get (line 14) | def get(self, name: str, *default):
    method has (line 25) | def has(self, name: str):
  function parameters (line 30) | def parameters(yaml_name: str):

FILE: EgoTracks/tracking/models/stark_tracker/position_encoding.py
  class PositionEmbeddingSine (line 11) | class PositionEmbeddingSine(nn.Module):
    method __init__ (line 17) | def __init__(
    method forward (line 30) | def forward(self, tensor_list: NestedTensor):
  class PositionEmbeddingLearned (line 71) | class PositionEmbeddingLearned(nn.Module):
    method __init__ (line 76) | def __init__(self, num_pos_feats=256):
    method reset_parameters (line 82) | def reset_parameters(self):
    method forward (line 86) | def forward(self, tensor_list: NestedTensor):
  class PositionEmbeddingNone (line 108) | class PositionEmbeddingNone(nn.Module):
    method __init__ (line 113) | def __init__(self, num_pos_feats=256):
    method forward (line 117) | def forward(self, tensor_list: NestedTensor):
  function build_position_encoding (line 123) | def build_position_encoding(cfg):

FILE: EgoTracks/tracking/models/stark_tracker/resnet.py
  class ResNet (line 39) | class ResNet(nn.Module):
    method __init__ (line 40) | def __init__(
    method _make_layer (line 120) | def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
    method _forward_impl (line 161) | def _forward_impl(self, x):
    method forward (line 182) | def forward(self, x):
  function _resnet (line 186) | def _resnet(arch, block, layers, pretrained, progress, **kwargs):
  function resnet18 (line 205) | def resnet18(pretrained=False, progress=True, **kwargs):
  function resnet34 (line 215) | def resnet34(pretrained=False, progress=True, **kwargs):
  function resnet50 (line 225) | def resnet50(pretrained=False, progress=True, **kwargs):
  function resnet101 (line 235) | def resnet101(pretrained=False, progress=True, **kwargs):
  function resnet152 (line 247) | def resnet152(pretrained=False, progress=True, **kwargs):
  function resnext50_32x4d (line 259) | def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
  function resnext101_32x8d (line 273) | def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
  function wide_resnet50_2 (line 287) | def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
  function wide_resnet101_2 (line 304) | def wide_resnet101_2(pretrained=False, progress=True, **kwargs):

FILE: EgoTracks/tracking/models/stark_tracker/stark_s.py
  class STARKS (line 15) | class STARKS(nn.Module):
    method __init__ (line 18) | def __init__(
    method forward (line 50) | def forward(
    method forward_backbone (line 67) | def forward_backbone(self, input: NestedTensor):
    method forward_transformer (line 80) | def forward_transformer(self, seq_dict, run_box_head=True, run_cls_hea...
    method forward_box_head (line 95) | def forward_box_head(self, hs, memory):
    method adjust (line 126) | def adjust(self, output_back: List, pos_embed: List):
    method _set_aux_loss (line 139) | def _set_aux_loss(self, outputs_coord):
  function build_starks (line 146) | def build_starks(cfg):

FILE: EgoTracks/tracking/models/stark_tracker/stark_st.py
  class STARKST (line 10) | class STARKST(STARKS):
    method __init__ (line 13) | def __init__(
    method forward (line 40) | def forward(
    method forward_transformer (line 57) | def forward_transformer(self, seq_dict, run_box_head=False, run_cls_he...
    method forward_head (line 74) | def forward_head(self, hs, memory, run_box_head=False, run_cls_head=Fa...
  function build_starkst (line 92) | def build_starkst(cfg):

FILE: EgoTracks/tracking/models/stark_tracker/stark_tracker.py
  class STARKTracker (line 21) | class STARKTracker(SingleObjectTracker):
    method __init__ (line 22) | def __init__(
    method init_tracker (line 67) | def init_tracker(self, img: torch.Tensor, meta_data: Dict):
    method run_model (line 138) | def run_model(
    method track_globally (line 164) | def track_globally(
    method track_locally (line 304) | def track_locally(
    method update_tracker (line 393) | def update_tracker(self, results):
    method map_box_back (line 438) | def map_box_back(self, pred_box: List, resize_factor: float, pos: List...

FILE: EgoTracks/tracking/models/stark_tracker/transformer.py
  function check_inf (line 19) | def check_inf(tensor):
  function check_nan (line 23) | def check_nan(tensor):
  function check_valid (line 27) | def check_valid(tensor, type_name):
  class Transformer (line 34) | class Transformer(nn.Module):
    method __init__ (line 35) | def __init__(
    method _reset_parameters (line 96) | def _reset_parameters(self):
    method forward (line 101) | def forward(
  class TransformerEncoder (line 151) | class TransformerEncoder(nn.Module):
    method __init__ (line 152) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 158) | def forward(
  class TransformerEncoderLite (line 200) | class TransformerEncoderLite(nn.Module):
    method __init__ (line 201) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 208) | def forward(self, seq_dict, return_intermediate=False, part_att=False):
  class TransformerDecoder (line 229) | class TransformerDecoder(nn.Module):
    method __init__ (line 230) | def __init__(self, decoder_layer, num_layers, norm=None, return_interm...
    method forward (line 237) | def forward(
  class TransformerEncoderLayer (line 278) | class TransformerEncoderLayer(nn.Module):
    method __init__ (line 279) | def __init__(
    method with_pos_embed (line 307) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    method forward_post (line 310) | def forward_post(
    method forward_pre (line 332) | def forward_pre(
    method forward (line 350) | def forward(
  class TransformerEncoderLayerLite (line 362) | class TransformerEncoderLayerLite(nn.Module):
    method __init__ (line 365) | def __init__(
    method with_pos_embed (line 393) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    method forward_post (line 396) | def forward_post(self, seq_dict, part_att=False):
    method forward (line 433) | def forward(self, seq_dict, part_att=False):
  class TransformerDecoderLayer (line 439) | class TransformerDecoderLayer(nn.Module):
    method __init__ (line 440) | def __init__(
    method with_pos_embed (line 471) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    method forward_post (line 474) | def forward_post(
    method forward_pre (line 520) | def forward_pre(
    method forward (line 551) | def forward(
  function _get_clones (line 585) | def _get_clones(module, N):
  function build_transformer (line 589) | def build_transformer(cfg):
  function _get_activation_fn (line 603) | def _get_activation_fn(activation):

FILE: EgoTracks/tracking/models/stark_tracker/utils/box_ops.py
  function box_cxcywh_to_xyxy (line 7) | def box_cxcywh_to_xyxy(x):
  function box_xywh_to_xyxy (line 13) | def box_xywh_to_xyxy(x):
  function box_xyxy_to_xywh (line 19) | def box_xyxy_to_xywh(x):
  function box_xyxy_to_cxcywh (line 25) | def box_xyxy_to_cxcywh(x):
  function box_iou (line 35) | def box_iou(boxes1, boxes2):
  function generalized_box_iou (line 60) | def generalized_box_iou(boxes1, boxes2):
  function giou_loss (line 85) | def giou_loss(boxes1, boxes2):
  function clip_box (line 96) | def clip_box(box: List, H, W, margin=0):

FILE: EgoTracks/tracking/models/stark_tracker/utils/merge.py
  function merge_template_search (line 4) | def merge_template_search(inp_list, return_search=False, return_template...
  function get_qkv (line 20) | def get_qkv(inp_list):

FILE: EgoTracks/tracking/models/stark_tracker/utils/misc.py
  function is_dist_avail_and_initialized (line 13) | def is_dist_avail_and_initialized():
  function get_world_size (line 21) | def get_world_size():
  function get_rank (line 27) | def get_rank():
  function is_main_process (line 33) | def is_main_process():
  class NestedTensor (line 39) | class NestedTensor(object):
    method __init__ (line 40) | def __init__(self, tensors, mask: Optional[Tensor]):
    method to (line 44) | def to(self, device):
    method decompose (line 55) | def decompose(self):
    method __repr__ (line 58) | def __repr__(self):
  class Preprocessor (line 62) | class Preprocessor(object):
    method __init__ (line 63) | def __init__(self):
    method process (line 67) | def process(

FILE: EgoTracks/tracking/models/stark_tracker/utils/preprocessing_utils.py
  function sample_target (line 14) | def sample_target(im, pos, crop_sz, output_sz=None, mask=None, verbose=F...

FILE: EgoTracks/tracking/models/template.py
  class TemplateImage (line 15) | class TemplateImage:
    method __init__ (line 23) | def __init__(
    method update_template (line 45) | def update_template(self, attribute: str, value: Any) -> None:
  class ObjectInstance (line 68) | class ObjectInstance:
    method __init__ (line 75) | def __init__(self, description: str = "") -> None:
    method add_template (line 82) | def add_template(
    method get_templates_list (line 99) | def get_templates_list(self) -> List:
    method __iter__ (line 111) | def __iter__(self):
    method __len__ (line 120) | def __len__(self) -> int:
  class InstanceRegistration (line 133) | class InstanceRegistration:
    method __init__ (line 146) | def __init__(self) -> None:
    method add (line 152) | def add(
    method remove (line 183) | def remove(self, instance_id: str) -> None:
    method get_instance (line 196) | def get_instance(self, instance_id: str) -> ObjectInstance:
    method get_instance_ids (line 208) | def get_instance_ids(self) -> List:
    method __iter__ (line 220) | def __iter__(self) -> Iterator:
    method __len__ (line 236) | def __len__(self) -> int:

FILE: EgoTracks/tracking/models/tracker.py
  class Tracker (line 11) | class Tracker(nn.Module):
    method __init__ (line 19) | def __init__(self, model: nn.Module, verbose: bool = False):
    method inference (line 32) | def inference(
    method inference_sequence (line 89) | def inference_sequence(self, video: Sequence, meta_data: Dict = None) ...
    method inference_img_sequence (line 125) | def inference_img_sequence(
    method inference_video_handler (line 165) | def inference_video_handler(
    method run_model (line 205) | def run_model(self, image: torch.Tensor) -> Dict:
    method update_tracker (line 220) | def update_tracker(self, result: Dict) -> None:
    method init_tracker (line 235) | def init_tracker(self, image: torch.Tensor, meta_data: Dict) -> None:
    method reset_tracker (line 249) | def reset_tracker(self) -> None:

FILE: EgoTracks/tracking/solver/build.py
  function build_optimizer_scheduler (line 7) | def build_optimizer_scheduler(cfg, model):
  function build_optimizer (line 14) | def build_optimizer(cfg, model):
  function build_scheduler (line 69) | def build_scheduler(cfg, optimizer):
  function get_optimizer_scheduler (line 85) | def get_optimizer_scheduler(net, cfg):

FILE: EgoTracks/tracking/utils/bbox_helper.py
  function corner2center (line 16) | def corner2center(corner):
  function center2corner (line 33) | def center2corner(center):
  function cxy_wh_2_rect (line 50) | def cxy_wh_2_rect(pos, sz):
  function xywh_2_rect (line 54) | def xywh_2_rect(bbox):
  function get_axis_aligned_bbox (line 72) | def get_axis_aligned_bbox(region):
  function aug_apply (line 99) | def aug_apply(bbox, param, shape, inv=False, rd=False):
  function IoU (line 175) | def IoU(rect1, rect2):
  function cxywh_2_xywh (line 198) | def cxywh_2_xywh(bbox: List, context_ratio: float = 0.0) -> List:
  function xywh_2_cxywh (line 217) | def xywh_2_cxywh(bbox: List, context_ratio: float = 0.0) -> List:

FILE: EgoTracks/tracking/utils/defaults.py
  function setup (line 8) | def setup(args):
  function default_argument_parser (line 19) | def default_argument_parser(epilog=None):

FILE: EgoTracks/tracking/utils/env.py
  function setup_environment (line 8) | def setup_environment():

FILE: EgoTracks/tracking/utils/load_helper.py
  function check_keys (line 8) | def check_keys(model, pretrained_state_dict):
  function remove_prefix (line 27) | def remove_prefix(state_dict, prefix):
  function load_pretrain (line 38) | def load_pretrain(model, pretrained_path):
  function restore_from (line 63) | def restore_from(model, optimizer, ckpt_path):

FILE: EgoTracks/tracking/utils/load_text.py
  function load_text_numpy (line 7) | def load_text_numpy(path, delimiter, dtype):
  function load_text_pandas (line 22) | def load_text_pandas(path, delimiter, dtype):
  function load_text (line 51) | def load_text(path, delimiter=" ", dtype=np.float32, backend="numpy"):

FILE: EgoTracks/tracking/utils/meters.py
  class AverageMeter (line 4) | class AverageMeter(object):
    method __init__ (line 7) | def __init__(self, name, fmt=":f"):
    method reset (line 12) | def reset(self):
    method update (line 18) | def update(self, val, n=1):
    method __str__ (line 24) | def __str__(self):
  class ProgressMeter (line 29) | class ProgressMeter(object):
    method __init__ (line 30) | def __init__(self, num_batches, meters, prefix=""):
    method display (line 35) | def display(self, batch):
    method _get_batch_fmtstr (line 40) | def _get_batch_fmtstr(self, num_batches):

FILE: EgoTracks/tracking/utils/multiprocessing.py
  function run (line 12) | def run(
  function launch_job (line 68) | def launch_job(

FILE: EgoTracks/tracking/utils/tensor.py
  class TensorDict (line 8) | class TensorDict(OrderedDict):
    method concat (line 11) | def concat(self, other):
    method copy (line 15) | def copy(self):
    method __deepcopy__ (line 18) | def __deepcopy__(self, memodict={}):
    method __getattr__ (line 21) | def __getattr__(self, name):
    method attribute (line 37) | def attribute(self, attr: str, *args):
    method apply (line 40) | def apply(self, fn, *args, **kwargs):
    method _iterable (line 44) | def _iterable(a):
  class TensorList (line 48) | class TensorList(list):
    method __init__ (line 51) | def __init__(self, list_of_tensors=None):
    method __deepcopy__ (line 56) | def __deepcopy__(self, memodict={}):
    method __getitem__ (line 59) | def __getitem__(self, item):
    method __add__ (line 67) | def __add__(self, other):
    method __radd__ (line 72) | def __radd__(self, other):
    method __iadd__ (line 77) | def __iadd__(self, other):
    method __sub__ (line 86) | def __sub__(self, other):
    method __rsub__ (line 91) | def __rsub__(self, other):
    method __isub__ (line 96) | def __isub__(self, other):
    method __mul__ (line 105) | def __mul__(self, other):
    method __rmul__ (line 110) | def __rmul__(self, other):
    method __imul__ (line 115) | def __imul__(self, other):
    method __truediv__ (line 124) | def __truediv__(self, other):
    method __rtruediv__ (line 129) | def __rtruediv__(self, other):
    method __itruediv__ (line 134) | def __itruediv__(self, other):
    method __matmul__ (line 143) | def __matmul__(self, other):
    method __rmatmul__ (line 148) | def __rmatmul__(self, other):
    method __imatmul__ (line 153) | def __imatmul__(self, other):
    method __mod__ (line 162) | def __mod__(self, other):
    method __rmod__ (line 167) | def __rmod__(self, other):
    method __pos__ (line 172) | def __pos__(self):
    method __neg__ (line 175) | def __neg__(self):
    method __le__ (line 178) | def __le__(self, other):
    method __ge__ (line 183) | def __ge__(self, other):
    method concat (line 188) | def concat(self, other):
    method copy (line 191) | def copy(self):
    method unroll (line 194) | def unroll(self):
    method list (line 206) | def list(self):
    method attribute (line 209) | def attribute(self, attr: str, *args):
    method apply (line 212) | def apply(self, fn):
    method __getattr__ (line 215) | def __getattr__(self, name):
    method _iterable (line 227) | def _iterable(a):
  function tensor_operation (line 231) | def tensor_operation(op):

FILE: EgoTracks/tracking/utils/types.py
  class SiamMaskTestParams (line 8) | class SiamMaskTestParams:
  class SiamMaskParams (line 41) | class SiamMaskParams:
  class Params (line 46) | class Params:

FILE: EgoTracks/tracking/utils/utils.py
  function opencv_loader (line 9) | def opencv_loader(path):
  function visualize_bbox (line 23) | def visualize_bbox(frames: List, bboxes: List, texts: List = None) -> List:
  function extract_frames (line 48) | def extract_frames(frame_numbers: List, container: av.container.Containe...
  function extract_frames_by_range (line 58) | def extract_frames_by_range(
  function pad_bboxes (line 69) | def pad_bboxes(frame_bbox_dict, frame_numbers):

FILE: MQ/Evaluation/ego4d/eval_action_detection.py
  class EvalActionDetection (line 10) | class EvalActionDetection(object):
    method __init__ (line 12) | def __init__(self, ground_truth_filename=None,
    method _import_ground_truth (line 30) | def _import_ground_truth(self, ground_truth_filename):
    method wrapper_compute_average_precision (line 55) | def wrapper_compute_average_precision(self, prediction):
    method evaluate (line 73) | def evaluate(self, prediction):
  function compute_average_precision_detection (line 90) | def compute_average_precision_detection(ground_truth, prediction, tiou_t...

FILE: MQ/Evaluation/ego4d/eval_detection.py
  class ANETdetection (line 20) | class ANETdetection(object):
    method __init__ (line 25) | def __init__(self, ground_truth_filename=None, prediction_filename=None,
    method _import_ground_truth (line 62) | def _import_ground_truth(self, ground_truth_filename):
    method _import_prediction (line 114) | def _import_prediction(self, prediction_filename):
    method _get_predictions_with_label (line 159) | def _get_predictions_with_label(self, prediction_by_label, label_name,...
    method wrapper_compute_average_precision (line 170) | def wrapper_compute_average_precision(self):
    method evaluate (line 200) | def evaluate(self):
  function compute_average_precision_detection (line 218) | def compute_average_precision_detection(ground_truth, prediction, tiou_t...

FILE: MQ/Evaluation/ego4d/generate_detection.py
  function IOU (line 9) | def IOU(s1, e1, s2, e2):
  function Soft_NMS (line 16) | def Soft_NMS(df, nms_threshold=1e-5, num_prop=200):
  function _gen_detection_video (line 62) | def _gen_detection_video(video_name, result, idx_classes, opt, num_prop=...
  function gen_detection_multicore (line 90) | def gen_detection_multicore(opt):

FILE: MQ/Evaluation/ego4d/generate_retrieval.py
  function IOU (line 8) | def IOU(s1, e1, s2, e2):
  function Soft_NMS (line 15) | def Soft_NMS(df, nms_threshold=1e-5, num_prop=200):
  function rm_other_category (line 63) | def rm_other_category(df, annots, classes):
  function _gen_retrieval_video (line 76) | def _gen_retrieval_video(video_name, result, classes, idx_classes, opt, ...
  function gen_retrieval_multicore (line 104) | def gen_retrieval_multicore(opt):

FILE: MQ/Evaluation/ego4d/get_detect_performance.py
  function run_evaluation (line 5) | def run_evaluation(ground_truth_filename, prediction_filename,
  function evaluation_detection (line 19) | def evaluation_detection(opt):

FILE: MQ/Evaluation/ego4d/get_retrieval_performance.py
  class Moment_Retrieval (line 5) | class Moment_Retrieval(object):
    method __init__ (line 9) | def __init__(self, ground_truth_filename=None, prediction_filename=None,
    method _import_ground_truth (line 41) | def _import_ground_truth(self, ground_truth_filename):
    method _import_prediction (line 64) | def _import_prediction(self, prediction_filename):
    method evaluate (line 86) | def evaluate(self):
  function iou (line 126) | def iou(pred, gt): # require pred and gt is numpy
  function evaluation_retrieval (line 146) | def evaluation_retrieval(opt):

FILE: MQ/Evaluation/utils.py
  function get_blocked_videos (line 8) | def get_blocked_videos(api=API):
  function interpolated_prec_rec (line 14) | def interpolated_prec_rec(prec, rec):
  function segment_iou (line 25) | def segment_iou(target_segment, candidate_segments):
  function wrapper_segment_iou (line 53) | def wrapper_segment_iou(target_segments, candidate_segments):

FILE: MQ/Infer.py
  function Infer_SegTAD (line 22) | def Infer_SegTAD(opt):
  function infer_batch_selectprop (line 48) | def infer_batch_selectprop(model,
  function infer_v_asis (line 82) | def infer_v_asis(*args, **kwargs):
  function nms (line 130) | def nms(dets, thresh=0.4):

FILE: MQ/Models/ActionGenerator.py
  class Pred_loc_cls (line 6) | class Pred_loc_cls(object):
    method __init__ (line 7) | def __init__(self, opt):
    method __call__ (line 16) | def __call__(self, cls_pred_dec, reg_pred_dec, anchors):
    method _call_one_stage (line 30) | def _call_one_stage(self, cls_pred, reg_pred, all_anchors):
    method cat_boxlist (line 59) | def cat_boxlist(self, bboxes):

FILE: MQ/Models/AnchorGenerator.py
  class AnchorGenerator (line 6) | class AnchorGenerator(nn.Module):
    method __init__ (line 7) | def __init__(self, opt):
    method gen_anchors (line 24) | def gen_anchors(self):
    method get_base_anchors (line 33) | def get_base_anchors(self, stride, scales):
    method _scale_enum (line 38) | def _scale_enum(self, anchor, scales):
    method _mkanchors (line 45) | def _mkanchors(self, ws, ctr):
    method _whctrs (line 55) | def _whctrs(self, anchor):

FILE: MQ/Models/BoundaryAdjust.py
  class BoundaryAdjust (line 6) | class BoundaryAdjust(nn.Module):
    method __init__ (line 8) | def __init__(self, opt):
    method forward (line 28) | def forward(self, loc_box, feat_frmlvl):
    method cal_loss (line 66) | def cal_loss(self, start_offsets, end_offsets, anchors, gt_bbox, num_gt):
    method update_bd (line 82) | def update_bd(self, anchors, start_offsets, end_offsets):

FILE: MQ/Models/BoxCoder.py
  class BoxCoder (line 5) | class BoxCoder(object):
    method __init__ (line 7) | def __init__(self, opt):
    method encode (line 10) | def encode(self, gt_boxes, anchors):
    method decode (line 39) | def decode(self, preds, anchors):

FILE: MQ/Models/GCNs.py
  function knn (line 7) | def knn(x, num_frms, opt, y=None, k=10):
  function get_neigh_idx_semantic (line 38) | def get_neigh_idx_semantic(x, n_neigh, num_frms, opt):
  class NeighConv (line 47) | class NeighConv(nn.Module):
    method __init__ (line 48) | def __init__(self, in_features, out_features, opt):
    method forward (line 57) | def forward(self, feat_prop, neigh_idx):
  class xGN (line 86) | class xGN(nn.Module):
    method __init__ (line 87) | def __init__(self,  opt, in_channels, out_channels, stride = 2, bias=T...
    method forward (line 100) | def forward(self, x, num_frms):

FILE: MQ/Models/Head.py
  class Head (line 5) | class Head(nn.Module):
    method __init__ (line 6) | def __init__(self, opt):
    method forward (line 56) | def forward(self, x):

FILE: MQ/Models/Loss.py
  class Loss_loc_cls (line 9) | class Loss_loc_cls(object):
    method __init__ (line 11) | def __init__(self, opt):
    method _iou_anchors_gts (line 23) | def _iou_anchors_gts(self, anchor, gt):
    method __call__ (line 37) | def __call__(self, cls_pred_dec, reg_pred_dec, anchors, gt_bbox, num_gt):
    method _loss_one_stage (line 59) | def _loss_one_stage(self, cls_pred, reg_pred, gt_bbox, num_gt, anchors...
    method cls_loss_func (line 79) | def cls_loss_func(self, cls_pred, cls_labels):
    method reg_loss_func (line 97) | def reg_loss_func(self, pred, target, anchor, pred_boxes=None, weight=...
    method prepare_targets (line 132) | def prepare_targets(self, gt_bbox, num_gt, anchors, stage=0):
  function bi_loss (line 165) | def bi_loss(prediction, groundtruth, reduction='mean'):
  function get_loss_supplement (line 186) | def get_loss_supplement(pred_action, gt_action, pred_start, gt_start, pr...

FILE: MQ/Models/VSGN.py
  class VSGN (line 11) | class VSGN(nn.Module):
    method __init__ (line 12) | def __init__(self, opt):
    method _forward_test (line 58) | def _forward_test(self, cls_pred_enc, reg_pred_enc, cls_pred_dec, reg_...
    method forward (line 66) | def forward(self, input, num_frms, gt_action= None, gt_start= None, gt...

FILE: MQ/Models/XGPN.py
  class XGPN (line 8) | class XGPN(nn.Module):
    method __init__ (line 9) | def __init__(self, opt):
    method _make_levels_enc (line 45) | def _make_levels_enc(self, opt, in_channels, out_channels, stride = 2):
    method _make_levels_dec (line 55) | def _make_levels_dec(self, in_channels, out_channels, output_padding =...
    method _make_levels (line 62) | def _make_levels(self, in_channels, out_channels):
    method _encoder (line 69) | def _encoder(self, input, num_frms):
    method _decoder (line 82) | def _decoder(self, input):
    method forward (line 99) | def forward(self, input, num_frms):

FILE: MQ/Models/matcher.py
  class Matcher (line 4) | class Matcher(object):
    method __init__ (line 22) | def __init__(self, allow_low_quality_matches=False):
    method __call__ (line 41) | def __call__(self, match_quality_matrix, iou_thr = 0.5):
    method set_low_quality_matches_ (line 78) | def set_low_quality_matches_(self, matches, all_matches, match_quality...

FILE: MQ/Train.py
  function Train_VSGN (line 17) | def Train_VSGN(opt):
  function train_VSGN_epoch (line 61) | def train_VSGN_epoch(data_loader, model, optimizer, epoch, writer, opt, ...
  function test_VSGN_epoch (line 111) | def test_VSGN_epoch(data_loader, model, epoch, writer, opt):

FILE: MQ/Utils/dataset.py
  function load_json (line 15) | def load_json(file):
  class VideoDataSet (line 21) | class VideoDataSet(data.Dataset):
    method __init__ (line 22) | def __init__(self, opt, subset="train", mode="train"):
    method _getDatasetDict (line 39) | def _getDatasetDict(self):
    method __getitem__ (line 71) | def __getitem__(self, index):
    method _get_video_data (line 81) | def _get_video_data(self, index):
    method _get_train_data_label_org (line 110) | def _get_train_data_label_org(self, num_frms, clip_name,  fps):
    method _ioa_with_anchors (line 180) | def _ioa_with_anchors(self, anchors_min, anchors_max, box_min, box_max):
    method __len__ (line 188) | def __len__(self):
  function iou_with_anchors (line 192) | def iou_with_anchors(anchors_min, anchors_max, box_min, box_max):

FILE: MQ/Utils/opts.py
  function parse_opt (line 3) | def parse_opt():

FILE: NLQ/2D-TAN/data/TACoS/merge_npys_to_hdf5.py
  function convert_tall_c3d_features (line 8) | def convert_tall_c3d_features(sampling_rate):

FILE: NLQ/2D-TAN/lib/core/config.py
  function _update_dict (line 89) | def _update_dict(cfg, value):
  function update_config (line 101) | def update_config(config_file):

FILE: NLQ/2D-TAN/lib/core/engine.py
  class Engine (line 1) | class Engine(object):
    method __init__ (line 2) | def __init__(self):
    method hook (line 5) | def hook(self, name, state):
    method train (line 10) | def train(self, network, iterator, maxepoch, optimizer, scheduler):
    method test (line 49) | def test(self, network, iterator, split):

FILE: NLQ/2D-TAN/lib/core/eval.py
  function iou (line 9) | def iou(pred, gt): # require pred and gt is numpy
  function rank (line 29) | def rank(pred, gt):
  function nms (line 32) | def nms(dets, thresh=0.4, top_k=-1):
  function eval (line 55) | def eval(segments, data):
  function eval_predictions (line 75) | def eval_predictions(segments, data, verbose=True, merge_window=False):
  function display_results (line 108) | def display_results(eval_result, miou, title=None):
  function parse_args (line 123) | def parse_args():
  function reset_config (line 138) | def reset_config(config, args):

FILE: NLQ/2D-TAN/lib/core/utils.py
  class AverageMeter (line 10) | class AverageMeter(object):
    method __init__ (line 12) | def __init__(self):
    method reset (line 15) | def reset(self):
    method update (line 21) | def update(self, val, n=1):
  function create_logger (line 27) | def create_logger(cfg, cfg_name, tag='train'):

FILE: NLQ/2D-TAN/lib/datasets/__init__.py
  function collate_fn (line 5) | def collate_fn(batch):
  function average_to_fixed_length (line 30) | def average_to_fixed_length(visual_input):

FILE: NLQ/2D-TAN/lib/datasets/activitynet.py
  class ActivityNet (line 16) | class ActivityNet(data.Dataset):
    method __init__ (line 24) | def __init__(self, split):
    method __getitem__ (line 49) | def __getitem__(self, index):
    method __len__ (line 115) | def __len__(self):
    method get_video_features (line 118) | def get_video_features(self, vid):

FILE: NLQ/2D-TAN/lib/datasets/charades.py
  class Charades (line 17) | class Charades(data.Dataset):
    method __init__ (line 25) | def __init__(self, split):
    method __getitem__ (line 51) | def __getitem__(self, index):
    method __len__ (line 88) | def __len__(self):
    method get_video_features (line 91) | def get_video_features(self, vid):
    method get_target_weights (line 99) | def get_target_weights(self):

FILE: NLQ/2D-TAN/lib/datasets/ego4d_clip.py
  class Ego4DClip (line 22) | class Ego4DClip(data.Dataset):
    method __init__ (line 23) | def __init__(self, split, temp=None):
    method __getitem__ (line 152) | def __getitem__(self, index):
    method __len__ (line 215) | def __len__(self):
    method cache_text_feature (line 218) | def cache_text_feature(self, sentence, rnd=False):
    method get_video_features (line 231) | def get_video_features(self, vid, duration, window_se=None, clip_se=No...

FILE: NLQ/2D-TAN/lib/datasets/tacos.py
  class TACoS (line 16) | class TACoS(data.Dataset):
    method __init__ (line 24) | def __init__(self, split):
    method __getitem__ (line 49) | def __getitem__(self, index):
    method __len__ (line 81) | def __len__(self):
    method get_video_features (line 84) | def get_video_features(self, vid):

FILE: NLQ/2D-TAN/lib/models/frame_modules/frame_pool.py
  class FrameAvgPool (line 4) | class FrameAvgPool(nn.Module):
    method __init__ (line 6) | def __init__(self, cfg):
    method forward (line 15) | def forward(self, visual_input):
  class FrameMaxPool (line 20) | class FrameMaxPool(nn.Module):
    method __init__ (line 22) | def __init__(self, input_size, hidden_size, stride):
    method forward (line 27) | def forward(self, visual_input):

FILE: NLQ/2D-TAN/lib/models/fusion_modules/base_fusion.py
  class BaseFusion (line 5) | class BaseFusion(nn.Module):
    method __init__ (line 7) | def __init__(self, cfg):
    method forward (line 18) | def forward(self, textual_input, textual_mask, map_h, map_mask):

FILE: NLQ/2D-TAN/lib/models/loss.py
  function bce_rescale_loss (line 4) | def bce_rescale_loss(scores, masks, targets, cfg):

FILE: NLQ/2D-TAN/lib/models/map_modules/__init__.py
  function get_padded_mask_and_weight (line 3) | def get_padded_mask_and_weight(*args):

FILE: NLQ/2D-TAN/lib/models/map_modules/map_conv.py
  class MapConv (line 5) | class MapConv(nn.Module):
    method __init__ (line 7) | def __init__(self, cfg):
    method forward (line 24) | def forward(self, x, mask):

FILE: NLQ/2D-TAN/lib/models/prop_modules/dense.py
  class PropMaxPool (line 3) | class PropMaxPool(nn.Module):
    method __init__ (line 4) | def __init__(self, cfg):
    method forward (line 13) | def forward(self, x):

FILE: NLQ/2D-TAN/lib/models/prop_modules/sparse.py
  class SparsePropMaxPool (line 3) | class SparsePropMaxPool(nn.Module):
    method __init__ (line 4) | def __init__(self, cfg):
    method forward (line 17) | def forward(self, x):
    method recover_to_original_map (line 41) | def recover_to_original_map(self, h_list, mask_list):
  class SparsePropConv (line 64) | class SparsePropConv(nn.Module):
    method __init__ (line 65) | def __init__(self, cfg):
    method forward (line 79) | def forward(self, x):
    method recover_to_original_map (line 102) | def recover_to_original_map(self, h_list, mask_list):

FILE: NLQ/2D-TAN/lib/models/tan.py
  class TAN (line 8) | class TAN(nn.Module):
    method __init__ (line 9) | def __init__(self):
    method forward (line 18) | def forward(self, textual_input, textual_mask, visual_input):
    method extract_features (line 28) | def extract_features(self, textual_input, textual_mask, visual_input):

FILE: NLQ/2D-TAN/moment_localization/_init_paths.py
  function add_path (line 16) | def add_path(path):

FILE: NLQ/2D-TAN/moment_localization/test.py
  function parse_args (line 24) | def parse_args():
  function reset_config (line 49) | def reset_config(config, args):
  function save_scores (line 70) | def save_scores(scores, data, dataset_name, split):
  function nms (line 77) | def nms(dets, thresh=0.4, top_k=-1):
  function post_process (line 100) | def post_process(segments, data, verbose=True, merge_window=False, run_e...
  function save_prediction_to_file (line 134) | def save_prediction_to_file(result_path, predictions, annotations):
  function network (line 195) | def network(sample):
  function get_proposal_results (line 227) | def get_proposal_results(scores, durations):
  function on_test_start (line 245) | def on_test_start(state):
  function on_test_forward (line 252) | def on_test_forward(state):
  function on_test_end (line 262) | def on_test_end(state):

FILE: NLQ/2D-TAN/moment_localization/train.py
  function parse_args (line 37) | def parse_args():
  function reset_config (line 60) | def reset_config(config, args):
  function iterator (line 119) | def iterator(split):
  function network (line 153) | def network(sample):
  function get_proposal_results (line 168) | def get_proposal_results(scores, durations):
  function on_start (line 186) | def on_start(state):
  function on_forward (line 194) | def on_forward(state):
  function on_update (line 198) | def on_update(state):# Save All
  function on_end (line 261) | def on_end(state):
  function on_test_start (line 266) | def on_test_start(state):
  function on_test_forward (line 279) | def on_test_forward(state):
  function on_test_end (line 289) | def on_test_end(state):

FILE: NLQ/VSLNet/main.py
  function main (line 26) | def main(configs, parser):
  function create_executor (line 258) | def create_executor(configs):

FILE: NLQ/VSLNet/model/VSLNet.py
  function build_optimizer_and_scheduler (line 19) | def build_optimizer_and_scheduler(model, configs):
  class VSLNet (line 52) | class VSLNet(nn.Module):
    method __init__ (line 53) | def __init__(self, configs, word_vectors):
    method init_parameters (line 103) | def init_parameters(self):
    method forward (line 118) | def forward(self, word_ids, char_ids, video_features, v_mask, q_mask):
    method extract_index (line 135) | def extract_index(self, start_logits, end_logits):
    method compute_highlight_loss (line 140) | def compute_highlight_loss(self, scores, labels, mask):
    method compute_loss (line 145) | def compute_loss(self, start_logits, end_logits, start_labels, end_lab...

FILE: NLQ/VSLNet/model/layers.py
  function mask_logits (line 11) | def mask_logits(inputs, mask, mask_value=-1e30):
  class Conv1D (line 16) | class Conv1D(nn.Module):
    method __init__ (line 17) | def __init__(self, in_dim, out_dim, kernel_size=1, stride=1, padding=0...
    method forward (line 28) | def forward(self, x):
  class WordEmbedding (line 35) | class WordEmbedding(nn.Module):
    method __init__ (line 36) | def __init__(self, num_words, word_dim, drop_rate, word_vectors=None):
    method forward (line 56) | def forward(self, word_ids):
  class CharacterEmbedding (line 68) | class CharacterEmbedding(nn.Module):
    method __init__ (line 69) | def __init__(self, num_chars, char_dim, drop_rate):
    method forward (line 91) | def forward(self, char_ids):
  class Embedding (line 112) | class Embedding(nn.Module):
    method __init__ (line 113) | def __init__(
    method forward (line 138) | def forward(self, word_ids, char_ids):
  class BertEmbedding (line 148) | class BertEmbedding(nn.Module):
    method __init__ (line 149) | def __init__(self, text_agnostic=False):
    method forward (line 162) | def forward(self, word_ids):
  class PositionalEmbedding (line 167) | class PositionalEmbedding(nn.Module):
    method __init__ (line 170) | def __init__(self, num_embeddings, embedding_dim):
    method forward (line 174) | def forward(self, inputs):
  class VisualProjection (line 182) | class VisualProjection(nn.Module):
    method __init__ (line 183) | def __init__(self, visual_dim, dim, drop_rate=0.0):
    method forward (line 195) | def forward(self, visual_features):
  class DepthwiseSeparableConvBlock (line 202) | class DepthwiseSeparableConvBlock(nn.Module):
    method __init__ (line 203) | def __init__(self, dim, kernel_size, drop_rate, num_layers=4):
    method forward (line 233) | def forward(self, x):
  class MultiHeadAttentionBlock (line 245) | class MultiHeadAttentionBlock(nn.Module):
    method __init__ (line 246) | def __init__(self, dim, num_heads, drop_rate):
    method transpose_for_scores (line 271) | def transpose_for_scores(self, x):
    method combine_last_two_dim (line 277) | def combine_last_two_dim(x):
    method forward (line 282) | def forward(self, x, mask=None):
  class FeatureEncoder (line 318) | class FeatureEncoder(nn.Module):
    method __init__ (line 319) | def __init__(
    method forward (line 333) | def forward(self, x, mask=None):
  class CQAttention (line 342) | class CQAttention(nn.Module):
    method __init__ (line 343) | def __init__(self, dim, drop_rate=0.0):
    method forward (line 359) | def forward(self, context, query, c_mask, q_mask):
    method trilinear_attention (line 380) | def trilinear_attention(self, context, query):
  class WeightedPool (line 396) | class WeightedPool(nn.Module):
    method __init__ (line 397) | def __init__(self, dim):
    method forward (line 403) | def forward(self, x, mask):
  class CQConcatenate (line 414) | class CQConcatenate(nn.Module):
    method __init__ (line 415) | def __init__(self, dim):
    method forward (line 422) | def forward(self, context, query, q_mask):
  class HighLightLayer (line 435) | class HighLightLayer(nn.Module):
    method __init__ (line 436) | def __init__(self, dim):
    method forward (line 442) | def forward(self, x, mask):
    method compute_loss (line 452) | def compute_loss(scores, labels, mask, epsilon=1e-12):
  class DynamicRNN (line 462) | class DynamicRNN(nn.Module):
    method __init__ (line 463) | def __init__(self, dim):
    method forward (line 474) | def forward(self, x, mask):
  class ConditionedPredictor (line 482) | class ConditionedPredictor(nn.Module):
    method __init__ (line 483) | def __init__(self, dim, num_heads, max_pos_len, drop_rate=0.0, predict...
    method forward (line 530) | def forward(self, x, mask):
    method extract_index (line 548) | def extract_index(start_logits, end_logits):
    method compute_cross_entropy_loss (line 567) | def compute_cross_entropy_loss(start_logits, end_logits, start_labels,...

FILE: NLQ/VSLNet/options.py
  function read_command_line (line 11) | def read_command_line():

FILE: NLQ/VSLNet/utils/data_gen.py
  class EpisodicNLQProcessor (line 22) | class EpisodicNLQProcessor:
    method __init__ (line 23) | def __init__(self, remove_empty_queries_from: Optional[List[str]]):
    method reset_idx_counter (line 32) | def reset_idx_counter(self):
    method process_data_tan (line 35) | def process_data_tan(self, data, scope):
    method convert (line 81) | def convert(self, data_dir, predictor=None):
  function load_glove (line 98) | def load_glove(glove_path):
  function filter_glove_embedding (line 110) | def filter_glove_embedding(word_dict, glove_path):
  function vocab_emb_gen (line 125) | def vocab_emb_gen(datasets, emb_path):
  function dataset_gen (line 151) | def dataset_gen(
  function dataset_gen_bert (line 230) | def dataset_gen_bert(data, vfeat_lens, tokenizer, max_pos_len, scope, nu...
  function gen_or_load_dataset (line 290) | def gen_or_load_dataset(configs):

FILE: NLQ/VSLNet/utils/data_loader.py
  class Dataset (line 8) | class Dataset(torch.utils.data.Dataset):
    method __init__ (line 9) | def __init__(self, dataset, video_features):
    method __getitem__ (line 14) | def __getitem__(self, index):
    method __len__ (line 22) | def __len__(self):
  function train_collate_fn (line 26) | def train_collate_fn(data):
  function test_collate_fn (line 80) | def test_collate_fn(data):
  function get_train_loader (line 114) | def get_train_loader(dataset, video_features, configs):
  function get_test_loader (line 127) | def get_test_loader(dataset, video_features, configs):

FILE: NLQ/VSLNet/utils/data_util.py
  function load_json (line 11) | def load_json(filename):
  function save_json (line 17) | def save_json(data, filename, save_pretty=False, sort_keys=False):
  function load_lines (line 25) | def load_lines(filename):
  function save_lines (line 30) | def save_lines(data, filename):
  function load_pickle (line 35) | def load_pickle(filename):
  function save_pickle (line 41) | def save_pickle(data, filename):
  function load_video_features (line 46) | def load_video_features(root, max_position_length):
  function visual_feature_sampling (line 66) | def visual_feature_sampling(visual_feature, max_num_clips):
  function compute_overlap (line 84) | def compute_overlap(pred, gt):
  function time_to_index (line 106) | def time_to_index(start_time, end_time, num_units, duration):
  function index_to_time (line 126) | def index_to_time(start_index, end_index, num_units, duration):
  function pad_seq (line 136) | def pad_seq(sequences, pad_tok=None, max_length=None):
  function pad_char_seq (line 149) | def pad_char_seq(sequences, max_length=None, max_length_2=None):
  function pad_video_seq (line 166) | def pad_video_seq(sequences, max_length=None):

FILE: NLQ/VSLNet/utils/evaluate_ego4d_nlq.py
  function display_results (line 17) | def display_results(results, mIoU, thresholds, topK, title=None):
  function compute_IoU (line 35) | def compute_IoU(pred, gt):
  function evaluate_nlq_performance (line 59) | def evaluate_nlq_performance(
  function main (line 109) | def main(args):

FILE: NLQ/VSLNet/utils/prepare_ego4d_dataset.py
  function get_nearest_frame (line 24) | def get_nearest_frame(time, floor_or_ceil=None):
  function process_question (line 29) | def process_question(question):
  function reformat_data (line 34) | def reformat_data(split_data, test_split=False):
  function convert_ego4d_dataset (line 87) | def convert_ego4d_dataset(args):

FILE: NLQ/VSLNet/utils/runner_utils.py
  function set_th_config (line 17) | def set_th_config(seed):
  function filter_checkpoints (line 27) | def filter_checkpoints(model_dir, suffix="t7", max_to_keep=5):
  function get_last_checkpoint (line 41) | def get_last_checkpoint(model_dir, suffix="t7"):
  function convert_length_to_mask (line 53) | def convert_length_to_mask(lengths):
  function eval_test (line 62) | def eval_test(

FILE: VQ2D/convert_videos_to_clips.py
  function read_video_md (line 17) | def read_video_md(path):
  function get_mp4_writer (line 23) | def get_mp4_writer(path, fps, output_params=["-crf", "22"]):
  function frames_to_select (line 37) | def frames_to_select(
  function approx_equal_durations (line 55) | def approx_equal_durations(dur1, dur2, thresh=1.0):
  function extract_clip (line 59) | def extract_clip(video_path, clip_data, save_root, downscale_height=700):
  function batchify_video_uids (line 122) | def batchify_video_uids(video_uids, batch_size):
  function video_to_clip_fn (line 134) | def video_to_clip_fn(inputs):
  function main (line 153) | def main(args):

FILE: VQ2D/convert_videos_to_images.py
  function read_video_md (line 16) | def read_video_md(path):
  function save_video_frames (line 22) | def save_video_frames(path, frames_to_save):
  function frames_to_select (line 42) | def frames_to_select(
  function extract_clip_frame_nos (line 60) | def extract_clip_frame_nos(video_md, clip_annotation, save_root):
  function batchify_video_uids (line 95) | def batchify_video_uids(video_uids, batch_size):
  function video_to_image_fn (line 107) | def video_to_image_fn(inputs):
  function main (line 135) | def main(args):

FILE: VQ2D/detectron2_extensions/config/defaults.py
  function get_cfg (line 69) | def get_cfg() -> CfgNode:

FILE: VQ2D/detectron2_extensions/layers/wrappers.py
  function binary_cross_entropy (line 7) | def binary_cross_entropy(
  function binary_cross_entropy_with_logits (line 29) | def binary_cross_entropy_with_logits(
  function kl_div (line 53) | def kl_div(
  function triplet_margin (line 79) | def triplet_margin(

FILE: VQ2D/detectron2_extensions/modeling/meta_arch/siam_rcnn.py
  class SiameseRCNN (line 17) | class SiameseRCNN(GeneralizedRCNN):
    method __init__ (line 28) | def __init__(self, *args, **kwargs) -> None:
    method from_config (line 32) | def from_config(cls, cfg: CfgNode) -> Dict[str, Any]:
    method forward (line 46) | def forward(self, batched_inputs: Tuple[Dict[str, torch.Tensor]]) -> D...
    method inference (line 101) | def inference(
    method preprocess_image (line 146) | def preprocess_image(

FILE: VQ2D/detectron2_extensions/modeling/roi_heads/set_heads.py
  class DotProduct (line 28) | class DotProduct(nn.Module):
    method forward (line 29) | def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
  function conv3x3 (line 47) | def conv3x3(in_channels: int, out_channels: int, stride: int = 1) -> nn....
  class ResidualBlock (line 53) | class ResidualBlock(nn.Module):
    method __init__ (line 54) | def __init__(
    method forward (line 67) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class InducedSetAttentionBlock (line 84) | class InducedSetAttentionBlock(nn.Module):
    method __init__ (line 85) | def __init__(
    method forward (line 126) | def forward(self, query: torch.Tensor, points: torch.Tensor) -> torch....
  class MultiheadAttentionBlock (line 154) | class MultiheadAttentionBlock(nn.Module):
    method __init__ (line 155) | def __init__(
    method forward (line 179) | def forward(self, query: torch.Tensor, points: torch.Tensor) -> torch....
  class RefSetTransHead (line 193) | class RefSetTransHead(nn.Module):
    method __init__ (line 204) | def __init__(
    method _create_projection_layers (line 331) | def _create_projection_layers(
    method forward (line 367) | def forward(
    method losses (line 457) | def losses(
    method _losses (line 496) | def _losses(
    method _losses_hnm (line 533) | def _losses_hnm(
    method inference (line 566) | def inference(self, predictions: List[torch.Tensor], proposals: List[I...
  class SetTransROIHeads (line 631) | class SetTransROIHeads(ROIHeads):
    method __init__ (line 637) | def __init__(
    method from_config (line 668) | def from_config(cls, cfg: CfgNode, input_shape: Dict[str, ShapeSpec]):
    method _init_siamese_head (line 680) | def _init_siamese_head(
    method forward (line 753) | def forward(
    method _forward_siam (line 800) | def _forward_siam(

FILE: VQ2D/detectron2_extensions/modeling/roi_heads/siam_heads.py
  class DotProduct (line 19) | class DotProduct(nn.Module):
    method forward (line 20) | def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
  function conv3x3 (line 38) | def conv3x3(in_channels: int, out_channels: int, stride: int = 1) -> nn....
  class ResidualBlock (line 44) | class ResidualBlock(nn.Module):
    method __init__ (line 45) | def __init__(
    method forward (line 58) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class SiameseHead (line 70) | class SiameseHead(nn.Module):
    method __init__ (line 79) | def __init__(
    method _create_projection_layers (line 129) | def _create_projection_layers(
    method forward (line 165) | def forward(
    method losses (line 205) | def losses(
    method _losses (line 224) | def _losses(
    method _losses_hnm (line 261) | def _losses_hnm(
    method inference (line 294) | def inference(self, predictions: List[torch.Tensor], proposals: List[I...
  class SiameseROIHeads (line 329) | class SiameseROIHeads(ROIHeads):
    method __init__ (line 335) | def __init__(
    method from_config (line 366) | def from_config(cls, cfg: CfgNode, input_shape: Dict[str, ShapeSpec]):
    method _init_siamese_head (line 378) | def _init_siamese_head(
    method forward (line 445) | def forward(
    method _forward_siam (line 472) | def _forward_siam(

FILE: VQ2D/evaluate_vq.py
  function validate_model_predictions (line 9) | def validate_model_predictions(model_predictions, test_annotations):
  function evaluate (line 72) | def evaluate(gt_file, pred_file):

FILE: VQ2D/extract_vq_detection_scores.py
  function extract_clip_bboxes_and_scores (line 29) | def extract_clip_bboxes_and_scores(
  class Task (line 123) | class Task:
    method __init__ (line 124) | def __init__(self, annots):
    method run (line 132) | def run(self, predictor, cfg):
  class WorkerWithDevice (line 168) | class WorkerWithDevice(mp.Process):
    method __init__ (line 169) | def __init__(self, cfg, task_queue, results_queue, worker_id, device_id):
    method work (line 175) | def work(self, task_queue, results_queue):
  function extract_detection_scores (line 200) | def extract_detection_scores(annotations, cfg):
  function convert_annotations_to_clipwise_list (line 241) | def convert_annotations_to_clipwise_list(annotations):
  function main (line 274) | def main(cfg: DictConfig) -> None:

FILE: VQ2D/perform_vq_inference.py
  function get_images_at_peak (line 33) | def get_images_at_peak(all_bboxes, all_scores, all_imgs, peak_idx, topk=5):
  class Task (line 44) | class Task:
    method __init__ (line 45) | def __init__(self, annots):
    method run (line 57) | def run(self, similarity_net, tracker, cfg, device):
  class WorkerWithDevice (line 251) | class WorkerWithDevice(mp.Process):
    method __init__ (line 252) | def __init__(self, cfg, task_queue, results_queue, worker_id, device_id):
    method work (line 258) | def work(self, task_queue, results_queue):
  function perform_vq2d_inference (line 284) | def perform_vq2d_inference(annotations, cfg):
  function convert_annotations_to_clipwise_list (line 329) | def convert_annotations_to_clipwise_list(annotations):
  function format_predictions (line 361) | def format_predictions(annotations, predicted_rts):
  function main (line 391) | def main(cfg: DictConfig) -> None:

FILE: VQ2D/process_vq_dataset.py
  function get_dataset_uid (line 10) | def get_dataset_uid(split, idx):
  function process_video_annot (line 14) | def process_video_annot(video_data, n_samples_so_far):
  function process_data (line 43) | def process_data(args):

FILE: VQ2D/scripts/faster_evaluation/merge_results.py
  function merge_results (line 18) | def merge_results(args):

FILE: VQ2D/tools/test_model_loading.py
  function test_model_loading (line 5) | def test_model_loading(config_path, checkpoint_path):

FILE: VQ2D/tools/validate_extracted_clips.py
  function approx_equal_durations (line 13) | def approx_equal_durations(dur1, dur2, thresh=1.0):
  function check_clip (line 17) | def check_clip(clip_uid, clip_annotations, clip_metadata, args):
  function main (line 55) | def main(args):

FILE: VQ2D/train_siam_rcnn.py
  function get_evaluator (line 39) | def get_evaluator(cfg, dataset_name, output_folder=None):
  function do_test (line 52) | def do_test(cfg, model):
  function set_model_to_train (line 69) | def set_model_to_train(model):
  function do_train (line 85) | def do_train(cfg, model, resume=False):
  function setup (line 174) | def setup(args):
  function build_siam_model (line 186) | def build_siam_model(cfg):
  function register_all_datasets (line 197) | def register_all_datasets(cfg):
  function main (line 227) | def main(args):

FILE: VQ2D/validate_challenge_predictions.py
  function validate_model_predictions (line 6) | def validate_model_predictions(model_predictions, test_annotations):

FILE: VQ2D/visualizations/visualize_annotations.py
  function _get_box (line 11) | def _get_box(annot_box):
  function extract_crop_from_image (line 16) | def extract_crop_from_image(image, box):
  function draw_box_on_image (line 37) | def draw_box_on_image(image, box, color=(255, 0, 0), thickness=5):
  function draw_border (line 43) | def draw_border(image, color=(255, 0, 0), thickness=5):
  function scale_im_height (line 49) | def scale_im_height(image, H):
  function visualize_query_set (line 55) | def visualize_query_set(video_reader, qset, save_height=640):
  function get_mp4_writer (line 95) | def get_mp4_writer(path, fps, output_params=["-crf", "31"]):
  function save_video (line 108) | def save_video(frames, path, fps):
  function get_text_box (line 115) | def get_text_box(text, shape, fg_color=(255, 255, 255), bg_color=(0, 0, ...
  function visualize_annotation (line 134) | def visualize_annotation(clip_path, rt_save_path, crop_save_path, qset):

FILE: VQ2D/vq2d/baselines/dataloader.py
  function build_augmentation (line 16) | def build_augmentation(
  class VisualQueryDatasetMapper (line 70) | class VisualQueryDatasetMapper:
    method __init__ (line 86) | def __init__(
    method from_config (line 121) | def from_config(cls, cfg, is_train: bool = True):
    method __call__ (line 137) | def __call__(self, dataset_dict):

FILE: VQ2D/vq2d/baselines/dataset.py
  function _register_visual_query_dataset (line 23) | def _register_visual_query_dataset(
  function register_visual_query_datasets (line 44) | def register_visual_query_datasets(
  function visual_query_dataset (line 77) | def visual_query_dataset(

FILE: VQ2D/vq2d/baselines/feature_retrieval.py
  function perform_retrieval (line 13) | def perform_retrieval(

FILE: VQ2D/vq2d/baselines/predictor.py
  class SiamPredictor (line 8) | class SiamPredictor(DefaultPredictor):
    method __call__ (line 9) | def __call__(

FILE: VQ2D/vq2d/baselines/utils.py
  function convert_image_np2torch (line 19) | def convert_image_np2torch(image: np.ndarray) -> torch.Tensor:
  function convert_annot_to_bbox (line 31) | def convert_annot_to_bbox(annot: Dict[str, Any]) -> BBox:
  function get_clip_name_from_clip_uid (line 41) | def get_clip_name_from_clip_uid(clip_uid: str) -> str:
  function get_image_name_from_clip_uid (line 45) | def get_image_name_from_clip_uid(clip_uid: str, fno: int) -> str:
  function create_similarity_network (line 49) | def create_similarity_network(pretrained: bool = True) -> nn.Sequential:
  function extract_window_with_context (line 67) | def extract_window_with_context(
  function get_bbox_from_data (line 115) | def get_bbox_from_data(data: Dict[str, Any]) -> List[Numeric]:
  function get_image_id_from_data (line 119) | def get_image_id_from_data(data: Dict[str, Any], data_ix: int, rno: int)...
  function resize_if_needed (line 128) | def resize_if_needed(image: np.uint8, shape: Tuple[int, int]) -> np.ndar...

FILE: VQ2D/vq2d/metrics/metrics.py
  function compute_visual_query_metrics (line 21) | def compute_visual_query_metrics(

FILE: VQ2D/vq2d/metrics/spatio_temporal_metrics.py
  class SpatioTemporalDetection (line 16) | class SpatioTemporalDetection(object):
    method __init__ (line 22) | def __init__(
    method _import_ground_truth (line 33) | def _import_ground_truth(self, ground_truth: List[ResponseTrack]) -> p...
    method _import_prediction (line 48) | def _import_prediction(self, prediction: List[List[ResponseTrack]]) ->...
    method evaluate (line 67) | def evaluate(self) -> None:
    method get_metrics (line 78) | def get_metrics(self) -> Dict[str, float]:
  function compute_average_precision_detection (line 93) | def compute_average_precision_detection(

FILE: VQ2D/vq2d/metrics/success_metrics.py
  class SuccessMetrics (line 15) | class SuccessMetrics(object):
    method __init__ (line 21) | def __init__(
    method _import_ground_truth (line 39) | def _import_ground_truth(self, ground_truth: List[ResponseTrack]) -> p...
    method _import_prediction (line 54) | def _import_prediction(self, prediction: List[List[ResponseTrack]]) ->...
    method evaluate (line 73) | def evaluate(self) -> None:
    method get_metrics (line 83) | def get_metrics(self) -> Dict[str, float]:
  function compute_success (line 99) | def compute_success(

FILE: VQ2D/vq2d/metrics/temporal_metrics.py
  class TemporalDetection (line 16) | class TemporalDetection(object):
    method __init__ (line 22) | def __init__(
    method _import_ground_truth (line 33) | def _import_ground_truth(self, ground_truth: List[ResponseTrack]) -> p...
    method _import_prediction (line 50) | def _import_prediction(self, prediction: List[List[ResponseTrack]]) ->...
    method evaluate (line 71) | def evaluate(self) -> None:
    method get_metrics (line 82) | def get_metrics(self) -> Dict[str, float]:
  function compute_average_precision_detection (line 99) | def compute_average_precision_detection(

FILE: VQ2D/vq2d/metrics/tracking_metrics.py
  class TrackingMetrics (line 15) | class TrackingMetrics(object):
    method __init__ (line 21) | def __init__(
    method _import_ground_truth (line 39) | def _import_ground_truth(self, ground_truth: List[ResponseTrack]) -> p...
    method _import_prediction (line 54) | def _import_prediction(self, prediction: List[List[ResponseTrack]]) ->...
    method evaluate (line 73) | def evaluate(self) -> None:
    method get_metrics (line 85) | def get_metrics(self) -> Dict[str, float]:
  function compute_tracking_metrics (line 103) | def compute_tracking_metrics(

FILE: VQ2D/vq2d/metrics/utils.py
  function segment_iou (line 11) | def segment_iou(
  function interpolated_prec_rec (line 43) | def interpolated_prec_rec(prec: np.ndarray, rec: np.ndarray) -> np.ndarray:
  function spatial_iou (line 54) | def spatial_iou(box1: BBox, box2: BBox) -> float:
  function spatial_intersection (line 72) | def spatial_intersection(box1: BBox, box2: BBox) -> float:
  function spatio_temporal_iou_response_track (line 85) | def spatio_temporal_iou_response_track(rt1: ResponseTrack, rt2: Response...
  function spatio_temporal_iou (line 111) | def spatio_temporal_iou(
  function spatial_matches_response_track (line 128) | def spatial_matches_response_track(
  function spatio_temporal_iou_matches (line 149) | def spatio_temporal_iou_matches(

FILE: VQ2D/vq2d/stats.py
  function barplot (line 10) | def barplot(
  function hist (line 49) | def hist(
  function get_video_coverage (line 95) | def get_video_coverage(
  function compute_coverage_statistics (line 118) | def compute_coverage_statistics(
  function compute_clip_statistics (line 145) | def compute_clip_statistics(video_annotations: List[Any]) -> Dict[str, i...
  function compute_query_statistics (line 164) | def compute_query_statistics(video_annotations: List[Any]) -> Dict[str, ...
  function compute_scenario_coverage_statistics (line 185) | def compute_scenario_coverage_statistics(
  function compute_university_coverage_statistics (line 213) | def compute_university_coverage_statistics(
  function compute_query_to_response_separation_statistics (line 236) | def compute_query_to_response_separation_statistics(
  function compute_response_track_length_statistics (line 259) | def compute_response_track_length_statistics(
  function compute_response_track_location_statistics (line 282) | def compute_response_track_location_statistics(

FILE: VQ2D/vq2d/structures.py
  class BBox (line 4) | class BBox:
    method __init__ (line 5) | def __init__(self, fno, x1, y1, x2, y2):
    method area (line 12) | def area(self):
    method __repr__ (line 15) | def __repr__(self):
    method to_json (line 20) | def to_json(self):
    method from_json (line 30) | def from_json(data):
  class ResponseTrack (line 34) | class ResponseTrack:
    method __init__ (line 35) | def __init__(self, bboxes: List[BBox], score: float = None):
    method temporal_extent (line 46) | def temporal_extent(self):
    method bboxes (line 50) | def bboxes(self):
    method length (line 54) | def length(self):
    method score (line 58) | def score(self):
    method has_score (line 61) | def has_score(self):
    method _check_empty (line 64) | def _check_empty(self, bboxes):
    method _empty_init (line 67) | def _empty_init(self):
    method _non_empty_init (line 73) | def _non_empty_init(self, bboxes):
    method _check_contiguous (line 78) | def _check_contiguous(self):
    method __repr__ (line 82) | def __repr__(self):
    method volume (line 89) | def volume(self):
    method to_json (line 95) | def to_json(self):
    method from_json (line 105) | def from_json(data):

FILE: VQ2D/vq2d/tools/get_average_detector_flops.py
  function setup_model (line 24) | def setup_model(args):
  function process_annotations (line 36) | def process_annotations(annotations):
  function get_visual_crop_image (line 67) | def get_visual_crop_image(reference, visual_crop, cfg):
  function process_image (line 92) | def process_image(image, visual_crop, downscale_height=700):
  function compute_average_flops (line 102) | def compute_average_flops(args):

FILE: VQ2D/vq2d/tracking/kys.py
  class KYSTracker (line 13) | class KYSTracker(object):
    method __init__ (line 14) | def __init__(self, model_path, device, lost_thresh=0.05):
    method initialize_tracker (line 35) | def initialize_tracker(self, frame, box):
    method _build_init_info (line 41) | def _build_init_info(self, box):
    method update_state (line 55) | def update_state(self, frame):
    method lost_track (line 61) | def lost_track(self):
  class KYSRunner (line 65) | class KYSRunner(object):
    method __init__ (line 66) | def __init__(self, cfg, device):
    method __call__ (line 73) | def __call__(
  function run_kys_tracker (line 87) | def run_kys_tracker(

FILE: VQ2D/vq2d/tracking/particle_filter.py
  function observe (line 19) | def observe(x, image, template_size):
  function deep_metric (line 68) | def deep_metric(x, y):
  function metric (line 80) | def metric(x, y, sigma=1):
  class PFRunner (line 92) | class PFRunner(object):
    method __init__ (line 93) | def __init__(self, cfg, device):
    method __call__ (line 97) | def __call__(
  function run_pfilter (line 120) | def run_pfilter(

FILE: VQ2D/vq2d/tracking/pfilter.py
  function make_heat_adjusted (line 12) | def make_heat_adjusted(sigma):
  function systematic_resample (line 21) | def systematic_resample(weights):
  function stratified_resample (line 27) | def stratified_resample(weights):
  function residual_resample (line 33) | def residual_resample(weights):
  function create_indices (line 52) | def create_indices(positions, weights):
  function multinomial_resample (line 70) | def multinomial_resample(weights):
  function resample (line 75) | def resample(weights):
  function squared_error (line 91) | def squared_error(x, y, sigma=1):
  function gaussian_noise (line 114) | def gaussian_noise(x, sigmas):
  function cauchy_noise (line 127) | def cauchy_noise(x, sigmas):
  function independent_sample (line 140) | def independent_sample(fn_list):
  function convert_image_np2torch (line 160) | def convert_image_np2torch(image, size=256):
  class ParticleFilter (line 189) | class ParticleFilter(object):
    method __init__ (line 226) | def __init__(
    method init_filter (line 310) | def init_filter(self, mask=None):
    method update (line 327) | def update(self, observed=None, **kwargs):
    method viz_particles (line 481) | def viz_particles(self, observed):

FILE: VQ2D/vq2d/tracking/tracker.py
  class Tracker (line 5) | class Tracker:
    method __init__ (line 14) | def __init__(self, cfg, device):
    method initialize_runner (line 23) | def initialize_runner(self):
    method __call__ (line 29) | def __call__(self, *args, **kwargs):

FILE: VQ2D/vq2d/tracking/utils.py
  function draw_bbox (line 7) | def draw_bbox(image: np.ndarray, bbox: BBox) -> np.ndarray:

FILE: VQ3D/VQ3D/API/get_query_3d_ground_truth.py
  class VisualQuery3DGroundTruth (line 14) | class VisualQuery3DGroundTruth():
    method __init__ (line 15) | def __init__(self):
    method load_pose (line 18) | def load_pose(self, dirname: str):
    method load_3d_annotation (line 45) | def load_3d_annotation(self, data: Dict):
    method create_traj_azure (line 52) | def create_traj_azure(self, output_traj, K, Ci_T_G=None):
    method read_pfm (line 80) | def read_pfm(self, path):

FILE: VQ3D/VQ3D/API/metrics.py
  class distL2 (line 8) | class distL2():
    method compute (line 9) | def compute(self, v1:np.ndarray, v2:np.ndarray) -> float:
  class angularError (line 13) | class angularError():
    method compute (line 14) | def compute(self, v1:np.ndarray, v2:np.ndarray) -> float:
  class accuracy (line 25) | class accuracy():
    method compute (line 26) | def compute(self, t:np.ndarray, box1:BoundingBox, box2:BoundingBox) ->...

FILE: VQ3D/VQ3D/scripts/prepare_ground_truth_for_queries.py
  function parse_VQ2D_queries (line 14) | def parse_VQ2D_queries(filename: str) -> Dict:

FILE: VQ3D/VQ3D/scripts/run.py
  function scale_im_height (line 15) | def scale_im_height(image, H):
  function _get_box (line 20) | def _get_box(annot_box):
  function parse_VQ2D_queries (line 24) | def parse_VQ2D_queries(filename: str) -> Dict:
  function parse_VQ2D_predictions (line 49) | def parse_VQ2D_predictions(filename: str) -> Dict:
  function parse_VQ2D_mapper (line 59) | def parse_VQ2D_mapper(filename: str) -> Dict:

FILE: VQ3D/annotation_API/API/bounding_box.py
  class BoundingBox (line 6) | class BoundingBox():
    method __init__ (line 7) | def __init__(self, data: Any = None, scale=1.0):
    method load (line 12) | def load(self, data: Any ) -> None:
    method volume (line 39) | def volume(self) -> float:
    method get_transformation_matrix (line 42) | def get_transformation_matrix(self) -> np.ndarray:
    method build_box (line 80) | def build_box(self) -> List[np.array]:
    method save_off (line 106) | def save_off(self, filename: str) -> None:

FILE: VQ3D/camera_pose_estimation/Camera_Intrinsics_API/extract_frames.py
  class FrameExtractor (line 4) | class FrameExtractor():
    method extract (line 5) | def extract(self, filename: str, output_dir: str) -> None:

FILE: VQ3D/camera_pose_estimation/Camera_Intrinsics_API/get_camera_intrinsics.py
  class CameraIntrinsicsHelper (line 11) | class CameraIntrinsicsHelper():
    method __init__ (line 12) | def __init__(self):
    method is_blurry (line 17) | def is_blurry(self, image: np.ndarray) -> bool:
    method select_good_frames_indices (line 26) | def select_good_frames_indices(self, images_files: List, images_dir: s...
    method select_good_frames (line 103) | def select_good_frames(self, images_dir:str) -> None:
    method run_colmap (line 124) | def run_colmap(self) -> List:
    method parse_colmap_intrinsics (line 155) | def parse_colmap_intrinsics(self, camera_txt_filename: str)-> Dict:
    method get_camera_intrinsics (line 176) | def get_camera_intrinsics(self, images_dir: str) -> Tuple:

FILE: VQ3D/camera_pose_estimation/SuperGlueMatching/extract_visual_database.py
  function convert_2d_to_3d (line 25) | def convert_2d_to_3d(u, v, z, K):
  class MatterportDataset (line 35) | class MatterportDataset(Dataset):
    method __init__ (line 36) | def __init__(self, dataset_name='walterlib', resize=[640, 480], root=''):
    method __getitem__ (line 45) | def __getitem__(self, index):
    method __len__ (line 55) | def __len__(self):
  class AzureKinect (line 59) | class AzureKinect(Dataset):
    method __init__ (line 60) | def __init__(self, dataset_name='walter_basement_03', resize=[640, 480...
    method __getitem__ (line 71) | def __getitem__(self, index):
    method __len__ (line 81) | def __len__(self):
  function PnP (line 85) | def PnP(x1s, f3ds, x2s, m1_ids, K1, K2, DATABASE_IMAGE_FOLDER):
  class AzureKinectPosePnP (line 194) | class AzureKinectPosePnP(Dataset):
    method __init__ (line 195) | def __init__(self, match_database='', database_image_folder='', image_...
    method __getitem__ (line 204) | def __getitem__(self, index):
    method __len__ (line 262) | def __len__(self):

FILE: VQ3D/camera_pose_estimation/SuperGlueMatching/models/matching.py
  class Matching (line 49) | class Matching(torch.nn.Module):
    method __init__ (line 51) | def __init__(self, config={}):
    method forward (line 56) | def forward(self, data):

FILE: VQ3D/camera_pose_estimation/SuperGlueMatching/models/superglue.py
  function MLP (line 49) | def MLP(channels: list, do_bn=True):
  function normalize_keypoints (line 63) | def normalize_keypoints(kpts, image_shape):
  class KeypointEncoder (line 73) | class KeypointEncoder(nn.Module):
    method __init__ (line 75) | def __init__(self, feature_dim, layers):
    method forward (line 80) | def forward(self, kpts, scores):
  function attention (line 85) | def attention(query, key, value):
  class MultiHeadedAttention (line 92) | class MultiHeadedAttention(nn.Module):
    method __init__ (line 94) | def __init__(self, num_heads: int, d_model: int):
    method forward (line 102) | def forward(self, query, key, value):
  class AttentionalPropagation (line 110) | class AttentionalPropagation(nn.Module):
    method __init__ (line 111) | def __init__(self, feature_dim: int, num_heads: int):
    method forward (line 117) | def forward(self, x, source):
  class AttentionalGNN (line 122) | class AttentionalGNN(nn.Module):
    method __init__ (line 123) | def __init__(self, feature_dim: int, layer_names: list):
    method forward (line 130) | def forward(self, desc0, desc1):
  function log_sinkhorn_iterations (line 141) | def log_sinkhorn_iterations(Z, log_mu, log_nu, iters: int):
  function log_optimal_transport (line 150) | def log_optimal_transport(scores, alpha, iters: int):
  function arange_like (line 173) | def arange_like(x, dim: int):
  class SuperGlue (line 177) | class SuperGlue(nn.Module):
    method __init__ (line 204) | def __init__(self, config):
    method forward (line 228) | def forward(self, data):

FILE: VQ3D/camera_pose_estimation/SuperGlueMatching/models/superpoint.py
  function simple_nms (line 47) | def simple_nms(scores, nms_radius: int):
  function remove_borders (line 65) | def remove_borders(keypoints, scores, border: int, height: int, width: i...
  function top_k_keypoints (line 73) | def top_k_keypoints(keypoints, scores, k: int):
  function sample_descriptors (line 80) | def sample_descriptors(keypoints, descriptors, s: int = 8):
  class SuperPoint (line 95) | class SuperPoint(nn.Module):
    method __init__ (line 111) | def __init__(self, config):
    method forward (line 145) | def forward(self, data):

FILE: VQ3D/camera_pose_estimation/SuperGlueMatching/models/utils.py
  class AverageTimer (line 57) | class AverageTimer:
    method __init__ (line 60) | def __init__(self, smoothing=0.3, newline=False):
    method reset (line 67) | def reset(self):
    method update (line 74) | def update(self, name='default'):
    method print (line 83) | def print(self, text='Timer'):
  class VideoStreamer (line 99) | class VideoStreamer:
    method __init__ (line 106) | def __init__(self, basedir, resize, skip, image_glob, max_length=10000...
    method load_image (line 159) | def load_image(self, impath):
    method next_frame (line 175) | def next_frame(self):
    method start_ip_camera_thread (line 213) | def start_ip_camera_thread(self):
    method update_ip_camera (line 220) | def update_ip_camera(self):
    method cleanup (line 235) | def cleanup(self):
  function process_resize (line 240) | def process_resize(w, h, resize):
  function frame2tensor (line 259) | def frame2tensor(frame, device):
  function read_image (line 263) | def read_image(path, device, resize, rotation, resize_float):
  function estimate_pose (line 288) | def estimate_pose(kpts0, kpts1, K0, K1, thresh, conf=0.99999):
  function rotate_intrinsics (line 315) | def rotate_intrinsics(K, image_shape, rot):
  function rotate_pose_inplane (line 335) | def rotate_pose_inplane(i_T_w, rot):
  function scale_intrinsics (line 346) | def scale_intrinsics(K, scales):
  function to_homogeneous (line 351) | def to_homogeneous(points):
  function compute_epipolar_error (line 355) | def compute_epipolar_error(kpts0, kpts1, T_0to1, K0, K1):
  function angle_error_mat (line 377) | def angle_error_mat(R1, R2):
  function angle_error_vec (line 383) | def angle_error_vec(v1, v2):
  function compute_pose_error (line 388) | def compute_pose_error(T_0to1, R, t):
  function pose_auc (line 397) | def pose_auc(errors, thresholds):
  function plot_image_pair (line 415) | def plot_image_pair(imgs, dpi=100, size=6, pad=.5):
  function plot_keypoints (line 429) | def plot_keypoints(kpts0, kpts1, color='w', ps=2):
  function plot_matches (line 435) | def plot_matches(kpts0, kpts1, color, lw=1.5, ps=4):
  function make_matching_plot (line 452) | def make_matching_plot(image0, image1, kpts0, kpts1, mkpts0, mkpts1,
  function make_matching_plot_fast (line 484) | def make_matching_plot_fast(image0, image1, kpts0, kpts1, mkpts0,
  function error_colormap (line 553) | def error_colormap(x):

FILE: VQ3D/camera_pose_estimation/Visualization/visualize_render_images.py
  function create_traj_azure (line 19) | def create_traj_azure(output_traj, K, Ci_T_G=None):
  function custom_draw_geometry_with_camera_trajectory (line 46) | def custom_draw_geometry_with_camera_trajectory(pcd, output_path='',

FILE: VQ3D/camera_pose_estimation/extract_frames_all_clips.py
  function frame_extractor (line 75) | def frame_extractor(inputs):

FILE: VQ3D/camera_pose_estimation/extract_frames_for_colmap.py
  function extract_frames_for_sfm (line 12) | def extract_frames_for_sfm(inputs):

FILE: VQ3D/camera_pose_estimation/get_intrinsics_for_all_clips.py
  function run_automatic_reconstruction (line 34) | def run_automatic_reconstruction(inputs):

FILE: VQ3D/camera_pose_estimation/get_intrinsics_for_all_clips_greedy.py
  function run_automatic_reconstruction (line 47) | def run_automatic_reconstruction(inputs):

FILE: VQ3D/camera_pose_estimation/pnp_api.py
  function PnP (line 12) | def PnP(x1s, f3ds, x2s, m1_ids, K1, K2, thres=1e-2):
  class PosePnP_points_accumulation (line 87) | class PosePnP_points_accumulation(Dataset):
    method __init__ (line 88) | def __init__(self, match_database='', img_desc_folder='', image_list=N...
    method __getitem__ (line 97) | def __getitem__(self, index):
    method __len__ (line 162) | def __len__(self):

FILE: VQ3D/camera_pose_estimation/reconstruction.py
  function FindMissingReconstruction (line 10) | def FindMissingReconstruction(X, track_i):
  function Triangulation_nl (line 31) | def Triangulation_nl(X, P1, P2, x1, x2):
  function Triangulation_RANSAC (line 89) | def Triangulation_RANSAC(uv1, P, ransac_n_iter=30, threshold=1e-2):
  function TriangulationD_RANSAC (line 127) | def TriangulationD_RANSAC(Ci_f, P, ransac_n_iter=10, threshold=1e-2):
  function Triangulation_LS (line 161) | def Triangulation_LS(uv1_inlier, P_inlier):
  function ComputePointJacobian (line 170) | def ComputePointJacobian(X, p):
  function SetupBundleAdjustment (line 205) | def SetupBundleAdjustment(P, X, track, fixed_poses=None):
  function MeasureReprojection (line 299) | def MeasureReprojection(z, b, n_cameras, n_points, camera_index, point_i...
  function UpdatePosePoint (line 341) | def UpdatePosePoint(z0, z, n_cameras, n_points):
  function RunBundleAdjustment (line 381) | def RunBundleAdjustment(P, X, track, fixed_poses=None):

FILE: VQ3D/camera_pose_estimation/run_all_data.py
  function load_vq3d_annotation (line 12) | def load_vq3d_annotation(filename):

FILE: VQ3D/camera_pose_estimation/sfm_api_wsuperglue.py
  function convert_2d_to_3d (line 16) | def convert_2d_to_3d(u, v, z, K):
  function PnP (line 25) | def PnP(x1s, x2s, m1_ids, K1, K2, DATABASE_IMAGE_FOLDER):
  function valid_2Dfeatures (line 111) | def valid_2Dfeatures(x):
  function valid_3Dfeatures (line 115) | def valid_3Dfeatures(X):
  function SetupPnPNL (line 119) | def SetupPnPNL(P, X, track):
  function MeasureReprojectionSinglePose (line 164) | def MeasureReprojectionSinglePose(z, b, point_index):
  function UpdatePose (line 187) | def UpdatePose(z):
  function RunPnPNL (line 200) | def RunPnPNL(P, X, track):
  function triangulate_with_track_feat (line 266) | def triangulate_with_track_feat(inputs):
  function refine_poses (line 286) | def refine_poses(inputs):

FILE: VQ3D/camera_pose_estimation/superglue_tracker.py
  function SuperGlueMatcher (line 23) | def SuperGlueMatcher(model,
  function get_tracks_parallel (line 204) | def get_tracks_parallel(inputs):
  function fetch_graph (line 268) | def fetch_graph(g, i, f_idx, start_i):

FILE: VQ3D/camera_pose_estimation/utils.py
  function Vec2Skew (line 14) | def Vec2Skew(v):
  function Rotation2Quaternion (line 23) | def Rotation2Quaternion(R):
  function Quaternion2Rotation (line 62) | def Quaternion2Rotation(q):
  function WritePosesToPly (line 96) | def WritePosesToPly(P, output_path):
  function skewsymm (line 114) | def skewsymm(x):
  function VisualizeTriangulationMultiPoses (line 126) | def VisualizeTriangulationMultiPoses(X, uv1, P, Im, K):
  function VisualizeMatches (line 149) | def VisualizeMatches(im1_file, kp1, im2_file, kp2):
  function VisualizeTrack (line 163) | def VisualizeTrack(track, Im_input, K):
  function VisualizeReprojectionError (line 190) | def VisualizeReprojectionError(P, X, track, K, Im):
  function VisualizeBadPoseImage (line 207) | def VisualizeBadPoseImage(Im):
  function convert_2d_to_3d (line 225) | def convert_2d_to_3d(u, v, z, K):
  class MatterportDataset (line 235) | class MatterportDataset(Dataset):
    method __init__ (line 236) | def __init__(self, dataset_folder='walterlib', resize=[640, 480]):
    method __getitem__ (line 245) | def __getitem__(self, index):
    method __len__ (line 255) | def __len__(self):
  class AzureKinect (line 259) | class AzureKinect(Dataset):
    method __init__ (line 260) | def __init__(self, dataset_folder='walter_basement_03', resize=[640, 4...
    method __getitem__ (line 271) | def __getitem__(self, index):
    method __len__ (line 282) | def __len__(self):

FILE: VQ3D/depth_estimation/prepare_inputs_for_depth_estimation.py
  function parse_VQ2D_queries (line 14) | def parse_VQ2D_queries(filename: str) -> Dict:
  function parse_VQ3D_queries (line 38) | def parse_VQ3D_queries(filename: str) -> List:
  function parse_VQ2D_predictions (line 47) | def parse_VQ2D_predictions(filename: str) -> Dict:
  function parse_VQ2D_mapper (line 74) | def parse_VQ2D_mapper(filename: str) -> Dict: