Update video render panel of web viewer

1. Enable constant camera moving speed
2. Allow negative spline tension

Author: yzslab

internal/viewer/ui/render_panel.py

@@ -83,6 +83,7 @@ def __init__(self, server: viser.ViserServer, viewer):
         self._viewer = viewer
         self._keyframes: Dict[int, Tuple[Keyframe, viser.CameraFrustumHandle]] = {}
         self._keyframe_counter: int = 0
+        self._max_t = 0
         self._spline: Optional[viser.SceneNodeHandle] = None
         self._camera_edit_panel: Optional[viser.Gui3dContainerHandle] = None
 
@@ -97,6 +98,7 @@ def __init__(self, server: viser.ViserServer, viewer):
         # These parameters should be overridden externally.
         self.loop: bool = False
         self.smoothness: float = 0.5  # Tension / alpha term.
+        self.constant_speed: bool = True
         self.default_fov: float = 0.0
         self.framerate: float = 0
         self.duration: float = 0
@@ -276,14 +278,15 @@ def interpolate_pose_and_fov(self, normalized_t: float) -> Optional[Tuple[tf.SE3
                 keyframe[0].override_fov_value if keyframe[0].override_fov_enabled else self.default_fov
                 for keyframe in self._keyframes.values()
             ],
+            self._position_spline.grid,
             tcb=(self.smoothness, 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 = len(self._keyframes) if self.loop else len(self._keyframes) - 1
+        max_t = self._max_t
         t = max_t * normalized_t
         quat = self._orientation_spline.evaluate(t)
         assert isinstance(quat, splines.quaternion.UnitQuaternion)
@@ -317,6 +320,15 @@ def interpolate_pose_and_fov(self, normalized_t: float) -> Optional[Tuple[tf.SE3
             model_poses,
         )
 
+    def get_keyframe_times(self):
+        keyframe_positions = [keyframe[0].position for keyframe in self._keyframes.values()]
+        if self.loop is True:
+            keyframe_positions += keyframe_positions[:1]
+        keyframe_distances = onp.linalg.norm(onp.diff(keyframe_positions, axis=0), axis=1)
+        keyframe_times = onp.concatenate([[0], onp.cumsum(keyframe_distances)])
+
+        return keyframe_times
+
     def update_spline(self) -> None:
         keyframes = list(self._keyframes.values())
         if len(keyframes) <= 1:
@@ -329,17 +341,26 @@ def update_spline(self) -> None:
         if num_frames <= 0:
             return
 
+        keyframe_times = None
+        max_t = len(keyframes) if self.loop else len(keyframes) - 1
+        if self.constant_speed is True:
+            keyframe_times = self.get_keyframe_times()
+            max_t = keyframe_times[-1]
+        self._max_t = max_t
+
         # Update internal splines.
         self._orientation_spline = splines.quaternion.KochanekBartels(
             [
                 splines.quaternion.UnitQuaternion.from_unit_xyzw(onp.roll(keyframe[0].wxyz, shift=-1))
                 for keyframe in keyframes
             ],
+            keyframe_times,
             tcb=(self.smoothness, 0.0, 0.0),
             endconditions="closed" if self.loop else "natural",
         )
         self._position_spline = splines.KochanekBartels(
             [keyframe[0].position for keyframe in keyframes],
+            keyframe_times,
             tcb=(self.smoothness, 0.0, 0.0),
             endconditions="closed" if self.loop else "natural",
         )
@@ -382,9 +403,8 @@ def update_spline(self) -> None:
             ))
 
         # Update visualized spline.
-        num_keyframes = len(keyframes) + 1 if self.loop else len(keyframes)
         points_array = onp.array(
-            [self._position_spline.evaluate(t) for t in onp.linspace(0, num_keyframes - 1, num_frames)]
+            [self._position_spline.evaluate(t) for t in onp.linspace(0, self._max_t, num_frames)]
         )
         colors_array = onp.array([colorsys.hls_to_rgb(h, 0.5, 1.0) for h in onp.linspace(0.0, 1.0, len(points_array))])
         self._spline = self._server.add_point_cloud(
@@ -529,7 +549,7 @@ def _(_) -> None:
 
     smoothness = server.gui.add_slider(
         "Spline Tension",
-        min=0.0,
+        min=-1.0,
         max=1.0,
         initial_value=0.0,
         step=0.01,
@@ -541,6 +561,17 @@ def _(_) -> None:
         camera_path.smoothness = smoothness.value
         camera_path.update_spline()
 
+    constant_speed_checkbox = server.gui.add_checkbox(
+        "Constant Speed",
+        initial_value=True,
+        hint="Maintain a constant speed for camera movement",
+    )
+
+    @constant_speed_checkbox.on_update
+    def _(_) -> None:
+        camera_path.constant_speed = constant_speed_checkbox.value
+        camera_path.update_spline()
+
     move_checkbox = server.gui.add_checkbox(
         "Move keyframes",
         initial_value=False,