SYMBOL INDEX (1221 symbols across 118 files)

FILE: demo.py
  function main (line 13) | def main():

FILE: hubconf.py
  function _load_ckpt (line 14) | def _load_ckpt(spec: str):
  function _extract_model_state (line 26) | def _extract_model_state(sd):
  function _build_model (line 44) | def _build_model(**overrides):
  function _load_into (line 69) | def _load_into(model, checkpoint_key: str):
  function mvtracker_model (line 78) | def mvtracker_model(*,
  function mvtracker_predictor (line 96) | def mvtracker_predictor(*,
  function mvtracker (line 132) | def mvtracker(pretrained: bool = True, device: str = "cuda"):
  function mvtracker_cleandepth (line 137) | def mvtracker_cleandepth(pretrained: bool = True, device: str = "cuda"):

FILE: mvtracker/cli/eval.py
  function main (line 8) | def main(cfg: DictConfig):

FILE: mvtracker/cli/train.py
  function fetch_optimizer (line 55) | def fetch_optimizer(trainer_cfg, model):
  function forward_batch_multi_view (line 78) | def forward_batch_multi_view(batch, model, cfg, step, train_iters, gamma...
  function run_test_eval (line 232) | def run_test_eval(cfg, evaluator, model, dataloaders, writer, step):
  function augment_train_iters (line 317) | def augment_train_iters(train_iters: int, current_step: int, warmup_step...
  function main (line 344) | def main(cfg: DictConfig):

FILE: mvtracker/cli/utils/helpers.py
  function extras (line 15) | def extras(cfg: DictConfig) -> None:
  function task_wrapper (line 50) | def task_wrapper(task_func: Callable) -> Callable:
  function get_metric_value (line 105) | def get_metric_value(metric_dict: Dict[str, Any], metric_name: Optional[...
  function maybe_close_wandb (line 129) | def maybe_close_wandb(fn: Callable) -> Callable:

FILE: mvtracker/cli/utils/pylogger.py
  class RankedLogger (line 7) | class RankedLogger(logging.LoggerAdapter):
    method __init__ (line 10) | def __init__(
    method log (line 27) | def log(self, level: int, msg: str, rank: Optional[int] = None, *args,...

FILE: mvtracker/cli/utils/rich_utils.py
  function print_config_tree (line 18) | def print_config_tree(
  function enforce_tags (line 74) | def enforce_tags(cfg: DictConfig, save_to_file: bool = False) -> None:

FILE: mvtracker/datasets/dexycb_multiview_dataset.py
  class DexYCBMultiViewDataset (line 20) | class DexYCBMultiViewDataset(Dataset):
    method from_name (line 23) | def from_name(dataset_name: str, dataset_root: str):
    method __init__ (line 115) | def __init__(
    method _get_sequence_names (line 146) | def _get_sequence_names(self, max_videos):
    method _cache_key (line 184) | def _cache_key(self):
    method __len__ (line 194) | def __len__(self):
    method __getitem__ (line 197) | def __getitem__(self, index):
    method _getitem_helper (line 207) | def _getitem_helper(self, index):
  function rerun_viz_scene (line 572) | def rerun_viz_scene(entity_prefix, rgbs, depths, intrs, extrs, tracks, r...

FILE: mvtracker/datasets/generic_scene_dataset.py
  class GenericSceneDataset (line 20) | class GenericSceneDataset(Dataset):
    method __init__ (line 21) | def __init__(
    method __len__ (line 95) | def __len__(self):
    method __getitem__ (line 98) | def __getitem__(self, idx):
  function compute_auto_scene_normalization (line 288) | def compute_auto_scene_normalization(
  function _ensure_moge2_cache_and_load (line 361) | def _ensure_moge2_cache_and_load(rgbs, seq_name, dataset_root, moge2_cac...
  function _ensure_monofusion_cache_and_load (line 387) | def _ensure_monofusion_cache_and_load(rgbs, seq_name, dataset_root, mono...
  function _static_bg_mask_from_window (line 511) | def _static_bg_mask_from_window(
  function _moge_depths (line 555) | def _moge_depths(seq_name, rgbs, cache_root, resize_to=512, batch_size=18):
  function _ensure_vggt_raw_cache_and_load (line 607) | def _ensure_vggt_raw_cache_and_load(
  function _vggt_load_and_preprocess_images (line 720) | def _vggt_load_and_preprocess_images(image_items, mode="crop"):
  function _ensure_vggt_aligned_cache_and_load (line 854) | def _ensure_vggt_aligned_cache_and_load(

FILE: mvtracker/datasets/kubric_multiview_dataset.py
  class KubricMultiViewDataset (line 27) | class KubricMultiViewDataset(torch.utils.data.Dataset):
    method from_name (line 30) | def from_name(
    method __init__ (line 206) | def __init__(
    method _cache_key (line 431) | def _cache_key(self):
    method __len__ (line 445) | def __len__(self):
    method __getitem__ (line 448) | def __getitem__(self, index):
    method _getitem_helper (line 470) | def _getitem_helper(self, index):
    method getitem_raw_datapoint (line 1114) | def getitem_raw_datapoint(scene_path, perform_2d_projection_sanity_che...
    method depth_from_euclidean_to_z (line 1258) | def depth_from_euclidean_to_z(depth, sensor_width, focal_length):
    method _add_photometric_augs (line 1276) | def _add_photometric_augs(
    method _add_cropping_augs (line 1405) | def _add_cropping_augs(self, crop_size, rgbs, depths, intrs, trajs, vi...
    method _add_cropping_augs_with_pp_at_center (line 1570) | def _add_cropping_augs_with_pp_at_center(self, crop_size, rgbs, depths...
    method _rescale_and_erase_depth_patches (line 1656) | def _rescale_and_erase_depth_patches(self, depths, trajs, visibles, rn...
    method _crop (line 1722) | def _crop(self, rgbs, trajs, crop_size):

FILE: mvtracker/datasets/panoptic_studio_multiview_dataset.py
  class PanopticStudioMultiViewDataset (line 19) | class PanopticStudioMultiViewDataset(Dataset):
    method from_name (line 21) | def from_name(dataset_name: str, dataset_root: str):
    method __init__ (line 100) | def __init__(
    method _get_sequence_names (line 127) | def _get_sequence_names(self, max_videos):
    method _cache_key (line 161) | def _cache_key(self):
    method __len__ (line 169) | def __len__(self):
    method __getitem__ (line 172) | def __getitem__(self, index):
    method _getitem_helper (line 182) | def _getitem_helper(self, index):

FILE: mvtracker/datasets/tap_vid_datasets.py
  function resize_video (line 30) | def resize_video(video: np.ndarray, output_size: Tuple[int, int]) -> np....
  function sample_queries_first (line 37) | def sample_queries_first(
  function sample_queries_strided (line 79) | def sample_queries_strided(
  class TapVidDataset (line 143) | class TapVidDataset(torch.utils.data.Dataset):
    method from_name (line 146) | def from_name(dataset_name: str, dataset_root: str):
    method __init__ (line 196) | def __init__(
    method __getitem__ (line 250) | def __getitem__(self, index):
    method __len__ (line 704) | def __len__(self):
  function zoedepth_nk (line 709) | def zoedepth_nk(rgbs, batch_size=2, device="cuda", cached_file=None):
  function rigid_registration (line 734) | def rigid_registration(
  function rigid_registration_ransac (line 762) | def rigid_registration_ransac(
  function to_homogeneous (line 795) | def to_homogeneous(x):
  function from_homogeneous (line 799) | def from_homogeneous(x, assert_homogeneous_part_is_equal_to_1=False, eps...
  function to_homogenous_torch (line 805) | def to_homogenous_torch(x):
  function moge (line 810) | def moge(rgbs, batch_size=10, device="cuda", cached_file=None, intrinsic...
  function megasam (line 920) | def megasam(rgbs: torch.Tensor, batch_size: int = 10, device: str = "cud...

FILE: mvtracker/datasets/utils.py
  class Datapoint (line 23) | class Datapoint:
  function collate_fn (line 55) | def collate_fn(batch):
  function try_to_cuda (line 144) | def try_to_cuda(t: Any) -> Any:
  function dataclass_to_cuda_ (line 161) | def dataclass_to_cuda_(obj):
  function read_json (line 176) | def read_json(filename: str) -> Any:
  function read_tiff (line 181) | def read_tiff(filename: str) -> np.ndarray:
  function read_png (line 189) | def read_png(filename: str, rescale_range=None) -> np.ndarray:
  function transform_scene (line 210) | def transform_scene(
  function add_camera_noise (line 304) | def add_camera_noise(intrs, extrs, noise_std_intr=0.01, noise_std_extr=0...
  function aug_depth (line 332) | def aug_depth(depth, grid=(8, 8), scale=(0.7, 1.3), shift=(-0.1, 0.1),
  function align_umeyama (line 362) | def align_umeyama(model, data, known_scale=False, yaw_only=False):
  function get_camera_center (line 397) | def get_camera_center(extr):
  function apply_sim3_to_extrinsics (line 403) | def apply_sim3_to_extrinsics(vggt_extrinsics, s, R_align, t_align):
  function get_best_yaw (line 418) | def get_best_yaw(C):
  function rot_z (line 431) | def rot_z(theta):

FILE: mvtracker/evaluation/evaluator_3dpt.py
  class NumpyEncoder (line 29) | class NumpyEncoder(json.JSONEncoder):
    method default (line 30) | def default(self, obj):
  function kmeans_sample (line 42) | def kmeans_sample(pts, count):
  function evaluate_3dpt (line 62) | def evaluate_3dpt(
  class Evaluator (line 176) | class Evaluator:
    method __init__ (line 177) | def __init__(
    method evaluate_sequence (line 212) | def evaluate_sequence(

FILE: mvtracker/evaluation/metrics.py
  function compute_metrics (line 10) | def compute_metrics(
  function compute_tapvid_metrics (line 61) | def compute_tapvid_metrics(
  function compute_tapvid_metrics_original (line 174) | def compute_tapvid_metrics_original(
  function evaluate_predictions (line 303) | def evaluate_predictions(

FILE: mvtracker/models/core/copycat.py
  class CopyCat (line 5) | class CopyCat(nn.Module):
    method __init__ (line 10) | def __init__(self):
    method forward (line 14) | def forward(

FILE: mvtracker/models/core/cotracker2/blocks.py
  function _ntuple (line 17) | def _ntuple(n):
  function exists (line 26) | def exists(val):
  function default (line 30) | def default(val, d):
  class Mlp (line 37) | class Mlp(nn.Module):
    method __init__ (line 40) | def __init__(
    method forward (line 61) | def forward(self, x):
  class ResidualBlock (line 70) | class ResidualBlock(nn.Module):
    method __init__ (line 71) | def __init__(self, in_planes, planes, norm_fn="group", stride=1):
    method forward (line 119) | def forward(self, x):
  class BasicEncoder (line 130) | class BasicEncoder(nn.Module):
    method __init__ (line 131) | def __init__(self, input_dim=3, output_dim=128, stride=4):
    method _make_layer (line 172) | def _make_layer(self, dim, stride=1):
    method forward (line 180) | def forward(self, x):
  class Attention (line 212) | class Attention(nn.Module):
    method __init__ (line 213) | def __init__(self, query_dim, context_dim=None, num_heads=8, dim_head=...
    method forward (line 224) | def forward(self, x, context=None, attn_mask=None):
  class FlashAttention (line 246) | class FlashAttention(nn.Module):
    method __init__ (line 247) | def __init__(self, query_dim, context_dim=None, num_heads=8, dim_head=...
    method forward (line 258) | def forward(self, x, context=None, attn_mask=None):
  class AttnBlock (line 274) | class AttnBlock(nn.Module):
    method __init__ (line 275) | def __init__(
    method forward (line 297) | def forward(self, x, attn_mask=None):
  class CrossAttnBlock (line 303) | class CrossAttnBlock(nn.Module):
    method __init__ (line 304) | def __init__(
    method forward (line 334) | def forward(self, x, context, attn_mask=None):
  class EfficientUpdateFormer (line 340) | class EfficientUpdateFormer(nn.Module):
    method __init__ (line 345) | def __init__(
    method initialize_weights (line 436) | def initialize_weights(self):
    method forward (line 455) | def forward(self, input_tensor, mask=None):

FILE: mvtracker/models/core/dpt/base_model.py
  class BaseModel (line 4) | class BaseModel(torch.nn.Module):
    method load (line 5) | def load(self, path):

FILE: mvtracker/models/core/dpt/blocks.py
  function _make_encoder (line 12) | def _make_encoder(
  function _make_scratch (line 77) | def _make_scratch(in_shape, out_shape, groups=1, expand=False):
  function _make_resnet_backbone (line 130) | def _make_resnet_backbone(resnet):
  function _make_pretrained_resnext101_wsl (line 143) | def _make_pretrained_resnext101_wsl(use_pretrained):
  class Interpolate (line 148) | class Interpolate(nn.Module):
    method __init__ (line 151) | def __init__(self, scale_factor, mode, align_corners=False):
    method forward (line 165) | def forward(self, x):
  class ResidualConvUnit (line 185) | class ResidualConvUnit(nn.Module):
    method __init__ (line 188) | def __init__(self, features):
    method forward (line 206) | def forward(self, x):
  class FeatureFusionBlock (line 223) | class FeatureFusionBlock(nn.Module):
    method __init__ (line 226) | def __init__(self, features):
    method forward (line 237) | def forward(self, *xs):
  class ResidualConvUnit_custom (line 257) | class ResidualConvUnit_custom(nn.Module):
    method __init__ (line 260) | def __init__(self, features, activation, bn):
    method forward (line 300) | def forward(self, x):
  class FeatureFusionBlock_custom (line 328) | class FeatureFusionBlock_custom(nn.Module):
    method __init__ (line 331) | def __init__(
    method forward (line 372) | def forward(self, *xs):

FILE: mvtracker/models/core/dpt/midas_net.py
  class MidasNet_large (line 12) | class MidasNet_large(BaseModel):
    method __init__ (line 15) | def __init__(self, path=None, features=256, non_negative=True):
    method forward (line 50) | def forward(self, x):

FILE: mvtracker/models/core/dpt/models.py
  function _make_fusion_block (line 14) | def _make_fusion_block(features, use_bn):
  class DPT (line 25) | class DPT(BaseModel):
    method __init__ (line 26) | def __init__(
    method forward (line 87) | def forward(self, x, only_enc=False):
  class DPTDepthModel (line 142) | class DPTDepthModel(DPT):
    method __init__ (line 143) | def __init__(
    method forward (line 167) | def forward(self, x):
  class DPTEncoder (line 179) | class DPTEncoder(DPT):
    method __init__ (line 180) | def __init__(
    method forward (line 197) | def forward(self, x):
  class DPTSegmentationModel (line 203) | class DPTSegmentationModel(DPT):
    method __init__ (line 204) | def __init__(self, num_classes, path=None, **kwargs):

FILE: mvtracker/models/core/dpt/transforms.py
  function apply_min_size (line 6) | def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AR...
  class Resize (line 48) | class Resize(object):
    method __init__ (line 51) | def __init__(
    method constrain_to_multiple_of (line 93) | def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
    method get_size (line 104) | def get_size(self, width, height):
    method __call__ (line 161) | def __call__(self, sample):
  class NormalizeImage (line 196) | class NormalizeImage(object):
    method __init__ (line 199) | def __init__(self, mean, std):
    method __call__ (line 203) | def __call__(self, sample):
  class PrepareForNet (line 209) | class PrepareForNet(object):
    method __init__ (line 212) | def __init__(self):
    method __call__ (line 215) | def __call__(self, sample):

FILE: mvtracker/models/core/dpt/vit.py
  function get_activation (line 12) | def get_activation(name):
  function get_attention (line 22) | def get_attention(name):
  function get_mean_attention_map (line 45) | def get_mean_attention_map(attn, token, shape):
  class Slice (line 57) | class Slice(nn.Module):
    method __init__ (line 58) | def __init__(self, start_index=1):
    method forward (line 62) | def forward(self, x):
  class AddReadout (line 66) | class AddReadout(nn.Module):
    method __init__ (line 67) | def __init__(self, start_index=1):
    method forward (line 71) | def forward(self, x):
  class ProjectReadout (line 79) | class ProjectReadout(nn.Module):
    method __init__ (line 80) | def __init__(self, in_features, start_index=1):
    method forward (line 86) | def forward(self, x):
  class Transpose (line 93) | class Transpose(nn.Module):
    method __init__ (line 94) | def __init__(self, dim0, dim1):
    method forward (line 99) | def forward(self, x):
  function forward_vit (line 104) | def forward_vit(pretrained, x):
  function _resize_pos_embed (line 148) | def _resize_pos_embed(self, posemb, gs_h, gs_w):
  function forward_flex (line 165) | def forward_flex(self, x):
  function get_readout_oper (line 203) | def get_readout_oper(vit_features, features, use_readout, start_index=1):
  function _make_vit_b16_backbone (line 220) | def _make_vit_b16_backbone(
  function _make_vit_b_rn50_backbone (line 350) | def _make_vit_b_rn50_backbone(
  function _make_pretrained_vitb_rn50_384 (line 493) | def _make_pretrained_vitb_rn50_384(
  function _make_pretrained_vit_tiny (line 515) | def _make_pretrained_vit_tiny(
  function _make_pretrained_vitl16_384 (line 538) | def _make_pretrained_vitl16_384(
  function _make_pretrained_vitb16_384 (line 554) | def _make_pretrained_vitb16_384(
  function _make_pretrained_deitb16_384 (line 569) | def _make_pretrained_deitb16_384(
  function _make_pretrained_deitb16_distil_384 (line 584) | def _make_pretrained_deitb16_distil_384(

FILE: mvtracker/models/core/dynamic3dgs/export_depths_from_pretrained_checkpoint.py
  function load_scene_data (line 14) | def load_scene_data(params_path, seg_as_col=False):
  function render (line 33) | def render(w, h, k, w2c, timestep_data, near=0.01, far=100.0):
  function export_depth (line 41) | def export_depth(scene_root, output_root, checkpoint_path):

FILE: mvtracker/models/core/dynamic3dgs/external.py
  function build_rotation (line 24) | def build_rotation(q):
  function calc_mse (line 44) | def calc_mse(img1, img2):
  function calc_psnr (line 48) | def calc_psnr(img1, img2):
  function gaussian (line 53) | def gaussian(window_size, sigma):
  function create_window (line 58) | def create_window(window_size, channel):
  function calc_ssim (line 65) | def calc_ssim(img1, img2, window_size=11, size_average=True):
  function _ssim (line 76) | def _ssim(img1, img2, window, window_size, channel, size_average=True):
  function accumulate_mean2d_gradient (line 99) | def accumulate_mean2d_gradient(variables):
  function update_params_and_optimizer (line 106) | def update_params_and_optimizer(new_params, params, optimizer):
  function cat_params_to_optimizer (line 121) | def cat_params_to_optimizer(new_params, params, optimizer):
  function remove_points (line 138) | def remove_points(to_remove, params, variables, optimizer):
  function inverse_sigmoid (line 160) | def inverse_sigmoid(x):
  function densify (line 164) | def densify(params, variables, optimizer, i):

FILE: mvtracker/models/core/dynamic3dgs/helpers.py
  function setup_camera (line 9) | def setup_camera(w, h, k, w2c, near=0.01, far=100):
  function params2rendervar (line 35) | def params2rendervar(params):
  function l1_loss_v1 (line 47) | def l1_loss_v1(x, y):
  function l1_loss_v2 (line 51) | def l1_loss_v2(x, y):
  function weighted_l2_loss_v1 (line 55) | def weighted_l2_loss_v1(x, y, w):
  function weighted_l2_loss_v2 (line 59) | def weighted_l2_loss_v2(x, y, w):
  function quat_mult (line 63) | def quat_mult(q1, q2):
  function o3d_knn (line 73) | def o3d_knn(pts, num_knn):
  function params2cpu (line 86) | def params2cpu(params, is_initial_timestep):
  function save_params (line 95) | def save_params(output_params, seq, exp):

FILE: mvtracker/models/core/dynamic3dgs/merge_tapvid3d_per_camera_annotations.py
  function to_homogeneous (line 18) | def to_homogeneous(x):
  function from_homogeneous (line 22) | def from_homogeneous(x, assert_homogeneous_part_is_equal_to_1=False, eps...
  function load_scene_data (line 28) | def load_scene_data(params_path, seg_as_col=False):
  function render (line 47) | def render(h, w, k, w2c, timestep_data, near=0.01, far=100.0):
  function merge_annotations (line 55) | def merge_annotations(

FILE: mvtracker/models/core/dynamic3dgs/test.py
  function load_saved_params (line 17) | def load_saved_params(seq, exp):
  function prepare_test_dataset (line 25) | def prepare_test_dataset(t, md, seq, exclude_cam_ids):
  function render_image (line 47) | def render_image(cam, rendervar):
  function test (line 54) | def test(seq, exp, exclude_cam_ids=[]):

FILE: mvtracker/models/core/dynamic3dgs/track_2d.py
  function gaussian_influence (line 18) | def gaussian_influence(point, gaussians):
  function render_depth (line 72) | def render_depth(timestep_data, w2c, k):
  function load_scene_data (line 96) | def load_scene_data(seq, exp, seg_as_col=False):
  function unproject_2d_to_3d (line 124) | def unproject_2d_to_3d(query_pt, depth_map, intrinsics):
  function load_camera_params (line 139) | def load_camera_params(dataset_path, seq, cam_id_g):
  function c2w_convert (line 150) | def c2w_convert(point_3d, w2c):
  function w2c_convert (line 157) | def w2c_convert(point_3d_h, w2c):
  function track_query_point (line 163) | def track_query_point(scene_data, query_point, depth_map, w2c, k, t_give...

FILE: mvtracker/models/core/dynamic3dgs/track_3d.py
  function load_scene_data (line 19) | def load_scene_data(seq, exp, seg_as_col=False):
  function load_depth_maps (line 45) | def load_depth_maps(dataset_path, seq, cam_ids):
  function preload_camera_data (line 60) | def preload_camera_data(dataset_path, seq, cam_ids):
  function gaussian_influence (line 79) | def gaussian_influence(point, gaussians):
  function get_visibilities (line 135) | def get_visibilities(
  function track_query_point (line 170) | def track_query_point(

FILE: mvtracker/models/core/dynamic3dgs/train.py
  function get_dataset (line 17) | def get_dataset(t, md, seq):
  function get_batch (line 32) | def get_batch(todo_dataset, dataset):
  function initialize_params (line 39) | def initialize_params(seq, md):
  function initialize_optimizer (line 66) | def initialize_optimizer(params, variables):
  function get_loss (line 81) | def get_loss(params, curr_data, variables, is_initial_timestep):
  function initialize_per_timestep (line 133) | def initialize_per_timestep(params, variables, optimizer):
  function initialize_post_first_timestep (line 156) | def initialize_post_first_timestep(params, variables, optimizer, num_knn...
  function report_progress (line 179) | def report_progress(params, data, i, progress_bar, every_i=100):
  function train (line 189) | def train(seq, exp):

FILE: mvtracker/models/core/dynamic3dgs/visualize.py
  function load_scene_data (line 39) | def load_scene_data(params_path, seg_as_col=False):
  function render (line 62) | def render(w2c, k, timestep_data):
  function log_tracks_to_rerun (line 70) | def log_tracks_to_rerun(
  function visualize (line 165) | def visualize(seq, exp):

FILE: mvtracker/models/core/embeddings.py
  function get_3d_sincos_pos_embed (line 11) | def get_3d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, extra...
  function get_3d_sincos_pos_embed_from_grid (line 35) | def get_3d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_2d_sincos_pos_embed (line 53) | def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, extra...
  function get_2d_sincos_pos_embed_from_grid (line 77) | def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_1d_sincos_pos_embed_from_grid (line 88) | def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
  function get_2d_embedding (line 109) | def get_2d_embedding(xy, C, cat_coords=True):
  function get_3d_embedding (line 134) | def get_3d_embedding(xyz, C, cat_coords=True):
  function get_4d_embedding (line 164) | def get_4d_embedding(xyzw, C, cat_coords=True):
  class Embedder_Fourier (line 202) | class Embedder_Fourier(nn.Module):
    method __init__ (line 203) | def __init__(self, input_dim, max_freq_log2, N_freqs,
    method forward (line 234) | def forward(self,

FILE: mvtracker/models/core/loftr/linear_attention.py
  function elu_feature_map (line 10) | def elu_feature_map(x):
  class LinearAttention (line 14) | class LinearAttention(Module):
    method __init__ (line 15) | def __init__(self, eps=1e-6):
    method forward (line 20) | def forward(self, queries, keys, values, q_mask=None, kv_mask=None):
  class FullAttention (line 50) | class FullAttention(Module):
    method __init__ (line 51) | def __init__(self, use_dropout=False, attention_dropout=0.1):
    method forward (line 56) | def forward(self, queries, keys, values, q_mask=None, kv_mask=None):

FILE: mvtracker/models/core/loftr/transformer.py
  function elu_feature_map (line 13) | def elu_feature_map(x):
  class FullAttention (line 17) | class FullAttention(Module):
    method __init__ (line 18) | def __init__(self, use_dropout=False, attention_dropout=0.1):
    method forward (line 23) | def forward(self, queries, keys, values, q_mask=None, kv_mask=None):
  class TransformerEncoderLayer (line 53) | class TransformerEncoderLayer(nn.Module):
    method __init__ (line 54) | def __init__(self,
    method forward (line 80) | def forward(self, x, source, x_mask=None, source_mask=None):
  class LocalFeatureTransformer (line 106) | class LocalFeatureTransformer(nn.Module):
    method __init__ (line 109) | def __init__(self, config):
    method _reset_parameters (line 120) | def _reset_parameters(self):
    method forward (line 125) | def forward(self, feat0, feat1, mask0=None, mask1=None):

FILE: mvtracker/models/core/losses.py
  function balanced_ce_loss (line 22) | def balanced_ce_loss(pred, gt, valid=None):
  function sequence_loss_3d (line 49) | def sequence_loss_3d(flow_preds, flow_gt, vis, valids, gamma=0.8, dmin=0...

FILE: mvtracker/models/core/model_utils.py
  function smart_cat (line 18) | def smart_cat(tensor1, tensor2, dim):
  function normalize_single (line 24) | def normalize_single(d):
  function normalize (line 32) | def normalize(d):
  function meshgrid2d (line 43) | def meshgrid2d(B, Y, X, stack=False, norm=False, device="cuda"):
  function reduce_masked_mean (line 63) | def reduce_masked_mean(x, mask, dim=None, keepdim=False):
  function bilinear_sample2d (line 81) | def bilinear_sample2d(im, x, y, return_inbounds=False):
  function procrustes_analysis (line 168) | def procrustes_analysis(X0, X1, Weight):  # [B,N,3]
  function bilinear_sampler (line 189) | def bilinear_sampler(input, coords, align_corners=True, padding_mode="bo...
  function sample_features4d (line 252) | def sample_features4d(input, coords):
  function sample_features5d (line 287) | def sample_features5d(input, coords):
  function pixel_xy_and_camera_z_to_world_space (line 320) | def pixel_xy_and_camera_z_to_world_space(pixel_xy, camera_z, intrs_inv, ...
  function world_space_to_pixel_xy_and_camera_z (line 344) | def world_space_to_pixel_xy_and_camera_z(world_xyz, intrs, extrs):
  function get_points_on_a_grid (line 361) | def get_points_on_a_grid(
  function init_pointcloud_from_rgbd (line 420) | def init_pointcloud_from_rgbd(
  function save_pointcloud_to_ply (line 485) | def save_pointcloud_to_ply(filename, points, colors, edges=None):

FILE: mvtracker/models/core/monocular_baselines.py
  class CoTrackerOfflineWrapper (line 16) | class CoTrackerOfflineWrapper(nn.Module):
    method __init__ (line 17) | def __init__(self, model_name="cotracker3_offline", grid_size=10):
    method forward (line 22) | def forward(self, rgbs, queries, **kwargs):
  class CoTrackerOnlineWrapper (line 39) | class CoTrackerOnlineWrapper(nn.Module):
    method __init__ (line 40) | def __init__(self, model_name="cotracker3_online", grid_size=10):
    method forward (line 45) | def forward(self, rgbs, queries, **kwargs):
  class SpaTrackerV2Wrapper (line 65) | class SpaTrackerV2Wrapper(nn.Module):
    method __init__ (line 85) | def __init__(
    method forward (line 104) | def forward(self, rgbs, depths, queries, queries_xyz_worldspace, intrs...
  class LocoTrackWrapper (line 160) | class LocoTrackWrapper(nn.Module):
    method __init__ (line 172) | def __init__(self, model_size="base"):
    method forward (line 179) | def forward(self, rgbs, queries, **kwargs):
  class TAPTRWrapper (line 216) | class TAPTRWrapper(nn.Module):
  class TAPIRWrapper (line 220) | class TAPIRWrapper(nn.Module):
  class PIPSWrapper (line 224) | class PIPSWrapper(nn.Module):
  class PIPSPlusPlusWrapper (line 228) | class PIPSPlusPlusWrapper(nn.Module):
  class SceneTrackerWrapper (line 232) | class SceneTrackerWrapper(nn.Module):
    method __init__ (line 244) | def __init__(
    method forward (line 264) | def forward(self, rgbs, depths, queries_with_z, **kwargs):
  class DELTAWrapper (line 293) | class DELTAWrapper(nn.Module):
    method __init__ (line 307) | def __init__(
    method forward (line 340) | def forward(self, rgbs, depths, queries, **kwargs):
  class TAPIP3DWrapper (line 370) | class TAPIP3DWrapper(nn.Module):
    method __init__ (line 383) | def __init__(
    method forward (line 409) | def forward(self, rgbs, depths, intrs, extrs, queries_xyz_worldspace, ...
    method inference (line 463) | def inference(
  class MonocularToMultiViewAdapter (line 540) | class MonocularToMultiViewAdapter(nn.Module):
    method __init__ (line 541) | def __init__(self, model, **kwargs):
    method forward (line 545) | def forward(
  function bilinear_sampler (line 737) | def bilinear_sampler(input, coords, align_corners=True, padding_mode="bo...

FILE: mvtracker/models/core/mvtracker/mvtracker.py
  function _knn_pointops (line 26) | def _knn_pointops(k: int, xyz_ref: torch.Tensor, xyz_query: torch.Tensor):
  function _knn_torch (line 75) | def _knn_torch(k: int, xyz_ref: torch.Tensor, xyz_query: torch.Tensor):
  class MVTracker (line 93) | class MVTracker(nn.Module):
    method __init__ (line 94) | def __init__(
    method fnet_fwd (line 185) | def fnet_fwd(self, rgbs_normalized, image_features=None):
    method init_stats (line 190) | def init_stats(self):
    method consume_stats (line 194) | def consume_stats(self):
    method forward_iteration (line 244) | def forward_iteration(
    method forward (line 412) | def forward(
  function compute_vggt_scene_normalization_transform (line 735) | def compute_vggt_scene_normalization_transform(depths, extrs, intrs):
  class PointcloudCorrBlock (line 769) | class PointcloudCorrBlock:
    method __init__ (line 770) | def __init__(
    method corr_sample (line 800) | def corr_sample(

FILE: mvtracker/models/core/ptv3/model.py
  function offset2bincount (line 30) | def offset2bincount(offset):
  function offset2batch (line 37) | def offset2batch(offset):
  function batch2offset (line 45) | def batch2offset(batch):
  class Point (line 49) | class Point(Dict):
    method __init__ (line 74) | def __init__(self, *args, **kwargs):
    method serialization (line 82) | def serialization(self, order="z", depth=None, shuffle_orders=False):
    method sparsify (line 139) | def sparsify(self, pad=96):
  class PointModule (line 178) | class PointModule(nn.Module):
    method __init__ (line 183) | def __init__(self, *args, **kwargs):
  class PointSequential (line 187) | class PointSequential(PointModule):
    method __init__ (line 193) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 208) | def __getitem__(self, idx):
    method __len__ (line 218) | def __len__(self):
    method add (line 221) | def add(self, module, name=None):
    method forward (line 228) | def forward(self, input):
  class PDNorm (line 256) | class PDNorm(PointModule):
    method __init__ (line 257) | def __init__(
    method forward (line 279) | def forward(self, point):
  class RPE (line 298) | class RPE(torch.nn.Module):
    method __init__ (line 299) | def __init__(self, patch_size, num_heads):
    method forward (line 308) | def forward(self, coord):
  class SerializedAttention (line 320) | class SerializedAttention(PointModule):
    method __init__ (line 321) | def __init__(
    method get_rel_pos (line 374) | def get_rel_pos(self, point, order):
    method get_padding_and_inverse (line 384) | def get_padding_and_inverse(self, point):
    method forward (line 441) | def forward(self, point):
  class MLP (line 494) | class MLP(nn.Module):
    method __init__ (line 495) | def __init__(
    method forward (line 511) | def forward(self, x):
  class Block (line 520) | class Block(PointModule):
    method __init__ (line 521) | def __init__(
    method forward (line 587) | def forward(self, point: Point):
  class SerializedPooling (line 610) | class SerializedPooling(PointModule):
    method __init__ (line 611) | def __init__(
    method forward (line 640) | def forward(self, point: Point):
  class SerializedUnpooling (line 716) | class SerializedUnpooling(PointModule):
    method __init__ (line 717) | def __init__(
    method forward (line 740) | def forward(self, point):
  class Embedding (line 754) | class Embedding(PointModule):
    method __init__ (line 755) | def __init__(
    method forward (line 782) | def forward(self, point: Point):
  class PointTransformerV3 (line 787) | class PointTransformerV3(PointModule):
    method __init__ (line 788) | def __init__(
    method forward (line 967) | def forward(self, data_dict):

FILE: mvtracker/models/core/ptv3/serialization/default.py
  function encode (line 10) | def encode(grid_coord, batch=None, depth=16, order="z"):
  function decode (line 29) | def decode(code, depth=16, order="z"):
  function z_order_encode (line 42) | def z_order_encode(grid_coord: torch.Tensor, depth: int = 16):
  function z_order_decode (line 49) | def z_order_decode(code: torch.Tensor, depth):
  function hilbert_encode (line 55) | def hilbert_encode(grid_coord: torch.Tensor, depth: int = 16):
  function hilbert_decode (line 59) | def hilbert_decode(code: torch.Tensor, depth: int = 16):

FILE: mvtracker/models/core/ptv3/serialization/hilbert.py
  function right_shift (line 12) | def right_shift(binary, k=1, axis=-1):
  function binary2gray (line 46) | def binary2gray(binary, axis=-1):
  function gray2binary (line 69) | def gray2binary(gray, axis=-1):
  function encode (line 91) | def encode(locs, num_dims, num_bits):
  function decode (line 201) | def decode(hilberts, num_dims, num_bits):

FILE: mvtracker/models/core/ptv3/serialization/z_order.py
  class KeyLUT (line 13) | class KeyLUT:
    method __init__ (line 14) | def __init__(self):
    method encode_lut (line 29) | def encode_lut(self, device=torch.device("cpu")):
    method decode_lut (line 35) | def decode_lut(self, device=torch.device("cpu")):
    method xyz2key (line 41) | def xyz2key(self, x, y, z, depth):
    method key2xyz (line 53) | def key2xyz(self, key, depth):
  function xyz2key (line 67) | def xyz2key(
  function key2xyz (line 105) | def key2xyz(key: torch.Tensor, depth: int = 16):

FILE: mvtracker/models/core/shape-of-motion/flow3d/configs.py
  class FGLRConfig (line 5) | class FGLRConfig:
  class BGLRConfig (line 15) | class BGLRConfig:
  class MotionLRConfig (line 24) | class MotionLRConfig:
  class SceneLRConfig (line 30) | class SceneLRConfig:
  class LossesConfig (line 37) | class LossesConfig:
  class OptimizerConfig (line 51) | class OptimizerConfig:

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/__init__.py
  function get_train_val_datasets (line 16) | def get_train_val_datasets(

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/base_dataset.py
  class BaseDataset (line 7) | class BaseDataset(Dataset):
    method num_frames (line 10) | def num_frames(self) -> int: ...
    method keyframe_idcs (line 13) | def keyframe_idcs(self) -> torch.Tensor:
    method get_w2cs (line 17) | def get_w2cs(self) -> torch.Tensor: ...
    method get_Ks (line 20) | def get_Ks(self) -> torch.Tensor: ...
    method get_image (line 23) | def get_image(self, index: int) -> torch.Tensor: ...
    method get_depth (line 26) | def get_depth(self, index: int) -> torch.Tensor: ...
    method get_mask (line 29) | def get_mask(self, index: int) -> torch.Tensor: ...
    method get_img_wh (line 31) | def get_img_wh(self) -> tuple[int, int]: ...
    method get_tracks_3d (line 34) | def get_tracks_3d(
    method get_bkgd_points (line 48) | def get_bkgd_points(
    method train_collate_fn (line 80) | def train_collate_fn(batch):

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/casual_dataset.py
  class DavisDataConfig (line 30) | class DavisDataConfig:
  class CustomDataConfig (line 54) | class CustomDataConfig:
  class CasualDataset (line 77) | class CasualDataset(BaseDataset):
    method __init__ (line 78) | def __init__(
    method num_frames (line 175) | def num_frames(self) -> int:
    method keyframe_idcs (line 179) | def keyframe_idcs(self) -> torch.Tensor:
    method __len__ (line 182) | def __len__(self):
    method get_w2cs (line 185) | def get_w2cs(self) -> torch.Tensor:
    method get_Ks (line 188) | def get_Ks(self) -> torch.Tensor:
    method get_img_wh (line 191) | def get_img_wh(self) -> tuple[int, int]:
    method get_image (line 194) | def get_image(self, index) -> torch.Tensor:
    method get_mask (line 200) | def get_mask(self, index) -> torch.Tensor:
    method get_depth (line 206) | def get_depth(self, index) -> torch.Tensor:
    method load_image (line 211) | def load_image(self, index) -> torch.Tensor:
    method load_mask (line 215) | def load_mask(self, index) -> torch.Tensor:
    method load_depth (line 232) | def load_depth(self, index) -> torch.Tensor:
    method load_target_tracks (line 240) | def load_target_tracks(
    method get_tracks_3d (line 257) | def get_tracks_3d(
    method get_bkgd_points (line 295) | def get_bkgd_points(
    method __getitem__ (line 398) | def __getitem__(self, index: int):
  function load_cameras (line 451) | def load_cameras(
  function compute_scene_norm (line 472) | def compute_scene_norm(

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/colmap.py
  function get_colmap_camera_params (line 10) | def get_colmap_camera_params(colmap_dir, img_files):
  class CameraModel (line 30) | class CameraModel:
  class Camera (line 37) | class Camera:
  class BaseImage (line 46) | class BaseImage:
  class Point3D (line 57) | class Point3D:
  class Image (line 66) | class Image(BaseImage):
    method qvec2rotmat (line 67) | def qvec2rotmat(self):
  function read_next_bytes (line 89) | def read_next_bytes(fid, num_bytes, format_char_sequence, endian_charact...
  function read_cameras_text (line 101) | def read_cameras_text(path: Union[str, Path]) -> Dict[int, Camera]:
  function read_cameras_binary (line 127) | def read_cameras_binary(path_to_model_file: Union[str, Path]) -> Dict[in...
  function read_images_text (line 160) | def read_images_text(path: Union[str, Path]) -> Dict[int, Image]:
  function read_images_binary (line 197) | def read_images_binary(path_to_model_file: Union[str, Path]) -> Dict[int...
  function read_points3D_text (line 243) | def read_points3D_text(path: Union[str, Path]):
  function read_points3d_binary (line 275) | def read_points3d_binary(path_to_model_file: Union[str, Path]) -> Dict[i...
  function qvec2rotmat (line 313) | def qvec2rotmat(qvec):
  function get_intrinsics_extrinsics (line 335) | def get_intrinsics_extrinsics(img, cameras):

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/iphone_dataset.py
  class iPhoneDataConfig (line 32) | class iPhoneDataConfig:
  class iPhoneDataset (line 51) | class iPhoneDataset(BaseDataset):
    method __init__ (line 52) | def __init__(
    method num_frames (line 348) | def num_frames(self) -> int:
    method __len__ (line 351) | def __len__(self):
    method get_w2cs (line 354) | def get_w2cs(self) -> torch.Tensor:
    method get_Ks (line 357) | def get_Ks(self) -> torch.Tensor:
    method get_image (line 360) | def get_image(self, index: int) -> torch.Tensor:
    method get_depth (line 363) | def get_depth(self, index: int) -> torch.Tensor:
    method get_mask (line 366) | def get_mask(self, index: int) -> torch.Tensor:
    method get_img_wh (line 369) | def get_img_wh(self) -> tuple[int, int]:
    method get_tracks_3d (line 377) | def get_tracks_3d(
    method get_bkgd_points (line 544) | def get_bkgd_points(
    method get_video_dataset (line 602) | def get_video_dataset(self) -> Dataset:
    method __getitem__ (line 605) | def __getitem__(self, index: int):
    method preprocess (line 685) | def preprocess(self, data):
  class iPhoneDatasetKeypointView (line 689) | class iPhoneDatasetKeypointView(Dataset):
    method __init__ (line 692) | def __init__(self, dataset: iPhoneDataset):
    method __len__ (line 718) | def __len__(self):
    method __getitem__ (line 721) | def __getitem__(self, index: int):
  class iPhoneDatasetVideoView (line 732) | class iPhoneDatasetVideoView(Dataset):
    method __init__ (line 735) | def __init__(self, dataset: iPhoneDataset):
    method __len__ (line 741) | def __len__(self):
    method __getitem__ (line 744) | def __getitem__(self, index):

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/panoptic_dataset.py
  class PanopticDataConfig (line 37) | class PanopticDataConfig:
  class PanopticStudioDatasetSoM (line 59) | class PanopticStudioDatasetSoM(BaseDataset):
    method __init__ (line 60) | def __init__(
    method num_frames (line 180) | def num_frames(self) -> int:
    method keyframe_idcs (line 184) | def keyframe_idcs(self) -> torch.Tensor:
    method __len__ (line 188) | def __len__(self):
    method get_w2cs (line 191) | def get_w2cs(self, view_index=0) -> torch.Tensor:
    method get_Ks (line 194) | def get_Ks(self, view_index=0) -> torch.Tensor:
    method get_img_wh (line 197) | def get_img_wh(self) -> tuple[int, int]:
    method get_image (line 200) | def get_image(self, index, view_index=0) -> torch.Tensor:
    method get_mask (line 203) | def get_mask(self, index, view_index=0) -> torch.Tensor:
    method get_depth (line 209) | def get_depth(self, index, view=0) -> torch.Tensor:
    method load_mask (line 213) | def load_mask(self, index, view=0) -> torch.Tensor:
    method load_depth (line 232) | def load_depth(self, index, view=0) -> torch.Tensor:
    method get_foreground_points (line 240) | def get_foreground_points(
    method get_bkgd_points (line 341) | def get_bkgd_points(
    method load_target_tracks (line 422) | def load_target_tracks(
    method get_tracks_3d (line 442) | def get_tracks_3d(
    method train_collate_fn (line 502) | def train_collate_fn(self, batch):
    method get_batches (line 590) | def get_batches(self, batch_size):
    method __getitem_as_batch__ (line 599) | def __getitem_as_batch__(self, batch_size):
    method __getitem_single_view__ (line 615) | def __getitem_single_view__(self, index: int, view: int):
    method __getitem__ (line 670) | def __getitem__(self, index: int):
  function compute_scene_norm (line 728) | def compute_scene_norm(

FILE: mvtracker/models/core/shape-of-motion/flow3d/data/utils.py
  class SceneNormDict (line 12) | class SceneNormDict(TypedDict):
  function to_device (line 17) | def to_device(batch, device):
  function normalize_coords (line 27) | def normalize_coords(coords, h, w):
  function postprocess_occlusions (line 32) | def postprocess_occlusions(occlusions, expected_dist):
  function parse_tapir_track_info (line 53) | def parse_tapir_track_info(occlusions, expected_dist):
  function get_tracks_3d_for_query_frame (line 69) | def get_tracks_3d_for_query_frame(
  function _get_padding (line 171) | def _get_padding(x, k, stride, padding, same: bool):
  function median_filter_2d (line 192) | def median_filter_2d(x, kernel_size=3, stride=1, padding=1, same: bool =...
  function masked_median_blur (line 207) | def masked_median_blur(image, mask, kernel_size=11):
  function _compute_zero_padding (line 253) | def _compute_zero_padding(kernel_size: Tuple[int, int]) -> Tuple[int, int]:
  function get_binary_kernel2d (line 259) | def get_binary_kernel2d(
  function _unpack_2d_ks (line 280) | def _unpack_2d_ks(kernel_size: tuple[int, int] | int) -> tuple[int, int]:
  function ndc_2_cam (line 294) | def ndc_2_cam(ndc_xyz, intrinsic, W, H):
  function depth2point_cam (line 303) | def depth2point_cam(sampled_depth, ref_intrinsic):
  function depth2point_world (line 323) | def depth2point_world(depth_image, intrinsic_matrix, extrinsic_matrix):
  function depth_pcd2normal (line 337) | def depth_pcd2normal(xyz):
  function normal_from_depth_image (line 353) | def normal_from_depth_image(depth, intrinsic_matrix, extrinsic_matrix):

FILE: mvtracker/models/core/shape-of-motion/flow3d/init_utils.py
  function init_fg_from_tracks_3d (line 32) | def init_fg_from_tracks_3d(
  function init_bg (line 61) | def init_bg(
  function init_motion_params_with_procrustes (line 115) | def init_motion_params_with_procrustes(
  function run_initial_optim (line 271) | def run_initial_optim(
  function random_quats (line 403) | def random_quats(N: int) -> torch.Tensor:
  function compute_means (line 419) | def compute_means(ts, fg: GaussianParams, bases: MotionBases):
  function vis_init_params (line 429) | def vis_init_params(
  function vis_se3_init_3d (line 446) | def vis_se3_init_3d(server, init_rots, init_ts, basis_centers):
  function vis_tracks_2d_video (line 473) | def vis_tracks_2d_video(
  function vis_tracks_3d (line 495) | def vis_tracks_3d(
  function sample_initial_bases_centers (line 532) | def sample_initial_bases_centers(
  function interp_masked (line 592) | def interp_masked(vals: cp.ndarray, mask: cp.ndarray, pad: int = 1) -> c...
  function batched_interp_masked (line 639) | def batched_interp_masked(

FILE: mvtracker/models/core/shape-of-motion/flow3d/loss_utils.py
  function masked_mse_loss (line 7) | def masked_mse_loss(pred, gt, mask=None, normalize=True, quantile: float...
  function masked_l1_loss (line 26) | def masked_l1_loss(pred, gt, mask=None, normalize=True, quantile: float ...
  function masked_huber_loss (line 45) | def masked_huber_loss(pred, gt, delta, mask=None, normalize=True):
  function trimmed_mse_loss (line 57) | def trimmed_mse_loss(pred, gt, quantile=0.9):
  function trimmed_l1_loss (line 64) | def trimmed_l1_loss(pred, gt, quantile=0.9):
  function compute_gradient_loss (line 71) | def compute_gradient_loss(pred, gt, mask, quantile=0.98):
  function knn (line 93) | def knn(x: torch.Tensor, k: int) -> tuple[np.ndarray, np.ndarray]:
  function get_weights_for_procrustes (line 102) | def get_weights_for_procrustes(clusters, visibilities=None):
  function compute_z_acc_loss (line 118) | def compute_z_acc_loss(means_ts_nb: torch.Tensor, w2cs: torch.Tensor):
  function compute_se3_smoothness_loss (line 138) | def compute_se3_smoothness_loss(
  function compute_accel_loss (line 154) | def compute_accel_loss(transls):

FILE: mvtracker/models/core/shape-of-motion/flow3d/metrics.py
  function compute_psnr (line 13) | def compute_psnr(
  function compute_pose_errors (line 45) | def compute_pose_errors(
  class mPSNR (line 81) | class mPSNR(PeakSignalNoiseRatio):
    method __init__ (line 85) | def __init__(self, **kwargs) -> None:
    method __len__ (line 96) | def __len__(self) -> int:
    method update (line 99) | def update(
    method compute (line 120) | def compute(self) -> torch.Tensor:
  class mSSIM (line 127) | class mSSIM(StructuralSimilarityIndexMeasure):
    method __init__ (line 130) | def __init__(self, **kwargs) -> None:
    method __len__ (line 139) | def __len__(self) -> int:
    method update (line 142) | def update(
    method compute (line 215) | def compute(self) -> torch.Tensor:
  class mLPIPS (line 220) | class mLPIPS(Metric):
    method __init__ (line 224) | def __init__(
    method __len__ (line 247) | def __len__(self) -> int:
    method update (line 250) | def update(
    method compute (line 274) | def compute(self) -> torch.Tensor:
  class PCK (line 282) | class PCK(Metric):
    method __init__ (line 286) | def __init__(self, **kwargs):
    method __len__ (line 291) | def __len__(self) -> int:
    method update (line 294) | def update(self, preds: torch.Tensor, targets: torch.Tensor, threshold...
    method compute (line 308) | def compute(self) -> torch.Tensor:

FILE: mvtracker/models/core/shape-of-motion/flow3d/params.py
  class GaussianParams (line 10) | class GaussianParams(nn.Module):
    method __init__ (line 11) | def __init__(
    method init_from_state_dict (line 51) | def init_from_state_dict(state_dict, prefix="params."):
    method num_gaussians (line 65) | def num_gaussians(self) -> int:
    method get_colors (line 68) | def get_colors(self) -> torch.Tensor:
    method get_scales (line 71) | def get_scales(self) -> torch.Tensor:
    method get_opacities (line 74) | def get_opacities(self) -> torch.Tensor:
    method get_quats (line 77) | def get_quats(self) -> torch.Tensor:
    method get_coefs (line 80) | def get_coefs(self) -> torch.Tensor:
    method densify_params (line 84) | def densify_params(self, should_split, should_dup):
    method cull_params (line 99) | def cull_params(self, should_cull):
    method reset_opacities (line 110) | def reset_opacities(self, new_val):
  class MotionBases (line 119) | class MotionBases(nn.Module):
    method __init__ (line 120) | def __init__(self, rots, transls):
    method init_from_state_dict (line 133) | def init_from_state_dict(state_dict, prefix="params."):
    method compute_transforms (line 139) | def compute_transforms(self, ts: torch.Tensor, coefs: torch.Tensor) ->...
  function check_gaussian_sizes (line 153) | def check_gaussian_sizes(
  function check_bases_sizes (line 179) | def check_bases_sizes(motion_rots: torch.Tensor, motion_transls: torch.T...

FILE: mvtracker/models/core/shape-of-motion/flow3d/renderer.py
  class Renderer (line 12) | class Renderer:
    method __init__ (line 13) | def __init__(
    method init_from_checkpoint (line 44) | def init_from_checkpoint(
    method render_fn (line 58) | def render_fn(self, camera_state: CameraState, img_wh: tuple[int, int]):

FILE: mvtracker/models/core/shape-of-motion/flow3d/scene_model.py
  class SceneModel (line 11) | class SceneModel(nn.Module):
    method __init__ (line 12) | def __init__(
    method num_gaussians (line 35) | def num_gaussians(self) -> int:
    method num_bg_gaussians (line 39) | def num_bg_gaussians(self) -> int:
    method num_fg_gaussians (line 43) | def num_fg_gaussians(self) -> int:
    method num_motion_bases (line 47) | def num_motion_bases(self) -> int:
    method has_bg (line 51) | def has_bg(self) -> bool:
    method compute_poses_bg (line 54) | def compute_poses_bg(self) -> tuple[torch.Tensor, torch.Tensor]:
    method compute_transforms (line 63) | def compute_transforms(
    method compute_poses_fg (line 72) | def compute_poses_fg(
    method compute_poses_all (line 104) | def compute_poses_all(
    method get_colors_all (line 118) | def get_colors_all(self) -> torch.Tensor:
    method get_scales_all (line 124) | def get_scales_all(self) -> torch.Tensor:
    method get_opacities_all (line 130) | def get_opacities_all(self) -> torch.Tensor:
    method init_from_state_dict (line 142) | def init_from_state_dict(state_dict, prefix=""):
    method render (line 158) | def render(

FILE: mvtracker/models/core/shape-of-motion/flow3d/tensor_dataclass.py
  class TensorDataclass (line 10) | class TensorDataclass:
    method __getitem__ (line 15) | def __getitem__(self, key) -> Self:
    method to (line 18) | def to(self, device: torch.device | str) -> Self:
    method map (line 29) | def map(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Self:
  class TrackObservations (line 63) | class TrackObservations(TensorDataclass):
    method check_sizes (line 70) | def check_sizes(self) -> bool:
    method filter_valid (line 81) | def filter_valid(self, valid_mask: torch.Tensor) -> Self:
  class StaticObservations (line 86) | class StaticObservations(TensorDataclass):
    method check_sizes (line 91) | def check_sizes(self) -> bool:
    method filter_valid (line 95) | def filter_valid(self, valid_mask: torch.Tensor) -> Self:

FILE: mvtracker/models/core/shape-of-motion/flow3d/trainer.py
  class Trainer (line 27) | class Trainer:
    method __init__ (line 28) | def __init__(
    method set_epoch (line 97) | def set_epoch(self, epoch: int):
    method save_checkpoint (line 100) | def save_checkpoint(self, path: str):
    method init_from_checkpoint (line 115) | def init_from_checkpoint(
    method load_checkpoint_optimizers (line 133) | def load_checkpoint_optimizers(self, opt_ckpt):
    method load_checkpoint_schedulers (line 137) | def load_checkpoint_schedulers(self, sched_ckpt):
    method render_fn (line 142) | def render_fn(self, camera_state: CameraState, img_wh: tuple[int, int]):
    method train_step (line 164) | def train_step(self, batch):
    method compute_losses (line 211) | def compute_losses(self, batch):
    method log_dict (line 555) | def log_dict(self, stats: dict):
    method run_control_steps (line 559) | def run_control_steps(self):
    method _prepare_control_step (line 586) | def _prepare_control_step(self) -> bool:
    method _densify_control_step (line 621) | def _densify_control_step(self, global_step):
    method _cull_control_step (line 698) | def _cull_control_step(self, global_step):
    method _reset_opacity_control_step (line 745) | def _reset_opacity_control_step(self):
    method configure_optimizers (line 757) | def configure_optimizers(self):
  function dup_in_optim (line 786) | def dup_in_optim(optimizer, new_params: list, should_dup: torch.Tensor, ...
  function remove_from_optim (line 808) | def remove_from_optim(optimizer, new_params: list, _should_cull: torch.T...
  function reset_in_optim (line 826) | def reset_in_optim(optimizer, new_params: list):

FILE: mvtracker/models/core/shape-of-motion/flow3d/trajectories.py
  function get_avg_w2c (line 9) | def get_avg_w2c(w2cs: torch.Tensor):
  function get_lookat (line 26) | def get_lookat(origins: torch.Tensor, viewdirs: torch.Tensor) -> torch.T...
  function get_lookat_w2cs (line 50) | def get_lookat_w2cs(positions: torch.Tensor, lookat: torch.Tensor, up: t...
  function get_arc_w2cs (line 70) | def get_arc_w2cs(
  function get_lemniscate_w2cs (line 97) | def get_lemniscate_w2cs(
  function get_spiral_w2cs (line 127) | def get_spiral_w2cs(
  function get_wander_w2cs (line 162) | def get_wander_w2cs(ref_w2c, focal_length, num_frames, **_):

FILE: mvtracker/models/core/shape-of-motion/flow3d/transforms.py
  function rt_to_mat4 (line 8) | def rt_to_mat4(
  function rmat_to_cont_6d (line 33) | def rmat_to_cont_6d(matrix):
  function cont_6d_to_rmat (line 41) | def cont_6d_to_rmat(cont_6d):
  function solve_procrustes (line 56) | def solve_procrustes(

FILE: mvtracker/models/core/shape-of-motion/flow3d/validator.py
  class Validator (line 30) | class Validator:
    method __init__ (line 31) | def __init__(
    method reset_metrics (line 61) | def reset_metrics(self):
    method validate (line 74) | def validate(self):
    method validate_imgs (line 81) | def validate_imgs(self):
    method validate_keypoints (line 151) | def validate_keypoints(self):
    method save_train_videos (line 241) | def save_train_videos(self, epoch: int):

FILE: mvtracker/models/core/shape-of-motion/flow3d/vis/playback_panel.py
  function add_gui_playback_group (line 7) | def add_gui_playback_group(

FILE: mvtracker/models/core/shape-of-motion/flow3d/vis/render_panel.py
  class Keyframe (line 37) | class Keyframe:
    method from_camera (line 48) | def from_camera(time: float, camera: viser.CameraHandle, aspect: float...
  class CameraPath (line 61) | class CameraPath:
    method __init__ (line 62) | def __init__(
    method set_keyframes_visible (line 88) | def set_keyframes_visible(self, visible: bool) -> None:
    method add_camera (line 93) | def add_camera(
    method update_aspect (line 231) | def update_aspect(self, aspect: float) -> None:
    method get_aspect (line 236) | def get_aspect(self) -> float:
    method reset (line 241) | def reset(self) -> None:
    method spline_t_from_t_sec (line 249) | def spline_t_from_t_sec(self, time: np.ndarray) -> np.ndarray:
    method interpolate_pose_and_fov_rad (line 283) | def interpolate_pose_and_fov_rad(
    method update_spline (line 328) | def update_spline(self) -> None:
    method compute_duration (line 472) | def compute_duration(self) -> float:
    method compute_transition_times_cumsum (line 487) | def compute_transition_times_cumsum(self) -> np.ndarray:
  class RenderTabState (line 517) | class RenderTabState:
  function populate_render_tab (line 526) | def populate_render_tab(

FILE: mvtracker/models/core/shape-of-motion/flow3d/vis/utils.py
  class Singleton (line 14) | class Singleton(type):
    method __call__ (line 17) | def __call__(cls, *args, **kwargs):
  class VisManager (line 23) | class VisManager(metaclass=Singleton):
  function get_server (line 27) | def get_server(port: int | None = None) -> ViserServer:
  function project_2d_tracks (line 37) | def project_2d_tracks(tracks_3d_w, Ks, T_cw, return_depth=False):
  function draw_keypoints_video (line 56) | def draw_keypoints_video(
  function draw_keypoints_cv2 (line 77) | def draw_keypoints_cv2(img, kps, colors=None, occs=None, radius=3):
  function draw_tracks_2d (line 96) | def draw_tracks_2d(
  function generate_line_verts_faces (line 150) | def generate_line_verts_faces(starts, ends, line_width):
  function generate_point_verts_faces (line 188) | def generate_point_verts_faces(points, point_size, num_segments=10):
  function pixel_to_verts_clip (line 227) | def pixel_to_verts_clip(pixels, img_wh, z: float | torch.Tensor = 0.0, w...
  function draw_tracks_2d_th (line 234) | def draw_tracks_2d_th(
  function make_video_divisble (line 358) | def make_video_divisble(
  function apply_float_colormap (line 367) | def apply_float_colormap(img: torch.Tensor, colormap: str = "turbo") -> ...
  function apply_depth_colormap (line 391) | def apply_depth_colormap(
  function float2uint8 (line 418) | def float2uint8(x):
  function uint82float (line 422) | def uint82float(img):
  function drawMatches (line 426) | def drawMatches(
  function plot_correspondences (line 512) | def plot_correspondences(

FILE: mvtracker/models/core/shape-of-motion/flow3d/vis/viewer.py
  class DynamicViewer (line 13) | class DynamicViewer(Viewer):
    method __init__ (line 14) | def __init__(
    method _define_guis (line 32) | def _define_guis(self):

FILE: mvtracker/models/core/shape-of-motion/launch_davis.py
  function main (line 7) | def main(

FILE: mvtracker/models/core/spatracker/blocks.py
  function _ntuple (line 17) | def _ntuple(n):
  function exists (line 26) | def exists(val):
  function default (line 30) | def default(val, d):
  class Mlp (line 37) | class Mlp(nn.Module):
    method __init__ (line 40) | def __init__(
    method forward (line 61) | def forward(self, x):
  class ResidualBlock (line 70) | class ResidualBlock(nn.Module):
    method __init__ (line 71) | def __init__(self, in_planes, planes, norm_fn="group", stride=1):
    method forward (line 119) | def forward(self, x):
  class BasicEncoder (line 130) | class BasicEncoder(nn.Module):
    method __init__ (line 131) | def __init__(
    method _make_layer (line 206) | def _make_layer(self, dim, stride=1):
    method forward (line 214) | def forward(self, x, feat_PE=None):
  class DeeperBasicEncoder (line 287) | class DeeperBasicEncoder(nn.Module):
    method __init__ (line 288) | def __init__(
    method _make_layer (line 352) | def _make_layer(self, dim, stride=1):
    method forward (line 360) | def forward(self, x, feat_PE=None):
  class CorrBlock (line 423) | class CorrBlock:
    method __init__ (line 424) | def __init__(self, fmaps, num_levels=4, radius=4, depths_dnG=None):
    method sample (line 450) | def sample(self, coords):
    method corr (line 476) | def corr(self, targets):
    method corr_sample (line 492) | def corr_sample(self, targets, coords, coords_dp=None):
  class Attention (line 536) | class Attention(nn.Module):
    method __init__ (line 537) | def __init__(self, query_dim, num_heads=8, dim_head=48, qkv_bias=False...
    method forward (line 547) | def forward(self, x, attn_bias=None):
  class AttnBlock (line 572) | class AttnBlock(nn.Module):
    method __init__ (line 577) | def __init__(self, hidden_size, num_heads, mlp_ratio=4.0,
    method forward (line 598) | def forward(self, x):
  function bilinear_sampler (line 604) | def bilinear_sampler(img, coords, mode="bilinear", mask=False):
  class EUpdateFormer (line 622) | class EUpdateFormer(nn.Module):
    method __init__ (line 627) | def __init__(
    method initialize_weights (line 693) | def initialize_weights(self):
    method forward (line 702) | def forward(self, input_tensor, se3_feature):
  function pix2cam (line 734) | def pix2cam(coords,
  function cam2pix (line 756) | def cam2pix(coords,

FILE: mvtracker/models/core/spatracker/softsplat.py
  function cuda_int32 (line 19) | def cuda_int32(intIn: int):
  function cuda_float32 (line 23) | def cuda_float32(fltIn: float):
  function cuda_kernel (line 27) | def cuda_kernel(strFunction: str, strKernel: str, objVariables: typing.D...
  function cuda_launch (line 206) | def cuda_launch(strKey: str):
  function softsplat (line 218) | def softsplat(
  class softsplat_func (line 278) | class softsplat_func(torch.autograd.Function):
    method forward (line 281) | def forward(self, tenIn, tenFlow, H=None, W=None):
    method backward (line 360) | def backward(self, tenOutgrad):
  function cuda_int64 (line 535) | def cuda_int64(intIn: int):
  function cuda_kernel_longlong (line 539) | def cuda_kernel_longlong(strFunction: str, strKernel: str, objVariables:...
  class softsplat_pointcloud_func (line 729) | class softsplat_pointcloud_func(torch.autograd.Function):
    method forward (line 732) | def forward(self, tenIn, tenFlow, H=None, W=None):
    method backward (line 811) | def backward(self, tenOutgrad):

FILE: mvtracker/models/core/spatracker/spatracker_monocular.py
  function sample_pos_embed (line 36) | def sample_pos_embed(grid_size, embed_dim, coords):
  class SpaTracker (line 59) | class SpaTracker(nn.Module):
    method __init__ (line 60) | def __init__(
    method prepare_track (line 147) | def prepare_track(self, rgbds, queries):
    method sample_trifeat (line 221) | def sample_trifeat(self, t,
    method neural_arap (line 260) | def neural_arap(self, coords, Traj_arap, intrs_S, T_mark):
    method gradient_arap (line 300) | def gradient_arap(self, coords, aff_avg=None, aff_std=None, aff_f_sg=N...
    method forward_iteration (line 317) | def forward_iteration(
    method forward (line 478) | def forward(self, rgbds, queries, iters=4, feat_init=None, is_train=Fa...
  class SpaTrackerMultiViewAdapter (line 672) | class SpaTrackerMultiViewAdapter(nn.Module):
    method __init__ (line 673) | def __init__(self, **kwargs):
    method forward (line 677) | def forward(

FILE: mvtracker/models/core/spatracker/spatracker_multiview.py
  class MultiViewSpaTracker (line 21) | class MultiViewSpaTracker(nn.Module):
    method __init__ (line 31) | def __init__(
    method sample_trifeat (line 151) | def sample_trifeat(self, t, coords, featMapxy, featMapyz, featMapxz):
    method forward_iteration (line 186) | def forward_iteration(
    method forward (line 388) | def forward(
    method _plot_pointcloud (line 861) | def _plot_pointcloud(logs_path, filename, xyz, c, q_xyz=None, q_c=None,
    method _plot_featuremaps (line 883) | def _plot_featuremaps(

FILE: mvtracker/models/core/vggt/heads/camera_head.py
  class CameraHead (line 19) | class CameraHead(nn.Module):
    method __init__ (line 26) | def __init__(
    method forward (line 83) | def forward(self, aggregated_tokens_list: list, num_iterations: int = ...
    method trunk_fn (line 105) | def trunk_fn(self, pose_tokens: torch.Tensor, num_iterations: int) -> ...
  function modulate (line 157) | def modulate(x: torch.Tensor, shift: torch.Tensor, scale: torch.Tensor) ...

FILE: mvtracker/models/core/vggt/heads/dpt_head.py
  class DPTHead (line 21) | class DPTHead(nn.Module):
    method __init__ (line 43) | def __init__(
    method forward (line 128) | def forward(
    method _forward_impl (line 191) | def _forward_impl(
    method _apply_pos_embed (line 273) | def _apply_pos_embed(self, x: torch.Tensor, W: int, H: int, ratio: flo...
    method scratch_forward (line 285) | def scratch_forward(self, features: List[torch.Tensor]) -> torch.Tensor:
  function _make_fusion_block (line 323) | def _make_fusion_block(features: int, size: int = None, has_residual: bo...
  function _make_scratch (line 337) | def _make_scratch(in_shape: List[int], out_shape: int, groups: int = 1, ...
  class ResidualConvUnit (line 368) | class ResidualConvUnit(nn.Module):
    method __init__ (line 371) | def __init__(self, features, activation, bn, groups=1):
    method forward (line 390) | def forward(self, x):
  class FeatureFusionBlock (line 413) | class FeatureFusionBlock(nn.Module):
    method __init__ (line 416) | def __init__(
    method forward (line 456) | def forward(self, *xs, size=None):
  function custom_interpolate (line 483) | def custom_interpolate(

FILE: mvtracker/models/core/vggt/heads/head_act.py
  function activate_pose (line 12) | def activate_pose(pred_pose_enc, trans_act="linear", quat_act="linear", ...
  function base_pose_act (line 38) | def base_pose_act(pose_enc, act_type="linear"):
  function activate_head (line 61) | def activate_head(out, activation="norm_exp", conf_activation="expp1"):
  function inverse_log_transform (line 115) | def inverse_log_transform(y):

FILE: mvtracker/models/core/vggt/heads/track_head.py
  class TrackHead (line 12) | class TrackHead(nn.Module):
    method __init__ (line 18) | def __init__(
    method forward (line 72) | def forward(self, aggregated_tokens_list, images, patch_start_idx, que...

FILE: mvtracker/models/core/vggt/heads/track_modules/base_track_predictor.py
  class BaseTrackerPredictor (line 17) | class BaseTrackerPredictor(nn.Module):
    method __init__ (line 18) | def __init__(
    method forward (line 82) | def forward(self, query_points, fmaps=None, iters=6, return_feat=False...

FILE: mvtracker/models/core/vggt/heads/track_modules/blocks.py
  class EfficientUpdateFormer (line 19) | class EfficientUpdateFormer(nn.Module):
    method __init__ (line 24) | def __init__(
    method initialize_weights (line 90) | def initialize_weights(self):
    method forward (line 100) | def forward(self, input_tensor, mask=None):
  class CorrBlock (line 147) | class CorrBlock:
    method __init__ (line 148) | def __init__(self, fmaps, num_levels=4, radius=4, multiple_track_feats...
    method corr_sample (line 186) | def corr_sample(self, targets, coords):
  function compute_corr_level (line 241) | def compute_corr_level(fmap1, fmap2s, C):

FILE: mvtracker/models/core/vggt/heads/track_modules/modules.py
  function _ntuple (line 19) | def _ntuple(n):
  function exists (line 28) | def exists(val):
  function default (line 32) | def default(val, d):
  class ResidualBlock (line 39) | class ResidualBlock(nn.Module):
    method __init__ (line 44) | def __init__(self, in_planes, planes, norm_fn="group", stride=1, kerne...
    method forward (line 100) | def forward(self, x):
  class Mlp (line 111) | class Mlp(nn.Module):
    method __init__ (line 114) | def __init__(
    method forward (line 138) | def forward(self, x):
  class AttnBlock (line 147) | class AttnBlock(nn.Module):
    method __init__ (line 148) | def __init__(
    method forward (line 170) | def forward(self, x, mask=None):
  class CrossAttnBlock (line 187) | class CrossAttnBlock(nn.Module):
    method __init__ (line 188) | def __init__(self, hidden_size, context_dim, num_heads=1, mlp_ratio=4....
    method forward (line 206) | def forward(self, x, context, mask=None):

FILE: mvtracker/models/core/vggt/heads/track_modules/utils.py
  function get_2d_sincos_pos_embed (line 18) | def get_2d_sincos_pos_embed(embed_dim: int, grid_size: Union[int, Tuple[...
  function get_2d_sincos_pos_embed_from_grid (line 46) | def get_2d_sincos_pos_embed_from_grid(embed_dim: int, grid: torch.Tensor...
  function get_1d_sincos_pos_embed_from_grid (line 67) | def get_1d_sincos_pos_embed_from_grid(embed_dim: int, pos: torch.Tensor)...
  function get_2d_embedding (line 93) | def get_2d_embedding(xy: torch.Tensor, C: int, cat_coords: bool = True) ...
  function bilinear_sampler (line 127) | def bilinear_sampler(input, coords, align_corners=True, padding_mode="bo...
  function sample_features4d (line 196) | def sample_features4d(input, coords):

FILE: mvtracker/models/core/vggt/heads/utils.py
  function position_grid_to_embed (line 11) | def position_grid_to_embed(pos_grid: torch.Tensor, embed_dim: int, omega...
  function make_sincos_pos_embed (line 36) | def make_sincos_pos_embed(embed_dim: int, pos: torch.Tensor, omega_0: fl...
  function create_uv_grid (line 65) | def create_uv_grid(

FILE: mvtracker/models/core/vggt/layers/attention.py
  class Attention (line 21) | class Attention(nn.Module):
    method __init__ (line 22) | def __init__(
    method forward (line 50) | def forward(self, x: Tensor, pos=None) -> Tensor:
  class MemEffAttention (line 80) | class MemEffAttention(Attention):
    method forward (line 81) | def forward(self, x: Tensor, attn_bias=None, pos=None) -> Tensor:

FILE: mvtracker/models/core/vggt/layers/block.py
  class Block (line 27) | class Block(nn.Module):
    method __init__ (line 28) | def __init__(
    method forward (line 81) | def forward(self, x: Tensor, pos=None) -> Tensor:
  function drop_add_residual_stochastic_depth (line 110) | def drop_add_residual_stochastic_depth(
  function get_branges_scales (line 140) | def get_branges_scales(x, sample_drop_ratio=0.0):
  function add_residual (line 148) | def add_residual(x, brange, residual, residual_scale_factor, scaling_vec...
  function get_attn_bias_and_cat (line 163) | def get_attn_bias_and_cat(x_list, branges=None):
  function drop_add_residual_stochastic_depth_list (line 187) | def drop_add_residual_stochastic_depth_list(
  class NestedTensorBlock (line 210) | class NestedTensorBlock(Block):
    method forward_nested (line 211) | def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
    method forward (line 251) | def forward(self, x_or_x_list):

FILE: mvtracker/models/core/vggt/layers/drop_path.py
  function drop_path (line 14) | def drop_path(x, drop_prob: float = 0.0, training: bool = False):
  class DropPath (line 26) | class DropPath(nn.Module):
    method __init__ (line 29) | def __init__(self, drop_prob=None):
    method forward (line 33) | def forward(self, x):

FILE: mvtracker/models/core/vggt/layers/layer_scale.py
  class LayerScale (line 15) | class LayerScale(nn.Module):
    method __init__ (line 16) | def __init__(
    method forward (line 26) | def forward(self, x: Tensor) -> Tensor:

FILE: mvtracker/models/core/vggt/layers/mlp.py
  class Mlp (line 16) | class Mlp(nn.Module):
    method __init__ (line 17) | def __init__(
    method forward (line 34) | def forward(self, x: Tensor) -> Tensor:

FILE: mvtracker/models/core/vggt/layers/patch_embed.py
  function make_2tuple (line 16) | def make_2tuple(x):
  class PatchEmbed (line 25) | class PatchEmbed(nn.Module):
    method __init__ (line 37) | def __init__(
    method forward (line 68) | def forward(self, x: Tensor) -> Tensor:
    method flops (line 83) | def flops(self) -> float:

FILE: mvtracker/models/core/vggt/layers/rope.py
  class PositionGetter (line 24) | class PositionGetter:
    method __init__ (line 35) | def __init__(self):
    method __call__ (line 39) | def __call__(self, batch_size: int, height: int, width: int, device: t...
  class RotaryPositionEmbedding2D (line 62) | class RotaryPositionEmbedding2D(nn.Module):
    method __init__ (line 79) | def __init__(self, frequency: float = 100.0, scaling_factor: float = 1...
    method _compute_frequency_components (line 86) | def _compute_frequency_components(
    method _rotate_features (line 120) | def _rotate_features(x: torch.Tensor) -> torch.Tensor:
    method _apply_1d_rope (line 133) | def _apply_1d_rope(
    method forward (line 154) | def forward(self, tokens: torch.Tensor, positions: torch.Tensor) -> to...

FILE: mvtracker/models/core/vggt/layers/swiglu_ffn.py
  class SwiGLUFFN (line 14) | class SwiGLUFFN(nn.Module):
    method __init__ (line 15) | def __init__(
    method forward (line 30) | def forward(self, x: Tensor) -> Tensor:
  class SwiGLUFFNFused (line 54) | class SwiGLUFFNFused(SwiGLU):
    method __init__ (line 55) | def __init__(

FILE: mvtracker/models/core/vggt/layers/vision_transformer.py
  function named_apply (line 24) | def named_apply(fn: Callable, module: nn.Module, name="", depth_first=Tr...
  class BlockChunk (line 35) | class BlockChunk(nn.ModuleList):
    method forward (line 36) | def forward(self, x):
  class DinoVisionTransformer (line 42) | class DinoVisionTransformer(nn.Module):
    method __init__ (line 43) | def __init__(
    method init_weights (line 176) | def init_weights(self):
    method interpolate_pos_encoding (line 183) | def interpolate_pos_encoding(self, x, w, h):
    method prepare_tokens_with_masks (line 217) | def prepare_tokens_with_masks(self, x, masks=None):
    method forward_features_list (line 238) | def forward_features_list(self, x_list, masks_list):
    method forward_features (line 262) | def forward_features(self, x, masks=None):
    method _get_intermediate_layers_not_chunked (line 283) | def _get_intermediate_layers_not_chunked(self, x, n=1):
    method _get_intermediate_layers_chunked (line 295) | def _get_intermediate_layers_chunked(self, x, n=1):
    method get_intermediate_layers (line 309) | def get_intermediate_layers(
    method forward (line 335) | def forward(self, *args, is_training=True, **kwargs):
  function init_weights_vit_timm (line 343) | def init_weights_vit_timm(module: nn.Module, name: str = ""):
  function vit_small (line 351) | def vit_small(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_base (line 365) | def vit_base(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_large (line 379) | def vit_large(patch_size=16, num_register_tokens=0, **kwargs):
  function vit_giant2 (line 393) | def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs):

FILE: mvtracker/models/core/vggt/models/aggregator.py
  class Aggregator (line 24) | class Aggregator(nn.Module):
    method __init__ (line 50) | def __init__(
    method __build_patch_embed__ (line 146) | def __build_patch_embed__(
    method forward (line 187) | def forward(
    method _process_frame_attention (line 266) | def _process_frame_attention(self, tokens, B, S, P, C, frame_idx, pos=...
    method _process_global_attention (line 287) | def _process_global_attention(self, tokens, B, S, P, C, global_idx, po...
  function slice_expand_and_flatten (line 308) | def slice_expand_and_flatten(token_tensor, B, S):

FILE: mvtracker/models/core/vggt/models/vggt.py
  class VGGT (line 17) | class VGGT(nn.Module, PyTorchModelHubMixin):
    method __init__ (line 18) | def __init__(self, img_size=518, patch_size=14, embed_dim=1024):
    method forward (line 27) | def forward(

FILE: mvtracker/models/core/vggt/utils/geometry.py
  function unproject_depth_map_to_point_map (line 12) | def unproject_depth_map_to_point_map(
  function depth_to_world_coords_points (line 44) | def depth_to_world_coords_points(
  function depth_to_cam_coords_points (line 84) | def depth_to_cam_coords_points(depth_map: np.ndarray, intrinsic: np.ndar...
  function closed_form_inverse_se3 (line 117) | def closed_form_inverse_se3(se3, R=None, T=None):

FILE: mvtracker/models/core/vggt/utils/load_fn.py
  function load_and_preprocess_images (line 12) | def load_and_preprocess_images(image_path_list, mode="crop"):

FILE: mvtracker/models/core/vggt/utils/pose_enc.py
  function extri_intri_to_pose_encoding (line 11) | def extri_intri_to_pose_encoding(
  function pose_encoding_to_extri_intri (line 65) | def pose_encoding_to_extri_intri(

FILE: mvtracker/models/core/vggt/utils/rotation.py
  function quat_to_mat (line 14) | def quat_to_mat(quaternions: torch.Tensor) -> torch.Tensor:
  function mat_to_quat (line 47) | def mat_to_quat(matrix: torch.Tensor) -> torch.Tensor:
  function _sqrt_positive_part (line 112) | def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
  function standardize_quaternion (line 126) | def standardize_quaternion(quaternions: torch.Tensor) -> torch.Tensor:

FILE: mvtracker/models/core/vggt/utils/visual_track.py
  function color_from_xy (line 13) | def color_from_xy(x, y, W, H, cmap_name="hsv"):
  function get_track_colors_by_position (line 37) | def get_track_colors_by_position(tracks_b, vis_mask_b=None, image_width=...
  function visualize_tracks_on_images (line 80) | def visualize_tracks_on_images(

FILE: mvtracker/models/core/vit/common.py
  class MLPBlock (line 13) | class MLPBlock(nn.Module):
    method __init__ (line 14) | def __init__(
    method forward (line 25) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class LayerNorm2d (line 31) | class LayerNorm2d(nn.Module):
    method __init__ (line 32) | def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
    method forward (line 38) | def forward(self, x: torch.Tensor) -> torch.Tensor:

FILE: mvtracker/models/core/vit/encoder.py
  class ImageEncoderViT (line 19) | class ImageEncoderViT(nn.Module):
    method __init__ (line 20) | def __init__(
    method forward (line 108) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class Block (line 122) | class Block(nn.Module):
    method __init__ (line 125) | def __init__(
    method forward (line 169) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class Attention (line 188) | class Attention(nn.Module):
    method __init__ (line 191) | def __init__(
    method forward (line 227) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  function window_partition (line 246) | def window_partition(x: torch.Tensor, window_size: int) -> Tuple[torch.T...
  function window_unpartition (line 270) | def window_unpartition(
  function get_rel_pos (line 295) | def get_rel_pos(q_size: int, k_size: int, rel_pos: torch.Tensor) -> torc...
  function add_decomposed_rel_pos (line 328) | def add_decomposed_rel_pos(
  class PatchEmbed (line 367) | class PatchEmbed(nn.Module):
    method __init__ (line 372) | def __init__(
    method forward (line 394) | def forward(self, x: torch.Tensor) -> torch.Tensor:

FILE: mvtracker/models/evaluation_predictor_3dpt.py
  class EvaluationPredictor (line 17) | class EvaluationPredictor(torch.nn.Module):
    method __init__ (line 18) | def __init__(
    method forward (line 47) | def forward(
  function get_uniformly_sampled_pts (line 417) | def get_uniformly_sampled_pts(
  function get_superpoint_sampled_pts (line 431) | def get_superpoint_sampled_pts(
  function get_sift_sampled_pts (line 450) | def get_sift_sampled_pts(

FILE: mvtracker/utils/basic.py
  function sub2ind (line 11) | def sub2ind(height, width, y, x):
  function ind2sub (line 15) | def ind2sub(height, width, ind):
  function get_lr_str (line 21) | def get_lr_str(lr):
  function strnum (line 27) | def strnum(x):
  function assert_same_shape (line 36) | def assert_same_shape(t1, t2):
  function print_stats (line 41) | def print_stats(name, tensor):
  function print_stats_py (line 48) | def print_stats_py(name, tensor):
  function print_ (line 54) | def print_(name, tensor):
  function mkdir (line 59) | def mkdir(path):
  function normalize_single (line 64) | def normalize_single(d):
  function normalize (line 72) | def normalize(d):
  function hard_argmax2d (line 83) | def hard_argmax2d(tensor):
  function argmax2d (line 101) | def argmax2d(heat, hard=True):
  function reduce_masked_mean (line 126) | def reduce_masked_mean(x, mask, dim=None, keepdim=False):
  function reduce_masked_median (line 146) | def reduce_masked_median(x, mask, keep_batch=False):
  function pack_seqdim (line 182) | def pack_seqdim(tensor, B):
  function unpack_seqdim (line 191) | def unpack_seqdim(tensor, B):
  function meshgrid2d (line 201) | def meshgrid2d(B, Y, X, stack=False, norm=False, device='cuda', on_chans...
  function meshgrid3d (line 228) | def meshgrid3d(B, Z, Y, X, stack=False, norm=False, device='cuda'):
  function normalize_grid2d (line 261) | def normalize_grid2d(grid_y, grid_x, Y, X, clamp_extreme=True):
  function normalize_grid3d (line 273) | def normalize_grid3d(grid_z, grid_y, grid_x, Z, Y, X, clamp_extreme=True):
  function gridcloud2d (line 287) | def gridcloud2d(B, Y, X, norm=False, device='cuda'):
  function gridcloud3d (line 298) | def gridcloud3d(B, Z, Y, X, norm=False, device='cuda'):
  function readPFM (line 313) | def readPFM(file):
  function normalize_boxlist2d (line 351) | def normalize_boxlist2d(boxlist2d, H, W):
  function unnormalize_boxlist2d (line 362) | def unnormalize_boxlist2d(boxlist2d, H, W):
  function unnormalize_box2d (line 373) | def unnormalize_box2d(box2d, H, W):
  function normalize_box2d (line 377) | def normalize_box2d(box2d, H, W):
  function get_gaussian_kernel_2d (line 381) | def get_gaussian_kernel_2d(channels, kernel_size=3, sigma=2.0, mid_one=F...
  function gaussian_blur_2d (line 403) | def gaussian_blur_2d(input, kernel_size=3, sigma=2.0, reflect_pad=False,...
  function gradient2d (line 415) | def gradient2d(x, absolute=False, square=False, return_sum=False):
  function to_homogeneous (line 437) | def to_homogeneous(x):
  function from_homogeneous (line 441) | def from_homogeneous(x, assert_homogeneous_part_is_equal_to_1=False, eps...
  function time_now (line 447) | def time_now():

FILE: mvtracker/utils/eval_utils.py
  function medianTrajError (line 12) | def medianTrajError(output, target):
  function averageTrajError (line 20) | def averageTrajError(output, target):
  function pointTrack (line 27) | def pointTrack(queryPoint, anchorPos, anchorRot):
  function qToRot (line 37) | def qToRot(q):
  function get3DCov (line 52) | def get3DCov(scale, rotation, scale_mod = 1):
  function getAll3DCov (line 66) | def getAll3DCov(scales, rotations, scale_mod = 1):
  function getContributions (line 74) | def getContributions(mean3Ds, cov3Ds, query):

FILE: mvtracker/utils/geom.py
  function matmul2 (line 6) | def matmul2(mat1, mat2):
  function matmul3 (line 10) | def matmul3(mat1, mat2, mat3):
  function eye_3x3 (line 14) | def eye_3x3(B, device='cuda'):
  function eye_4x4 (line 19) | def eye_4x4(B, device='cuda'):
  function safe_inverse (line 24) | def safe_inverse(a):  # parallel version
  function safe_inverse_single (line 35) | def safe_inverse_single(a):
  function split_intrinsics (line 46) | def split_intrinsics(K):
  function apply_pix_T_cam (line 55) | def apply_pix_T_cam(pix_T_cam, xyz):
  function apply_pix_T_cam_py (line 79) | def apply_pix_T_cam_py(pix_T_cam, xyz):
  function get_camM_T_camXs (line 103) | def get_camM_T_camXs(origin_T_camXs, ind=0):
  function apply_4x4 (line 113) | def apply_4x4(RT, xyz):
  function apply_4x4_py (line 125) | def apply_4x4_py(RT, xyz):
  function apply_3x3 (line 142) | def apply_3x3(RT, xy):
  function generate_polygon (line 154) | def generate_polygon(ctr_x, ctr_y, avg_r, irregularity, spikiness, num_v...
  function get_random_affine_2d (line 199) | def get_random_affine_2d(B, rot_min=-5.0, rot_max=5.0, tx_min=-0.1, tx_m...
  function get_centroid_from_box2d (line 291) | def get_centroid_from_box2d(box2d):
  function normalize_boxlist2d (line 301) | def normalize_boxlist2d(boxlist2d, H, W):
  function unnormalize_boxlist2d (line 312) | def unnormalize_boxlist2d(boxlist2d, H, W):
  function unnormalize_box2d (line 323) | def unnormalize_box2d(box2d, H, W):
  function normalize_box2d (line 327) | def normalize_box2d(box2d, H, W):
  function get_size_from_box2d (line 331) | def get_size_from_box2d(box2d):
  function crop_and_resize (line 341) | def crop_and_resize(im, boxlist, PH, PW, boxlist_is_normalized=False):
  function get_boxlist_from_centroid_and_size (line 403) | def get_boxlist_from_centroid_and_size(cy, cx, h, w):  # , clip=False):
  function get_box2d_from_mask (line 420) | def get_box2d_from_mask(mask, normalize=False):
  function convert_box2d_to_intrinsics (line 444) | def convert_box2d_to_intrinsics(box2d, pix_T_cam, H, W, use_image_aspect...
  function pixels2camera (line 512) | def pixels2camera(x, y, z, fx, fy, x0, y0):
  function camera2pixels (line 538) | def camera2pixels(xyz, pix_T_cam):
  function depth2pointcloud (line 562) | def depth2pointcloud(z, pix_T_cam):

FILE: mvtracker/utils/improc.py
  function _convert (line 16) | def _convert(input_, type_):
  function _generic_transform_sk_3d (line 23) | def _generic_transform_sk_3d(transform, in_type='', out_type=''):
  function preprocess_color_tf (line 47) | def preprocess_color_tf(x):
  function preprocess_color (line 52) | def preprocess_color(x):
  function pca_embed (line 59) | def pca_embed(emb, keep, valid=None):
  function pca_embed_together (line 105) | def pca_embed_together(emb, keep):
  function reduce_emb (line 129) | def reduce_emb(emb, valid=None, inbound=None, together=False):
  function get_feat_pca (line 150) | def get_feat_pca(feat, valid=None):
  function gif_and_tile (line 159) | def gif_and_tile(ims, just_gif=False):
  function back2color (line 174) | def back2color(i, blacken_zeros=False):
  function convert_occ_to_height (line 183) | def convert_occ_to_height(occ, reduce_axis=3):
  function xy2heatmap (line 207) | def xy2heatmap(xy, sigma, grid_xs, grid_ys, norm=False):
  function xy2heatmaps (line 244) | def xy2heatmaps(xy, Y, X, sigma=30.0, norm=True):
  function draw_circles_at_xy (line 260) | def draw_circles_at_xy(xy, Y, X, sigma=12.5, round=False):
  function seq2color (line 270) | def seq2color(im, norm=True, colormap='coolwarm'):
  function colorize (line 331) | def colorize(d):
  function oned2inferno (line 372) | def oned2inferno(d, norm=True, do_colorize=False):
  function oned2gray (line 400) | def oned2gray(d, norm=True):
  function draw_frame_id_on_vis (line 418) | def draw_frame_id_on_vis(vis, frame_id, scale=0.5, left=5, top=20):
  class ColorMap2d (line 449) | class ColorMap2d:
    method __init__ (line 450) | def __init__(self, filename=None):
    method __call__ (line 457) | def __call__(self, X):
  function get_n_colors (line 470) | def get_n_colors(N, sequential=False):
  class Summ_writer (line 484) | class Summ_writer(object):
    method __init__ (line 485) | def __init__(self, writer, global_step, log_freq=10, fps=8, scalar_fre...
    method summ_gif (line 495) | def summ_gif(self, name, tensor, blacken_zeros=False):
    method draw_boxlist2d_on_image (line 515) | def draw_boxlist2d_on_image(self, rgb, boxlist, scores=None, tids=None...
    method draw_boxlist2d_on_image_py (line 540) | def draw_boxlist2d_on_image_py(self, rgb, boxlist, scores, tids, linew...
    method summ_boxlist2d (line 609) | def summ_boxlist2d(self, name, rgb, boxlist, scores=None, tids=None, f...
    method summ_rgbs (line 614) | def summ_rgbs(self, name, ims, frame_ids=None, blacken_zeros=False, on...
    method summ_rgb (line 640) | def summ_rgb(self, name, ims, blacken_zeros=False, frame_id=None, only...
    method flow2color (line 665) | def flow2color(self, flow, clip=50.0):
    method summ_flow (line 704) | def summ_flow(self, name, im, clip=0.0, only_return=False, frame_id=No...
    method summ_oneds (line 711) | def summ_oneds(self, name, ims, frame_ids=None, bev=False, fro=False, ...
    method summ_oned (line 767) | def summ_oned(self, name, im, bev=False, fro=False, logvis=False, max_...
    method summ_feats (line 804) | def summ_feats(self, name, feats, valids=None, pca=True, fro=False, on...
    method summ_feat (line 852) | def summ_feat(self, name, feat, valid=None, pca=True, only_return=Fals...
    method summ_scalar (line 880) | def summ_scalar(self, name, value):
    method summ_seg (line 890) | def summ_seg(self, name, seg, only_return=False, frame_id=None, colorm...
    method summ_pts_on_rgb (line 941) | def summ_pts_on_rgb(self, name, trajs, rgb, valids=None, frame_id=None...
    method summ_pts_on_rgbs (line 984) | def summ_pts_on_rgbs(self, name, trajs, rgbs, valids=None, frame_ids=N...
    method summ_traj2ds_on_rgbs (line 1028) | def summ_traj2ds_on_rgbs(self, name, trajs, rgbs, valids=None, frame_i...
    method summ_traj2ds_on_rgbs2 (line 1113) | def summ_traj2ds_on_rgbs2(self, name, trajs, visibles, rgbs, valids=No...
    method summ_traj2ds_on_rgb (line 1175) | def summ_traj2ds_on_rgb(self, name, trajs, rgb, valids=None, show_dots...
    method draw_traj_on_image_py (line 1219) | def draw_traj_on_image_py(self, rgb, traj, S=50, linewidth=1, show_dot...
    method draw_traj_on_images_py (line 1271) | def draw_traj_on_images_py(self, rgbs, traj, S=50, linewidth=1, show_d...
    method draw_circs_on_image_py (line 1298) | def draw_circs_on_image_py(self, rgb, xy, colors=None, linewidth=10, r...
    method draw_circ_on_images_py (line 1336) | def draw_circ_on_images_py(self, rgbs, traj, vis, S=50, linewidth=1, s...
    method summ_traj_as_crops (line 1376) | def summ_traj_as_crops(self, name, trajs_e, rgbs, frame_id=None, only_...
    method summ_occ (line 1445) | def summ_occ(self, name, occ, reduce_axes=[3], bev=False, fro=False, p...
  function erode2d (line 1464) | def erode2d(im, times=1, device='cuda'):
  function dilate2d (line 1471) | def dilate2d(im, times=1, device='cuda', mode='square'):

FILE: mvtracker/utils/misc.py
  function count_parameters (line 6) | def count_parameters(model):
  function posemb_sincos_2d_xy (line 21) | def posemb_sincos_2d_xy(xy, C, temperature=10000, dtype=torch.float32, c...
  class SimplePool (line 41) | class SimplePool():
    method __init__ (line 42) | def __init__(self, pool_size, version='pt'):
    method __len__ (line 51) | def __len__(self):
    method mean (line 54) | def mean(self, min_size=1):
    method sample (line 71) | def sample(self, with_replacement=True):
    method fetch (line 78) | def fetch(self, num=None):
    method is_full (line 96) | def is_full(self):
    method empty (line 100) | def empty(self):
    method update (line 103) | def update(self, items):
  function farthest_point_sample (line 117) | def farthest_point_sample(xyz, npoint, include_ends=False, deterministic...
  function farthest_point_sample_py (line 154) | def farthest_point_sample_py(xyz, npoint):

FILE: mvtracker/utils/visualizer_mp4.py
  function read_video_from_path (line 25) | def read_video_from_path(path):
  class Visualizer (line 42) | class Visualizer:
    method __init__ (line 43) | def __init__(
    method visualize (line 71) | def visualize(
    method save_video (line 172) | def save_video(video, save_dir, filename, writer=None, fps=12, step=0):
    method draw_tracks_on_video (line 190) | def draw_tracks_on_video(
    method _draw_pred_tracks (line 374) | def _draw_pred_tracks(
    method _draw_gt_tracks (line 418) | def _draw_gt_tracks(
  function put_debug_text_onto_image (line 455) | def put_debug_text_onto_image(img: np.ndarray, text: str, font_scale: fl...
  class MultiViewVisualizer (line 500) | class MultiViewVisualizer(Visualizer):
    method __init__ (line 501) | def __init__(self, **kwargs):
    method visualize (line 504) | def visualize(
  function log_mp4_track_viz (line 582) | def log_mp4_track_viz(

FILE: mvtracker/utils/visualizer_rerun.py
  function setup_libs (line 13) | def setup_libs(latex=False):
  function log_pointclouds_to_rerun (line 38) | def log_pointclouds_to_rerun(
  function _log_tracks_to_rerun (line 169) | def _log_tracks_to_rerun(
  function _log_tracks_to_rerun_lightweight (line 262) | def _log_tracks_to_rerun_lightweight(
  function log_tracks_to_rerun (line 368) | def log_tracks_to_rerun(

FILE: scripts/4ddress_preprocessing.py
  function load_pickle (line 247) | def load_pickle(p):
  function save_pickle (line 252) | def save_pickle(p, data):
  function load_image (line 257) | def load_image(path):
  function extract_4d_dress_data (line 261) | def extract_4d_dress_data(
  function crete_overview_pngs (line 499) | def crete_overview_pngs(dataset_root, subject_names, overview_dir):
  function crete_overview_mp4s (line 547) | def crete_overview_mp4s(dataset_root, subject_names, overview_dir, fps=30):

FILE: scripts/compare_cdist-topk_against_pointops-knn.py
  function knn_torch (line 9) | def knn_torch(k: int, xyz_ref: torch.Tensor, xyz_query: torch.Tensor):
  function knn_pointops (line 15) | def knn_pointops(k: int, xyz_ref: torch.Tensor, xyz_query: torch.Tensor):
  function benchmark (line 36) | def benchmark(fn, name, HALF_PRECISION=False, iters=100):

FILE: scripts/dex_ycb_to_neus_format.py
  function sample_surface (line 188) | def sample_surface(mesh: trimesh.Trimesh, count, face_weight=None, seed=...
  function pick_points_from_mesh (line 271) | def pick_points_from_mesh(mesh, picked_faces, picked_weights, reference_...
  class SequenceLoader (line 296) | class SequenceLoader():
    method __init__ (line 299) | def __init__(
    method _load_frame_rgbd (line 1376) | def _load_frame_rgbd(self, c, i):
    method _deproject_depth_and_filter_points (line 1396) | def _deproject_depth_and_filter_points(self, d, c):
    method transform_ycb (line 1434) | def transform_ycb(self,
    method serials (line 1505) | def serials(self):
    method num_cameras (line 1509) | def num_cameras(self):
    method num_frames (line 1513) | def num_frames(self):
    method dimensions (line 1517) | def dimensions(self):
    method ycb_ids (line 1521) | def ycb_ids(self):
    method K (line 1525) | def K(self):
    method master_intrinsics (line 1529) | def master_intrinsics(self):
    method step (line 1532) | def step(self):
    method _update_pcd (line 1538) | def _update_pcd(self):
    method pcd_rgb (line 1548) | def pcd_rgb(self):
    method pcd_vert (line 1555) | def pcd_vert(self):
    method pcd_tex_coord (line 1562) | def pcd_tex_coord(self):
    method pcd_mask (line 1566) | def pcd_mask(self):
    method ycb_group_layer (line 1573) | def ycb_group_layer(self):
    method num_ycb (line 1577) | def num_ycb(self):
    method ycb_model_dir (line 1581) | def ycb_model_dir(self):
    method ycb_count (line 1585) | def ycb_count(self):
    method ycb_material (line 1589) | def ycb_material(self):
    method ycb_pose (line 1593) | def ycb_pose(self):
    method ycb_vert (line 1600) | def ycb_vert(self):
    method ycb_norm (line 1607) | def ycb_norm(self):
    method ycb_tex_coords (line 1614) | def ycb_tex_coords(self):
    method mano_group_layer (line 1618) | def mano_group_layer(self):
    method num_mano (line 1622) | def num_mano(self):
    method mano_vert (line 1626) | def mano_vert(self):
    method mano_norm (line 1633) | def mano_norm(self):
    method mano_line (line 1640) | def mano_line(self):
    method mano_joint_3d (line 1647) | def mano_joint_3d(self):
  function visualize_3dpt_tracks (line 1659) | def visualize_3dpt_tracks(tracks_path, output_video_path):
  function main (line 1759) | def main():

FILE: scripts/egoexo4d_preprocessing.py
  function main_preprocess_egoexo4d (line 90) | def main_preprocess_egoexo4d(
  function main_estimate_duster_depth (line 389) | def main_estimate_duster_depth(

FILE: scripts/estimate_depth_with_duster.py
  function seed_all (line 82) | def seed_all(seed):
  function get_view_visibility (line 104) | def get_view_visibility(scene, pts):
  function get_3D_model_from_scene (line 154) | def get_3D_model_from_scene(
  function get_2D_matches (line 296) | def get_2D_matches(output_file_prefix, scene, input_views, min_conf_thr,...
  function load_images (line 358) | def load_images(folder_or_list, size, square_ok=False, verbose=True):
  function tensor_to_pil (line 415) | def tensor_to_pil(img_tensor):
  function load_tensor_images (line 420) | def load_tensor_images(tensor_list, size, square_ok=False, verbose=True):
  function global_aligner (line 452) | def global_aligner(dust3r_output, device, **optim_kw):
  function load_known_camera_parameters_from_neus_dataset (line 458) | def load_known_camera_parameters_from_neus_dataset(dataset_path, input_v...
  function run_duster (line 495) | def run_duster(
  function main_on_neus_scene (line 748) | def main_on_neus_scene(scene_root, views_selection, **duster_kwargs):
  function main_on_kubric_scene (line 787) | def main_on_kubric_scene(scene_root, views_selection, **duster_kwargs):
  function main_on_d3dgs_panoptic_scene (line 829) | def main_on_d3dgs_panoptic_scene(

FILE: scripts/hi4d_preprocessing.py
  function load_pickle (line 111) | def load_pickle(p):
  function save_pickle (line 137) | def save_pickle(p, data):
  function load_image (line 143) | def load_image(path):
  function _safe_load_rgb_cameras (line 147) | def _safe_load_rgb_cameras(npz_path: str) -> Dict[str, np.ndarray]:
  function _find_all_frames_for_action (line 162) | def _find_all_frames_for_action(images_root: str, cam_ids: List[int]) ->...
  function _mesh_path_for_frame (line 179) | def _mesh_path_for_frame(frames_dir: str, frame_idx: int) -> str:
  function extract_hi4d_action_to_pkl (line 186) | def extract_hi4d_action_to_pkl(

FILE: scripts/merge_comparison_mp4s.py
  function create_title_image (line 21) | def create_title_image(text, width, height=50, bg_color=(255, 255, 255)):
  function merge_mp4s (line 44) | def merge_mp4s(mp4s_title_to_path_dict, merged_mp4_output_path, num_colu...

FILE: scripts/panoptic_studio_preprocessing.py
  function parse_args (line 62) | def parse_args():

FILE: scripts/plot_aj_for_varying_depth_noise_levels.py
  function set_size (line 9) | def set_size(width, fraction=1, golden_ratio=(5 ** .5 - 1) / 2):
  function setup_plot (line 44) | def setup_plot():
  function plot_aj (line 51) | def plot_aj(

FILE: scripts/plot_aj_for_varying_n_of_views.py
  function set_size (line 10) | def set_size(width, fraction=1):
  function setup_plot (line 45) | def setup_plot():
  function plot_aj (line 52) | def plot_aj(

FILE: scripts/selfcap_preprocessing.py
  function main_preprocess_selfcap (line 52) | def main_preprocess_selfcap(

FILE: scripts/summarize_eval_results.py
  function find_file_with_max_steps (line 206) | def find_file_with_max_steps(folder):
  function create_table (line 222) | def create_table(
  function kubric_single_point (line 278) | def kubric_single_point():
  function kubric_before_gt0123 (line 291) | def kubric_before_gt0123():
  function kubric (line 310) | def kubric():
  function kubric_duster (line 330) | def kubric_duster():
  function mv3_kubric_duster_transformed (line 363) | def mv3_kubric_duster_transformed():
  function mv3_kubric_nviews (line 383) | def mv3_kubric_nviews():
  function mv3_kubric_duster_nviews (line 401) | def mv3_kubric_duster_nviews():
  function kubric_nviews (line 417) | def kubric_nviews():
  function tavid2d_davis (line 678) | def tavid2d_davis():
  function dexycb (line 708) | def dexycb():
  function kubric_refactored (line 743) | def kubric_refactored():
  function panoptic (line 785) | def panoptic():
  function kubric_single (line 809) | def kubric_single():
  function dexycb_single (line 836) | def dexycb_single():
  function panoptic_single (line 863) | def panoptic_single():
  function ablation_2dpt (line 899) | def ablation_2dpt():
  function one_to_rule_them_all (line 921) | def one_to_rule_them_all(models, datasets, separate_datasets=True, **cre...
  function ablation_model_params (line 943) | def ablation_model_params():
  function ablation_camera_setups (line 957) | def ablation_camera_setups():
  function ablation_num_views (line 969) | def ablation_num_views(separate_datasets):