|
|
import viser |
|
|
from pathlib import Path |
|
|
from typing import Literal |
|
|
from typing import Tuple, Callable |
|
|
from nerfview import Viewer, RenderTabState |
|
|
|
|
|
|
|
|
class GsplatRenderTabState(RenderTabState): |
|
|
|
|
|
total_gs_count: int = 0 |
|
|
rendered_gs_count: int = 0 |
|
|
|
|
|
|
|
|
max_sh_degree: int = 5 |
|
|
near_plane: float = 1e-2 |
|
|
far_plane: float = 1e2 |
|
|
radius_clip: float = 0.0 |
|
|
eps2d: float = 0.3 |
|
|
backgrounds: Tuple[float, float, float] = (0.0, 0.0, 0.0) |
|
|
render_mode: Literal[ |
|
|
"rgb", "depth(accumulated)", "depth(expected)", "alpha" |
|
|
] = "rgb" |
|
|
normalize_nearfar: bool = False |
|
|
inverse: bool = True |
|
|
colormap: Literal[ |
|
|
"turbo", "viridis", "magma", "inferno", "cividis", "gray" |
|
|
] = "turbo" |
|
|
rasterize_mode: Literal["classic", "antialiased"] = "classic" |
|
|
camera_model: Literal["pinhole", "ortho", "fisheye"] = "pinhole" |
|
|
|
|
|
|
|
|
class GsplatViewer(Viewer): |
|
|
""" |
|
|
Viewer for gsplat. |
|
|
""" |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
server: viser.ViserServer, |
|
|
render_fn: Callable, |
|
|
output_dir: Path, |
|
|
mode: Literal["rendering", "training"] = "rendering", |
|
|
): |
|
|
super().__init__(server, render_fn, output_dir, mode) |
|
|
server.gui.set_panel_label("gsplat viewer") |
|
|
|
|
|
def _init_rendering_tab(self): |
|
|
self.render_tab_state = GsplatRenderTabState() |
|
|
self._rendering_tab_handles = {} |
|
|
self._rendering_folder = self.server.gui.add_folder("Rendering") |
|
|
|
|
|
def _populate_rendering_tab(self): |
|
|
server = self.server |
|
|
with self._rendering_folder: |
|
|
with server.gui.add_folder("Gsplat"): |
|
|
total_gs_count_number = server.gui.add_number( |
|
|
"Total", |
|
|
initial_value=self.render_tab_state.total_gs_count, |
|
|
disabled=True, |
|
|
hint="Total number of splats in the scene.", |
|
|
) |
|
|
rendered_gs_count_number = server.gui.add_number( |
|
|
"Rendered", |
|
|
initial_value=self.render_tab_state.rendered_gs_count, |
|
|
disabled=True, |
|
|
hint="Number of splats rendered.", |
|
|
) |
|
|
|
|
|
max_sh_degree_number = server.gui.add_number( |
|
|
"Max SH", |
|
|
initial_value=self.render_tab_state.max_sh_degree, |
|
|
min=0, |
|
|
max=5, |
|
|
step=1, |
|
|
hint="Maximum SH degree used", |
|
|
) |
|
|
|
|
|
@max_sh_degree_number.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.max_sh_degree = int( |
|
|
max_sh_degree_number.value |
|
|
) |
|
|
self.rerender(_) |
|
|
|
|
|
near_far_plane_vec2 = server.gui.add_vector2( |
|
|
"Near/Far", |
|
|
initial_value=( |
|
|
self.render_tab_state.near_plane, |
|
|
self.render_tab_state.far_plane, |
|
|
), |
|
|
min=(1e-3, 1e1), |
|
|
max=(1e1, 1e2), |
|
|
step=1e-3, |
|
|
hint="Near and far plane for rendering.", |
|
|
) |
|
|
|
|
|
@near_far_plane_vec2.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.near_plane = near_far_plane_vec2.value[0] |
|
|
self.render_tab_state.far_plane = near_far_plane_vec2.value[1] |
|
|
self.rerender(_) |
|
|
|
|
|
radius_clip_slider = server.gui.add_number( |
|
|
"Radius Clip", |
|
|
initial_value=self.render_tab_state.radius_clip, |
|
|
min=0.0, |
|
|
max=100.0, |
|
|
step=1.0, |
|
|
hint="2D radius clip for rendering.", |
|
|
) |
|
|
|
|
|
@radius_clip_slider.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.radius_clip = radius_clip_slider.value |
|
|
self.rerender(_) |
|
|
|
|
|
eps2d_slider = server.gui.add_number( |
|
|
"2D Epsilon", |
|
|
initial_value=self.render_tab_state.eps2d, |
|
|
min=0.0, |
|
|
max=1.0, |
|
|
step=0.01, |
|
|
hint="Epsilon added to the egienvalues of projected 2D covariance matrices.", |
|
|
) |
|
|
|
|
|
@eps2d_slider.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.eps2d = eps2d_slider.value |
|
|
self.rerender(_) |
|
|
|
|
|
backgrounds_slider = server.gui.add_rgb( |
|
|
"Background", |
|
|
initial_value=self.render_tab_state.backgrounds, |
|
|
hint="Background color for rendering.", |
|
|
) |
|
|
|
|
|
@backgrounds_slider.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.backgrounds = backgrounds_slider.value |
|
|
self.rerender(_) |
|
|
|
|
|
render_mode_dropdown = server.gui.add_dropdown( |
|
|
"Render Mode", |
|
|
("rgb", "depth(accumulated)", "depth(expected)", "alpha"), |
|
|
initial_value=self.render_tab_state.render_mode, |
|
|
hint="Render mode to use.", |
|
|
) |
|
|
|
|
|
@render_mode_dropdown.on_update |
|
|
def _(_) -> None: |
|
|
if "depth" in render_mode_dropdown.value: |
|
|
normalize_nearfar_checkbox.disabled = False |
|
|
else: |
|
|
normalize_nearfar_checkbox.disabled = True |
|
|
if render_mode_dropdown.value == "rgb": |
|
|
inverse_checkbox.disabled = True |
|
|
else: |
|
|
inverse_checkbox.disabled = False |
|
|
self.render_tab_state.render_mode = render_mode_dropdown.value |
|
|
self.rerender(_) |
|
|
|
|
|
normalize_nearfar_checkbox = server.gui.add_checkbox( |
|
|
"Normalize Near/Far", |
|
|
initial_value=self.render_tab_state.normalize_nearfar, |
|
|
disabled=True, |
|
|
hint="Normalize depth with near/far plane.", |
|
|
) |
|
|
|
|
|
@normalize_nearfar_checkbox.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.normalize_nearfar = ( |
|
|
normalize_nearfar_checkbox.value |
|
|
) |
|
|
self.rerender(_) |
|
|
|
|
|
inverse_checkbox = server.gui.add_checkbox( |
|
|
"Inverse", |
|
|
initial_value=self.render_tab_state.inverse, |
|
|
disabled=True, |
|
|
hint="Inverse the depth.", |
|
|
) |
|
|
|
|
|
@inverse_checkbox.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.inverse = inverse_checkbox.value |
|
|
self.rerender(_) |
|
|
|
|
|
colormap_dropdown = server.gui.add_dropdown( |
|
|
"Colormap", |
|
|
("turbo", "viridis", "magma", "inferno", "cividis", "gray"), |
|
|
initial_value=self.render_tab_state.colormap, |
|
|
hint="Colormap used for rendering depth/alpha.", |
|
|
) |
|
|
|
|
|
@colormap_dropdown.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.colormap = colormap_dropdown.value |
|
|
self.rerender(_) |
|
|
|
|
|
rasterize_mode_dropdown = server.gui.add_dropdown( |
|
|
"Anti-Aliasing", |
|
|
("classic", "antialiased"), |
|
|
initial_value=self.render_tab_state.rasterize_mode, |
|
|
hint="Whether to use classic or antialiased rasterization.", |
|
|
) |
|
|
|
|
|
@rasterize_mode_dropdown.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.rasterize_mode = rasterize_mode_dropdown.value |
|
|
self.rerender(_) |
|
|
|
|
|
camera_model_dropdown = server.gui.add_dropdown( |
|
|
"Camera", |
|
|
("pinhole", "ortho", "fisheye"), |
|
|
initial_value=self.render_tab_state.camera_model, |
|
|
hint="Camera model used for rendering.", |
|
|
) |
|
|
|
|
|
@camera_model_dropdown.on_update |
|
|
def _(_) -> None: |
|
|
self.render_tab_state.camera_model = camera_model_dropdown.value |
|
|
self.rerender(_) |
|
|
|
|
|
self._rendering_tab_handles.update( |
|
|
{ |
|
|
"total_gs_count_number": total_gs_count_number, |
|
|
"rendered_gs_count_number": rendered_gs_count_number, |
|
|
"near_far_plane_vec2": near_far_plane_vec2, |
|
|
"radius_clip_slider": radius_clip_slider, |
|
|
"eps2d_slider": eps2d_slider, |
|
|
"backgrounds_slider": backgrounds_slider, |
|
|
"render_mode_dropdown": render_mode_dropdown, |
|
|
"normalize_nearfar_checkbox": normalize_nearfar_checkbox, |
|
|
"inverse_checkbox": inverse_checkbox, |
|
|
"colormap_dropdown": colormap_dropdown, |
|
|
"rasterize_mode_dropdown": rasterize_mode_dropdown, |
|
|
"camera_model_dropdown": camera_model_dropdown, |
|
|
} |
|
|
) |
|
|
super()._populate_rendering_tab() |
|
|
|
|
|
def _after_render(self): |
|
|
|
|
|
self._rendering_tab_handles[ |
|
|
"total_gs_count_number" |
|
|
].value = self.render_tab_state.total_gs_count |
|
|
self._rendering_tab_handles[ |
|
|
"rendered_gs_count_number" |
|
|
].value = self.render_tab_state.rendered_gs_count |
|
|
|
