Add recording to visualizer runtime and commands

+ multibody/Visualizer : `stopRecording()` now returns a flag
+ runtime : add resetCamera() command

Author: ManifoldFR

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - CMake : sync jrl-cmakemodules to new release 1.0.0 (https://github.com/Simple-Robotics/candlewick/pull/37)
 - CMake : change option `BUILD_PYTHON_BINDINGS` to `BUILD_PYTHON_INTERFACE` (https://github.com/Simple-Robotics/candlewick/pull/37)
+- multibody/Visualizer : `stopRecording()` now returns a flag (https://github.com/Simple-Robotics/candlewick/pull/37)
 
 ### Fixed
 

bindings/python/candlewick/async_visualizer.py

@@ -61,13 +61,6 @@ def send_cam_pose(sock: zmq.Socket, M: np.ndarray):
     return sock.recv()
 
 
-def cmd_clean(sock: zmq.Socket):
-    """Clean the robot from the renderer. Equivalent to `viz.clean()` on the synchronous `Visualizer` class."""
-    assert sock.socket_type == zmq.REQ
-    sock.send_multipart([b"cmd_clean", b""])
-    return sock.recv()
-
-
 class AsyncVisualizer(BaseVisualizer):
     """A visualizer-like client for the candlewick runtime."""
 
@@ -111,6 +104,11 @@ def rebuildData(self):
     def setCameraPose(self, pose: np.ndarray):
         send_cam_pose(self.sync_sock, pose)
 
+    def resetCamera(self):
+        self.sync_sock.send_multipart([b"reset_camera", b""])
+        response = self.sync_sock.recv().decode()
+        assert response == "ok"
+
     def display(self, q: np.ndarray, v: Optional[np.ndarray] = None):
         """Publish the robot state."""
         assert q.size == self.model.nq
@@ -119,7 +117,10 @@ def display(self, q: np.ndarray, v: Optional[np.ndarray] = None):
         send_state(self.publisher, q, v)
 
     def clean(self):
-        cmd_clean(self.sync_sock)
+        """Clean the robot from the renderer. Equivalent to `viz.clean()` on the synchronous `Visualizer` class."""
+        self.sync_sock.send_multipart([b"cmd_clean", b""])
+        response = self.sync_sock.recv().decode()
+        assert response == "ok"
 
     def close(self):
         self.clean()
@@ -155,3 +156,19 @@ def enableCameraControl(self):
 
     def drawFrameVelocities(self, *args, **kwargs):
         raise NotImplementedError()
+
+    def startRecording(self, filename: str):
+        """Open a recording to a given file."""
+        self.sync_sock.send_multipart([b"start_recording", filename.encode("utf-8")])
+        response = self.sync_sock.recv().decode("utf-8")
+        if response != "ok":
+            print(f"Visualizer runtime error: {response}")
+
+    def stopRecording(self):
+        """
+        Stop the recording if it's running.
+
+        :returns: Whether a recording was actually stopped.
+        """
+        self.sync_sock.send_multipart([b"stop_recording", b""])
+        return bool(self.sync_sock.recv())

bindings/python/candlewick/video_context.py

@@ -1,15 +1,19 @@
 from contextlib import contextmanager
 from . import Visualizer, hasFfmpegSupport
+from typing import Union, TYPE_CHECKING
 import warnings
 
+if TYPE_CHECKING:
+    from .async_visualizer import AsyncVisualizer
+
 _DEFAULT_VIDEO_SETTINGS = {"fps": 30, "bitRate": 3_000_000}
 
 __all__ = ["create_recorder_context"]
 
 
 @contextmanager
 def create_recorder_context(
-    viz: Visualizer,
+    viz: Union[Visualizer, "AsyncVisualizer"],
     filename: str,
     /,
     fps: int = _DEFAULT_VIDEO_SETTINGS["fps"],
@@ -20,8 +24,9 @@ def create_recorder_context(
             "This context will do nothing, as Candlewick was built without video recording support."
         )
     else:
-        viz.videoSettings().fps = fps
-        viz.videoSettings().bitRate = bitRate
+        if isinstance(viz, Visualizer):
+            viz.videoSettings().fps = fps
+            viz.videoSettings().bitRate = bitRate
         viz.startRecording(filename)
     try:
         yield

examples/python/ur3_async_runtime.py

@@ -7,6 +7,7 @@
 import numpy as np
 import warnings
 
+from candlewick import create_recorder_context
 from candlewick.async_visualizer import AsyncVisualizer
 
 try:
@@ -47,11 +48,15 @@ def f(i, vel=False):
         q = pin.interpolate(model, q0, q1, ph)
         client.display(q, _v if vel else None)
 
-    for i in range(400):
-        f(i)
+    with create_recorder_context(client, "async_record.mp4"):
+        for i in range(400):
+            f(i)
 
     # test setting camera
     input("[enter] to set camera pose")
     Mref = np.eye(4)
     Mref[:3, 3] = (0.05, 0, 2.0)
     client.setCameraPose(pose=Mref)
+
+    input("[enter] to reset camera")
+    client.resetCamera()

src/candlewick/multibody/Visualizer.cpp

@@ -230,13 +230,16 @@ void Visualizer::startRecording([[maybe_unused]] std::string_view filename) {
 #endif
 }
 
-void Visualizer::stopRecording() {
+bool Visualizer::stopRecording() {
 #ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
   if (!m_videoRecorder.isRecording())
-    return;
+    return false;
   m_currentVideoFilename.clear();
   SDL_Log("Wrote %d frames.", m_videoRecorder.frameCounter());
   m_videoRecorder.close();
+  return true;
+#else
+  return false;
 #endif
 }
 

src/candlewick/multibody/Visualizer.h

@@ -134,7 +134,9 @@ class Visualizer final : public BaseVisualizer {
 
   void startRecording(std::string_view filename);
 
-  void stopRecording();
+  /// \brief Stop recording the window.
+  /// \returns Whether a recording was actually stopped.
+  bool stopRecording();
 
 #ifdef CANDLEWICK_WITH_FFMPEG_SUPPORT
   auto &videoSettings() { return m_videoSettings; }

src/candlewick/runtime/main.cpp

@@ -25,6 +25,9 @@ using cdw::multibody::Visualizer;
 CANDLEWICK_RUNTIME_DEFINE_COMMAND(send_models);
 CANDLEWICK_RUNTIME_DEFINE_COMMAND(state_update);
 CANDLEWICK_RUNTIME_DEFINE_COMMAND(send_cam_pose);
+CANDLEWICK_RUNTIME_DEFINE_COMMAND(reset_camera);
+CANDLEWICK_RUNTIME_DEFINE_COMMAND(start_recording);
+CANDLEWICK_RUNTIME_DEFINE_COMMAND(stop_recording);
 CANDLEWICK_RUNTIME_DEFINE_COMMAND(clean);
 
 using RowMat4d = Eigen::Matrix<pin::context::Scalar, 4, 4, Eigen::RowMajor>;
@@ -83,12 +86,27 @@ void pull_socket_router(Visualizer &viz, std::span<zmq::message_t, 2> msgs,
     auto M = get_eigen_view_from_spec<RowMat4d>(M_msg);
     viz.setCameraPose(M);
     sync_sock.send(zmq::str_buffer("ok"));
+  } else if (header == CMD_reset_camera) {
+    viz.resetCamera();
+    sync_sock.send(zmq::str_buffer("ok"));
   } else if (header == CMD_clean) {
     viz.clean();
     sync_sock.send(zmq::str_buffer("ok"));
   } else if (header == CMD_send_models) {
     sync_sock.send(
         zmq::str_buffer("error: visualizer already has models open."));
+  } else if (header == CMD_start_recording) {
+    auto filename = msgs[1].to_string_view();
+    try {
+      viz.startRecording(filename);
+      sync_sock.send(zmq::str_buffer("ok"));
+    } catch (const std::runtime_error &err) {
+      std::string err_msg{err.what()};
+      sync_sock.send(zmq::message_t(err_msg));
+    }
+  } else if (header == CMD_stop_recording) {
+    char data{viz.stopRecording()};
+    sync_sock.send(zmq::buffer(&data, 1));
   }
 }