nerfbaselines.viewer

nerfbaselines.viewer.deserialize_nb_info(info: dict) → dict

nerfbaselines.viewer.get_c2w(camera)

nerfbaselines.viewer.get_orientation_transform(poses)

nerfbaselines.viewer.get_position_quaternion(c2s)

nerfbaselines.viewer.handle_cli_error(fn)

nerfbaselines.viewer.open_any_directory(path: str | Path, mode: Literal['r', 'w'] = 'r') → Iterator[str]

nerfbaselines.viewer.qvec2rotmat(qvec)

nerfbaselines.viewer.rotation_matrix(a, b)

Compute the rotation matrix that rotates vector a to vector b.

Parameters:

• a – The vector to rotate.

• b – The vector to rotate to.

Returns:

The rotation matrix.

nerfbaselines.viewer.rotmat2qvec(R)

nerfbaselines.viewer.setup_logging(verbose: bool | Literal['disabled'])

nerfbaselines.viewer.viser

class nerfbaselines.viewer.viser.BindableSource(getter, update, on_update)

Bases: object

map(fn, fn_back=None)

with_default(default)

class nerfbaselines.viewer.viser.BindableViserServer(server: ViserServer)

Bases: ViserServer

exception nerfbaselines.viewer.viser.CancelledException

Bases: Exception

class nerfbaselines.viewer.viser.Dataset

Bases: _IncompleteDataset

cameras: Cameras

image_paths: List[str]

image_paths_root: str

images: ndarray | List[ndarray]

images_points3D_indices: List[ndarray] | None

metadata: Dict

points3D_rgb: ndarray | None

points3D_xyz: ndarray | None

sampling_mask_paths: List[str] | None

sampling_mask_paths_root: str | None

sampling_masks: ndarray | List[ndarray] | None

class nerfbaselines.viewer.viser.EventCancellationToken(*args, **kwargs)

Bases: CancellationToken

cancel()

property cancelled

class nerfbaselines.viewer.viser.Keyframe(position: numpy.ndarray, wxyz: numpy.ndarray, fov: float | None = None, transition_duration: float | None = None, appearance_train_index: int | None = None)

Bases: object

appearance_train_index: int | None = None

fov: float | None = None

position: ndarray

transition_duration: float | None = None

wxyz: ndarray

class nerfbaselines.viewer.viser.KochanekBartelsInterpolationSource

Bases: TypedDict

default_appearance: NotRequired[TrajectoryFrameAppearance | None]

default_fov: float

default_transition_duration: float

interpolation: Literal['kochanek-bartels']

is_cycle: bool

keyframes: List[TrajectoryKeyframe]

tension: float

type: Literal['interpolation']

class nerfbaselines.viewer.viser.Trajectory

Bases: TypedDict

appearances: NotRequired[List[TrajectoryFrameAppearance]]

camera_model: Literal['pinhole', 'opencv', 'opencv_fisheye', 'full_opencv']

fps: float

frames: List[TrajectoryFrame]

image_size: Tuple[int, int]

source: NotRequired[ImageSetInterpolationSource | KochanekBartelsInterpolationSource | None]

class nerfbaselines.viewer.viser.TrajectoryFrame

Bases: TypedDict

appearance_weights: NotRequired[ndarray]

intrinsics: ndarray

pose: ndarray

class nerfbaselines.viewer.viser.TrajectoryFrameAppearance

Bases: TypedDict

embedding: ndarray | None

embedding_train_index: int | None

class nerfbaselines.viewer.viser.TrajectoryKeyframe

Bases: TypedDict

appearance: NotRequired[TrajectoryFrameAppearance]

fov: float | None

pose: ndarray

transition_duration: NotRequired[float | None]

class nerfbaselines.viewer.viser.ViewerRenderer(method: Method | None, expected_depth_scale=0.5)

Bases: object

add_render_video_task(trajectory: Trajectory, callback, error_callback=None)

property output_type_options

render(camera, *, embedding=None, allow_cancel=False, output_type=None, background_color=None, split_output_type: str | None = None, split_percentage: float | None = 0.5, output_aspect_ratio: float | None = None)

update()

class nerfbaselines.viewer.viser.ViewerState(resolution: int = 512, background_color: Tuple[int, int, int] = (38, 42, 55), output_type: Optional[str] = 'color', output_type_options: Tuple[str, ...] = ('color', ), composite_depth: bool = False, output_split: bool = False, split_percentage: float = 0.5, split_output_type: Optional[str] = None, show_train_cameras: bool = False, show_test_cameras: bool = False, show_input_points: bool = True, fps: str = '', preview_render: bool = False, preview_time: float = 0.0, preview_current_frame: int = 0, preview_is_playing: bool = False, render_resolution: Tuple[int, int] = (1920, 1080), render_fov: float = 75.0, render_appearance_train_index: Optional[int] = None, _temporary_appearance_train_index: Optional[int] = None, camera_path_interpolation: str = 'kochanek-bartels', camera_path_loop: bool = False, camera_path_tension: float = 0.0, camera_path_keyframes: Tuple[nerfbaselines.viewer.viser.Keyframe, ...] = (), camera_path_default_transition_duration: float = 2.0, camera_path_framerate: float = 30.0, camera_path_show_keyframes: bool = True, camera_path_move_keyframes: bool = False, camera_path_show_spline: bool = True, input_points: Optional[Tuple[numpy.ndarray, Optional[numpy.ndarray]]] = None, camera_frustums_train: Optional[Any] = None, camera_frustums_test: Optional[Any] = None, image_names_train: Tuple[str, ...] = (), supports_appearance_from_train_images: bool = False, _update_callbacks: List = <factory>)

Bases: object

property b: BindableSource

background_color: Tuple[int, int, int] = (38, 42, 55)

camera_frustums_test: Any | None = None

camera_frustums_train: Any | None = None

camera_path_default_transition_duration: float = 2.0

camera_path_framerate: float = 30.0

camera_path_interpolation: str = 'kochanek-bartels'

camera_path_keyframes: Tuple[Keyframe, ...] = ()

camera_path_loop: bool = False

camera_path_move_keyframes: bool = False

camera_path_show_keyframes: bool = True

camera_path_show_spline: bool = True

camera_path_tension: float = 0.0

composite_depth: bool = False

fps: str = ''

get()

get_trajectory(inv_transform) → Trajectory

image_names_train: Tuple[str, ...] = ()

input_points: Tuple[ndarray, ndarray | None] | None = None

load_trajectory(trajectory: Trajectory, transform) → None

on_update(callback)

output_split: bool = False

output_type: str | None = 'color'

output_type_options: Tuple[str, ...] = ('color',)

preview_current_frame: int = 0

preview_is_playing: bool = False

preview_render: bool = False

preview_time: float = 0.0

render_appearance_train_index: int | None = None

render_fov: float = 75.0

render_resolution: Tuple[int, int] = (1920, 1080)

resolution: int = 512

show_input_points: bool = True

show_test_cameras: bool = False

show_train_cameras: bool = False

split_output_type: str | None = None

split_percentage: float = 0.5

supports_appearance_from_train_images: bool = False

update(**kwargs)

class nerfbaselines.viewer.viser.ViserViewer(method: Method | None, port, dataset_metadata=None, state=None)

Bases: object

add_dataset_views(dataset: Dataset, split: str)

add_initial_point_cloud(points, colors)

run()

nerfbaselines.viewer.viser.apply_colormap(array: TTensor, *, pallete: str = 'viridis', invert: bool = False) → TTensor

nerfbaselines.viewer.viser.apply_transform(transform, poses)

nerfbaselines.viewer.viser.assert_not_none(value: T | None) → T

nerfbaselines.viewer.viser.autobind(fn) → Callable[[BindableSource | ViewerState], Any]

nerfbaselines.viewer.viser.dataset_index_select(dataset: TDataset, i: slice | int | list | ndarray) → TDataset

nerfbaselines.viewer.viser.dataset_load_features(dataset: UnloadedDataset, features=None, supported_camera_models=None) → Dataset

nerfbaselines.viewer.viser.get_c2w(position, wxyz)

nerfbaselines.viewer.viser.get_position_quaternion(c2s)

nerfbaselines.viewer.viser.get_transform_and_scale(transform)

nerfbaselines.viewer.viser.image_to_srgb(tensor, dtype, color_space: str | None = None, allow_alpha: bool = False, background_color: ndarray | None = None)

nerfbaselines.viewer.viser.invert_transform(transform, has_scale=False)

nerfbaselines.viewer.viser.load_dataset(path: Path | str, split: str, features: FrozenSet[Literal['color', 'points3D_xyz', 'points3D_rgb']] | None = None, supported_camera_models: FrozenSet[Literal['pinhole', 'opencv', 'opencv_fisheye', 'full_opencv']] | None = None, load_features: bool = True, **kwargs) → Dataset | UnloadedDataset

nerfbaselines.viewer.viser.load_trajectory(file) → Trajectory

nerfbaselines.viewer.viser.new_cameras(*, poses: ndarray, intrinsics: ndarray, camera_types: ndarray, distortion_parameters: ndarray, image_sizes: ndarray, nears_fars: ndarray | None = None, metadata: ndarray | None = None) → Cameras

nerfbaselines.viewer.viser.pad_poses(p)

Pad […, 3, 4] pose matrices with a homogeneous bottom row [0,0,0,1].

nerfbaselines.viewer.viser.pad_to_aspect_ratio(img, aspect_ratio)

nerfbaselines.viewer.viser.render_frames(method: Method, cameras: Cameras, output: str | Path, fps: float, embeddings: List[ndarray] | None = None, description: str = 'rendering frames', output_type: Literal['color', 'depth'] = 'color', nb_info: dict | None = None) → None

nerfbaselines.viewer.viser.run_viser_viewer(method: Method | None = None, data=None, port=6006, nb_info=None)

nerfbaselines.viewer.viser.safe_eq(a, b) → bool

Check if a and b are equal, even if they are numpy arrays

nerfbaselines.viewer.viser.save_trajectory(trajectory: Trajectory, file) → None

nerfbaselines.viewer.viser.simple_cache(fn)

nerfbaselines.viewer.viser.state_compute_duration(state)

nerfbaselines.viewer.viser.three_js_perspective_camera_focal_length(fov: float, image_height: int)

Returns the focal length of a three.js perspective camera.

Parameters:

• fov – the field of view of the camera in degrees.

• image_height – the height of the image in pixels.

See:

https://github.com/nerfstudio-project/nerfstudio/blob/1aba4ea7a29b05e86f5d223245a573e7dcd86caa/nerfstudio/viewer_legacy/server/utils.py#L52

nerfbaselines.viewer.viser.trajectory_get_cameras(trajectory: Trajectory) → Cameras

nerfbaselines.viewer.viser.trajectory_get_embeddings(method: Method, trajectory: Trajectory) → List[ndarray] | None

nerfbaselines.viewer.viser.transform_points(transform, points)

nerfbaselines.viewer.viser.visualize_depth(depth: ndarray, expected_scale: float | None = None, near_far: ndarray | None = None, pallete: str = 'viridis') → ndarray