SYMBOL INDEX (785 symbols across 54 files)

FILE: efm3d/aria/camera.py
  class DefaultCameraTWData (line 34) | class DefaultCameraTWData(TensorWrapper):
    method __init__ (line 37) | def __init__(self):
    method shape (line 41) | def shape(self):
  class DefaultCameraTWParam (line 45) | class DefaultCameraTWParam(TensorWrapper):
    method __init__ (line 48) | def __init__(self):
    method shape (line 52) | def shape(self):
  class DefaultCameraTWDistParam (line 56) | class DefaultCameraTWDistParam(TensorWrapper):
    method __init__ (line 59) | def __init__(self):
    method shape (line 63) | def shape(self):
  function is_fisheye624 (line 86) | def is_fisheye624(inp):
  function is_kb3 (line 99) | def is_kb3(inp):
  function is_pinhole (line 105) | def is_pinhole(inp):
  function get_aria_camera (line 111) | def get_aria_camera(params=SLAM_PARAMS, width=640, height=480, valid_rad...
  function get_pinhole_camera (line 128) | def get_pinhole_camera(params, width=640, height=480, valid_radius=None,...
  function get_base_aria_rgb_camera_full_res (line 145) | def get_base_aria_rgb_camera_full_res():
  function get_base_aria_rgb_camera (line 151) | def get_base_aria_rgb_camera():
  function get_base_aria_slam_camera (line 155) | def get_base_aria_slam_camera():
  class CameraTW (line 159) | class CameraTW(TensorWrapper):
    method __init__ (line 175) | def __init__(
    method from_parameters (line 184) | def from_parameters(
    method from_surreal (line 223) | def from_surreal(
    method size (line 318) | def size(self) -> torch.Tensor:
    method f (line 323) | def f(self) -> torch.Tensor:
    method c (line 328) | def c(self) -> torch.Tensor:
    method K (line 333) | def K(self) -> torch.Tensor:
    method K44 (line 348) | def K44(self) -> torch.Tensor:
    method gain (line 363) | def gain(self) -> torch.Tensor:
    method exposure_s (line 368) | def exposure_s(self) -> torch.Tensor:
    method valid_radius (line 373) | def valid_radius(self) -> torch.Tensor:
    method T_camera_rig (line 378) | def T_camera_rig(self) -> torch.Tensor:
    method dist (line 383) | def dist(self) -> torch.Tensor:
    method params (line 388) | def params(self) -> torch.Tensor:
    method is_fisheye624 (line 393) | def is_fisheye624(self):
    method is_kb3 (line 397) | def is_kb3(self):
    method is_linear (line 401) | def is_linear(self):
    method set_valid_radius (line 404) | def set_valid_radius(self, valid_radius: torch.Tensor):
    method set_T_camera_rig (line 407) | def set_T_camera_rig(self, T_camera_rig: PoseTW):
    method scale (line 410) | def scale(self, scales: Union[float, int, Tuple[Union[float, int]]]):
    method scale_to_size (line 430) | def scale_to_size(self, size_wh: Union[int, Tuple[int]]):
    method scale_to (line 444) | def scale_to(self, im: torch.Tensor):
    method crop (line 452) | def crop(self, left_top: Tuple[float], size: Tuple[int]):
    method in_image (line 479) | def in_image(self, p2d: torch.Tensor):
    method in_radius (line 488) | def in_radius(self, p2d: torch.Tensor):
    method in_radius_mask (line 500) | def in_radius_mask(self):
    method project (line 516) | def project(self, p3d: torch.Tensor) -> Tuple[torch.Tensor]:
    method unproject (line 549) | def unproject(self, p2d: torch.Tensor) -> Tuple[torch.Tensor]:
    method rotate_90_cw (line 580) | def rotate_90_cw(self):
    method rotate_90_ccw (line 583) | def rotate_90_ccw(self):
    method rotate_90 (line 586) | def rotate_90(self, clock_wise: bool):
    method __repr__ (line 639) | def __repr__(self):
  function grid_2d (line 643) | def grid_2d(
  function pixel_grid (line 661) | def pixel_grid(cam: CameraTW):
  function scale_image_to_cam (line 667) | def scale_image_to_cam(cams: CameraTW, ims: torch.Tensor) -> torch.Tensor:

FILE: efm3d/aria/obb.py
  class ObbTW (line 97) | class ObbTW(TensorWrapper):
    method __init__ (line 105) | def __init__(self, data: torch.Tensor = PAD_VAL * torch.ones((1, 34))):
    method from_lmc (line 112) | def from_lmc(
    method bb3_object (line 144) | def bb3_object(self) -> torch.Tensor:
    method bb3_min_object (line 149) | def bb3_min_object(self) -> torch.Tensor:
    method bb3_max_object (line 154) | def bb3_max_object(self) -> torch.Tensor:
    method bb3_center_object (line 159) | def bb3_center_object(self) -> torch.Tensor:
    method bb3_center_world (line 164) | def bb3_center_world(self) -> torch.Tensor:
    method bb3_diagonal (line 173) | def bb3_diagonal(self) -> torch.Tensor:
    method bb3_volumes (line 178) | def bb3_volumes(self) -> torch.Tensor:
    method bb2_rgb (line 184) | def bb2_rgb(self) -> torch.Tensor:
    method visible_bb3_ind (line 188) | def visible_bb3_ind(self, cam_id) -> torch.Tensor:
    method bb2_slaml (line 195) | def bb2_slaml(self) -> torch.Tensor:
    method bb2_slamr (line 200) | def bb2_slamr(self) -> torch.Tensor:
    method bb2 (line 204) | def bb2(self, cam_id) -> torch.Tensor:
    method set_bb2 (line 214) | def set_bb2(self, cam_id, bb2d, use_mask=True):
    method set_bb3_object (line 226) | def set_bb3_object(self, bb3_object, use_mask=True) -> torch.Tensor:
    method set_prob (line 233) | def set_prob(self, prob, use_mask=True):
    method T_world_object (line 241) | def T_world_object(self) -> torch.Tensor:
    method get_padding_mask (line 245) | def get_padding_mask(self) -> torch.Tensor:
    method set_T_world_object (line 249) | def set_T_world_object(self, T_world_object: PoseTW):
    method sem_id (line 256) | def sem_id(self) -> torch.Tensor:
    method set_sem_id (line 260) | def set_sem_id(self, sem_id: torch.Tensor):
    method inst_id (line 265) | def inst_id(self) -> torch.Tensor:
    method set_inst_id (line 269) | def set_inst_id(self, inst_id: torch.Tensor):
    method prob (line 274) | def prob(self) -> torch.Tensor:
    method moveable (line 279) | def moveable(self) -> torch.Tensor:
    method bb3corners_world (line 284) | def bb3corners_world(self) -> torch.Tensor:
    method bb3corners_object (line 288) | def bb3corners_object(self) -> torch.Tensor:
    method bb3edge_pts_object (line 296) | def bb3edge_pts_object(self, num_samples_per_edge: int = 10) -> torch....
    method center (line 320) | def center(self):
    method add_padding (line 355) | def add_padding(self, max_elts: int = 1000) -> "ObbTW":
    method remove_padding (line 377) | def remove_padding(self) -> List["ObbTW"]:
    method _mark_invalid (line 408) | def _mark_invalid(self, invalid_mask: torch.Tensor) -> "ObbTW":
    method _mark_invalid_ids (line 418) | def _mark_invalid_ids(self, invalid_ids: torch.Tensor) -> "ObbTW":
    method num_valid (line 427) | def num_valid(self) -> int:
    method scale_bb2 (line 446) | def scale_bb2(self, scale_rgb: float, scale_slam: float):
    method crop_bb2 (line 491) | def crop_bb2(self, left_top_rgb: Tuple[float], left_top_slam: Tuple[fl...
    method rotate_bb2_cw (line 527) | def rotate_bb2_cw(self, image_sizes: List[Tuple[int]]):
    method rectify_obb2 (line 561) | def rectify_obb2(self, fisheye_cams: List[CameraTW], pinhole_cams: Lis...
    method get_pseudo_bb2 (line 632) | def get_pseudo_bb2(
    method get_bb2_heights (line 654) | def get_bb2_heights(self, cam_id):
    method get_bb2_widths (line 661) | def get_bb2_widths(self, cam_id):
    method get_bb2_areas (line 668) | def get_bb2_areas(self, cam_id):
    method get_bb2_centers (line 675) | def get_bb2_centers(self, cam_id):
    method batch_points_inside_bb3 (line 684) | def batch_points_inside_bb3(self, pts_world: torch.Tensor) -> torch.Te...
    method points_inside_bb3 (line 696) | def points_inside_bb3(
    method _transform (line 708) | def _transform(self, T_new_world):
    method transform (line 716) | def transform(self, T_new_world):
    method _transform_object (line 724) | def _transform_object(self, T_object_new):
    method filter_by_sem_id (line 732) | def filter_by_sem_id(self, keep_sem_ids):
    method filter_by_prob (line 739) | def filter_by_prob(self, prob_thr: float):
    method filter_bb2_center_by_radius (line 745) | def filter_bb2_center_by_radius(self, calib, cam_id):
    method voxel_grid (line 757) | def voxel_grid(self, vD: int, vH: int, vW: int):
    method __repr__ (line 798) | def __repr__(self):
  function _single_transform_obbs (line 802) | def _single_transform_obbs(obbs_padded, Ts_other_world):
  function _batched_transform_obbs (line 819) | def _batched_transform_obbs(obbs_padded, Ts_other_world):
  function transform_obbs (line 832) | def transform_obbs(obbs_padded, Ts_other_world):
  function rot_obb2_cw (line 842) | def rot_obb2_cw(bb2: torch.Tensor, size: Tuple[int]):
  function project_bb3d_onto_image (line 853) | def project_bb3d_onto_image(
  function bb2d_from_project_bb3d (line 956) | def bb2d_from_project_bb3d(
  function bb2_xxyy_to_xyxy (line 1040) | def bb2_xxyy_to_xyxy(bb2s):
  function bb2_xyxy_to_xxyy (line 1051) | def bb2_xyxy_to_xxyy(bb2s):
  function bb3_xyzxyz_to_xxyyzz (line 1062) | def bb3_xyzxyz_to_xxyyzz(bb3s):
  function bb3_xyz_xyz_to_xxyyzz (line 1069) | def bb3_xyz_xyz_to_xxyyzz(bb3s_min, bb3s_max):
  function rnd_obbs (line 1076) | def rnd_obbs(N: int = 1, num_semcls: int = 10, bb3_min_diag=0.1, bb2_min...
  function obb_time_union (line 1092) | def obb_time_union(obbs, pad_size=128):
  function obb_filter_outside_volume (line 1129) | def obb_filter_outside_volume(obbs, T_ws, T_wv, voxel_extent, border=0.1):
  function tensor_linspace (line 1162) | def tensor_linspace(start, end, steps, device):
  function make_obb (line 1192) | def make_obb(sz, position, prob=1.0, roll=0.0, pitch=0.0, yaw=0.1):
  function obb_iou3d (line 1212) | def obb_iou3d(obb1: ObbTW, obb2: ObbTW, samp_per_dim=32):
  function is_point_inside_box (line 1249) | def is_point_inside_box(points: torch.Tensor, box: torch.Tensor, verbose...
  function box_planar_dir (line 1281) | def box_planar_dir(
  function get_plane_verts (line 1346) | def get_plane_verts(box: torch.Tensor) -> torch.Tensor:
  function is_inside (line 1363) | def is_inside(
  function get_plane_center_normal (line 1424) | def get_plane_center_normal(planes: torch.Tensor) -> torch.Tensor:

FILE: efm3d/aria/pose.py
  function get_T_rot_z (line 36) | def get_T_rot_z(angle: float):
  function skew_symmetric (line 47) | def skew_symmetric(v):
  function inv_skew_symmetric (line 67) | def inv_skew_symmetric(V):
  function so3exp_map (line 82) | def so3exp_map(w, eps: float = 1e-7):
  function so3log_map (line 99) | def so3log_map(R, eps: float = 1e-7):
  function interpolation_boundaries_alphas (line 118) | def interpolation_boundaries_alphas(times: torch.Tensor, interp_times: t...
  function quaternion_to_matrix (line 159) | def quaternion_to_matrix(quaternions_wxyz: torch.Tensor) -> torch.Tensor:
  class PoseTW (line 194) | class PoseTW(TensorWrapper):
    method __init__ (line 197) | def __init__(self, data: torch.Tensor = IdentityPose):
    method from_Rt (line 204) | def from_Rt(cls, R: torch.Tensor, t: torch.Tensor):
    method from_qt (line 220) | def from_qt(cls, quaternion_wxyz: torch.Tensor, t: torch.Tensor):
    method from_aa (line 240) | def from_aa(cls, aa: torch.Tensor, t: torch.Tensor):
    method from_matrix (line 255) | def from_matrix(cls, T: torch.Tensor):
    method from_matrix3x4 (line 266) | def from_matrix3x4(cls, T_3x4: torch.Tensor):
    method exp (line 277) | def exp(cls, u_omega: torch.Tensor, eps: float = 1e-7):
    method R (line 319) | def R(self) -> torch.Tensor:
    method t (line 325) | def t(self) -> torch.Tensor:
    method q (line 330) | def q(self) -> torch.Tensor:
    method q_xyzw (line 408) | def q_xyzw(self) -> torch.Tensor:
    method matrix3x4 (line 418) | def matrix3x4(self) -> torch.Tensor:
    method matrix (line 427) | def matrix(self) -> torch.Tensor:
    method to_euler (line 434) | def to_euler(self, rad=True) -> torch.Tensor:
    method to_ypr (line 451) | def to_ypr(self, rad=True) -> torch.Tensor:
    method inverse (line 462) | def inverse(self) -> "PoseTW":
    method compose (line 468) | def compose(self, other: "PoseTW") -> "PoseTW":
    method transform (line 475) | def transform(self, p3d: torch.Tensor) -> torch.Tensor:
    method batch_transform (line 488) | def batch_transform(self, p3d: torch.Tensor) -> torch.Tensor:
    method rotate (line 507) | def rotate(self, p3d: torch.Tensor) -> torch.Tensor:
    method __mul__ (line 518) | def __mul__(self, p3D: torch.Tensor) -> torch.Tensor:
    method __matmul__ (line 522) | def __matmul__(self, other: "PoseTW") -> "PoseTW":
    method numpy (line 526) | def numpy(self) -> Tuple[np.ndarray]:
    method magnitude (line 529) | def magnitude(self, deg=True, eps=0) -> Tuple[torch.Tensor]:
    method so3_geodesic (line 545) | def so3_geodesic(self, other: "PoseTW", deg=False) -> "PoseTW":
    method log (line 551) | def log(self, eps: float = 1e-6) -> torch.Tensor:
    method interpolate (line 589) | def interpolate(self, times: torch.Tensor, interp_times: torch.Tensor):
    method align (line 625) | def align(self, other, self_times=None, other_times=None):
    method fit_to_SO3 (line 689) | def fit_to_SO3(self):
    method __repr__ (line 697) | def __repr__(self):
  function interpolate_timed_poses (line 701) | def interpolate_timed_poses(
  function lower_timed_poses (line 750) | def lower_timed_poses(
  function closest_timed_poses (line 773) | def closest_timed_poses(
  function all_rot90 (line 800) | def all_rot90():
  function find_r90 (line 816) | def find_r90(Ta, Tb, R90s):
  function stereographic_unproject (line 837) | def stereographic_unproject(a, axis=None):
  function rotation_from_ortho_6d (line 857) | def rotation_from_ortho_6d(ortho6d):
  function rotation_from_ortho_5d (line 881) | def rotation_from_ortho_5d(ortho5d):
  function rotation_from_euler (line 904) | def rotation_from_euler(euler):
  function fit_to_SO3 (line 929) | def fit_to_SO3(R):

FILE: efm3d/aria/projection_utils.py
  function sign_plus (line 18) | def sign_plus(x):
  function fisheye624_project (line 29) | def fisheye624_project(xyz, params):
  function fisheye624_unproject (line 142) | def fisheye624_unproject(uv, params, max_iters: int = 5):
  function pinhole_project (line 303) | def pinhole_project(xyz, params):
  function pinhole_unproject (line 332) | def pinhole_unproject(uv, params, max_iters: int = 5):

FILE: efm3d/aria/tensor_wrapper.py
  function smart_cat (line 33) | def smart_cat(inp_arr, dim=-1):
  function smart_stack (line 46) | def smart_stack(inp_arr, dim: int = 0):
  function get_default_args (line 59) | def get_default_args(func):
  function get_nonempty_arg_names (line 68) | def get_nonempty_arg_names(func):
  function autocast (line 78) | def autocast(func):
  function autoinit (line 106) | def autoinit(func):
  function tensor_wrapper_collate (line 206) | def tensor_wrapper_collate(batch, *, collate_fn_map=None):
  function float_collate (line 211) | def float_collate(batch, *, collate_fn_map=None):
  function list_dict_collate (line 216) | def list_dict_collate(batch, *, collate_fn_map=None):
  function tensor_wrapper_collate_cat (line 231) | def tensor_wrapper_collate_cat(batch, *, collate_fn_map=None):
  function tensor_collate_cat (line 236) | def tensor_collate_cat(batch, *, collate_fn_map=None):
  function custom_collate_fn (line 254) | def custom_collate_fn(batch):
  class TensorWrapper (line 283) | class TensorWrapper:
    method __init__ (line 293) | def __init__(self, data: torch.Tensor):
    method shape (line 297) | def shape(self):
    method device (line 301) | def device(self):
    method dtype (line 305) | def dtype(self):
    method ndim (line 309) | def ndim(self):
    method dim (line 312) | def dim(self):
    method nelement (line 315) | def nelement(self):
    method numel (line 318) | def numel(self):
    method collate_fn (line 322) | def collate_fn(self):
    method is_cuda (line 326) | def is_cuda(self):
    method is_contiguous (line 330) | def is_contiguous(self):
    method requires_grad (line 334) | def requires_grad(self):
    method grad (line 338) | def grad(self):
    method grad_fn (line 342) | def grad_fn(self):
    method requires_grad_ (line 345) | def requires_grad_(self, requires_grad: bool = True):
    method __getitem__ (line 348) | def __getitem__(self, index):
    method __setitem__ (line 351) | def __setitem__(self, index, item):
    method to (line 354) | def to(self, *args, **kwargs):
    method reshape (line 357) | def reshape(self, *args, **kwargs):
    method repeat (line 360) | def repeat(self, *args, **kwargs):
    method expand (line 363) | def expand(self, *args, **kwargs):
    method clone (line 366) | def clone(self):
    method cpu (line 369) | def cpu(self):
    method cuda (line 372) | def cuda(self, gpu_id=0):
    method contiguous (line 375) | def contiguous(self):
    method pin_memory (line 378) | def pin_memory(self):
    method float (line 381) | def float(self):
    method double (line 384) | def double(self):
    method detach (line 387) | def detach(self):
    method numpy (line 390) | def numpy(self):
    method tensor (line 393) | def tensor(self):
    method tolist (line 396) | def tolist(self):
    method squeeze (line 399) | def squeeze(self, dim=None):
    method unsqueeze (line 405) | def unsqueeze(self, dim=None):
    method view (line 409) | def view(self, *shape):
    method __len__ (line 413) | def __len__(self):
    method stack (line 417) | def stack(cls, objects: List, dim=0, *, out=None):
    method cat (line 422) | def cat(cls, objects: List, dim=0, *, out=None):
    method allclose (line 427) | def allclose(
    method take_along_dim (line 440) | def take_along_dim(cls, obj, indices, dim, *, out=None):
    method flatten (line 445) | def flatten(cls, obj, start_dim=0, end_dim=-1):
    method __torch_function__ (line 450) | def __torch_function__(self, func, types, args=(), kwargs=None):

FILE: efm3d/dataset/atek_vrs_dataset.py
  class AtekRawDataloaderAsEfm (line 37) | class AtekRawDataloaderAsEfm:
    method __init__ (line 38) | def __init__(
    method __len__ (line 74) | def __len__(self):
    method get_timestamps_by_sample_index (line 77) | def get_timestamps_by_sample_index(self, index: int) -> List[int]:
    method get_atek_sample_at_timestamps_ns (line 80) | def get_atek_sample_at_timestamps_ns(
    method get_model_specific_sample_at_timestamps_ns (line 85) | def get_model_specific_sample_at_timestamps_ns(
    method __getitem__ (line 112) | def __getitem__(self, index):
  function create_atek_raw_data_loader_from_vrs_path (line 122) | def create_atek_raw_data_loader_from_vrs_path(

FILE: efm3d/dataset/atek_wds_dataset.py
  function batchify (line 37) | def batchify(datum, device=None):
  function unbatchify (line 49) | def unbatchify(datum):
  class AtekWdsStreamDataset (line 57) | class AtekWdsStreamDataset:
    method __init__ (line 60) | def __init__(
    method __len__ (line 113) | def __len__(self):
    method sample_snippet_ (line 116) | def sample_snippet_(self, snippet, start, end):
    method __iter__ (line 130) | def __iter__(self):
    method if_get_next_ (line 133) | def if_get_next_(self):
    method __next__ (line 142) | def __next__(self):

FILE: efm3d/dataset/augmentation.py
  class ColorJitter (line 36) | class ColorJitter:
    method __init__ (line 41) | def __init__(
    method rnd_sharpen (line 68) | def rnd_sharpen(self, im):
    method apply (line 73) | def apply(self, im):
    method __call__ (line 78) | def __call__(self, batch: Dict):
  class PointDrop (line 90) | class PointDrop:
    method __init__ (line 101) | def __init__(
    method __call__ (line 118) | def __call__(self, batch: Dict):
  class PointDropSimple (line 166) | class PointDropSimple:
    method __init__ (line 171) | def __init__(
    method __call__ (line 178) | def __call__(self, batch: Dict):
  class PointJitter (line 195) | class PointJitter:
    method __init__ (line 200) | def __init__(
    method __call__ (line 213) | def __call__(self, batch: Dict):

FILE: efm3d/dataset/efm_model_adaptor.py
  function get_local_pose_helper (line 48) | def get_local_pose_helper(snippet_origin_time_s, batch, local_coordinate):
  function run_local_cosy (line 86) | def run_local_cosy(
  function get_snippet_cosy_from_rig (line 148) | def get_snippet_cosy_from_rig(
  function get_snippet_cosy_from_cam_rgb (line 166) | def get_snippet_cosy_from_cam_rgb(
  class EfmModelAdaptor (line 195) | class EfmModelAdaptor:
    method __init__ (line 205) | def __init__(
    method get_dict_key_mapping_for_camera (line 228) | def get_dict_key_mapping_for_camera(atek_camera_label: str, efm_camera...
    method get_dict_key_mapping_all (line 242) | def get_dict_key_mapping_all():
    method _get_pose_to_align_gravity (line 272) | def _get_pose_to_align_gravity(self, sample_dict: Dict) -> Optional[Po...
    method _load_taxonomy_mapping_file (line 297) | def _load_taxonomy_mapping_file(self, filename: str) -> Dict:
    method _fill_dict_with_freq (line 316) | def _fill_dict_with_freq(self, sample_dict: Dict) -> Dict:
    method _convert_to_batched_camera_tw (line 333) | def _convert_to_batched_camera_tw(
    method _update_efm_obb_gt (line 370) | def _update_efm_obb_gt(self, atek_gt_dict: Dict) -> Dict:
    method _pad_semidense_data (line 492) | def _pad_semidense_data(self, sample_dict: Dict) -> Dict:
    method _pad_over_frames (line 520) | def _pad_over_frames(self, sample_dict: Dict, fields_to_pad: List[str]...
    method _split_pose_over_snippet (line 533) | def _split_pose_over_snippet(self, sample_dict: Dict) -> Dict:
    method _split_timestamps_over_snippet (line 579) | def _split_timestamps_over_snippet(self, sample_dict: Dict) -> Dict:
    method atek_to_efm (line 602) | def atek_to_efm(self, data, train=False):
  function load_atek_wds_dataset_as_efm (line 706) | def load_atek_wds_dataset_as_efm(
  function load_atek_wds_dataset_as_efm_train (line 733) | def load_atek_wds_dataset_as_efm_train(

FILE: efm3d/dataset/vrs_dataset.py
  function is_adt (line 74) | def is_adt(vrs_path):
  function is_aeo (line 84) | def is_aeo(vrs_path):
  function get_transform_to_vio_gravity_convention (line 88) | def get_transform_to_vio_gravity_convention(gravity_direction: np.array):
  function compute_time_intersection (line 121) | def compute_time_intersection(time_lists):
  function preprocess_inference (line 137) | def preprocess_inference(batch):
  function preprocess (line 157) | def preprocess(
  function tensor_unify (line 205) | def tensor_unify(tensor, dim_size: int, dim: int = 0):
  function run_sensor_poses (line 254) | def run_sensor_poses(batch, num_notified=-1, max_notified=10):
  class VrsSequenceDataset (line 283) | class VrsSequenceDataset(Dataset):
    method __init__ (line 284) | def __init__(
    method load_objects (line 366) | def load_objects(self):
    method load_semidense (line 439) | def load_semidense(self, vrs_path, max_inv_depth_std=0.005, max_depth_...
    method load_poses (line 532) | def load_poses(self, vrs_path, subsample):
    method load_snippet_pose (line 571) | def load_snippet_pose(self, start, end):
    method load_snippet_semidense (line 583) | def load_snippet_semidense(self, start, end, max_size=20000):
    method load_snippet_objects (line 606) | def load_snippet_objects(self, start, end):
    method __len__ (line 696) | def __len__(self):
    method __getitem__ (line 699) | def __getitem__(self, index):

FILE: efm3d/dataset/wds_dataset.py
  function convert_to_aria_multimodal_dataset (line 36) | def convert_to_aria_multimodal_dataset(sample):
  function batchify (line 122) | def batchify(datum, device=None):
  function unbatchify (line 134) | def unbatchify(datum):
  function get_tar_sample_num (line 142) | def get_tar_sample_num(tar_file):
  class WdsStreamDataset (line 150) | class WdsStreamDataset:
    method __init__ (line 153) | def __init__(
    method __len__ (line 201) | def __len__(self):
    method sample_snippet_ (line 204) | def sample_snippet_(self, snippet, start, end):
    method __iter__ (line 218) | def __iter__(self):
    method if_get_next_ (line 221) | def if_get_next_(self):
    method __next__ (line 230) | def __next__(self):

FILE: efm3d/inference/eval.py
  function check_sem_id_conflict (line 29) | def check_sem_id_conflict(ids_pred, ids_gt):
  function evaluate_obb_csv (line 42) | def evaluate_obb_csv(
  function obb_eval_dataset (line 140) | def obb_eval_dataset(input_folder: str, iou: float = 0.2):
  function main (line 227) | def main():

FILE: efm3d/inference/fuse.py
  function set_boundary_value (line 35) | def set_boundary_value(x, val, thickness):
  function load_tensor (line 47) | def load_tensor(fname, device):
  class VolumeFusion (line 54) | class VolumeFusion:
    method __init__ (line 55) | def __init__(
    method set_boundary_mask (line 98) | def set_boundary_mask(self, mask):
    method fuse (line 112) | def fuse(
    method get_volume (line 168) | def get_volume(self, reshape=True):
    method get_weights (line 174) | def get_weights(self, reshape=True):
    method get_mask (line 180) | def get_mask(self, reshape=True):
    method get_trimesh (line 187) | def get_trimesh(self, iso_level=0.5):
  class VolumetricFusion (line 202) | class VolumetricFusion:
    method __init__ (line 203) | def __init__(
    method reinit (line 248) | def reinit(self):
    method init_from_range (line 254) | def init_from_range(self, xyz_min, xyz_max):
    method get_trimesh (line 283) | def get_trimesh(self):
    method run_step (line 286) | def run_step(self, i):
    method run (line 303) | def run(self):

FILE: efm3d/inference/model.py
  class EfmInference (line 41) | class EfmInference:
    method __init__ (line 42) | def __init__(self, streamer, model, output_dir, device, zip, obb_only=...
    method __del__ (line 63) | def __del__(self):
    method save_tensor (line 75) | def save_tensor(self, tensor, key, idx=None, output_dir=""):
    method save_output (line 82) | def save_output(self, data, idx, output_dir):
    method run (line 148) | def run(self):

FILE: efm3d/inference/pipeline.py
  function get_gt_mesh_ply (line 33) | def get_gt_mesh_ply(data_path):
  function compute_avg_metrics (line 51) | def compute_avg_metrics(paths):
  function create_streamer (line 71) | def create_streamer(
  function create_output_dir (line 122) | def create_output_dir(output_dir, model_ckpt, data_path):
  function run_one (line 137) | def run_one(

FILE: efm3d/inference/track.py
  function track_obbs (line 27) | def track_obbs(input_path, prob_inst_thr=0.3, prob_assoc_thr=0.25):
  function main (line 83) | def main():

FILE: efm3d/inference/viz.py
  function find_nearest (line 52) | def find_nearest(array, value):
  function fill_obbs_to_snippet (line 66) | def fill_obbs_to_snippet(obbs, rgb_ts, T_ws):
  function compose_views (line 86) | def compose_views(view_dict, keys, vertical=True):
  function draw_scene_with_mesh_and_obbs (line 104) | def draw_scene_with_mesh_and_obbs(
  function render_views (line 141) | def render_views(snippet, h, w, pred_sem_ids_to_names, gt_sem_ids_to_nam...
  function generate_video (line 230) | def generate_video(

FILE: efm3d/model/cnn.py
  function cnn_weight_initialization (line 23) | def cnn_weight_initialization(modules):
  class GELU (line 37) | class GELU(nn.Module):
    method forward (line 38) | def forward(self, x):
  class LayerNorm2d (line 42) | class LayerNorm2d(nn.LayerNorm):
    method __init__ (line 47) | def __init__(self, num_channels, eps=1e-6, affine=True):
    method forward (line 50) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class UpsampleCNN (line 60) | class UpsampleCNN(nn.Module):
    method __init__ (line 61) | def __init__(
    method forward (line 120) | def forward(self, x, force_hw=None):
  class LayerNorm3d (line 159) | class LayerNorm3d(nn.LayerNorm):
    method __init__ (line 164) | def __init__(self, num_channels, eps=1e-6, affine=True):
    method forward (line 167) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class UpConv3d (line 177) | class UpConv3d(torch.nn.Module):
    method __init__ (line 178) | def __init__(self, dim_in, dim_out):
    method forward (line 191) | def forward(self, x_up):
  class FpnUpConv3d (line 197) | class FpnUpConv3d(torch.nn.Module):
    method __init__ (line 198) | def __init__(self, dim_in, dim_out):
    method forward (line 212) | def forward(self, x_up, x_lat):
  class InvBottleNeck3d (line 220) | class InvBottleNeck3d(torch.nn.Module):
    method __init__ (line 221) | def __init__(self, dim_in, dim_out, stride: int = 1, expansion: float ...
    method forward (line 238) | def forward(self, x):
  class InvResnetBlock3d (line 247) | class InvResnetBlock3d(torch.nn.Module):
    method __init__ (line 248) | def __init__(
    method forward (line 260) | def forward(self, x):
  class InvResnetFpn3d (line 266) | class InvResnetFpn3d(torch.nn.Module):
    method __init__ (line 267) | def __init__(self, dims, num_bottles, strides, expansions, freeze=False):
    method forward (line 297) | def forward(self, x):
  class VolumeCNN (line 312) | class VolumeCNN(nn.Module):
    method __init__ (line 318) | def __init__(self, hidden_dims, conv3=nn.Conv3d, freeze=False):
    method forward (line 346) | def forward(self, x):
  class VolumeCNNHead (line 362) | class VolumeCNNHead(nn.Module):
    method __init__ (line 363) | def __init__(
    method forward (line 419) | def forward(self, x):
  class ResidualConvUnit3d (line 434) | class ResidualConvUnit3d(nn.Module):
    method __init__ (line 437) | def __init__(self, features, kernel_size):
    method forward (line 448) | def forward(self, x):
  class FeatureFusionBlock3d (line 452) | class FeatureFusionBlock3d(nn.Module):
    method __init__ (line 455) | def __init__(self, features, kernel_size, with_skip=True):
    method forward (line 463) | def forward(self, x, skip_x=None):
  class VolumeResnet (line 472) | class VolumeResnet(nn.Module):
    method __init__ (line 473) | def __init__(self, hidden_dims, conv3=nn.Conv3d, freeze=False):
    method forward (line 507) | def forward(self, x):

FILE: efm3d/model/dinov2_utils.py
  class Attention (line 54) | class Attention(nn.Module):
    method __init__ (line 55) | def __init__(
    method forward (line 74) | def forward(self, x: Tensor) -> Tensor:
  class MemEffAttention (line 94) | class MemEffAttention(Attention):
    method forward (line 95) | def forward(self, x: Tensor, attn_bias=None) -> Tensor:
  class CrossAttention (line 113) | class CrossAttention(nn.Module):
    method __init__ (line 114) | def __init__(
    method forward (line 134) | def forward(self, x_kv: Tensor, x_q: Tensor) -> Tensor:
  class MemEffCrossAttention (line 160) | class MemEffCrossAttention(CrossAttention):
    method forward (line 161) | def forward(self, x_kv: Tensor, x_q: Tensor, attn_bias=None) -> Tensor:
  class Mlp (line 181) | class Mlp(nn.Module):
    method __init__ (line 182) | def __init__(
    method forward (line 199) | def forward(self, x: Tensor) -> Tensor:
    method __init__ (line 623) | def __init__(
    method forward (line 640) | def forward(self, x: Tensor) -> Tensor:
  class Block (line 208) | class Block(nn.Module):
    method __init__ (line 209) | def __init__(
    method forward (line 257) | def forward(self, x: Tensor) -> Tensor:
  class CrossBlock (line 285) | class CrossBlock(nn.Module):
    method __init__ (line 286) | def __init__(
    method forward (line 335) | def forward(self, x_kv: Tensor, x_q: Tensor) -> Tensor:
  function drop_add_residual_stochastic_depth (line 351) | def drop_add_residual_stochastic_depth(
  function get_branges_scales (line 377) | def get_branges_scales(x, sample_drop_ratio=0.0):
  function add_residual (line 385) | def add_residual(x, brange, residual, residual_scale_factor, scaling_vec...
  function get_attn_bias_and_cat (line 406) | def get_attn_bias_and_cat(x_list, branges=None):
  function drop_add_residual_stochastic_depth_list (line 436) | def drop_add_residual_stochastic_depth_list(
  class NestedTensorBlock (line 467) | class NestedTensorBlock(Block):
    method forward_nested (line 468) | def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
    method forward (line 512) | def forward(self, x_or_x_list):
  class DINOHead (line 524) | class DINOHead(nn.Module):
    method __init__ (line 525) | def __init__(
    method _init_weights (line 549) | def _init_weights(self, m):
    method forward (line 555) | def forward(self, x):
  function _build_mlp (line 563) | def _build_mlp(
  function drop_path (line 582) | def drop_path(x, drop_prob: float = 0.0, training: bool = False):
  class DropPath (line 596) | class DropPath(nn.Module):
    method __init__ (line 599) | def __init__(self, drop_prob=None):
    method forward (line 603) | def forward(self, x):
  class LayerScale (line 607) | class LayerScale(nn.Module):
    method __init__ (line 608) | def __init__(
    method forward (line 618) | def forward(self, x: Tensor) -> Tensor:
  class Mlp (line 622) | class Mlp(nn.Module):
    method __init__ (line 182) | def __init__(
    method forward (line 199) | def forward(self, x: Tensor) -> Tensor:
    method __init__ (line 623) | def __init__(
    method forward (line 640) | def forward(self, x: Tensor) -> Tensor:
  function make_2tuple (line 649) | def make_2tuple(x):
  class PatchEmbed (line 658) | class PatchEmbed(nn.Module):
    method __init__ (line 670) | def __init__(
    method forward (line 703) | def forward(self, x: Tensor) -> Tensor:
    method flops (line 722) | def flops(self) -> float:
  class SwiGLUFFN (line 736) | class SwiGLUFFN(nn.Module):
    method __init__ (line 737) | def __init__(
    method forward (line 752) | def forward(self, x: Tensor) -> Tensor:
  class SwiGLUFFNFused (line 768) | class SwiGLUFFNFused(SwiGLU):
    method __init__ (line 769) | def __init__(
  function named_apply (line 789) | def named_apply(
  class BlockChunk (line 808) | class BlockChunk(nn.ModuleList):
    method forward (line 809) | def forward(self, x):
  class DinoVisionTransformer (line 815) | class DinoVisionTransformer(nn.Module):
    method __init__ (line 816) | def __init__(
    method init_weights (line 958) | def init_weights(self):
    method interpolate_pos_encoding (line 965) | def interpolate_pos_encoding(self, x, w, h):
    method prepare_tokens_with_masks (line 999) | def prepare_tokens_with_masks(self, x, masks=None):
    method forward_features_list (line 1022) | def forward_features_list(self, x_list, masks_list):
    method forward_features (line 1045) | def forward_features(self, x, masks=None):
    method forward_features_multi (line 1063) | def forward_features_multi(self, x, masks=None):
    method _get_intermediate_layers_not_chunked (line 1098) | def _get_intermediate_layers_not_chunked(self, x, n=1):
    method _get_intermediate_layers_chunked (line 1114) | def _get_intermediate_layers_chunked(self, x, n=1):
    method get_intermediate_layers (line 1132) | def get_intermediate_layers(
    method forward (line 1160) | def forward(self, *args, is_training=False, **kwargs):
  function init_weights_vit_timm (line 1168) | def init_weights_vit_timm(module: nn.Module, name: str = ""):
  function vit_small (line 1176) | def vit_small(patch_size, **kwargs):
  function vit_small_reg (line 1190) | def vit_small_reg(patch_size, **kwargs):
  function vit_base (line 1207) | def vit_base(patch_size, **kwargs):
  function vit_base_reg (line 1220) | def vit_base_reg(patch_size, **kwargs):
  function vit_large (line 1236) | def vit_large(patch_size, **kwargs):
  function vit_large_reg (line 1249) | def vit_large_reg(patch_size, **kwargs):
  function vit_giant2 (line 1265) | def vit_giant2(patch_size, **kwargs):
  class DinoV2Wrapper (line 1322) | class DinoV2Wrapper(torch.nn.Module):
    method __init__ (line 1327) | def __init__(
    method forward (line 1376) | def forward(self, img):

FILE: efm3d/model/dpt.py
  class ResidualConvUnit (line 22) | class ResidualConvUnit(nn.Module):
    method __init__ (line 25) | def __init__(self, features, kernel_size):
    method forward (line 36) | def forward(self, x):
  class FeatureFusionBlock (line 40) | class FeatureFusionBlock(nn.Module):
    method __init__ (line 43) | def __init__(self, features, kernel_size, with_skip=True):
    method forward (line 51) | def forward(self, x, skip_x=None):
  class Interpolate (line 63) | class Interpolate(nn.Module):
    method __init__ (line 68) | def __init__(self, scale_factor, mode, align_corners=False):
    method forward (line 82) | def forward(self, x):
  class DPTOri (line 101) | class DPTOri(nn.Module):
    method __init__ (line 106) | def __init__(self, input_dim, hidden_dim=256, output_dim=256, depth=Fa...
    method forward (line 163) | def forward(self, feats):

FILE: efm3d/model/evl.py
  class EVL (line 35) | class EVL(torch.nn.Module):
    method __init__ (line 36) | def __init__(
    method post_process (line 137) | def post_process(self, batch, out):
    method forward (line 172) | def forward(self, batch, obb_only=False):

FILE: efm3d/model/evl_train.py
  class EVLTrain (line 59) | class EVLTrain(EVL):
    method __init__ (line 60) | def __init__(
    method compute_losses (line 82) | def compute_losses(self, outputs, batch):
    method render2d (line 122) | def render2d(self, imgs, obbs, Ts_wr, cams):
    method log_single_obb (line 141) | def log_single_obb(self, batch, outputs, batch_idx):
    method log_single (line 242) | def log_single(self, batch, outputs, batch_idx):
    method render3d_mesh (line 368) | def render3d_mesh(
    method render3d_points (line 457) | def render3d_points(
    method render3d_obb (line 543) | def render3d_obb(
    method render3d_occ (line 611) | def render3d_occ(
    method get_log_images (line 689) | def get_log_images(self, batch, outputs):
    method reset_metrics (line 697) | def reset_metrics(self):
    method update_metrics (line 710) | def update_metrics(self, outputs, batch):
    method compute_metrics (line 732) | def compute_metrics(self):

FILE: efm3d/model/image_tokenizer.py
  class ImageToDinoV2Tokens (line 29) | class ImageToDinoV2Tokens(torch.nn.Module):
    method __init__ (line 34) | def __init__(
    method feat_dim (line 76) | def feat_dim(self):
    method patch_size (line 79) | def patch_size(self):
    method post_process (line 82) | def post_process(self, feats, B, T, out_size=None):
    method forward_resize (line 105) | def forward_resize(self, img: torch.Tensor) -> torch.Tensor:
    method forward (line 123) | def forward(self, img: torch.Tensor) -> torch.Tensor:

FILE: efm3d/model/lifter.py
  class VideoBackbone3d (line 44) | class VideoBackbone3d(torch.nn.Module, ABC):
    method __init__ (line 49) | def __init__(
    method feat_dim (line 61) | def feat_dim(self):
    method forward_impl (line 64) | def forward_impl(self, batch):
    method forward (line 67) | def forward(self, batch):
  class Lifter (line 86) | class Lifter(VideoBackbone3d):
    method __init__ (line 91) | def __init__(
    method output_dim (line 165) | def output_dim(self):
    method get_freespace_world (line 178) | def get_freespace_world(self, batch, batch_idx, T_wv, vW, vH, vD, S=1):
    method get_points_world (line 230) | def get_points_world(self, batch, batch_idx, keep_T=False):
    method get_freespace_counts (line 260) | def get_freespace_counts(
    method get_points_counts (line 295) | def get_points_counts(
    method get_voxelgrid_pose (line 343) | def get_voxelgrid_pose(self, cams, T_ws, Ts_sr):
    method lift (line 360) | def lift(self, feats2d, vox_w, cam, Ts_wr, vD, vH, vW):
    method aggregate (line 377) | def aggregate(self, vox_feats, vox_valid):
    method lift_aggregate_centers (line 396) | def lift_aggregate_centers(self, batch, feats2d, vox_w, Ts_wr, T_wv=No...
    method forward (line 458) | def forward(self, batch):

FILE: efm3d/model/video_backbone.py
  class VideoBackbone (line 31) | class VideoBackbone(torch.nn.Module, ABC):
    method __init__ (line 37) | def __init__(
    method feat_dim (line 76) | def feat_dim(self):
    method feat_dim (line 80) | def feat_dim(self, _feat_dim: int):
    method patch_size (line 84) | def patch_size(self):
    method forward_impl (line 87) | def forward_impl(self, img, stream) -> Dict[str, torch.Tensor]:
    method forward (line 97) | def forward(self, batch):
  class VideoBackboneDinov2 (line 129) | class VideoBackboneDinov2(VideoBackbone):
    method __init__ (line 134) | def __init__(
    method patch_size (line 161) | def patch_size(self):
    method forward_impl (line 164) | def forward_impl(self, img, stream):

FILE: efm3d/thirdparty/mmdetection3d/cuda/cuda_utils.h
  function opt_n_thread (line 15) | inline int opt_n_thread(int work_size) {
  function dim3 (line 20) | inline dim3 opt_block_config(int x, int y) {

FILE: efm3d/thirdparty/mmdetection3d/cuda/iou3d.cpp
  function gpuAssert (line 27) | inline void
  function boxes_overlap_bev_gpu (line 62) | int boxes_overlap_bev_gpu(
  function boxes_iou_bev_gpu (line 87) | int boxes_iou_bev_gpu(
  function nms_gpu (line 111) | int nms_gpu(
  function nms_normal_gpu (line 171) | int nms_normal_gpu(

FILE: efm3d/thirdparty/mmdetection3d/cuda/sort_vert.cpp
  function sort_vertices (line 20) | at::Tensor
  function PYBIND11_MODULE (line 54) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: efm3d/thirdparty/mmdetection3d/iou3d.py
  class SortVertices (line 17) | class SortVertices(Function):
    method forward (line 19) | def forward(ctx, vertices, mask, num_valid):
    method backward (line 25) | def backward(ctx, gradout):
  function box_intersection (line 29) | def box_intersection(corners1: Tensor, corners2: Tensor) -> Tuple[Tensor...
  function box1_in_box2 (line 70) | def box1_in_box2(corners1: Tensor, corners2: Tensor) -> Tensor:
  function box_in_box (line 101) | def box_in_box(corners1: Tensor, corners2: Tensor) -> Tuple[Tensor, Tens...
  function build_vertices (line 118) | def build_vertices(
  function sort_indices (line 153) | def sort_indices(vertices: Tensor, mask: Tensor) -> Tensor:
  function calculate_area (line 180) | def calculate_area(idx_sorted: Tensor, vertices: Tensor) -> Tuple[Tensor...
  function oriented_box_intersection_2d (line 203) | def oriented_box_intersection_2d(
  function box2corners (line 226) | def box2corners(box: Tensor) -> Tensor:
  function diff_iou_rotated_2d (line 254) | def diff_iou_rotated_2d(box1: Tensor, box2: Tensor) -> Tensor:
  function diff_iou_rotated_3d (line 274) | def diff_iou_rotated_3d(box3d1: Tensor, box3d2: Tensor) -> Tensor:
  function rotated_iou_3d_loss (line 301) | def rotated_iou_3d_loss(pred, target):
  class RotatedIoU3DLoss (line 318) | class RotatedIoU3DLoss(torch.nn.Module):
    method __init__ (line 325) | def __init__(self, loss_weight=1.0):
    method forward (line 329) | def forward(
  function boxes_iou_bev (line 352) | def boxes_iou_bev(boxes_a, boxes_b):
  function nms_gpu (line 369) | def nms_gpu(boxes, scores, thresh, pre_maxsize=None, post_max_size=None):
  function nms_normal_gpu (line 397) | def nms_normal_gpu(boxes, scores, thresh):

FILE: efm3d/utils/common.py
  function sample_nearest (line 19) | def sample_nearest(value_a, value_b, array_b):
  function find_nearest (line 27) | def find_nearest(array, value, return_index=False):

FILE: efm3d/utils/depth.py
  function dist_im_to_point_cloud_im (line 19) | def dist_im_to_point_cloud_im(dist_m, cams):

FILE: efm3d/utils/detection_utils.py
  function norm2ind (line 22) | def norm2ind(norm_xyz, vD, vH, vW):
  function ind2norm (line 49) | def ind2norm(inds_dhw, vD, vH, vW):
  function normalize_coord3d (line 62) | def normalize_coord3d(xyz, extent):
  function unnormalize_coord3d (line 74) | def unnormalize_coord3d(xyz_n, extent):
  function create_heatmap_gt (line 86) | def create_heatmap_gt(mu_xy, H, W, valid=None):
  function simple_nms (line 126) | def simple_nms(scores, nms_radius: int):
  function simple_nms3d (line 146) | def simple_nms3d(scores, nms_radius: int):
  function heatmap2obb (line 166) | def heatmap2obb(scores, threshold=0.3, size=20, max_elts=1000):
  function compute_focal_loss (line 192) | def compute_focal_loss(pred, gt, focal_gamma=2, focal_alpha=0.25):
  function compute_chamfer_loss (line 220) | def compute_chamfer_loss(vals, target):
  function obb2voxel (line 232) | def obb2voxel(obb_v, vD, vH, vW, voxel_extent, num_class, splat_sigma=2):
  function voxel2obb (line 370) | def voxel2obb(

FILE: efm3d/utils/evl_loss.py
  function get_gt_obbs (line 34) | def get_gt_obbs(batch, voxel_extent, T_wv=None):
  function obbs_to_7d (line 58) | def obbs_to_7d(obbs):
  function iou_3d_loss (line 74) | def iou_3d_loss(obbs_pr, obbs_gt, cent_pr, cent_gt, valid_gt):
  function compute_obb_losses (line 97) | def compute_obb_losses(
  function compute_occ_losses (line 195) | def compute_occ_losses(

FILE: efm3d/utils/file_utils.py
  function load_gt_calibration (line 38) | def load_gt_calibration(
  function get_image_info (line 102) | def get_image_info(image_reader: SyncVRSReader) -> Tuple[Dict, Dict]:
  function load_factory_calib (line 124) | def load_factory_calib(
  function load_2d_bounding_boxes (line 168) | def load_2d_bounding_boxes(bb2d_path, time_in_secs=False):
  function load_2d_bounding_boxes_adt (line 224) | def load_2d_bounding_boxes_adt(bb2d_path):
  function remove_invalid_2d_bbs (line 278) | def remove_invalid_2d_bbs(timed_bb2s, filter_bb2_area=-1):
  function load_instances (line 296) | def load_instances(instances_path):
  function load_instances_adt (line 314) | def load_instances_adt(instances_path):
  function load_3d_bounding_box_transforms (line 331) | def load_3d_bounding_box_transforms(scene_path, time_in_secs=False, load...
  function load_3d_bounding_box_local_extents (line 377) | def load_3d_bounding_box_local_extents(bb3d_path, load_torch=False):
  function load_obbs_gt (line 408) | def load_obbs_gt(
  function load_trajectory_adt (line 532) | def load_trajectory_adt(
  function load_trajectory_aeo (line 585) | def load_trajectory_aeo(
  function load_trajectory (line 652) | def load_trajectory(
  function parse_global_name_to_id_csv (line 714) | def parse_global_name_to_id_csv(csv_path: str, verbose: bool = True) -> ...
  function exists_nonzero_path (line 741) | def exists_nonzero_path(path: Union[str, list]) -> Optional[str]:
  function get_timestamp_list_ns (line 767) | def get_timestamp_list_ns(reader, stream_id=None):
  function sample_times (line 780) | def sample_times(time_list: List, start_time: int, end_time: int) -> Tup...
  function sample_from_range (line 819) | def sample_from_range(
  function read_image_from_vrs (line 881) | def read_image_from_vrs(
  function read_image_snippet_from_vrs (line 945) | def read_image_snippet_from_vrs(
  function load_global_points_csv (line 1007) | def load_global_points_csv(
  function load_semidense_observations (line 1066) | def load_semidense_observations(path: str):

FILE: efm3d/utils/gravity.py
  function get_transform_to_vio_gravity_convention (line 25) | def get_transform_to_vio_gravity_convention(gravity_direction: np.array):
  function correct_adt_mesh_gravity (line 58) | def correct_adt_mesh_gravity(mesh):
  function reject_vector_a_from_b (line 69) | def reject_vector_a_from_b(a, b):
  function gravity_align_T_world_cam (line 79) | def gravity_align_T_world_cam(

FILE: efm3d/utils/image.py
  function string2color (line 34) | def string2color(string):
  function normalize (line 50) | def normalize(img, robust=0.0, eps=1e-6):
  function put_text (line 73) | def put_text(
  function rotate_image90 (line 123) | def rotate_image90(image: np.ndarray, k: int = 3):
  function smart_resize (line 134) | def smart_resize(
  function torch2cv2 (line 174) | def torch2cv2(
  function numpy2mp4 (line 243) | def numpy2mp4(imgs, output_path, fps=10):

FILE: efm3d/utils/image_sampling.py
  function compute_factor (line 21) | def compute_factor(size):
  function convert_pixel_to_coordinates (line 25) | def convert_pixel_to_coordinates(coordinates, factor):
  function normalize_keypoints (line 29) | def normalize_keypoints(kpts, height, width):
  function sample_images (line 39) | def sample_images(

FILE: efm3d/utils/marching_cubes.py
  function marching_cubes_scaled (line 24) | def marching_cubes_scaled(values, isolevel, voxel_extent, voxel_mask):

FILE: efm3d/utils/mesh_utils.py
  function point_to_closest_vertex_dist (line 25) | def point_to_closest_vertex_dist(pts, verts, tris):
  function point_to_closest_tri_dist (line 45) | def point_to_closest_tri_dist(pts, verts, tris):
  function compute_pts_to_mesh_dist (line 95) | def compute_pts_to_mesh_dist(pts, faces, verts, step):
  function eval_mesh_to_mesh (line 118) | def eval_mesh_to_mesh(

FILE: efm3d/utils/obb_csv_writer.py
  class ObbCsvReader (line 25) | class ObbCsvReader:
    method __init__ (line 26) | def __init__(self, file_name):
    method parse_row (line 37) | def parse_row(self, row):
    method __iter__ (line 108) | def __iter__(self):
    method __next__ (line 111) | def __next__(self):
    method obbs (line 132) | def obbs(self):
  class ObbCsvWriter (line 143) | class ObbCsvWriter:
    method __init__ (line 144) | def __init__(self, file_name=""):
    method write_rows (line 158) | def write_rows(self):
    method write (line 164) | def write(
    method flush (line 206) | def flush(self):
    method __del__ (line 209) | def __del__(self):

FILE: efm3d/utils/obb_io.py
  function bb2extent (line 22) | def bb2extent(bb):
  function extent2bb (line 35) | def extent2bb(extent):
  function get_all_Ts_world_object_for_time (line 80) | def get_all_Ts_world_object_for_time(
  function get_inst_id_in_camera (line 126) | def get_inst_id_in_camera(
  function get_instance_id_in_frameset (line 152) | def get_instance_id_in_frameset(
  function get_bb2s_for_instances (line 206) | def get_bb2s_for_instances(obs, time, inst_ids, cam_names, cam_scales=No...
  function next_obb_observations (line 243) | def next_obb_observations(

FILE: efm3d/utils/obb_matchers.py
  class HungarianMatcher2d3d (line 29) | class HungarianMatcher2d3d(torch.nn.Module):
    method __init__ (line 36) | def __init__(
    method forward_obbs (line 65) | def forward_obbs(
    method forward (line 102) | def forward(

FILE: efm3d/utils/obb_metrics.py
  class ObbMetrics (line 33) | class ObbMetrics(torch.nn.Module):
    method __init__ (line 39) | def __init__(
    method update (line 118) | def update(self, prediction: ObbTW, target: ObbTW, cam: Optional[Camer...
    method forward (line 151) | def forward(self, prediction: ObbTW, target: ObbTW):
    method update_3d (line 155) | def update_3d(
    method update_2d (line 184) | def update_2d(
    method update_2d_instances (line 211) | def update_2d_instances(
    method compute (line 227) | def compute(self):
    method reset (line 251) | def reset(self):

FILE: efm3d/utils/obb_trackers.py
  function nms_3d (line 32) | def nms_3d(
  function nms_2d (line 97) | def nms_2d(obbs, nms_iou2_thr: float, verbose: bool = False):
  class ObbTracker (line 128) | class ObbTracker:
    method __init__ (line 134) | def __init__(
    method reset (line 226) | def reset(self):
    method set_hz (line 234) | def set_hz(self, hz: float):
    method obbs_world (line 239) | def obbs_world(self):
    method track (line 294) | def track(
    method update_last_obs_time (line 514) | def update_last_obs_time(self, cam, T_world_rig):
    method add_new_obbs (line 534) | def add_new_obbs(self, new_obbs, new_probs_full):
    method nms_3d (line 567) | def nms_3d(self, obbs):
    method nms_2d (line 571) | def nms_2d(self, obbs):
    method set_2d_bbs (line 574) | def set_2d_bbs(self, obbs_w: ObbTW, cam: CameraTW, T_world_rig: PoseTW):

FILE: efm3d/utils/obb_utils.py
  class IouOutputs (line 44) | class IouOutputs:
  function input_validator_box3d (line 49) | def input_validator_box3d(  # noqa
  class MAPMetricResults3D (line 103) | class MAPMetricResults3D(BaseMetricResults):
  function box3d_volume (line 116) | def box3d_volume(boxes: Tensor) -> Tensor:
  function box3d_convert (line 136) | def box3d_convert(boxes: Tensor, in_fmt: str, out_fmt: str) -> Tensor:
  class MeanAveragePrecision3D (line 145) | class MeanAveragePrecision3D(MeanAveragePrecision):
    method __init__ (line 146) | def __init__(
    method update (line 208) | def update(
    method _compute_iou (line 290) | def _compute_iou(self, id: int, class_id: int, max_det: int) -> Tensor:
    method _evaluate_image (line 330) | def _evaluate_image(
    method _summarize_results (line 443) | def _summarize_results(
    method compute (line 497) | def compute(self, sem_id_to_name_mapping: Optional[Dict[int, str]] = N...
  function coplanar_mask (line 534) | def coplanar_mask(boxes: torch.Tensor, eps: float = 1e-4) -> None:
  function nonzero_area_mask (line 555) | def nonzero_area_mask(boxes: torch.Tensor, eps: float = 1e-4) -> None:
  function bb3_valid (line 571) | def bb3_valid(boxes: torch.Tensor, eps: float = 1e-4) -> None:
  function box3d_overlap_wrapper (line 579) | def box3d_overlap_wrapper(
  function remove_invalid_box3d (line 607) | def remove_invalid_box3d(obbs: ObbTW, mark_in_place: bool = False) -> to...
  function prec_recall_bb3 (line 627) | def prec_recall_bb3(
  function prec_recall_curve (line 752) | def prec_recall_curve(
  function draw_prec_recall_curve (line 810) | def draw_prec_recall_curve(

FILE: efm3d/utils/pointcloud.py
  function get_points_world (line 33) | def get_points_world(batch, batch_idx=None, dist_std0=0.04, prefer_point...
  function get_freespace_world (line 73) | def get_freespace_world(
  function collapse_pointcloud_time (line 172) | def collapse_pointcloud_time(pc_w):
  function pointcloud_to_voxel_ids (line 183) | def pointcloud_to_voxel_ids(pc_v, vW, vH, vD, voxel_extent):
  function pointcloud_to_occupancy_snippet (line 216) | def pointcloud_to_occupancy_snippet(
  function pointcloud_occupancy_samples (line 292) | def pointcloud_occupancy_samples(
  function pointcloud_to_occupancy (line 357) | def pointcloud_to_occupancy(
  function pointcloud_to_voxel_counts (line 409) | def pointcloud_to_voxel_counts(points_v, voxel_extent, vW, vH, vD):
  function get_points_counts (line 449) | def get_points_counts(
  function get_freespace_counts (line 497) | def get_freespace_counts(

FILE: efm3d/utils/ray.py
  function grid_ray (line 24) | def grid_ray(pixel_grid, camera):
  function ray_grid (line 72) | def ray_grid(cam: CameraTW):
  function transform_rays (line 87) | def transform_rays(rays_old: torch.Tensor, T_new_old):
  function ray_obb_intersection (line 99) | def ray_obb_intersection(
  function sample_depths_in_grid (line 178) | def sample_depths_in_grid(

FILE: efm3d/utils/reconstruction.py
  function build_gt_occupancy (line 36) | def build_gt_occupancy(occ, visible, p3s_w, Ts_wc, cams, T_wv, voxel_ext...
  function get_fused_gt_feat (line 62) | def get_fused_gt_feat(
  function get_feats_world (line 111) | def get_feats_world(batch, tgt_feats):
  function compute_tv_loss (line 144) | def compute_tv_loss(occ):
  function compute_occupancy_loss_subvoxel (line 153) | def compute_occupancy_loss_subvoxel(

FILE: efm3d/utils/render.py
  function get_colors (line 32) | def get_colors(num_colors: int, scale_to_255: bool = False):
  function get_colors_from_sem_map (line 80) | def get_colors_from_sem_map(
  function draw_bb2s (line 116) | def draw_bb2s(
  function draw_bb3_lines (line 194) | def draw_bb3_lines(
  function draw_bb3s (line 248) | def draw_bb3s(
  function draw_obbs_image (line 355) | def draw_obbs_image(
  function draw_obbs_snippet (line 455) | def draw_obbs_snippet(
  function discretize_values (line 521) | def discretize_values(values: torch.Tensor, precision: int):

FILE: efm3d/utils/rescale.py
  function get_crops_scale (line 24) | def get_crops_scale(
  function rescale_camera_tw (line 91) | def rescale_camera_tw(
  function rescale_calib (line 135) | def rescale_calib(
  function rescale_image (line 170) | def rescale_image(
  function rescale_image_tensor (line 199) | def rescale_image_tensor(
  function rescale_depth_img (line 245) | def rescale_depth_img(
  function rescale_obb_tw (line 279) | def rescale_obb_tw(

FILE: efm3d/utils/viz.py
  function render_points (line 57) | def render_points(pts, rgba, prog=None, ctx=None, point_size=1.0, scene=...
  function render_cubes (line 74) | def render_cubes(centers, bb3_halfdiag, prog, ctx, rgb=None):
  function render_tri_mesh (line 110) | def render_tri_mesh(pts, normals, tris, prog, ctx):
  function render_rgb_tri_mesh (line 134) | def render_rgb_tri_mesh(pts, normals, tris, rgb, prog, ctx):
  function render_scalar_field_points (line 164) | def render_scalar_field_points(
  function render_rgb_points (line 209) | def render_rgb_points(
  function render_linestrip (line 233) | def render_linestrip(pts, rgba, prog=None, ctx=None, scene=None):
  function render_line (line 251) | def render_line(p0, p1, rgba, prog=None, ctx=None, scene=None):
  function render_cosy (line 266) | def render_cosy(
  function render_frustum (line 282) | def render_frustum(
  function render_obbs_line (line 328) | def render_obbs_line(
  function get_color_from_id (line 363) | def get_color_from_id(sem_id, max_sem_id, rgba=None):
  function render_obb_line (line 369) | def render_obb_line(obb: ObbTW, prog, ctx, rgba=None, draw_cosy=False):
  class SceneView (line 390) | class SceneView:
    method __init__ (line 427) | def __init__(
    method valid (line 480) | def valid(self):
    method clear (line 483) | def clear(self, bg_color: Optional[Tuple[float, float, float]] = None):
    method set_default_view (line 511) | def set_default_view(self, T_world_camera: PoseTW, zoom_factor: float ...
    method set_follow_view (line 518) | def set_follow_view(self, T_world_camera: PoseTW, zoom_factor: float =...
    method set_birds_eye_view (line 525) | def set_birds_eye_view(self, T_world_camera: PoseTW, zoom_factor: floa...
    method set_side_view (line 534) | def set_side_view(self, T_world_camera: PoseTW, zoom_factor: float = 6...
    method set_birds_eye_view_from_bb (line 543) | def set_birds_eye_view_from_bb(
    method set_view (line 565) | def set_view(self, mv: Union[PoseTW, np.array]):
    method finish (line 583) | def finish(self):
  function draw_obb_scene_3d (line 595) | def draw_obb_scene_3d(
  function draw_snippet_scene_3d (line 876) | def draw_snippet_scene_3d(
  function normalize (line 1064) | def normalize(x):
  function model_view_look_at_rdf (line 1072) | def model_view_look_at_rdf(e, look_at, u):
  function get_mv (line 1100) | def get_mv(T_world_cam: PoseTW, zoom_factor: float = 3.0, position=[-1, ...
  function projection_matrix_rdf_top_left (line 1133) | def projection_matrix_rdf_top_left(w, h, fu, fv, u0, v0, zNear, zFar):
  function init_egl_context (line 1151) | def init_egl_context():
  function simple_shader_program (line 1163) | def simple_shader_program(ctx):
  function mesh_normal_shader_program (line 1187) | def mesh_normal_shader_program(ctx):
  function mesh_rgb_shader_program (line 1216) | def mesh_rgb_shader_program(ctx):
  function rgb_point_cloud_shader_program (line 1249) | def rgb_point_cloud_shader_program(ctx):
  function scalar_field_shader_program (line 1278) | def scalar_field_shader_program(ctx):
  function semantic_color_shader_program (line 1371) | def semantic_color_shader_program(ctx):

FILE: efm3d/utils/voxel.py
  function tensor_wrap_voxel_extent (line 18) | def tensor_wrap_voxel_extent(voxel_extent, B=None, device="cpu"):
  function create_voxel_grid (line 32) | def create_voxel_grid(vW, vH, vD, voxel_extent, device="cpu"):
  function erode_voxel_mask (line 57) | def erode_voxel_mask(mask):

FILE: efm3d/utils/voxel_sampling.py
  function pc_to_vox (line 19) | def pc_to_vox(pc_v, vW, vH, vD, voxel_extent):
  function compute_factor (line 57) | def compute_factor(size):
  function convert_coordinates_to_voxel (line 61) | def convert_coordinates_to_voxel(coordinates, factor):
  function convert_voxel_to_coordinates (line 65) | def convert_voxel_to_coordinates(coordinates, factor):
  function normalize_keypoints (line 69) | def normalize_keypoints(kpts, depth, height, width):
  function denormalize_keypoints (line 81) | def denormalize_keypoints(kpts, depth, height, width):
  function in_grid (line 99) | def in_grid(pt_vox, depth, height, width):
  function sample_voxels (line 109) | def sample_voxels(feat3d, pts_v, differentiable=False, interp_mode="bili...
  function diff_grid_sample (line 147) | def diff_grid_sample(feature_3d, pts_norm, align_corners=False):

FILE: train.py
  function get_lr (line 60) | def get_lr(it, warmup_its, max_its, max_lr, min_lr):
  function get_dataloader (line 80) | def get_dataloader(