import colorsys import dataclasses import threading import time from pathlib import Path import numpy as np import scipy import splines import splines.quaternion import torch import viser import viser.transforms as vt from seva.geometry import get_preset_pose_fov @dataclasses.dataclass class Keyframe(object): position: np.ndarray wxyz: np.ndarray override_fov_enabled: bool override_fov_rad: float aspect: float override_transition_enabled: bool override_transition_sec: float | None @staticmethod def from_camera(camera: viser.CameraHandle, aspect: float) -> "Keyframe": return Keyframe( camera.position, camera.wxyz, override_fov_enabled=False, override_fov_rad=camera.fov, aspect=aspect, override_transition_enabled=False, override_transition_sec=None, ) @staticmethod def from_se3(se3: vt.SE3, fov: float, aspect: float) -> "Keyframe": return Keyframe( se3.translation(), se3.rotation().wxyz, override_fov_enabled=False, override_fov_rad=fov, aspect=aspect, override_transition_enabled=False, override_transition_sec=None, ) class CameraTrajectory(object): def __init__( self, server: viser.ViserServer, duration_element: viser.GuiInputHandle[float], scene_scale: float, scene_node_prefix: str = "/", ): self._server = server self._keyframes: dict[int, tuple[Keyframe, viser.CameraFrustumHandle]] = {} self._keyframe_counter: int = 0 self._spline_nodes: list[viser.SceneNodeHandle] = [] self._camera_edit_panel: viser.Gui3dContainerHandle | None = None self._orientation_spline: splines.quaternion.KochanekBartels | None = None self._position_spline: splines.KochanekBartels | None = None self._fov_spline: splines.KochanekBartels | None = None self._keyframes_visible: bool = True self._duration_element = duration_element self._scene_node_prefix = scene_node_prefix self.scene_scale = scene_scale # These parameters should be overridden externally. self.loop: bool = False self.framerate: float = 30.0 self.tension: float = 0.0 # Tension / alpha term. self.default_fov: float = 0.0 self.default_transition_sec: float = 0.0 self.show_spline: bool = True def set_keyframes_visible(self, visible: bool) -> None: self._keyframes_visible = visible for keyframe in self._keyframes.values(): keyframe[1].visible = visible def add_camera(self, keyframe: Keyframe, keyframe_index: int | None = None) -> None: """Add a new camera, or replace an old one if `keyframe_index` is passed in.""" server = self._server # Add a keyframe if we aren't replacing an existing one. if keyframe_index is None: keyframe_index = self._keyframe_counter self._keyframe_counter += 1 print( f"{keyframe.wxyz=} {keyframe.position=} {keyframe_index=} {keyframe.aspect=}" ) frustum_handle = server.scene.add_camera_frustum( str(Path(self._scene_node_prefix) / f"cameras/{keyframe_index}"), fov=( keyframe.override_fov_rad if keyframe.override_fov_enabled else self.default_fov ), aspect=keyframe.aspect, scale=0.1 * self.scene_scale, color=(200, 10, 30), wxyz=keyframe.wxyz, position=keyframe.position, visible=self._keyframes_visible, ) self._server.scene.add_icosphere( str(Path(self._scene_node_prefix) / f"cameras/{keyframe_index}/sphere"), radius=0.03, color=(200, 10, 30), ) @frustum_handle.on_click def _(_) -> None: if self._camera_edit_panel is not None: self._camera_edit_panel.remove() self._camera_edit_panel = None with server.scene.add_3d_gui_container( "/camera_edit_panel", position=keyframe.position, ) as camera_edit_panel: self._camera_edit_panel = camera_edit_panel override_fov = server.gui.add_checkbox( "Override FOV", initial_value=keyframe.override_fov_enabled ) override_fov_degrees = server.gui.add_slider( "Override FOV (degrees)", 5.0, 175.0, step=0.1, initial_value=keyframe.override_fov_rad * 180.0 / np.pi, disabled=not keyframe.override_fov_enabled, ) delete_button = server.gui.add_button( "Delete", color="red", icon=viser.Icon.TRASH ) go_to_button = server.gui.add_button("Go to") close_button = server.gui.add_button("Close") @override_fov.on_update def _(_) -> None: keyframe.override_fov_enabled = override_fov.value override_fov_degrees.disabled = not override_fov.value self.add_camera(keyframe, keyframe_index) @override_fov_degrees.on_update def _(_) -> None: keyframe.override_fov_rad = override_fov_degrees.value / 180.0 * np.pi self.add_camera(keyframe, keyframe_index) @delete_button.on_click def _(event: viser.GuiEvent) -> None: assert event.client is not None with event.client.gui.add_modal("Confirm") as modal: event.client.gui.add_markdown("Delete keyframe?") confirm_button = event.client.gui.add_button( "Yes", color="red", icon=viser.Icon.TRASH ) exit_button = event.client.gui.add_button("Cancel") @confirm_button.on_click def _(_) -> None: assert camera_edit_panel is not None keyframe_id = None for i, keyframe_tuple in self._keyframes.items(): if keyframe_tuple[1] is frustum_handle: keyframe_id = i break assert keyframe_id is not None self._keyframes.pop(keyframe_id) frustum_handle.remove() camera_edit_panel.remove() self._camera_edit_panel = None modal.close() self.update_spline() @exit_button.on_click def _(_) -> None: modal.close() @go_to_button.on_click def _(event: viser.GuiEvent) -> None: assert event.client is not None client = event.client T_world_current = vt.SE3.from_rotation_and_translation( vt.SO3(client.camera.wxyz), client.camera.position ) T_world_target = vt.SE3.from_rotation_and_translation( vt.SO3(keyframe.wxyz), keyframe.position ) @ vt.SE3.from_translation(np.array([0.0, 0.0, -0.5])) T_current_target = T_world_current.inverse() @ T_world_target for j in range(10): T_world_set = T_world_current @ vt.SE3.exp( T_current_target.log() * j / 9.0 ) # Important bit: we atomically set both the orientation and # the position of the camera. with client.atomic(): client.camera.wxyz = T_world_set.rotation().wxyz client.camera.position = T_world_set.translation() time.sleep(1.0 / 30.0) @close_button.on_click def _(_) -> None: assert camera_edit_panel is not None camera_edit_panel.remove() self._camera_edit_panel = None self._keyframes[keyframe_index] = (keyframe, frustum_handle) def update_aspect(self, aspect: float) -> None: for keyframe_index, frame in self._keyframes.items(): frame = dataclasses.replace(frame[0], aspect=aspect) self.add_camera(frame, keyframe_index=keyframe_index) def get_aspect(self) -> float: """Get W/H aspect ratio, which is shared across all keyframes.""" assert len(self._keyframes) > 0 return next(iter(self._keyframes.values()))[0].aspect def reset(self) -> None: for frame in self._keyframes.values(): print(f"removing {frame[1]}") frame[1].remove() self._keyframes.clear() self.update_spline() print("camera traj reset") def spline_t_from_t_sec(self, time: np.ndarray) -> np.ndarray: """From a time value in seconds, compute a t value for our geometric spline interpolation. An increment of 1 for the latter will move the camera forward by one keyframe. We use a PCHIP spline here to guarantee monotonicity. """ transition_times_cumsum = self.compute_transition_times_cumsum() spline_indices = np.arange(transition_times_cumsum.shape[0]) if self.loop: # In the case of a loop, we pad the spline to match the start/end # slopes. interpolator = scipy.interpolate.PchipInterpolator( x=np.concatenate( [ [-(transition_times_cumsum[-1] - transition_times_cumsum[-2])], transition_times_cumsum, transition_times_cumsum[-1:] + transition_times_cumsum[1:2], ], axis=0, ), y=np.concatenate( [[-1], spline_indices, [spline_indices[-1] + 1]], # type: ignore axis=0, ), ) else: interpolator = scipy.interpolate.PchipInterpolator( x=transition_times_cumsum, y=spline_indices ) # Clip to account for floating point error. return np.clip(interpolator(time), 0, spline_indices[-1]) def interpolate_pose_and_fov_rad( self, normalized_t: float ) -> tuple[vt.SE3, float] | None: if len(self._keyframes) < 2: return None self._fov_spline = splines.KochanekBartels( [ ( keyframe[0].override_fov_rad if keyframe[0].override_fov_enabled else self.default_fov ) for keyframe in self._keyframes.values() ], tcb=(self.tension, 0.0, 0.0), endconditions="closed" if self.loop else "natural", ) assert self._orientation_spline is not None assert self._position_spline is not None assert self._fov_spline is not None max_t = self.compute_duration() t = max_t * normalized_t spline_t = float(self.spline_t_from_t_sec(np.array(t))) quat = self._orientation_spline.evaluate(spline_t) assert isinstance(quat, splines.quaternion.UnitQuaternion) return ( vt.SE3.from_rotation_and_translation( vt.SO3(np.array([quat.scalar, *quat.vector])), self._position_spline.evaluate(spline_t), ), float(self._fov_spline.evaluate(spline_t)), ) def update_spline(self) -> None: num_frames = int(self.compute_duration() * self.framerate) keyframes = list(self._keyframes.values()) if num_frames <= 0 or not self.show_spline or len(keyframes) < 2: for node in self._spline_nodes: node.remove() self._spline_nodes.clear() return transition_times_cumsum = self.compute_transition_times_cumsum() self._orientation_spline = splines.quaternion.KochanekBartels( [ splines.quaternion.UnitQuaternion.from_unit_xyzw( np.roll(keyframe[0].wxyz, shift=-1) ) for keyframe in keyframes ], tcb=(self.tension, 0.0, 0.0), endconditions="closed" if self.loop else "natural", ) self._position_spline = splines.KochanekBartels( [keyframe[0].position for keyframe in keyframes], tcb=(self.tension, 0.0, 0.0), endconditions="closed" if self.loop else "natural", ) # Update visualized spline. points_array = self._position_spline.evaluate( self.spline_t_from_t_sec( np.linspace(0, transition_times_cumsum[-1], num_frames) ) ) colors_array = np.array( [ colorsys.hls_to_rgb(h, 0.5, 1.0) for h in np.linspace(0.0, 1.0, len(points_array)) ] ) # Clear prior spline nodes. for node in self._spline_nodes: node.remove() self._spline_nodes.clear() self._spline_nodes.append( self._server.scene.add_spline_catmull_rom( str(Path(self._scene_node_prefix) / "camera_spline"), positions=points_array, color=(220, 220, 220), closed=self.loop, line_width=1.0, segments=points_array.shape[0] + 1, ) ) self._spline_nodes.append( self._server.scene.add_point_cloud( str(Path(self._scene_node_prefix) / "camera_spline/points"), points=points_array, colors=colors_array, point_size=0.04, ) ) def make_transition_handle(i: int) -> None: assert self._position_spline is not None transition_pos = self._position_spline.evaluate( float( self.spline_t_from_t_sec( (transition_times_cumsum[i] + transition_times_cumsum[i + 1]) / 2.0, ) ) ) transition_sphere = self._server.scene.add_icosphere( str(Path(self._scene_node_prefix) / f"camera_spline/transition_{i}"), radius=0.04, color=(255, 0, 0), position=transition_pos, ) self._spline_nodes.append(transition_sphere) @transition_sphere.on_click def _(_) -> None: server = self._server if self._camera_edit_panel is not None: self._camera_edit_panel.remove() self._camera_edit_panel = None keyframe_index = (i + 1) % len(self._keyframes) keyframe = keyframes[keyframe_index][0] with server.scene.add_3d_gui_container( "/camera_edit_panel", position=transition_pos, ) as camera_edit_panel: self._camera_edit_panel = camera_edit_panel override_transition_enabled = server.gui.add_checkbox( "Override transition", initial_value=keyframe.override_transition_enabled, ) override_transition_sec = server.gui.add_number( "Override transition (sec)", initial_value=( keyframe.override_transition_sec if keyframe.override_transition_sec is not None else self.default_transition_sec ), min=0.001, max=30.0, step=0.001, disabled=not override_transition_enabled.value, ) close_button = server.gui.add_button("Close") @override_transition_enabled.on_update def _(_) -> None: keyframe.override_transition_enabled = ( override_transition_enabled.value ) override_transition_sec.disabled = ( not override_transition_enabled.value ) self._duration_element.value = self.compute_duration() @override_transition_sec.on_update def _(_) -> None: keyframe.override_transition_sec = override_transition_sec.value self._duration_element.value = self.compute_duration() @close_button.on_click def _(_) -> None: assert camera_edit_panel is not None camera_edit_panel.remove() self._camera_edit_panel = None (num_transitions_plus_1,) = transition_times_cumsum.shape for i in range(num_transitions_plus_1 - 1): make_transition_handle(i) def compute_duration(self) -> float: """Compute the total duration of the trajectory.""" total = 0.0 for i, (keyframe, frustum) in enumerate(self._keyframes.values()): if i == 0 and not self.loop: continue del frustum total += ( keyframe.override_transition_sec if keyframe.override_transition_enabled and keyframe.override_transition_sec is not None else self.default_transition_sec ) return total def compute_transition_times_cumsum(self) -> np.ndarray: """Compute the total duration of the trajectory.""" total = 0.0 out = [0.0] for i, (keyframe, frustum) in enumerate(self._keyframes.values()): if i == 0: continue del frustum total += ( keyframe.override_transition_sec if keyframe.override_transition_enabled and keyframe.override_transition_sec is not None else self.default_transition_sec ) out.append(total) if self.loop: keyframe = next(iter(self._keyframes.values()))[0] total += ( keyframe.override_transition_sec if keyframe.override_transition_enabled and keyframe.override_transition_sec is not None else self.default_transition_sec ) out.append(total) return np.array(out) @dataclasses.dataclass class GuiState: preview_render: bool preview_fov: float preview_aspect: float camera_traj_list: list | None active_input_index: int def define_gui( server: viser.ViserServer, init_fov: float = 75.0, img_wh: tuple[int, int] = (576, 576), **kwargs, ) -> GuiState: gui_state = GuiState( preview_render=False, preview_fov=0.0, preview_aspect=1.0, camera_traj_list=None, active_input_index=0, ) with server.gui.add_folder( "Preset camera trajectories", order=99, expand_by_default=False ): preset_traj_dropdown = server.gui.add_dropdown( "Options", [ "orbit", "spiral", "lemniscate", "zoom-out", "dolly zoom-out", ], initial_value="orbit", hint="Select a preset camera trajectory.", ) preset_duration_num = server.gui.add_number( "Duration (sec)", min=1.0, max=60.0, step=0.5, initial_value=2.0, ) preset_submit_button = server.gui.add_button( "Submit", icon=viser.Icon.PICK, hint="Add a new keyframe at the current pose.", ) @preset_submit_button.on_click def _(event: viser.GuiEvent) -> None: camera_traj.reset() gui_state.camera_traj_list = None duration = preset_duration_num.value fps = framerate_number.value num_frames = int(duration * fps) transition_sec = duration / num_frames transition_sec_number.value = transition_sec assert event.client_id is not None transition_sec_number.disabled = True loop_checkbox.disabled = True add_keyframe_button.disabled = True camera = server.get_clients()[event.client_id].camera start_w2c = torch.linalg.inv( torch.as_tensor( vt.SE3.from_rotation_and_translation( vt.SO3(camera.wxyz), camera.position ).as_matrix(), dtype=torch.float32, ) ) look_at = torch.as_tensor(camera.look_at, dtype=torch.float32) up_direction = torch.as_tensor(camera.up_direction, dtype=torch.float32) poses, fovs = get_preset_pose_fov( option=preset_traj_dropdown.value, # type: ignore num_frames=num_frames, start_w2c=start_w2c, look_at=look_at, up_direction=up_direction, fov=camera.fov, ) assert poses is not None and fovs is not None for pose, fov in zip(poses, fovs): camera_traj.add_camera( Keyframe.from_se3( vt.SE3.from_matrix(pose), fov=fov, aspect=img_wh[0] / img_wh[1], ) ) duration_number.value = camera_traj.compute_duration() camera_traj.update_spline() with server.gui.add_folder("Advanced", expand_by_default=False, order=100): transition_sec_number = server.gui.add_number( "Transition (sec)", min=0.001, max=30.0, step=0.001, initial_value=1.5, hint="Time in seconds between each keyframe, which can also be overridden on a per-transition basis.", ) framerate_number = server.gui.add_number( "FPS", min=0.1, max=240.0, step=1e-2, initial_value=30.0 ) framerate_buttons = server.gui.add_button_group("", ("24", "30", "60")) duration_number = server.gui.add_number( "Duration (sec)", min=0.0, max=1e8, step=0.001, initial_value=0.0, disabled=True, ) @framerate_buttons.on_click def _(_) -> None: framerate_number.value = float(framerate_buttons.value) fov_degree_slider = server.gui.add_slider( "FOV", initial_value=init_fov, min=0.1, max=175.0, step=0.01, hint="Field-of-view for rendering, which can also be overridden on a per-keyframe basis.", ) @fov_degree_slider.on_update def _(_) -> None: fov_radians = fov_degree_slider.value / 180.0 * np.pi for client in server.get_clients().values(): client.camera.fov = fov_radians camera_traj.default_fov = fov_radians # Updating the aspect ratio will also re-render the camera frustums. # Could rethink this. camera_traj.update_aspect(img_wh[0] / img_wh[1]) compute_and_update_preview_camera_state() scene_node_prefix = "/render_assets" base_scene_node = server.scene.add_frame(scene_node_prefix, show_axes=False) add_keyframe_button = server.gui.add_button( "Add keyframe", icon=viser.Icon.PLUS, hint="Add a new keyframe at the current pose.", ) @add_keyframe_button.on_click def _(event: viser.GuiEvent) -> None: assert event.client_id is not None camera = server.get_clients()[event.client_id].camera pose = vt.SE3.from_rotation_and_translation( vt.SO3(camera.wxyz), camera.position ) print(f"client {event.client_id} at {camera.position} {camera.wxyz}") print(f"camera pose {pose.as_matrix()}") # Add this camera to the trajectory. camera_traj.add_camera( Keyframe.from_camera( camera, aspect=img_wh[0] / img_wh[1], ), ) duration_number.value = camera_traj.compute_duration() camera_traj.update_spline() clear_keyframes_button = server.gui.add_button( "Clear keyframes", icon=viser.Icon.TRASH, hint="Remove all keyframes from the render trajectory.", ) @clear_keyframes_button.on_click def _(event: viser.GuiEvent) -> None: assert event.client_id is not None client = server.get_clients()[event.client_id] with client.atomic(), client.gui.add_modal("Confirm") as modal: client.gui.add_markdown("Clear all keyframes?") confirm_button = client.gui.add_button( "Yes", color="red", icon=viser.Icon.TRASH ) exit_button = client.gui.add_button("Cancel") @confirm_button.on_click def _(_) -> None: camera_traj.reset() modal.close() duration_number.value = camera_traj.compute_duration() add_keyframe_button.disabled = False transition_sec_number.disabled = False transition_sec_number.value = 1.5 loop_checkbox.disabled = False nonlocal gui_state gui_state.camera_traj_list = None @exit_button.on_click def _(_) -> None: modal.close() play_button = server.gui.add_button("Play", icon=viser.Icon.PLAYER_PLAY) pause_button = server.gui.add_button( "Pause", icon=viser.Icon.PLAYER_PAUSE, visible=False ) # Poll the play button to see if we should be playing endlessly. def play() -> None: while True: while not play_button.visible: max_frame = int(framerate_number.value * duration_number.value) if max_frame > 0: assert preview_frame_slider is not None preview_frame_slider.value = ( preview_frame_slider.value + 1 ) % max_frame time.sleep(1.0 / framerate_number.value) time.sleep(0.1) threading.Thread(target=play).start() # Play the camera trajectory when the play button is pressed. @play_button.on_click def _(_) -> None: play_button.visible = False pause_button.visible = True # Play the camera trajectory when the play button is pressed. @pause_button.on_click def _(_) -> None: play_button.visible = True pause_button.visible = False preview_render_button = server.gui.add_button( "Preview render", hint="Show a preview of the render in the viewport.", icon=viser.Icon.CAMERA_CHECK, ) preview_render_stop_button = server.gui.add_button( "Exit render preview", color="red", icon=viser.Icon.CAMERA_CANCEL, visible=False, ) @preview_render_button.on_click def _(_) -> None: gui_state.preview_render = True preview_render_button.visible = False preview_render_stop_button.visible = True play_button.visible = False pause_button.visible = True preset_submit_button.disabled = True maybe_pose_and_fov_rad = compute_and_update_preview_camera_state() if maybe_pose_and_fov_rad is None: remove_preview_camera() return pose, fov = maybe_pose_and_fov_rad del fov # Hide all render assets when we're previewing the render. nonlocal base_scene_node base_scene_node.visible = False # Back up and then set camera poses. for client in server.get_clients().values(): camera_pose_backup_from_id[client.client_id] = ( client.camera.position, client.camera.look_at, client.camera.up_direction, ) with client.atomic(): client.camera.wxyz = pose.rotation().wxyz client.camera.position = pose.translation() def stop_preview_render() -> None: gui_state.preview_render = False preview_render_button.visible = True preview_render_stop_button.visible = False play_button.visible = True pause_button.visible = False preset_submit_button.disabled = False # Revert camera poses. for client in server.get_clients().values(): if client.client_id not in camera_pose_backup_from_id: continue cam_position, cam_look_at, cam_up = camera_pose_backup_from_id.pop( client.client_id ) with client.atomic(): client.camera.position = cam_position client.camera.look_at = cam_look_at client.camera.up_direction = cam_up client.flush() # Un-hide render assets. nonlocal base_scene_node base_scene_node.visible = True remove_preview_camera() @preview_render_stop_button.on_click def _(_) -> None: stop_preview_render() def get_max_frame_index() -> int: return max(1, int(framerate_number.value * duration_number.value) - 1) def add_preview_frame_slider() -> viser.GuiInputHandle[int] | None: """Helper for creating the current frame # slider. This is removed and re-added anytime the `max` value changes.""" preview_frame_slider = server.gui.add_slider( "Preview frame", min=0, max=get_max_frame_index(), step=1, initial_value=0, order=set_traj_button.order + 0.01, disabled=get_max_frame_index() == 1, ) play_button.disabled = preview_frame_slider.disabled preview_render_button.disabled = preview_frame_slider.disabled set_traj_button.disabled = preview_frame_slider.disabled @preview_frame_slider.on_update def _(_) -> None: nonlocal preview_camera_handle maybe_pose_and_fov_rad = compute_and_update_preview_camera_state() if maybe_pose_and_fov_rad is None: return pose, fov_rad = maybe_pose_and_fov_rad preview_camera_handle = server.scene.add_camera_frustum( str(Path(scene_node_prefix) / "preview_camera"), fov=fov_rad, aspect=img_wh[0] / img_wh[1], scale=0.35, wxyz=pose.rotation().wxyz, position=pose.translation(), color=(10, 200, 30), ) if gui_state.preview_render: for client in server.get_clients().values(): with client.atomic(): client.camera.wxyz = pose.rotation().wxyz client.camera.position = pose.translation() return preview_frame_slider set_traj_button = server.gui.add_button( "Set camera trajectory", color="green", icon=viser.Icon.CHECK, hint="Save the camera trajectory for rendering.", ) @set_traj_button.on_click def _(event: viser.GuiEvent) -> None: assert event.client is not None num_frames = int(framerate_number.value * duration_number.value) def get_intrinsics(W, H, fov_rad): focal = 0.5 * H / np.tan(0.5 * fov_rad) return np.array( [[focal, 0.0, 0.5 * W], [0.0, focal, 0.5 * H], [0.0, 0.0, 1.0]] ) camera_traj_list = [] for i in range(num_frames): maybe_pose_and_fov_rad = camera_traj.interpolate_pose_and_fov_rad( i / num_frames ) if maybe_pose_and_fov_rad is None: return pose, fov_rad = maybe_pose_and_fov_rad H = img_wh[1] W = img_wh[0] K = get_intrinsics(W, H, fov_rad) w2c = pose.inverse().as_matrix() camera_traj_list.append( { "w2c": w2c.flatten().tolist(), "K": K.flatten().tolist(), "img_wh": (W, H), } ) nonlocal gui_state gui_state.camera_traj_list = camera_traj_list print(f"Get camera_traj_list: {gui_state.camera_traj_list}") stop_preview_render() preview_frame_slider = add_preview_frame_slider() loop_checkbox = server.gui.add_checkbox( "Loop", False, hint="Add a segment between the first and last keyframes." ) @loop_checkbox.on_update def _(_) -> None: camera_traj.loop = loop_checkbox.value duration_number.value = camera_traj.compute_duration() @transition_sec_number.on_update def _(_) -> None: camera_traj.default_transition_sec = transition_sec_number.value duration_number.value = camera_traj.compute_duration() preview_camera_handle: viser.SceneNodeHandle | None = None def remove_preview_camera() -> None: nonlocal preview_camera_handle if preview_camera_handle is not None: preview_camera_handle.remove() preview_camera_handle = None def compute_and_update_preview_camera_state() -> tuple[vt.SE3, float] | None: """Update the render tab state with the current preview camera pose. Returns current camera pose + FOV if available.""" if preview_frame_slider is None: return None maybe_pose_and_fov_rad = camera_traj.interpolate_pose_and_fov_rad( preview_frame_slider.value / get_max_frame_index() ) if maybe_pose_and_fov_rad is None: remove_preview_camera() return None pose, fov_rad = maybe_pose_and_fov_rad gui_state.preview_fov = fov_rad gui_state.preview_aspect = camera_traj.get_aspect() return pose, fov_rad # We back up the camera poses before and after we start previewing renders. camera_pose_backup_from_id: dict[int, tuple] = {} # Update the # of frames. @duration_number.on_update @framerate_number.on_update def _(_) -> None: remove_preview_camera() # Will be re-added when slider is updated. nonlocal preview_frame_slider old = preview_frame_slider assert old is not None preview_frame_slider = add_preview_frame_slider() if preview_frame_slider is not None: old.remove() else: preview_frame_slider = old camera_traj.framerate = framerate_number.value camera_traj.update_spline() camera_traj = CameraTrajectory( server, duration_number, scene_node_prefix=scene_node_prefix, **kwargs, ) camera_traj.default_fov = fov_degree_slider.value / 180.0 * np.pi camera_traj.default_transition_sec = transition_sec_number.value return gui_state