SYMBOL INDEX (426 symbols across 40 files)

FILE: 0a_preprocess_training_data.py
  function load_neutral_beta_conversion (line 64) | def load_neutral_beta_conversion(gender: str) -> Tuple[np.ndarray, np.nd...
  function convert_gender_neutral_beta (line 70) | def convert_gender_neutral_beta(
  function determine_floor_height_and_contacts (line 85) | def determine_floor_height_and_contacts(
  function detect_joint_contact (line 315) | def detect_joint_contact(
  function compute_root_align_mats (line 336) | def compute_root_align_mats(root_orient):
  function compute_joint_align_mats (line 356) | def compute_joint_align_mats(joint_seq):
  function compute_align_from_body_right (line 375) | def compute_align_from_body_right(body_right):
  function estimate_velocity (line 398) | def estimate_velocity(data_seq, h):
  function estimate_angular_velocity (line 413) | def estimate_angular_velocity(rot_seq, h):
  function load_seq_smpl_params (line 438) | def load_seq_smpl_params(input_path: str, num_betas: int = 16):
  function run_batch_smpl (line 475) | def run_batch_smpl(
  function process_seq (line 512) | def process_seq(
  function process_seq_data (line 543) | def process_seq_data(
  class Config (line 729) | class Config:
  function check_skip (line 740) | def check_skip(path_name: str) -> bool:
  function main (line 751) | def main(cfg: Config):

FILE: 0b_preprocess_training_data.py
  function main (line 21) | def main(

FILE: 1_train_motion_prior.py
  class EgoAlloTrainConfig (line 23) | class EgoAlloTrainConfig:
  function get_experiment_dir (line 53) | def get_experiment_dir(experiment_name: str, version: int = 0) -> Path:
  function run_training (line 68) | def run_training(

FILE: 2_run_hamer_on_vrs.py
  function main (line 26) | def main(traj_root: Path, overwrite: bool = False) -> None:
  function run_hamer_and_save (line 45) | def run_hamer_and_save(
  function put_text (line 203) | def put_text(

FILE: 3_aria_inference.py
  class Args (line 30) | class Args:
  function main (line 66) | def main(args: Args) -> None:

FILE: 4_visualize_outputs.py
  function main (line 32) | def main(
  function load_and_visualize (line 100) | def load_and_visualize(

FILE: 5_eval_body_metrics.py
  function main (line 47) | def main(

FILE: src/egoallo/fncsmpl.py
  class SmplhModel (line 37) | class SmplhModel(TensorDataclass):
    method load (line 58) | def load(model_path: Path) -> SmplhModel:
    method get_num_joints (line 90) | def get_num_joints(self) -> int:
    method with_shape (line 94) | def with_shape(self, betas: Float[Tensor, "*#batch n_betas"]) -> Smplh...
  class SmplhShaped (line 119) | class SmplhShaped(TensorDataclass):
    method with_pose_decomposed (line 135) | def with_pose_decomposed(
    method with_pose (line 158) | def with_pose(
  class SmplhShapedAndPosed (line 183) | class SmplhShapedAndPosed(TensorDataclass):
    method with_new_T_world_root (line 196) | def with_new_T_world_root(
    method lbs (line 210) | def lbs(self) -> SmplMesh:
  class SmplMesh (line 265) | class SmplMesh(TensorDataclass):
  function forward_kinematics (line 278) | def forward_kinematics(
  function broadcasting_cat (line 326) | def broadcasting_cat(tensors: list[Tensor], dim: int) -> Tensor:
  function _normalize_dtype (line 346) | def _normalize_dtype(v: np.ndarray) -> np.ndarray:

FILE: src/egoallo/fncsmpl_extensions.py
  function get_T_world_cpf (line 14) | def get_T_world_cpf(mesh: fncsmpl.SmplMesh) -> Float[Tensor, "*#batch 7"]:
  function get_T_head_cpf (line 29) | def get_T_head_cpf(shaped: fncsmpl.SmplhShaped) -> Float[Tensor, "*#batc...
  function get_T_world_root_from_cpf_pose (line 53) | def get_T_world_root_from_cpf_pose(

FILE: src/egoallo/fncsmpl_jax.py
  class SmplhModel (line 22) | class SmplhModel:
    method load (line 43) | def load(npz_path: Path) -> SmplhModel:
    method with_shape (line 58) | def with_shape(
  class SmplhShaped (line 86) | class SmplhShaped:
    method with_pose_decomposed (line 100) | def with_pose_decomposed(
    method with_pose (line 120) | def with_pose(
    method get_T_head_cpf (line 170) | def get_T_head_cpf(self) -> Float[Array, "7"]:
  class SmplhShapedAndPosed (line 187) | class SmplhShapedAndPosed:
    method with_new_T_world_root (line 200) | def with_new_T_world_root(
    method lbs (line 214) | def lbs(self) -> SmplhMesh:
  class SmplhMesh (line 262) | class SmplhMesh:
  function broadcasting_cat (line 272) | def broadcasting_cat(arrays: Sequence[jax.Array | onp.ndarray], axis: in...
  function _normalize_dtype (line 291) | def _normalize_dtype(v: onp.ndarray) -> onp.ndarray:

FILE: src/egoallo/guidance_optimizer_jax.py
  function do_guidance_optimization (line 34) | def do_guidance_optimization(
  class _SmplhBodyPosesVar (line 90) | class _SmplhBodyPosesVar(
  class _SmplhSingleHandPosesVar (line 103) | class _SmplhSingleHandPosesVar(
  function _optimize_vmapped (line 117) | def _optimize_vmapped(
  class JaxGuidanceParams (line 163) | class JaxGuidanceParams:
    method defaults (line 196) | def defaults(
  function _optimize (line 303) | def _optimize(
  function _get_mano_from_openpose_indices (line 887) | def _get_mano_from_openpose_indices(include_tips: bool) -> Int[onp.ndarr...

FILE: src/egoallo/hand_detection_structs.py
  class SingleHandHamerOutputWrtCamera (line 24) | class SingleHandHamerOutputWrtCamera(TypedDict):
  class SavedHamerOutputs (line 34) | class SavedHamerOutputs(TypedDict):
  class AriaHandWristPoseWrtWorld (line 52) | class AriaHandWristPoseWrtWorld(TensorDataclass):
  class CorrespondedAriaHandWristPoseDetections (line 63) | class CorrespondedAriaHandWristPoseDetections(TensorDataclass):
    method load (line 68) | def load(
  class SingleHandHamerOutputWrtCameraConcatenated (line 175) | class SingleHandHamerOutputWrtCameraConcatenated(TensorDataclass):
  class CorrespondedHamerDetections (line 183) | class CorrespondedHamerDetections(TensorDataclass):
    method get_length (line 195) | def get_length(self) -> int:
    method slice (line 199) | def slice(self, start_index: int, end_index: int) -> CorrespondedHamer...
    method load (line 233) | def load(

FILE: src/egoallo/inference_utils.py
  function load_denoiser (line 22) | def load_denoiser(checkpoint_dir: Path) -> EgoDenoiser:
  class InferenceTrajectoryPaths (line 41) | class InferenceTrajectoryPaths:
    method find (line 65) | def find(traj_root: Path) -> InferenceTrajectoryPaths:
  class InferenceInputTransforms (line 108) | class InferenceInputTransforms(TensorDataclass):
    method load (line 116) | def load(

FILE: src/egoallo/metrics_helpers.py
  function compute_foot_skate (line 12) | def compute_foot_skate(
  function compute_foot_contact (line 59) | def compute_foot_contact(
  function compute_head_ori (line 84) | def compute_head_ori(
  function compute_head_trans (line 101) | def compute_head_trans(
  function compute_mpjpe (line 115) | def compute_mpjpe(
  function procrustes_align (line 160) | def procrustes_align(
  function procrustes_align (line 169) | def procrustes_align(
  function procrustes_align (line 177) | def procrustes_align(

FILE: src/egoallo/network.py
  function project_rotmats_via_svd (line 20) | def project_rotmats_via_svd(
  class EgoDenoiseTraj (line 28) | class EgoDenoiseTraj(TensorDataclass):
    method get_packed_dim (line 46) | def get_packed_dim(include_hands: bool) -> int:
    method apply_to_body (line 52) | def apply_to_body(self, body_model: SmplhModel) -> SmplhShapedAndPosed:
    method pack (line 65) | def pack(self) -> Float[Tensor, "*#batch timesteps d_state"]:
    method unpack (line 79) | def unpack(
  class EgoDenoiserConfig (line 122) | class EgoDenoiserConfig:
    method d_cond (line 162) | def d_cond(self) -> int:
    method make_cond (line 192) | def make_cond(
  class EgoDenoiser (line 309) | class EgoDenoiser(nn.Module):
    method __init__ (line 316) | def __init__(self, config: EgoDenoiserConfig):
    method get_d_state (line 416) | def get_d_state(self) -> int:
    method forward (line 419) | def forward(
  function make_positional_encoding (line 559) | def make_positional_encoding(
  function fourier_encode (line 574) | def fourier_encode(
  class TransformerBlockConfig (line 591) | class TransformerBlockConfig:
  class TransformerBlock (line 604) | class TransformerBlock(nn.Module):
    method __init__ (line 607) | def __init__(self, config: TransformerBlockConfig) -> None:
    method forward (line 651) | def forward(
    method _sattn (line 692) | def _sattn(self, x: Tensor, attn_mask: Tensor | None) -> Tensor:
    method _xattn (line 717) | def _xattn(self, x: Tensor, attn_mask: Tensor | None, cond: Tensor) ->...
  function zero_module (line 753) | def zero_module(module):

FILE: src/egoallo/preprocessing/body_model/body_model.py
  class BodyModel (line 25) | class BodyModel(nn.Module):
    method __init__ (line 30) | def __init__(
    method _fill_default_vars (line 126) | def _fill_default_vars(self, model_args) -> Tuple[Dict, Dict]:
    method _get_batch_size (line 140) | def _get_batch_size(self, **model_args) -> int:
    method _get_default_model_var (line 151) | def _get_default_model_var(self, name: str, batch_size: int):
    method get_full_pose_mats (line 158) | def get_full_pose_mats(self, model_args, add_mean: bool = True):
    method get_hand_pose_mat (line 183) | def get_hand_pose_mat(
    method forward_joints (line 216) | def forward_joints(self, **kwargs):
    method get_extra_joints (line 242) | def get_extra_joints(self, betas, pose_mats, rel_transforms):
    method inverse_joints (line 261) | def inverse_joints(self, joints: torch.Tensor, **kwargs):
    method joints_to_beta (line 270) | def joints_to_beta(self, joint_unposed: torch.Tensor) -> torch.Tensor:
    method forward (line 290) | def forward(self, **kwargs):

FILE: src/egoallo/preprocessing/body_model/skeleton.py
  function smpl_kinematic_tree (line 18) | def smpl_kinematic_tree():
  function joint_angles_rel_to_glob (line 39) | def joint_angles_rel_to_glob(rel_mats):
  function joint_angles_glob_to_rel (line 64) | def joint_angles_glob_to_rel(glob_mats):

FILE: src/egoallo/preprocessing/body_model/specs.py
  function smpl_to_openpose (line 219) | def smpl_to_openpose(

FILE: src/egoallo/preprocessing/body_model/utils.py
  function run_smpl (line 37) | def run_smpl(
  function reflect_pose_aa (line 68) | def reflect_pose_aa(root_orient: Tensor, pose_body: Tensor):
  function reflect_root_trajectory (line 81) | def reflect_root_trajectory(
  function forward_kinematics (line 109) | def forward_kinematics(
  function get_pose_offsets (line 145) | def get_pose_offsets(
  function select_vert_params (line 155) | def select_vert_params(
  function get_verts_with_transforms (line 168) | def get_verts_with_transforms(
  function inverse_kinematics (line 185) | def inverse_kinematics(rot_mats: Tensor, joints: Tensor, parents: Tensor...
  function smpl_local_to_global (line 216) | def smpl_local_to_global(
  function select_smpl_joints (line 228) | def select_smpl_joints(joints_full):
  function get_openpose_from_smpl (line 236) | def get_openpose_from_smpl(joints_smpl, model_type="smplh"):
  function convert_local_pose_to_aa (line 259) | def convert_local_pose_to_aa(pose_body: Tensor, rot_rep: str):
  function convert_global_pose_to_aa (line 276) | def convert_global_pose_to_aa(pose_glob: Tensor, rot_rep: str):
  function load_beta_conversion (line 291) | def load_beta_conversion(path: str) -> Tuple[Tensor, Tensor]:
  function convert_model_betas (line 298) | def convert_model_betas(beta: Tensor, A: Tensor, b: Tensor) -> Tensor:

FILE: src/egoallo/preprocessing/geometry/camera.py
  function project_from_world (line 10) | def project_from_world(X_w, R_cw, t_cw, intrins):
  function proj_2d (line 20) | def proj_2d(xyz, intrins, eps=1e-4):
  function proj_h (line 34) | def proj_h(xyzw):
  function iproj_depth (line 42) | def iproj_depth(uv, z, intrins):
  function iproj (line 55) | def iproj(uv, disp, intrins):
  function normalize_coords (line 68) | def normalize_coords(uv, intrins):
  function iproj_to_world (line 74) | def iproj_to_world(uv, disp, intrins, extrins, ret_3d=True):
  function reproject (line 92) | def reproject(pose_params, intrins, disps, uv, ii, jj):
  function proj_2d_jac (line 108) | def proj_2d_jac(X, intrins):
  function actp_jac (line 124) | def actp_jac(X1):
  function iproj_jac (line 136) | def iproj_jac(X):
  function make_homogeneous (line 145) | def make_homogeneous(x):
  function make_transform (line 153) | def make_transform(R, t):
  function focal2fov (line 168) | def focal2fov(focal, R):
  function fov2focal (line 176) | def fov2focal(fov, R):
  function lookat_matrix (line 184) | def lookat_matrix(source_pos, target_pos, up):
  function normalize (line 201) | def normalize(x):
  function view_matrix (line 205) | def view_matrix(z, up, pos):
  function average_pose (line 222) | def average_pose(poses):
  function make_translation (line 233) | def make_translation(t):
  function make_rotation (line 237) | def make_rotation(rx=0, ry=0, rz=0, order="xyz"):
  function rotx (line 258) | def rotx(theta):
  function roty (line 269) | def roty(theta):
  function rotz (line 280) | def rotz(theta):
  function identity (line 291) | def identity(shape: Tuple, d=4, **kwargs):

FILE: src/egoallo/preprocessing/geometry/helpers.py
  function make_transform (line 7) | def make_transform(R, t):
  function transform_points (line 22) | def transform_points(T, x):
  function batch_apply_Rt (line 32) | def batch_apply_Rt(R, t, x):
  function transform_global_to_rel (line 41) | def transform_global_to_rel(T_glob):
  function transform_rel_to_global (line 53) | def transform_rel_to_global(T_rel):
  function RT_global_to_rel (line 68) | def RT_global_to_rel(R_glob, t_glob):
  function RT_rel_to_global (line 79) | def RT_rel_to_global(R_rel, t_rel):
  function joints_local_to_global (line 90) | def joints_local_to_global(
  function joints_global_to_local (line 112) | def joints_global_to_local(root_orient_mat, trans, joints_glob, joints_v...
  function align_pcl (line 134) | def align_pcl(Y, X, weight=None, fixed_scale=False):
  function get_translation_scale (line 187) | def get_translation_scale(fps=30):
  function estimate_velocity (line 195) | def estimate_velocity(data_seq, h=1 / 30):
  function estimate_angular_velocity (line 207) | def estimate_angular_velocity(rot_seq, h=1 / 30):

FILE: src/egoallo/preprocessing/geometry/plane.py
  function transform_align_body_right (line 10) | def transform_align_body_right(root_orient_mat, trans, **kwargs):
  function rotation_align_body_right (line 22) | def rotation_align_body_right(
  function compute_world2aligned (line 47) | def compute_world2aligned(T_w0, **kwargs):
  function rotation_align_vecs (line 60) | def rotation_align_vecs(src, target):
  function compute_point_height (line 74) | def compute_point_height(point, floor_plane):
  function compute_world2floor (line 87) | def compute_world2floor(
  function compute_plane_transform (line 113) | def compute_plane_transform(
  function fit_plane (line 137) | def fit_plane(
  function parse_floor_plane (line 165) | def parse_floor_plane(floor_plane: Tensor, force_sign: int = -1) -> Tensor:
  function force_plane_direction (line 187) | def force_plane_direction(
  function compute_plane_intersection (line 205) | def compute_plane_intersection(point, direction, plane, eps=1e-5):
  function project_vector (line 223) | def project_vector(x, d):
  function bdot (line 232) | def bdot(A1, A2, keepdim=True, **kwargs):

FILE: src/egoallo/preprocessing/geometry/rotation.py
  function get_rot_rep_shape (line 6) | def get_rot_rep_shape(rot_rep:str) -> Tuple:
  function convert_rotation (line 17) | def convert_rotation(rot, src_rep, tgt_rep):
  function rodrigues_vec_to_matrix (line 57) | def rodrigues_vec_to_matrix(rot_vecs, dtype=torch.float32):
  function matrix_to_axis_angle (line 83) | def matrix_to_axis_angle(matrix):
  function axis_angle_to_matrix (line 93) | def axis_angle_to_matrix(rot_vec):
  function axis_angle_to_cont_6d (line 98) | def axis_angle_to_cont_6d(rot_vec):
  function matrix_to_cont_6d (line 107) | def matrix_to_cont_6d(matrix):
  function cont_6d_to_matrix (line 115) | def cont_6d_to_matrix(cont_6d):
  function cont_6d_to_axis_angle (line 130) | def cont_6d_to_axis_angle(cont_6d):
  function quaternion_to_axis_angle (line 135) | def quaternion_to_axis_angle(quaternion, eps=1e-5):
  function quaternion_to_matrix (line 170) | def quaternion_to_matrix(quaternion):
  function axis_angle_to_quaternion (line 218) | def axis_angle_to_quaternion(axis_angle, eps=1e-5):
  function matrix_to_quaternion (line 240) | def matrix_to_quaternion(matrix, eps=1e-6):
  function quaternion_mul (line 325) | def quaternion_mul(q0, q1):
  function quaternion_inverse (line 338) | def quaternion_inverse(q, eps=1e-5):
  function quaternion_slerp (line 348) | def quaternion_slerp(t, q0, q1, eps=1e-5):

FILE: src/egoallo/preprocessing/geometry/transforms/_base.py
  class MatrixLieGroup (line 13) | class MatrixLieGroup(abc.ABC):
    method __init__ (line 31) | def __init__(self, parameters: torch.Tensor):
    method __mul__ (line 45) | def __mul__(self: GroupType, other: GroupType) -> GroupType:
    method __mul__ (line 49) | def __mul__(self, other: hints.Array) -> torch.Tensor:
    method __mul__ (line 52) | def __mul__(
    method Identity (line 72) | def Identity(
    method from_matrix (line 83) | def from_matrix(cls: Type[GroupType], matrix: hints.Array) -> GroupType:
    method matrix (line 96) | def matrix(self) -> torch.Tensor:
    method parameters (line 100) | def parameters(self) -> torch.Tensor:
    method data (line 104) | def data(self) -> torch.Tensor:
    method __getitem__ (line 107) | def __getitem__(self, index):
    method shape (line 111) | def shape(self):
    method act (line 117) | def act(self, target: hints.Array) -> torch.Tensor:
    method mul (line 128) | def mul(self: GroupType, other: GroupType) -> GroupType:
    method exp (line 137) | def exp(cls: Type[GroupType], tangent: hints.Array) -> GroupType:
    method log (line 148) | def log(self) -> torch.Tensor:
    method adjoint (line 156) | def adjoint(self, **kwargs) -> torch.Tensor:
    method inv (line 172) | def inv(self: GroupType) -> GroupType:
    method normalize (line 180) | def normalize(self: GroupType) -> GroupType:
  class SOBase (line 188) | class SOBase(MatrixLieGroup):
  class SEBase (line 195) | class SEBase(Generic[ContainedSOType], MatrixLieGroup):
    method from_rotation_and_translation (line 206) | def from_rotation_and_translation(
    method from_rotation (line 223) | def from_rotation(cls: Type[SEGroupType], rotation: ContainedSOType) -...
    method from_translation (line 234) | def from_translation(
    method rotation (line 240) | def rotation(self) -> ContainedSOType:
    method translation (line 244) | def translation(self) -> torch.Tensor:
    method act (line 251) | def act(self, target: hints.Array) -> torch.Tensor:
    method mul (line 267) | def mul(self: SEGroupType, other: SEGroupType) -> SEGroupType:
    method inv (line 275) | def inv(self: SEGroupType) -> SEGroupType:
    method normalize (line 284) | def normalize(self: SEGroupType) -> SEGroupType:

FILE: src/egoallo/preprocessing/geometry/transforms/_se2.py
  class SE2 (line 20) | class SE2(_base.SEBase[SO2]):
    method __repr__ (line 35) | def __repr__(self) -> str:
    method from_xy_theta (line 41) | def from_xy_theta(x: hints.Scalar, y: hints.Scalar, theta: hints.Scala...
    method from_rotation_and_translation (line 55) | def from_rotation_and_translation(
    method from_translation (line 66) | def from_translation(cls, translation: torch.Tensor) -> "SE2":
    method rotation (line 77) | def rotation(self) -> SO2:
    method translation (line 81) | def translation(self) -> torch.Tensor:
    method Identity (line 88) | def Identity(shape: Optional[Tuple] = (), **kwargs) -> "SE2":
    method from_matrix (line 98) | def from_matrix(matrix: hints.Array) -> "SE2":
    method parameters (line 109) | def parameters(self) -> torch.Tensor:
    method matrix (line 113) | def matrix(self) -> torch.Tensor:
    method exp (line 125) | def exp(tangent: hints.Array) -> "SE2":
    method log (line 171) | def log(self) -> torch.Tensor:
    method adjoint (line 217) | def adjoint(self, **kwargs) -> torch.Tensor:

FILE: src/egoallo/preprocessing/geometry/transforms/_se3.py
  function _skew (line 14) | def _skew(omega: torch.Tensor) -> torch.Tensor:
  class SE3 (line 36) | class SE3(_base.SEBase[SO3]):
    method __repr__ (line 51) | def __repr__(self) -> str:
    method from_rotation_and_translation (line 60) | def from_rotation_and_translation(
    method from_translation (line 69) | def from_translation(cls, translation: torch.Tensor) -> "SE3":
    method rotation (line 80) | def rotation(self) -> SO3:
    method translation (line 84) | def translation(self) -> torch.Tensor:
    method Identity (line 91) | def Identity(shape: Optional[Tuple] = (), **kwargs) -> "SE3":
    method from_matrix (line 101) | def from_matrix(matrix: torch.Tensor) -> "SE3":
    method matrix (line 112) | def matrix(self) -> torch.Tensor:
    method parameters (line 124) | def parameters(self) -> torch.Tensor:
    method exp (line 131) | def exp(tangent: torch.Tensor) -> "SE3":
    method log (line 177) | def log(self) -> torch.Tensor:
    method adjoint (line 213) | def adjoint(self) -> torch.Tensor:

FILE: src/egoallo/preprocessing/geometry/transforms/_so2.py
  class SO2 (line 20) | class SO2(_base.SOBase):
    method __repr__ (line 34) | def __repr__(self) -> str:
    method from_radians (line 39) | def from_radians(theta: hints.Scalar) -> SO2:
    method as_radians (line 46) | def as_radians(self) -> torch.Tensor:
    method Identity (line 55) | def Identity(shape: Optional[Tuple] = (), **kwargs) -> SO2:
    method from_matrix (line 65) | def from_matrix(matrix: torch.Tensor) -> SO2:
    method matrix (line 72) | def matrix(self) -> torch.Tensor:
    method parameters (line 81) | def parameters(self) -> torch.Tensor:
    method act (line 87) | def act(self, target: torch.Tensor) -> torch.Tensor:
    method mul (line 92) | def mul(self, other: SO2) -> SO2:
    method exp (line 101) | def exp(tangent: torch.Tensor) -> SO2:
    method log (line 107) | def log(self) -> torch.Tensor:
    method adjoint (line 113) | def adjoint(self, **kwargs) -> torch.Tensor:
    method inv (line 117) | def inv(self) -> SO2:
    method normalize (line 122) | def normalize(self) -> SO2:

FILE: src/egoallo/preprocessing/geometry/transforms/_so3.py
  class SO3 (line 21) | class SO3(_base.SOBase):
    method __repr__ (line 36) | def __repr__(self) -> str:
    method from_x_radians (line 41) | def from_x_radians(theta: torch.Tensor) -> SO3:
    method from_y_radians (line 51) | def from_y_radians(theta: torch.Tensor) -> SO3:
    method from_z_radians (line 61) | def from_z_radians(theta: torch.Tensor) -> SO3:
    method from_rpy_radians (line 71) | def from_rpy_radians(
    method from_quaternion_xyzw (line 89) | def from_quaternion_xyzw(xyzw: torch.Tensor) -> SO3:
    method as_quaternion_xyzw (line 100) | def as_quaternion_xyzw(self) -> torch.Tensor:
    method as_rpy_radians (line 104) | def as_rpy_radians(self) -> hints.RollPitchYaw:
    method compute_roll_radians (line 116) | def compute_roll_radians(self) -> torch.Tensor:
    method compute_pitch_radians (line 125) | def compute_pitch_radians(self) -> torch.Tensor:
    method compute_yaw_radians (line 134) | def compute_yaw_radians(self) -> torch.Tensor:
    method Identity (line 147) | def Identity(shape: Optional[Tuple] = (), **kwargs) -> SO3:
    method from_matrix (line 157) | def from_matrix(matrix: torch.Tensor) -> SO3:
    method matrix (line 243) | def matrix(self) -> torch.Tensor:
    method parameters (line 263) | def parameters(self) -> torch.Tensor:
    method act (line 269) | def act(self, target: torch.Tensor) -> torch.Tensor:
    method mul (line 277) | def mul(self, other: SO3) -> SO3:
    method exp (line 294) | def exp(tangent: torch.Tensor) -> SO3:
    method log (line 340) | def log(self) -> torch.Tensor:
    method adjoint (line 377) | def adjoint(self) -> torch.Tensor:
    method inv (line 381) | def inv(self) -> SO3:
    method normalize (line 387) | def normalize(self) -> SO3:

FILE: src/egoallo/preprocessing/geometry/transforms/hints/__init__.py
  class RollPitchYaw (line 14) | class RollPitchYaw(NamedTuple):

FILE: src/egoallo/preprocessing/geometry/transforms/utils/_utils.py
  function get_epsilon (line 12) | def get_epsilon(dtype: torch.dtype) -> float:
  function register_lie_group (line 27) | def register_lie_group(

FILE: src/egoallo/preprocessing/util/tensor.py
  function batch_sum (line 10) | def batch_sum(x, nldims=1):
  function batch_mean (line 21) | def batch_mean(x, nldims=1):
  function pad_dim (line 32) | def pad_dim(x, max_len, dim=0, start=0, **kwargs):
  function pad_back (line 55) | def pad_back(x, max_len, dim=0, **kwargs):
  function pad_front (line 59) | def pad_front(x, max_len, dim=0, **kwargs):
  function read_image (line 64) | def read_image(path, scale=1):
  function move_to (line 76) | def move_to(obj: T, device) -> T:
  function detach_all (line 86) | def detach_all(obj: T) -> T:
  function to_torch (line 96) | def to_torch(obj):
  function to_np (line 106) | def to_np(obj):
  function load_npz_as_dict (line 116) | def load_npz_as_dict(path, **kwargs):
  function get_device (line 121) | def get_device(i=0):
  function invert_nested_dict (line 126) | def invert_nested_dict(d):
  function batchify_dicts (line 137) | def batchify_dicts(dict_list: List[Dict]) -> Dict:
  function batchify_recursive (line 148) | def batchify_recursive(dict_list: List[Dict], levels: int = -1):
  function unbatch_dict (line 173) | def unbatch_dict(batched_dict, batch_size):
  function get_batch_element (line 185) | def get_batch_element(batch, idx, batch_size):
  function narrow_dict (line 201) | def narrow_dict(input_dict, tdim, start, length):
  function narrow_list (line 213) | def narrow_list(input_list, tdim, start, length):
  function narrow_obj (line 217) | def narrow_obj(v, tdim, start, length):
  function scatter_intervals (line 229) | def scatter_intervals(tensor, start, end, T: int = -1):
  function get_scatter_mask (line 261) | def get_scatter_mask(start, end, T):
  function select_intervals (line 274) | def select_intervals(series, start, end, pad_len: int = -1):
  function get_select_mask (line 291) | def get_select_mask(start, end):
  function time_segment_idcs (line 302) | def time_segment_idcs(start, end, min_len: int = -1, clip: bool = True):

FILE: src/egoallo/sampling.py
  function quadratic_ts (line 21) | def quadratic_ts() -> np.ndarray:
  class CosineNoiseScheduleConstants (line 30) | class CosineNoiseScheduleConstants(TensorDataclass):
    method compute (line 38) | def compute(timesteps: int, s: float = 0.008) -> CosineNoiseScheduleCo...
  function run_sampling_with_stitching (line 59) | def run_sampling_with_stitching(

FILE: src/egoallo/tensor_dataclass.py
  class TensorDataclass (line 8) | class TensorDataclass:
    method __init_subclass__ (line 13) | def __init_subclass__(cls) -> None:
    method to (line 16) | def to(self, device: torch.device | str) -> Self:
    method as_nested_dict (line 27) | def as_nested_dict(self, numpy: bool) -> dict[str, Any]:
    method map (line 47) | def map(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Self:

FILE: src/egoallo/training_loss.py
  class TrainingLossConfig (line 19) | class TrainingLossConfig:
  class TrainingLossComputer (line 35) | class TrainingLossComputer:
    method __init__ (line 39) | def __init__(self, config: TrainingLossConfig, device: torch.device) -...
    method compute_denoising_loss (line 59) | def compute_denoising_loss(

FILE: src/egoallo/training_utils.py
  function flattened_hparam_dict_from_dataclass (line 25) | def flattened_hparam_dict_from_dataclass(
  function pdb_safety_net (line 54) | def pdb_safety_net():
  class SizedIterable (line 76) | class SizedIterable[ContainedType](Iterable[ContainedType], Sized, Proto...
  class LoopMetrics (line 85) | class LoopMetrics:
  function range_with_metrics (line 92) | def range_with_metrics(stop: int, /) -> SizedIterable[LoopMetrics]: ...
  function range_with_metrics (line 96) | def range_with_metrics(start: int, stop: int, /) -> SizedIterable[LoopMe...
  function range_with_metrics (line 100) | def range_with_metrics(
  function range_with_metrics (line 105) | def range_with_metrics(*args: int) -> SizedIterable[LoopMetrics]:
  class _RangeWithMetrics (line 112) | class _RangeWithMetrics:
    method __iter__ (line 115) | def __iter__(self):
    method __len__ (line 120) | def __len__(self) -> int:
  function loop_metric_generator (line 124) | def loop_metric_generator(counter_init: int = 0) -> Generator[LoopMetric...
  function get_git_commit_hash (line 161) | def get_git_commit_hash(cwd: Path | None = None) -> str:
  function get_git_diff (line 172) | def get_git_diff(cwd: Path | None = None) -> str:

FILE: src/egoallo/transforms/_base.py
  class MatrixLieGroup (line 23) | class MatrixLieGroup(abc.ABC):
    method __init__ (line 41) | def __init__(
    method __matmul__ (line 56) | def __matmul__(self: GroupType, other: GroupType) -> GroupType: ...
    method __matmul__ (line 59) | def __matmul__(self, other: Tensor) -> Tensor: ...
    method __matmul__ (line 61) | def __matmul__(
    method identity (line 81) | def identity(
    method from_matrix (line 92) | def from_matrix(cls: Type[GroupType], matrix: Tensor) -> GroupType:
    method as_matrix (line 105) | def as_matrix(self) -> Tensor:
    method parameters (line 109) | def parameters(self) -> Tensor:
    method apply (line 115) | def apply(self, target: Tensor) -> Tensor:
    method multiply (line 126) | def multiply(self: Self, other: Self) -> Self:
    method exp (line 135) | def exp(cls: Type[GroupType], tangent: Tensor) -> GroupType:
    method log (line 146) | def log(self) -> Tensor:
    method adjoint (line 154) | def adjoint(self) -> Tensor:
    method inverse (line 171) | def inverse(self: GroupType) -> GroupType:
    method normalize (line 179) | def normalize(self: GroupType) -> GroupType:
    method get_batch_axes (line 199) | def get_batch_axes(self) -> Tuple[int, ...]:
  class SOBase (line 206) | class SOBase(MatrixLieGroup):
  class SEBase (line 213) | class SEBase(Generic[ContainedSOType], MatrixLieGroup):
    method from_rotation_and_translation (line 224) | def from_rotation_and_translation(
    method from_rotation (line 241) | def from_rotation(cls: Type[SEGroupType], rotation: ContainedSOType) -...
    method rotation (line 251) | def rotation(self) -> ContainedSOType:
    method translation (line 255) | def translation(self) -> Tensor:
    method apply (line 262) | def apply(self, target: Tensor) -> Tensor:
    method multiply (line 267) | def multiply(self: SEGroupType, other: SEGroupType) -> SEGroupType:  #...
    method inverse (line 275) | def inverse(self: SEGroupType) -> SEGroupType:
    method normalize (line 284) | def normalize(self: SEGroupType) -> SEGroupType:

FILE: src/egoallo/transforms/_se3.py
  function _skew (line 15) | def _skew(omega: Tensor) -> Tensor:
  class SE3 (line 37) | class SE3(_base.SEBase[SO3]):
    method __repr__ (line 50) | def __repr__(self) -> str:
    method from_rotation_and_translation (line 59) | def from_rotation_and_translation(
    method rotation (line 68) | def rotation(self) -> SO3:
    method translation (line 72) | def translation(self) -> Tensor:
    method identity (line 79) | def identity(cls, device: Union[torch.device, str], dtype: torch.dtype...
    method from_matrix (line 88) | def from_matrix(cls, matrix: Tensor) -> SE3:
    method as_matrix (line 99) | def as_matrix(self) -> Tensor:
    method parameters (line 111) | def parameters(self) -> Tensor:
    method exp (line 118) | def exp(cls, tangent: Tensor) -> SE3:
    method log (line 167) | def log(self) -> Tensor:
    method adjoint (line 212) | def adjoint(self) -> Tensor:

FILE: src/egoallo/transforms/_so3.py
  class SO3 (line 21) | class SO3(_base.SOBase):
    method __repr__ (line 34) | def __repr__(self) -> str:
    method from_x_radians (line 39) | def from_x_radians(theta: Tensor) -> SO3:
    method from_y_radians (line 52) | def from_y_radians(theta: Tensor) -> SO3:
    method from_z_radians (line 65) | def from_z_radians(theta: Tensor) -> SO3:
    method from_rpy_radians (line 78) | def from_rpy_radians(
    method from_quaternion_xyzw (line 101) | def from_quaternion_xyzw(xyzw: Tensor) -> SO3:
    method as_quaternion_xyzw (line 116) | def as_quaternion_xyzw(self) -> Tensor:
    method identity (line 124) | def identity(cls, device: Union[torch.device, str], dtype: torch.dtype...
    method from_matrix (line 129) | def from_matrix(cls, matrix: Tensor) -> SO3:
    method as_matrix (line 214) | def as_matrix(self) -> Tensor:
    method parameters (line 234) | def parameters(self) -> Tensor:
    method apply (line 240) | def apply(self, target: Tensor) -> Tensor:
    method multiply (line 249) | def multiply(self, other: SO3) -> SO3:  # type: ignore
    method exp (line 266) | def exp(cls, tangent: Tensor) -> SO3:
    method log (line 308) | def log(self) -> Tensor:
    method adjoint (line 341) | def adjoint(self) -> Tensor:
    method inverse (line 345) | def inverse(self) -> SO3:
    method normalize (line 351) | def normalize(self) -> SO3:

FILE: src/egoallo/transforms/utils/_utils.py
  function get_epsilon (line 12) | def get_epsilon(dtype: torch.dtype) -> float:
  function register_lie_group (line 27) | def register_lie_group(

FILE: src/egoallo/vis_helpers.py
  class SplatArgs (line 23) | class SplatArgs(TypedDict):
  function load_splat_file (line 34) | def load_splat_file(splat_path: Path, center: bool = False) -> SplatArgs:
  function load_ply_file (line 78) | def load_ply_file(ply_file_path: Path, center: bool = False) -> SplatArgs:
  function add_splat_to_viser (line 111) | def add_splat_to_viser(
  function visualize_traj_and_hand_detections (line 131) | def visualize_traj_and_hand_detections(