Upload folder using huggingface_hub

.gitattributes

@@ -223,3 +223,15 @@ task1_hdf5/20251107_multiview_task1_S1_43_1_episode_4_merged.hdf5 filter=lfs dif
 task1_hdf5/20251107_multiview_task1_S1_43_1_episode_2_merged.hdf5 filter=lfs diff=lfs merge=lfs -text
 task1_hdf5/20251107_multiview_task1_S1_43_1_episode_1_merged.hdf5 filter=lfs diff=lfs merge=lfs -text
 task1_hdf5/20251107_multiview_task1_S1_43_1_episode_3_merged.hdf5 filter=lfs diff=lfs merge=lfs -text
+code/nohup.out filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/assets/scenes/coffee_table_seats/collision/coffee_table_seats_ch.stl filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/assets/scenes/floor_lamp/collision/floor_lamp_ch.stl filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/assets/scenes/kitchen_background_pot/collision/kitchen_background_pot_ch.stl filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/assets/scenes/living_room_table/collision/living_room_table_ch.stl filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_10/LIVING_ROOM_SCENE2_put_both_the_alphabet_soup_and_the_tomato_sauce_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_10/LIVING_ROOM_SCENE2_put_both_the_cream_cheese_box_and_the_butter_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_90/LIVING_ROOM_SCENE2_pick_up_the_alphabet_soup_and_put_it_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_90/LIVING_ROOM_SCENE2_pick_up_the_butter_and_put_it_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_90/LIVING_ROOM_SCENE2_pick_up_the_milk_and_put_it_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_90/LIVING_ROOM_SCENE2_pick_up_the_orange_juice_and_put_it_in_the_basket.init filter=lfs diff=lfs merge=lfs -text
+code/unified_video_action/env/libero/init_files/libero_90/LIVING_ROOM_SCENE2_pick_up_the_tomato_sauce_and_put_it_in_the_basket.init filter=lfs diff=lfs merge=lfs -text

code/batch_test_views.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# 批量测试六个视角的shell脚本
+# 基于eval.sh，只是加了循环和view_key参数
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan5frame/train_2025-10-30T18-50-53/checkpoint-30000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/singleview/train_2025-10-29T04-42-47/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-40000
+export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan13frame_continue/train_2025-11-02T19-43-17/checkpoint-60000
+
+export GLOBAL_FRAME_NUM=13
+# 定义要测试的视角列表
+VIEW_KEYS=( "agentview_330_image"  "agentview_350_image" "agentview_30_image" "agentview_10_image")
+
+
+# 遍历每个视角进行测试
+for view_key in "${VIEW_KEYS[@]}"; do
+    echo "正在测试视角: ${view_key}"
+    CUDA_VISIBLE_DEVICES=1 python eval_sim.py \
+        --checkpoint /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/checkpoints/epoch=0022-test_mean_score=0.840.ckpt \
+        --output_dir /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/eval_epoch22/${view_key} \
+        --view-key ${view_key}
+    echo "------------------------------------------"
+done
+
+

code/batch_test_views2.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# 批量测试六个视角的shell脚本
+# 基于eval.sh，只是加了循环和view_key参数
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan5frame/train_2025-10-30T18-50-53/checkpoint-30000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/singleview/train_2025-10-29T04-42-47/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-40000
+export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan13frame_continue/train_2025-11-02T19-43-17/checkpoint-60000
+export GLOBAL_FRAME_NUM=13
+# 定义要测试的视角列表
+VIEW_KEYS=( "agentview_320_image"  "agentview_340_image" "agentview_40_image" "agentview_20_image" "agentview_image")
+
+
+# 遍历每个视角进行测试
+for view_key in "${VIEW_KEYS[@]}"; do
+    echo "正在测试视角: ${view_key}"
+    CUDA_VISIBLE_DEVICES=1 python eval_sim.py \
+        --checkpoint /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/checkpoints/epoch=0022-test_mean_score=0.840.ckpt\
+        --output_dir /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/eval_epoch22/${view_key} \
+        --view-key ${view_key}
+    echo "------------------------------------------"
+done
+
+

code/batch_test_views3.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# 批量测试六个视角的shell脚本
+# 基于eval.sh，只是加了循环和view_key参数
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan5frame/train_2025-10-30T18-50-53/checkpoint-30000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/singleview/train_2025-10-29T04-42-47/checkpoint-20000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-40000
+export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan13frame_continue/train_2025-11-02T19-43-17/checkpoint-60000
+
+export GLOBAL_FRAME_NUM=13
+# 定义要测试的视角列表
+VIEW_KEYS=( "agentview_320_image"  "agentview_340_image" "agentview_40_image" "agentview_20_image" "agentview_image" )
+
+
+# 遍历每个视角进行测试
+for view_key in "${VIEW_KEYS[@]}"; do
+    echo "正在测试视角: ${view_key}"
+    CUDA_VISIBLE_DEVICES=0 python eval_sim.py \
+        --checkpoint /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/checkpoints/epoch=0022-test_mean_score=0.840.ckpt \
+        --output_dir /data/user/jfeng644/code/manires/final_continue13frame_ckpt60_areg/eval_epoch22/${view_key} \
+        --view-key ${view_key}
+    echo "------------------------------------------"
+done
+
+

code/eval.sh

@@ -0,0 +1,8 @@
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+# python /hpc2hdd/home/jfeng644/anaconda3/envs/uva/lib/python3.9/site-packages/robosuite/scripts/setup_macros.py
+CUDA_VISIBLE_DEVICES=0 python eval_sim.py --checkpoint /data/user/jfeng644/code/unified_video_action/vpp_multiviewtrain_ell_4gpu/checkpoints/epoch=0024-test_mean_score=0.667.ckpt --output_dir /data/user/jfeng644/code/unified_video_action/vpp_multiviewtrain_ell_4gpu/eval_epoch24

code/eval_real.py

@@ -0,0 +1,214 @@
+import sys
+import os
+import time
+import click
+import numpy as np
+import torch
+import dill
+import hydra
+import zmq
+
+
+from unified_video_action.policy.base_image_policy import BaseImagePolicy
+from unified_video_action.workspace.base_workspace import BaseWorkspace
+from umi.real_world.real_inference_util import (
+    get_real_obs_resolution,
+    get_real_umi_action,
+)
+from unified_video_action.common.pytorch_util import dict_apply
+import omegaconf
+import traceback
+import pickle
+from omegaconf import open_dict
+
+language_latents = pickle.load(open("prepared_data/language_latents.pkl", "rb"))
+import torch
+import torch.nn.functional as F
+
+
+def echo_exception():
+    exc_type, exc_value, exc_traceback = sys.exc_info()
+    # Extract unformatted traceback
+    tb_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
+    # Print line of code where the exception occurred
+
+    return "".join(tb_lines)
+
+def smooth_action(act_out, window_size=3, pad_size=1):
+    # Define the moving average kernel
+    kernel = torch.ones(1, 1, window_size) / window_size  # 1x1x3 kernel
+    kernel = kernel.to(act_out.device)  # Match device of the input tensor
+
+    # Apply convolution with padding to preserve the sequence length
+    # Unsqueeze the last dimension for convolution along the time axis
+    print(act_out.shape)
+    act_out_padded = F.pad(act_out, (0, 0, pad_size, pad_size), mode="replicate")
+
+    batch_size, timesteps, action_dim = act_out_padded.shape
+    act_out_padded = act_out_padded.permute(
+        0, 2, 1
+    )  # Shape: [batch_size, action_dim, timesteps]
+    act_out_padded = act_out_padded.reshape(
+        -1, 1, timesteps
+    )  # Combine batch and action_dim
+
+    smoothed_act_out = F.conv1d(act_out_padded, kernel, padding=0)
+
+    smoothed_act_out = smoothed_act_out.reshape(
+        batch_size, action_dim, timesteps - 2 * pad_size
+    )
+    smoothed_act_out = smoothed_act_out.permute(
+        0, 2, 1
+    )  # Shape: [batch_size, timesteps, action_dim]
+
+    return smoothed_act_out
+
+class PolicyInferenceNode:
+    def __init__(
+        self, ckpt_path: str, ip: str, port: int, device: str, output_dir: str
+    ):
+        self.ckpt_path = ckpt_path
+        if not self.ckpt_path.endswith(".ckpt"):
+            self.ckpt_path = os.path.join(self.ckpt_path, "checkpoints", "latest.ckpt")
+        payload = torch.load(
+            open(self.ckpt_path, "rb"), map_location="cpu", pickle_module=dill
+        )
+        self.cfg = payload["cfg"]
+
+        
+        with open_dict(self.cfg):
+            if "autoregressive_model_params" in self.cfg.model.policy:
+                self.cfg.model.policy.autoregressive_model_params.num_sampling_steps = (
+                    "100"
+                )
+                print("-----------------------------------------------")
+                print(
+                    "num_sampling_steps",
+                    self.cfg.model.policy.autoregressive_model_params.num_sampling_steps,
+                )
+                print("-----------------------------------------------")
+        
+        # export cfg to yaml
+        cfg_path = self.ckpt_path.replace(".ckpt", ".yaml")
+        with open(cfg_path, "w") as f:
+            f.write(omegaconf.OmegaConf.to_yaml(self.cfg))
+            print(f"Exported config to {cfg_path}")
+        # print(f"Loading configure: {self.cfg.name}, workspace: {self.cfg._target_}, policy: {self.cfg.policy._target_}, model_name: {self.cfg.policy.obs_encoder.model_name}")
+        print(
+            f"Loading configure: {self.cfg.task.name}, workspace: {self.cfg.model._target_}, policy: {self.cfg.model.policy._target_}"
+        )
+
+        self.obs_res = get_real_obs_resolution(self.cfg.task.shape_meta)
+        self.get_class_start_time = time.monotonic()
+
+        cls = hydra.utils.get_class(self.cfg.model._target_)
+        self.workspace = cls(self.cfg, output_dir=output_dir)
+        self.workspace: BaseWorkspace
+        self.workspace.load_payload(payload, exclude_keys=None, include_keys=None)
+
+        self.policy: BaseImagePolicy = self.workspace.model
+
+
+        if self.cfg.training.use_ema:
+            self.policy = self.workspace.ema_model
+            print("Using EMA model")
+
+        self.device = torch.device(device)
+        self.policy.eval().to(self.device)
+        self.policy.reset()
+        self.ip = ip
+        self.port = port
+
+    def predict_action(self, obs_dict_np: dict, past_action_list=[]):
+
+        if "task_name" in obs_dict_np:
+            task_name = obs_dict_np["task_name"]
+            print("task_name", obs_dict_np["task_name"])
+            del obs_dict_np["task_name"]
+
+        if self.cfg.task.dataset.language_emb_model is not None:
+            if "cup" in task_name:
+                language_goal = language_latents["cup"]
+            elif "towel" in task_name:
+                language_goal = language_latents["towel"]
+            elif "mouse" in task_name:
+                language_goal = language_latents["mouse"]
+            language_goal = torch.tensor(language_goal).to(self.device)
+            language_goal = language_goal.unsqueeze(0)
+            print("task_name", task_name)
+        else:
+            language_goal = None
+
+        
+        with torch.no_grad():
+            obs_dict = dict_apply(
+                obs_dict_np, lambda x: torch.from_numpy(x).unsqueeze(0).to(self.device)
+            )
+
+            
+            if self.cfg.name == "uva":
+                result = self.policy.predict_action(
+                    obs_dict=obs_dict, language_goal=language_goal
+                )
+
+                past_action_list.append(np.array(result["action"][0].cpu()))
+                if len(past_action_list) > 2:
+                    past_action_list.pop(0)
+                action = smooth_action(result["action_pred"].detach().to("cpu")).numpy()[0]
+                
+
+            else:
+                result = self.policy.predict_action(
+                    obs_dict, language_goal=language_goal
+                )
+                action = result["action_pred"][0].detach().to("cpu").numpy()
+                print("action")
+
+            
+
+            del result
+            del obs_dict
+
+        return action, past_action_list
+
+    def run_node(self):
+        context = zmq.Context()
+        socket = context.socket(zmq.REP)
+        socket.bind(f"tcp://{self.ip}:{self.port}")
+        print(f"PolicyInferenceNode is listening on {self.ip}:{self.port}")
+
+        past_action_list = []
+        while True:
+            obs_dict_np = socket.recv_pyobj()
+
+            try:
+                start_time = time.monotonic()
+                action, past_action_list = self.predict_action(
+                    obs_dict_np, past_action_list
+                )
+                print(f"Inference time: {time.monotonic() - start_time:.3f} s")
+
+            except Exception as e:
+                err_str = echo_exception()
+                print(f"Error: {err_str}")
+                action = err_str
+            send_start_time = time.monotonic()
+            # time.sleep(0.1)
+            socket.send_pyobj(action)
+            print(f"Send time: {time.monotonic() - send_start_time:.3f} s")
+
+
+@click.command()
+@click.option("--input", "-i", required=True, help="Path to checkpoint")
+@click.option("--ip", default="0.0.0.0")
+@click.option("--port", default=8766, help="Port to listen on")
+@click.option("--device", default="cuda", help="Device to run on")
+@click.option("--output_dir", required=True)
+def main(input, ip, port, device, output_dir):
+
+    node = PolicyInferenceNode(input, ip, port, device, output_dir)
+    node.run_node()
+
+
+if __name__ == "__main__":
+    main()

code/eval_real_ws.py

@@ -0,0 +1,188 @@
+import sys
+import os
+import time
+import json
+import asyncio
+import pickle
+
+import click
+import numpy as np
+import torch
+import dill
+import hydra
+import omegaconf
+import traceback
+from omegaconf import open_dict
+
+from unified_video_action.policy.base_image_policy import BaseImagePolicy
+from unified_video_action.workspace.base_workspace import BaseWorkspace
+from unified_video_action.common.pytorch_util import dict_apply
+from umi.real_world.real_inference_util import get_real_obs_resolution
+
+import torch.nn.functional as F
+import websockets
+
+language_latents = pickle.load(open("prepared_data/language_latents.pkl", "rb"))
+
+
+def echo_exception():
+    exc_type, exc_value, exc_traceback = sys.exc_info()
+    tb_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
+    return "".join(tb_lines)
+
+
+def smooth_action(act_out, window_size=3, pad_size=1):
+    kernel = torch.ones(1, 1, window_size) / window_size
+    kernel = kernel.to(act_out.device)
+
+    act_out_padded = F.pad(act_out, (0, 0, pad_size, pad_size), mode="replicate")
+
+    batch_size, timesteps, action_dim = act_out_padded.shape
+    act_out_padded = act_out_padded.permute(0, 2, 1)
+    act_out_padded = act_out_padded.reshape(-1, 1, timesteps)
+
+    smoothed_act_out = F.conv1d(act_out_padded, kernel, padding=0)
+
+    smoothed_act_out = smoothed_act_out.reshape(batch_size, action_dim, timesteps - 2 * pad_size)
+    smoothed_act_out = smoothed_act_out.permute(0, 2, 1)
+
+    return smoothed_act_out
+
+
+class PolicyInferenceNode:
+    def __init__(self, ckpt_path: str, ip: str, port: int, device: str, output_dir: str):
+        self.ckpt_path = ckpt_path
+        if not self.ckpt_path.endswith(".ckpt"):
+            self.ckpt_path = os.path.join(self.ckpt_path, "checkpoints", "latest.ckpt")
+        payload = torch.load(open(self.ckpt_path, "rb"), map_location="cpu", pickle_module=dill)
+        self.cfg = payload["cfg"]
+
+        with open_dict(self.cfg):
+            if "autoregressive_model_params" in self.cfg.model.policy:
+                self.cfg.model.policy.autoregressive_model_params.num_sampling_steps = "100"
+                print("-----------------------------------------------")
+                print(
+                    "num_sampling_steps",
+                    self.cfg.model.policy.autoregressive_model_params.num_sampling_steps,
+                )
+                print("-----------------------------------------------")
+
+        cfg_path = self.ckpt_path.replace(".ckpt", ".yaml")
+        with open(cfg_path, "w") as f:
+            f.write(omegaconf.OmegaConf.to_yaml(self.cfg))
+            print(f"Exported config to {cfg_path}")
+        print(
+            f"Loading configure: {self.cfg.task.name}, workspace: {self.cfg.model._target_}, policy: {self.cfg.model.policy._target_}"
+        )
+
+        self.obs_res = get_real_obs_resolution(self.cfg.task.shape_meta)
+
+        cls = hydra.utils.get_class(self.cfg.model._target_)
+        self.workspace = cls(self.cfg, output_dir=output_dir)
+        self.workspace: BaseWorkspace
+        self.workspace.load_payload(payload, exclude_keys=None, include_keys=None)
+
+        self.policy: BaseImagePolicy = self.workspace.model
+
+        if self.cfg.training.use_ema:
+            self.policy = self.workspace.ema_model
+            print("Using EMA model")
+
+        self.device = torch.device(device)
+        self.policy.eval().to(self.device)
+        self.policy.reset()
+        self.ip = ip
+        self.port = port
+
+    def _prepare_language_goal(self, task_name: str):
+        if self.cfg.task.dataset.language_emb_model is None:
+            return None
+
+        key = None
+        if task_name is None:
+            return None
+        for candidate in ["cup", "towel", "mouse"]:
+            if candidate in task_name:
+                key = candidate
+                break
+        if key is None:
+            return None
+        language_goal = language_latents.get(key)
+        if language_goal is None:
+            return None
+        language_goal = torch.tensor(language_goal).to(self.device).unsqueeze(0)
+        return language_goal
+
+    def predict_action(self, obs_dict_np: dict, past_action_list=None):
+        if past_action_list is None:
+            past_action_list = []
+
+        task_name = obs_dict_np.pop("task_name", None)
+        language_goal = self._prepare_language_goal(task_name)
+
+        with torch.no_grad():
+            obs_dict = dict_apply(
+                obs_dict_np, lambda x: torch.from_numpy(x).unsqueeze(0).to(self.device)
+            )
+
+            if self.cfg.name == "uva":
+                result = self.policy.predict_action(obs_dict=obs_dict, language_goal=language_goal)
+                past_action_list.append(np.array(result["action"][0].cpu()))
+                if len(past_action_list) > 2:
+                    past_action_list.pop(0)
+                action = smooth_action(result["action_pred"].detach().to("cpu")).numpy()[0]
+            else:
+                result = self.policy.predict_action(obs_dict, language_goal=language_goal)
+                action = result["action_pred"][0].detach().to("cpu").numpy()
+
+            del result
+            del obs_dict
+
+        return action, past_action_list
+
+    async def _handle_connection(self, websocket):
+        past_action_list = []
+        async for message in websocket:
+            try:
+                request = json.loads(message)
+                payload = request.get("body", request.get("data", request))
+                if isinstance(payload, str):
+                    payload = json.loads(payload)
+                if not isinstance(payload, dict):
+                    raise ValueError("Parsed payload is not a dict")
+
+                start_time = time.monotonic()
+                action, past_action_list = self.predict_action(payload, past_action_list)
+                elapsed = time.monotonic() - start_time
+
+                response = {
+                    "status": "ok",
+                    "action": action.tolist(),
+                    "inference_time": elapsed,
+                }
+            except Exception:
+                err_str = echo_exception()
+                response = {"status": "error", "error": err_str}
+
+            await websocket.send(json.dumps(response))
+
+    async def run_node(self):
+        print(f"PolicyInferenceNode WebSocket listening on {self.ip}:{self.port}")
+        async with websockets.serve(self._handle_connection, self.ip, self.port):
+            await asyncio.Future()  # run forever
+
+
+@click.command()
+@click.option("--input", "-i", required=True, help="Path to checkpoint")
+@click.option("--ip", default="0.0.0.0")
+@click.option("--port", default=8766, help="Port to listen on")
+@click.option("--device", default="cuda", help="Device to run on")
+@click.option("--output_dir", required=True)
+def main(input, ip, port, device, output_dir):
+    node = PolicyInferenceNode(input, ip, port, device, output_dir)
+    asyncio.run(node.run_node())
+
+
+if __name__ == "__main__":
+    main()
+

code/eval_sim.py

@@ -0,0 +1,129 @@
+import sys
+
+sys.stdout = open(sys.stdout.fileno(), mode="w", buffering=1)
+sys.stderr = open(sys.stderr.fileno(), mode="w", buffering=1)
+import numpy as np
+import os
+import pathlib
+import click
+import hydra
+import torch
+import dill
+import wandb
+import json
+import random
+from omegaconf import open_dict, OmegaConf
+# os.environ["LD_LIBRARY_PATH"] = "/hpc2hdd/home/jfeng644/.mujoco/mujoco210/bin:/usr/lib/nvidia:" + os.environ.get("LD_LIBRARY_PATH", "") 
+from unified_video_action.workspace.base_workspace import BaseWorkspace
+from unified_video_action.utils.load_env import load_env_runner
+
+
+@click.command()
+@click.option("-c", "--checkpoint", required=True)
+@click.option("-o", "--output_dir", required=True)
+@click.option("-d", "--device", default="cuda:0")
+@click.option("--config-override", default='unified_video_action/config/task/libero10.yaml', help="Path to additional config file to override settings")
+@click.option("--view-key", default="agentview_340_image", help="View key for testing")
+def main(checkpoint, output_dir, device, config_override, view_key):
+
+    pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+    # load checkpoint
+    payload = torch.load(open(checkpoint, "rb"), pickle_module=dill)
+    cfg = payload["cfg"]
+
+    # # Update config with additional config file if provided
+    # if config_override is not None:
+    #     override_cfg = OmegaConf.load(config_override)
+        
+    #     # 确保task键存在，如果不存在就创建
+    #     if 'task' not in cfg:
+    #         cfg['task'] = OmegaConf.create({})
+        
+    #     # 递归地确保所有嵌套键都存在
+    #     def ensure_keys_exist(base_cfg, override_cfg):
+    #         for key, value in override_cfg.items():
+    #             if key not in base_cfg:
+    #                 base_cfg[key] = OmegaConf.create({})
+                
+    #             if isinstance(value, dict) and isinstance(base_cfg[key], dict):
+    #                 ensure_keys_exist(base_cfg[key], value)
+    #             else:
+    #                 base_cfg[key] = value
+        
+    #     ensure_keys_exist(cfg['task'], override_cfg)
+    #     ensure_keys_exist(cfg['model']['policy']['shape_meta'], override_cfg['shape_meta'])
+    #     print(f"Updated config with override file: {config_override}")
+    # config_2 = 'unified_video_action/config/vpp_libero10.yaml'
+    # override_cfg = OmegaConf.load(config_2)
+    # del override_cfg['defaults']
+    # ensure_keys_exist(cfg, override_cfg)
+
+    # config_3 = 'unified_video_action/config/model/vpp.yaml'
+    # override_cfg = OmegaConf.load(config_3)
+    # ensure_keys_exist(cfg['model'], override_cfg)
+    # print(f"Updated config with override file: {config_3}")
+    # print(f"Updated config with override file: {config_2}")
+    # set seed
+    seed = cfg.training.seed
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+
+    with open_dict(cfg):
+        cfg.output_dir = output_dir
+        # 设置view_key参数
+        cfg.task.env_runner.view_key = view_key
+        
+    # configure workspace
+    cls = hydra.utils.get_class(cfg.model._target_)
+    workspace = cls(cfg, output_dir=output_dir)
+    workspace: BaseWorkspace
+
+    print("Loaded checkpoint from %s" % checkpoint)
+    workspace.load_payload(payload, exclude_keys=None, include_keys=None)
+    
+    
+    # get policy from workspace
+    policy = workspace.ema_model
+    policy.to(device)
+    policy.eval()
+
+    env_runners = load_env_runner(cfg, output_dir)
+
+    if "libero" in cfg.task.name:
+        step_log = {}
+        for env_runner in env_runners:
+            runner_log = env_runner.run(policy)
+            step_log.update(runner_log)
+            print(step_log)
+
+        assert "test_mean_score" not in step_log
+        all_test_mean_score = {
+            k: v for k, v in step_log.items() if "test/" in k and "_mean_score" in k
+        }
+        step_log["test_mean_score"] = np.mean(list(all_test_mean_score.values()))
+
+        runner_log = step_log
+    else:
+        env_runner = env_runners
+        runner_log = env_runner.run(policy)
+
+    # dump log to json
+    json_log = dict()
+    for key, value in runner_log.items():
+        if isinstance(value, wandb.sdk.data_types.video.Video):
+            json_log[key] = value._path
+        else:
+            json_log[key] = value
+
+    for k, v in json_log.items():
+        print(k, v)
+
+    out_path = os.path.join(output_dir, f'eval_log_{checkpoint.split("/")[-1]}.json')
+    print("Saving log to %s" % out_path)
+    json.dump(json_log, open(out_path, "w"), indent=2, sort_keys=True)
+
+
+if __name__ == "__main__":
+    main()

code/msgpack_numpy.py

@@ -0,0 +1,62 @@
+
+
+"""Adds NumPy array support to msgpack.
+
+msgpack is good for (de)serializing data over a network for multiple reasons:
+- msgpack is secure (as opposed to pickle/dill/etc which allow for arbitrary code execution)
+- msgpack is widely used and has good cross-language support
+- msgpack does not require a schema (as opposed to protobuf/flatbuffers/etc) which is convenient in dynamically typed
+    languages like Python and JavaScript
+- msgpack is fast and efficient (as opposed to readable formats like JSON/YAML/etc); I found that msgpack was ~4x faster
+    than pickle for serializing large arrays using the below strategy
+
+The code below is adapted from GitHub - lebedov/msgpack-numpy: Serialize numpy arrays using msgpack. The reason not to use that library directly is
+that it falls back to pickle for object arrays.
+"""
+
+import functools
+
+import msgpack
+import numpy as np
+
+
+def pack_array(obj):
+    if (isinstance(obj, (np.ndarray, np.generic))) and obj.dtype.kind in ("V", "O", "c"):
+        raise ValueError(f"Unsupported dtype: {obj.dtype}")
+
+    if isinstance(obj, np.ndarray):
+        return {
+            b"__ndarray__": True,
+            b"data": obj.tobytes(),
+            b"dtype": obj.dtype.str,
+            b"shape": obj.shape,
+        }
+
+    if isinstance(obj, np.generic):
+        return {
+            b"__npgeneric__": True,
+            b"data": obj.item(),
+            b"dtype": obj.dtype.str,
+        }
+
+    return obj
+
+
+def unpack_array(obj):
+    if b"__ndarray__" in obj:
+        return np.ndarray(buffer=obj[b"data"], dtype=np.dtype(obj[b"dtype"]), shape=obj[b"shape"])
+
+    if b"__npgeneric__" in obj:
+        return np.dtype(obj[b"dtype"]).type(obj[b"data"])
+
+    return obj
+
+
+Packer = functools.partial(msgpack.Packer, default=pack_array)
+packb = functools.partial(msgpack.packb, default=pack_array)
+
+Unpacker = functools.partial(msgpack.Unpacker, object_hook=unpack_array)
+unpackb = functools.partial(msgpack.unpackb, object_hook=unpack_array)
+
+
+

code/nohup.out

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eaeca2f04bc98f1ee2b23467f1b027a9966e60021632905465d36f03d4a0c4e1
+size 38751283

code/run.sh

@@ -0,0 +1,33 @@
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+export MUJOCO_GL=egl
+export PYOPENGL_PLATFORM=egl
+
+
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/train_2025-10-21T03-58-20/checkpoint-64000
+export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/singleview/train_2025-10-29T04-42-47/checkpoint-30000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd/train_2025-10-03T03-11-11/checkpoint-80000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd/vppmvlibero/checkpoint-80000
+export GLOBAL_FRAME_NUM=13
+# 映射 EGL 渲染到可见 GPU：基于 CUDA_VISIBLE_DEVICES 与 LOCAL_RANK 选择物理 GPU 索引
+PREPARE_GPU=1,0
+if [ -n "$PREPARE_GPU" ]; then
+    IFS=',' read -r -a __CUDA_DEV_ARR <<< "$PREPARE_GPU"
+    __LOCAL_IDX=${LOCAL_RANK:-0}
+    export MUJOCO_EGL_DEVICE_ID=${__CUDA_DEV_ARR[$__LOCAL_IDX]}
+fi
+# python /hpc2hdd/home/jfeng644/anaconda3/envs/uva/lib/python3.9/site-packages/robosuite/scripts/setup_macros.py
+    # model.policy.autoregressive_model_params.pretrained_model_path=checkpoints/libero10.ckpt \
+# python train.py \
+CUDA_VISIBLE_DEVICES=1,0 NCCL_ASYNC_ERROR_HANDLING=1 accelerate launch --num_processes=2 --main_process_port=29512  train.py \
+    --config-dir=. \
+    --config-name=vpp_xc.yaml \
+    model.policy.action_model_params.predict_action=True \
+    model.policy.optimizer.learning_rate=1e-4 \
+    logging.project=vpp \
+    hydra.run.dir="../xcres/siglip" \
+    # model.policy.autoregressive_model_params.pretrained_model_path=checkpoints/libero10.ckpt \

code/run0.sh

@@ -0,0 +1,41 @@
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/user/jfeng644/.mujoco/mujoco210/bin  
+export PYTHONLOGLEVEL=ERROR
+export ACCELERATE_LOG_LEVEL=error
+export TRANSFORMERS_VERBOSITY=error
+export HF_DATASETS_VERBOSITY=error
+export MUJOCO_GL=egl
+export PYOPENGL_PLATFORM=egl
+
+
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/train_2025-10-21T03-58-20/checkpoint-64000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115/train_2025-10-24T01-59-16/checkpoint-48000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd/train_2025-10-03T03-11-11/checkpoint-80000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/multiview/train_2025-10-29T04-05-39/checkpoint-50000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan5frame/train_2025-10-30T18-50-53/checkpoint-30000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan/train_2025-10-30T18-21-29/checkpoint-40000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/mvwan13frame_continue/train_2025-11-02T19-43-17/checkpoint-60000
+export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115/5view/checkpoint-56000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd/vppmvlibero/checkpoint-80000
+# export STAGE1_MODEL_PATH=/data/user/jfeng644/code/vpp/output/svd3/livingellipse115move_studymove/singleview/train_2025-10-29T04-42-47/checkpoint-20000
+
+export GLOBAL_FRAME_NUM=5
+# 映射 EGL 渲染到可见 GPU：基于 CUDA_VISIBLE_DEVICES 与 LOCAL_RANK 选择物理 GPU 索引
+PREPARE_GPU=1,0
+if [ -n "$PREPARE_GPU" ]; then
+    IFS=',' read -r -a __CUDA_DEV_ARR <<< "$PREPARE_GPU"
+    __LOCAL_IDX=${LOCAL_RANK:-0}
+    export MUJOCO_EGL_DEVICE_ID=${__CUDA_DEV_ARR[$__LOCAL_IDX]}
+fi
+# python /hpc2hdd/home/jfeng644/anaconda3/envs/uva/lib/python3.9/site-packages/robosuite/scripts/setup_macros.py
+    # model.policy.autoregressive_model_params.pretrained_model_path=checkpoints/libero10.ckpt \
+# python train.py \
+# CUDA_VISIBLE_DEVICES=1,0 NCCL_ASYNC_ERROR_HANDLING=1 accelerate launch --num_processes=2 --main_process_port=29514 
+CUDA_VISIBLE_DEVICES=1,0 python train.py \
+    --config-dir=. \
+    --config-name=vpp_libero10.yaml \
+    model.policy.action_model_params.predict_action=True \
+    model.policy.optimizer.learning_rate=1e-4 \
+    logging.project=vpp \
+    hydra.run.dir="../manires/results/5frame_debug115ok_ckpt56" \
+    # model.policy.autoregressive_model_params.pretrained_model_path=checkpoints/libero10.ckpt \

code/serve_policy.py

@@ -0,0 +1,297 @@
+import dataclasses
+import enum
+import logging
+import os
+import pickle
+import socket
+import sys
+import time
+import traceback
+
+import dill
+import hydra
+import numpy as np
+import omegaconf
+import torch
+import torch.nn.functional as F
+import tyro
+
+from omegaconf import open_dict
+from openpi.policies import policy as _policy
+from openpi.policies import policy_config as _policy_config
+from openpi.serving import websocket_policy_server
+from openpi.training import config as _config
+from openpi.training.config import get_data_config
+
+from unified_video_action.common.pytorch_util import dict_apply
+from unified_video_action.policy.base_image_policy import BaseImagePolicy
+from unified_video_action.workspace.base_workspace import BaseWorkspace
+from umi.real_world.real_inference_util import get_real_obs_resolution
+
+language_latents = pickle.load(open("prepared_data/language_latents.pkl", "rb"))
+
+
+def echo_exception():
+    exc_type, exc_value, exc_traceback = sys.exc_info()
+    tb_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
+    return "".join(tb_lines)
+
+
+def smooth_action(act_out, window_size=3, pad_size=1):
+    kernel = torch.ones(1, 1, window_size) / window_size
+    kernel = kernel.to(act_out.device)
+
+    act_out_padded = F.pad(act_out, (0, 0, pad_size, pad_size), mode="replicate")
+
+    batch_size, timesteps, action_dim = act_out_padded.shape
+    act_out_padded = act_out_padded.permute(0, 2, 1)
+    act_out_padded = act_out_padded.reshape(-1, 1, timesteps)
+
+    smoothed_act_out = F.conv1d(act_out_padded, kernel, padding=0)
+
+    smoothed_act_out = smoothed_act_out.reshape(batch_size, action_dim, timesteps - 2 * pad_size)
+    smoothed_act_out = smoothed_act_out.permute(0, 2, 1)
+
+    return smoothed_act_out
+
+
+class EvalRealPolicyAdapter:
+    """Adapter to wrap eval_real.py PolicyInferenceNode as a Policy interface."""
+
+    def __init__(self, ckpt_path: str, device: str, output_dir: str):
+        self.ckpt_path = ckpt_path
+        if not self.ckpt_path.endswith(".ckpt"):
+            self.ckpt_path = os.path.join(self.ckpt_path, "checkpoints", "latest.ckpt")
+        
+        payload = torch.load(open(self.ckpt_path, "rb"), map_location="cpu", pickle_module=dill)
+        self.cfg = payload["cfg"]
+
+        with open_dict(self.cfg):
+            if "autoregressive_model_params" in self.cfg.model.policy:
+                self.cfg.model.policy.autoregressive_model_params.num_sampling_steps = "100"
+                print("-----------------------------------------------")
+                print("num_sampling_steps", self.cfg.model.policy.autoregressive_model_params.num_sampling_steps)
+                print("-----------------------------------------------")
+
+        cfg_path = self.ckpt_path.replace(".ckpt", ".yaml")
+        with open(cfg_path, "w") as f:
+            f.write(omegaconf.OmegaConf.to_yaml(self.cfg))
+            print(f"Exported config to {cfg_path}")
+        
+        print(f"Loading configure: {self.cfg.task.name}, workspace: {self.cfg.model._target_}, policy: {self.cfg.model.policy._target_}")
+
+        self.obs_res = get_real_obs_resolution(self.cfg.task.shape_meta)
+        self.device = torch.device(device)
+
+        cls = hydra.utils.get_class(self.cfg.model._target_)
+        self.workspace = cls(self.cfg, output_dir=output_dir)
+        self.workspace: BaseWorkspace
+        self.workspace.load_payload(payload, exclude_keys=None, include_keys=None)
+
+        self.policy: BaseImagePolicy = self.workspace.model
+
+        if self.cfg.training.use_ema:
+            self.policy = self.workspace.ema_model
+            print("Using EMA model")
+
+        self.policy.eval().to(self.device)
+        self.policy.reset()
+        
+        # Note: past_action_list is shared across connections, but since WebSocket
+        # processing is sequential per connection, this should work in practice
+        self.past_action_list = []
+        self._metadata = {"obs_resolution": self.obs_res}
+
+    @property
+    def metadata(self):
+        return self._metadata
+
+    def infer(self, obs: dict) -> dict:
+        """Infer action from observation. Returns dict with 'actions' key."""
+        obs_dict_np = obs.copy()
+        task_name = None
+
+        if "task_name" in obs_dict_np:
+            task_name = obs_dict_np["task_name"]
+            print("task_name", obs_dict_np["task_name"])
+            del obs_dict_np["task_name"]
+
+        if self.cfg.task.dataset.language_emb_model is not None and task_name:
+            if "cup" in task_name:
+                language_goal = language_latents["cup"]
+            elif "towel" in task_name:
+                language_goal = language_latents["towel"]
+            elif "mouse" in task_name:
+                language_goal = language_latents["mouse"]
+            else:
+                language_goal = None
+            if language_goal is not None:
+                language_goal = torch.tensor(language_goal).to(self.device)
+                language_goal = language_goal.unsqueeze(0)
+                print("task_name", task_name)
+        else:
+            language_goal = None
+
+        with torch.no_grad():
+            obs_dict = dict_apply(
+                obs_dict_np, lambda x: torch.from_numpy(x).unsqueeze(0).to(self.device)
+            )
+
+            if self.cfg.name == "uva":
+                result = self.policy.predict_action(
+                    obs_dict=obs_dict, language_goal=language_goal
+                )
+
+                self.past_action_list.append(np.array(result["action"][0].cpu()))
+                if len(self.past_action_list) > 2:
+                    self.past_action_list.pop(0)
+                action = smooth_action(result["action_pred"].detach().to("cpu")).numpy()[0]
+            else:
+                result = self.policy.predict_action(
+                    obs_dict, language_goal=language_goal
+                )
+                action = result["action_pred"][0].detach().to("cpu").numpy()
+                print("action")
+
+            del result
+            del obs_dict
+
+        return {"actions": action}
+
+class EnvMode(enum.Enum):
+    """Supported environments."""
+
+    ALOHA = "aloha"
+    ALOHA_SIM = "aloha_sim"
+    DROID = "droid"
+    LIBERO = "libero"
+
+    REAL = "real"
+
+
+@dataclasses.dataclass
+class Checkpoint:
+    """Load a policy from a trained checkpoint."""
+
+    # Training config name (e.g., "pi0_aloha_sim").
+    data_config: str
+    # Checkpoint directory (e.g., "checkpoints/pi0_aloha_sim/exp/10000").
+    dir: str | None = None
+
+
+@dataclasses.dataclass
+class EvalRealCheckpoint:
+    """Load a policy from eval_real.py style checkpoint."""
+
+    # Checkpoint path (directory or .ckpt file).
+    dir: str
+    # Device to run on.
+    device: str = "cuda"
+    # Output directory.
+    output_dir: str = "."
+
+
+@dataclasses.dataclass
+class Default:
+    """Use the default policy for the given environment."""
+
+
+@dataclasses.dataclass
+class Args:
+    """Arguments for the serve_policy script."""
+
+    # Environment to serve the policy for. This is only used when serving default policies.
+    env: EnvMode = EnvMode.ALOHA_SIM
+
+    # If provided, will be used in case the "prompt" key is not present in the data, or if the model doesn't have a default
+    # prompt.
+    default_prompt: str | None = None
+
+    # Port to serve the policy on.
+    port: int = 8012
+    # Record the policy's behavior for debugging.
+    record: bool = False
+
+    # Specifies how to load the policy. If not provided, the default policy for the environment will be used.
+    policy: Checkpoint | EvalRealCheckpoint | Default = dataclasses.field(default_factory=Default)
+    
+    # use_vllm: bool = False
+
+
+# Default checkpoints that should be used for each environment.
+# DEFAULT_CHECKPOINT: dict[EnvMode, Checkpoint] = {
+#     EnvMode.ALOHA: Checkpoint(
+#         config="pi0_aloha",
+#         dir="s3://openpi-assets/checkpoints/pi0_base",
+#     ),
+#     EnvMode.ALOHA_SIM: Checkpoint(
+#         config="pi0_aloha_sim",
+#         dir="s3://openpi-assets/checkpoints/pi0_aloha_sim",
+#     ),
+#     EnvMode.DROID: Checkpoint(
+#         config="pi0_fast_droid",
+#         dir="s3://openpi-assets/checkpoints/pi0_fast_droid",
+#     ),
+#     EnvMode.LIBERO: Checkpoint(
+#         config="pi0_fast_libero",
+#         dir="s3://openpi-assets/checkpoints/pi0_fast_libero",
+#     ),
+# }
+
+# def create_default_policy(env: EnvMode, *, default_prompt: str | None = None) -> _policy.Policy:
+#     """Create a default policy for the given environment."""
+#     if checkpoint := DEFAULT_CHECKPOINT.get(env):
+#         return _policy_config.create_trained_policy(
+#             _config.get_config(checkpoint.config), checkpoint.dir, default_prompt=default_prompt
+#         )
+#     raise ValueError(f"Unsupported environment mode: {env}")
+
+
+def create_policy(args: Args):
+    """Create a policy from the given arguments."""
+    match args.policy:
+        case EvalRealCheckpoint():
+            return EvalRealPolicyAdapter(
+                ckpt_path=args.policy.dir,
+                device=args.policy.device,
+                output_dir=args.policy.output_dir,
+            )
+        case Checkpoint():
+            import pathlib
+            import openpi.shared.normalize as _normalize
+            # _train_config = _config.get_config(args.policy.config)
+            _data_config: _config.DataConfig = get_data_config(args.policy.data_config)
+            norm_stats = _data_config.norm_stats            
+            return _policy_config.create_trained_policy(
+                _data_config, args.policy.dir, default_prompt=args.default_prompt, norm_stats=norm_stats, use_vllm=_data_config.inference_use_vllm
+            )
+        case Default():
+            raise NotImplementedError("Default policies are not yet supported.")
+            # return create_default_policy(args.env, default_prompt=args.default_prompt)
+
+
+
+def main(args: Args) -> None:
+    policy = create_policy(args)
+    policy_metadata = policy.metadata
+
+    # Record the policy's behavior.
+    if args.record:
+        policy = _policy.PolicyRecorder(policy, "policy_records")
+
+    # hostname = socket.gethostname()
+    # local_ip = socket.gethostbyname(hostname)
+    # logging.info("Creating server (host: %s, ip: %s)", hostname, local_ip)
+
+    server = websocket_policy_server.WebsocketPolicyServer(
+        policy=policy,
+        host="0.0.0.0",
+        port=args.port,
+        metadata=policy_metadata,
+    )
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, force=True)
+    main(tyro.cli(Args))

code/setup.py

@@ -0,0 +1,6 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="unified_video_action",
+    packages=find_packages(),
+)

code/train.py

@@ -0,0 +1,68 @@
+"""
+Usage:
+Training:
+python train.py --config-name=train_diffusion_lowdim_workspace
+"""
+
+import torch
+import os
+import sys
+import hydra
+from omegaconf import OmegaConf
+import pathlib
+from unified_video_action.workspace.base_workspace import BaseWorkspace
+from omegaconf import open_dict
+
+# allows arbitrary python code execution in configs using the ${eval:''} resolver
+OmegaConf.register_new_resolver("eval", eval, replace=True)
+
+
+import wandb
+
+if "WANDB_API_KEY" in os.environ:
+    wandb.login(key=os.environ["WANDB_API_KEY"])
+
+
+@hydra.main(
+    version_base=None,
+    config_path=str(
+        pathlib.Path(__file__).parent.joinpath("unified_video_action", "config")
+    ),
+)
+def main(cfg: OmegaConf):
+    OmegaConf.resolve(cfg)
+
+    if cfg.model.policy.action_model_params.predict_action == False:
+        cfg.checkpoint.topk.monitor_key = "video_fvd"
+        cfg.checkpoint.topk.format_str = (
+            "epoch={epoch:04d}-video_fvd={video_fvd:.3f}.ckpt"
+        )
+        cfg.checkpoint.topk.mode = "min"
+
+    with open_dict(cfg):
+        cfg.n_gpus = torch.cuda.device_count()
+        cfg.model.policy.debug = cfg.training.debug
+
+    if cfg.training.debug:
+        cfg.dataloader.batch_size = 2
+        cfg.val_dataloader.batch_size = 2
+        cfg.dataloader.shuffle = False
+        cfg.val_dataloader.shuffle = False
+
+        if "env_runner" in cfg.task:
+            cfg.task.env_runner.max_steps = 20
+
+        if "dataloader_cfg" in cfg.task.dataset:
+            cfg.task.dataset.dataloader_cfg.batch_size = 2
+
+    cls = hydra.utils.get_class(cfg.model._target_)
+    workspace: BaseWorkspace = cls(cfg)
+    workspace.run()
+
+
+if __name__ == "__main__":
+    print(sys.argv)
+    for arg in sys.argv:
+        if "local_rank" in arg:  # For deepspeed compatibility
+            sys.argv.remove(arg)
+    main()

code/umi/asset/mask.json

@@ -0,0 +1,17 @@
+{
+    "mirror_mask_pts":[
+        [540, 1700],
+        [680, 1450],
+        [590, 1070],
+        [290, 1130],
+        [290, 1770],
+        [550, 1770]
+    ],
+    "gripper_mask_pts": [
+        [1100, 1700],
+        [650, 1500],
+        [0, 1350],
+        [520, 2028]
+    ],
+    "resolution": [2028, 2704]
+}

code/umi/common/cv_util.py

@@ -0,0 +1,461 @@
+from typing import Dict, Tuple
+
+import json
+import pathlib
+import math
+import copy
+import numpy as np
+import cv2
+import scipy.interpolate as si
+
+# =================== intrinsics ===================
+
+
+def parse_fisheye_intrinsics(json_data: dict) -> Dict[str, np.ndarray]:
+    """
+    Reads camera intrinsics from OpenCameraImuCalibration to opencv format.
+    Example:
+    {
+        "final_reproj_error": 0.17053819312281043,
+        "fps": 60.0,
+        "image_height": 1080,
+        "image_width": 1920,
+        "intrinsic_type": "FISHEYE",
+        "intrinsics": {
+            "aspect_ratio": 1.0026582765352035,
+            "focal_length": 420.56809123853304,
+            "principal_pt_x": 959.857586309181,
+            "principal_pt_y": 542.8155851051391,
+            "radial_distortion_1": -0.011968137016185161,
+            "radial_distortion_2": -0.03929790706019372,
+            "radial_distortion_3": 0.018577224235396064,
+            "radial_distortion_4": -0.005075629959840777,
+            "skew": 0.0
+        },
+        "nr_calib_images": 129,
+        "stabelized": false
+    }
+    """
+    assert json_data["intrinsic_type"] == "FISHEYE"
+    intr_data = json_data["intrinsics"]
+
+    # img size
+    h = json_data["image_height"]
+    w = json_data["image_width"]
+
+    # pinhole parameters
+    f = intr_data["focal_length"]
+    px = intr_data["principal_pt_x"]
+    py = intr_data["principal_pt_y"]
+
+    # Kannala-Brandt non-linear parameters for distortion
+    kb8 = [
+        intr_data["radial_distortion_1"],
+        intr_data["radial_distortion_2"],
+        intr_data["radial_distortion_3"],
+        intr_data["radial_distortion_4"],
+    ]
+
+    opencv_intr_dict = {
+        "DIM": np.array([w, h], dtype=np.int64),
+        "K": np.array([[f, 0, px], [0, f, py], [0, 0, 1]], dtype=np.float64),
+        "D": np.array([kb8]).T,
+    }
+    return opencv_intr_dict
+
+
+def convert_fisheye_intrinsics_resolution(
+    opencv_intr_dict: Dict[str, np.ndarray], target_resolution: Tuple[int, int]
+) -> Dict[str, np.ndarray]:
+    """
+    Convert fisheye intrinsics parameter to a different resolution,
+    assuming that images are not cropped in the vertical dimension,
+    and only symmetrically cropped/padded in horizontal dimension.
+    """
+    iw, ih = opencv_intr_dict["DIM"]
+    iK = opencv_intr_dict["K"]
+    ifx = iK[0, 0]
+    ify = iK[1, 1]
+    ipx = iK[0, 2]
+    ipy = iK[1, 2]
+
+    ow, oh = target_resolution
+    ofx = ifx / ih * oh
+    ofy = ify / ih * oh
+    opx = (ipx - (iw / 2)) / ih * oh + (ow / 2)
+    opy = ipy / ih * oh
+    oK = np.array([[ofx, 0, opx], [0, ofy, opy], [0, 0, 1]], dtype=np.float64)
+
+    out_intr_dict = copy.deepcopy(opencv_intr_dict)
+    out_intr_dict["DIM"] = np.array([ow, oh], dtype=np.int64)
+    out_intr_dict["K"] = oK
+    return out_intr_dict
+
+
+class FisheyeRectConverter:
+    def __init__(self, K, D, DIM, out_size, out_fov):
+        out_size = np.array(out_size)
+        # vertical fov
+        out_f = (out_size[1] / 2) / np.tan(out_fov / 180 * np.pi / 2)
+        out_K = np.array(
+            [[out_f, 0, out_size[0] / 2], [0, out_f, out_size[1] / 2], [0, 0, 1]],
+            dtype=np.float32,
+        )
+        map1, map2 = cv2.fisheye.initUndistortRectifyMap(
+            K, D, np.eye(3), out_K, out_size, cv2.CV_16SC2
+        )
+
+        self.map1 = map1
+        self.map2 = map2
+
+    def forward(self, img):
+        rect_img = cv2.remap(
+            img,
+            self.map1,
+            self.map2,
+            interpolation=cv2.INTER_AREA,
+            borderMode=cv2.BORDER_CONSTANT,
+        )
+        return rect_img
+
+
+# ================= ArUcO tag =====================
+def parse_aruco_config(aruco_config_dict: dict):
+    """
+    example:
+    aruco_dict:
+        predefined: DICT_4X4_50
+    marker_size_map: # all unit in meters
+        default: 0.15
+        12: 0.2
+    """
+    aruco_dict = get_aruco_dict(**aruco_config_dict["aruco_dict"])
+
+    n_markers = len(aruco_dict.bytesList)
+    marker_size_map = aruco_config_dict["marker_size_map"]
+    default_size = marker_size_map.get("default", None)
+
+    out_marker_size_map = dict()
+    for marker_id in range(n_markers):
+        size = default_size
+        if marker_id in marker_size_map:
+            size = marker_size_map[marker_id]
+        out_marker_size_map[marker_id] = size
+
+    result = {"aruco_dict": aruco_dict, "marker_size_map": out_marker_size_map}
+    return result
+
+
+def get_aruco_dict(predefined: str) -> cv2.aruco.Dictionary:
+    return cv2.aruco.getPredefinedDictionary(getattr(cv2.aruco, predefined))
+
+
+def detect_localize_aruco_tags(
+    img: np.ndarray,
+    aruco_dict: cv2.aruco.Dictionary,
+    marker_size_map: Dict[int, float],
+    fisheye_intr_dict: Dict[str, np.ndarray],
+    refine_subpix: bool = True,
+):
+    K = fisheye_intr_dict["K"]
+    D = fisheye_intr_dict["D"]
+    param = cv2.aruco.DetectorParameters()
+    if refine_subpix:
+        param.cornerRefinementMethod = cv2.aruco.CORNER_REFINE_SUBPIX
+    corners, ids, rejectedImgPoints = cv2.aruco.detectMarkers(
+        image=img, dictionary=aruco_dict, parameters=param
+    )
+    if len(corners) == 0:
+        return dict()
+
+    tag_dict = dict()
+    for this_id, this_corners in zip(ids, corners):
+        this_id = int(this_id[0])
+        if this_id not in marker_size_map:
+            continue
+
+        marker_size_m = marker_size_map[this_id]
+        undistorted = cv2.fisheye.undistortPoints(this_corners, K, D, P=K)
+        rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(
+            undistorted, marker_size_m, K, np.zeros((1, 5))
+        )
+        tag_dict[this_id] = {
+            "rvec": rvec.squeeze(),
+            "tvec": tvec.squeeze(),
+            "corners": this_corners.squeeze(),
+        }
+    return tag_dict
+
+
+def get_charuco_board(
+    aruco_dict=cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_100),
+    tag_id_offset=50,
+    grid_size=(8, 5),
+    square_length_mm=50,
+    tag_length_mm=30,
+):
+
+    aruco_dict = cv2.aruco.Dictionary(
+        aruco_dict.bytesList[tag_id_offset:], aruco_dict.markerSize
+    )
+    board = cv2.aruco.CharucoBoard(
+        size=grid_size,
+        squareLength=square_length_mm / 1000,
+        markerLength=tag_length_mm / 1000,
+        dictionary=aruco_dict,
+    )
+    return board
+
+
+def draw_charuco_board(board, dpi=300, padding_mm=15):
+    grid_size = np.array(board.getChessboardSize())
+    square_length_mm = board.getSquareLength() * 1000
+
+    mm_per_inch = 25.4
+    board_size_pixel = (
+        (grid_size * square_length_mm + padding_mm * 2) / mm_per_inch * dpi
+    )
+    board_size_pixel = board_size_pixel.round().astype(np.int64)
+    padding_pixel = int(padding_mm / mm_per_inch * dpi)
+    board_img = board.generateImage(outSize=board_size_pixel, marginSize=padding_pixel)
+    return board_img
+
+
+def get_gripper_width(tag_dict, left_id, right_id, nominal_z=0.072, z_tolerance=0.008):
+    zmax = nominal_z + z_tolerance
+    zmin = nominal_z - z_tolerance
+
+    left_x = None
+    if left_id in tag_dict:
+        tvec = tag_dict[left_id]["tvec"]
+        # check if depth is reasonable (to filter outliers)
+        if zmin < tvec[-1] < zmax:
+            left_x = tvec[0]
+
+    right_x = None
+    if right_id in tag_dict:
+        tvec = tag_dict[right_id]["tvec"]
+        if zmin < tvec[-1] < zmax:
+            right_x = tvec[0]
+
+    width = None
+    if (left_x is not None) and (right_x is not None):
+        width = right_x - left_x
+    elif left_x is not None:
+        width = abs(left_x) * 2
+    elif right_x is not None:
+        width = abs(right_x) * 2
+    return width
+
+
+# =========== image mask ====================
+def canonical_to_pixel_coords(coords, img_shape=(2028, 2704)):
+    pts = np.asarray(coords) * img_shape[0] + np.array(img_shape[::-1]) * 0.5
+    return pts
+
+
+def pixel_coords_to_canonical(pts, img_shape=(2028, 2704)):
+    coords = (np.asarray(pts) - np.array(img_shape[::-1]) * 0.5) / img_shape[0]
+    return coords
+
+
+def draw_canonical_polygon(img: np.ndarray, coords: np.ndarray, color: tuple):
+    pts = canonical_to_pixel_coords(coords, img.shape[:2])
+    pts = np.round(pts).astype(np.int32)
+    cv2.fillPoly(img, pts, color=color)
+    return img
+
+
+def get_mirror_canonical_polygon():
+    left_pts = [
+        [540, 1700],
+        [680, 1450],
+        [590, 1070],
+        [290, 1130],
+        [290, 1770],
+        [550, 1770],
+    ]
+    resolution = [2028, 2704]
+    left_coords = pixel_coords_to_canonical(left_pts, resolution)
+    right_coords = left_coords.copy()
+    right_coords[:, 0] *= -1
+    coords = np.stack([left_coords, right_coords])
+    return coords
+
+
+def get_mirror_crop_slices(img_shape=(1080, 1920), left=True):
+    left_pts = [[290, 1120], [650, 1480]]
+    resolution = [2028, 2704]
+    left_coords = pixel_coords_to_canonical(left_pts, resolution)
+    if not left:
+        left_coords[:, 0] *= -1
+    left_pts = canonical_to_pixel_coords(left_coords, img_shape=img_shape)
+    left_pts = np.round(left_pts).astype(np.int32)
+    slices = (
+        slice(np.min(left_pts[:, 1]), np.max(left_pts[:, 1])),
+        slice(np.min(left_pts[:, 0]), np.max(left_pts[:, 0])),
+    )
+    return slices
+
+
+def get_gripper_canonical_polygon():
+    left_pts = [
+        [1352, 1730],
+        [1100, 1700],
+        [650, 1500],
+        [0, 1350],
+        [0, 2028],
+        [1352, 2704],
+    ]
+    resolution = [2028, 2704]
+    left_coords = pixel_coords_to_canonical(left_pts, resolution)
+    right_coords = left_coords.copy()
+    right_coords[:, 0] *= -1
+    coords = np.stack([left_coords, right_coords])
+    return coords
+
+
+def get_finger_canonical_polygon(height=0.37, top_width=0.25, bottom_width=1.4):
+    # image size
+    resolution = [2028, 2704]
+    img_h, img_w = resolution
+
+    # calculate coordinates
+    top_y = 1.0 - height
+    bottom_y = 1.0
+    width = img_w / img_h
+    middle_x = width / 2.0
+    top_left_x = middle_x - top_width / 2.0
+    top_right_x = middle_x + top_width / 2.0
+    bottom_left_x = middle_x - bottom_width / 2.0
+    bottom_right_x = middle_x + bottom_width / 2.0
+
+    top_y *= img_h
+    bottom_y *= img_h
+    top_left_x *= img_h
+    top_right_x *= img_h
+    bottom_left_x *= img_h
+    bottom_right_x *= img_h
+
+    # create polygon points for opencv API
+    points = [
+        [
+            [bottom_left_x, bottom_y],
+            [top_left_x, top_y],
+            [top_right_x, top_y],
+            [bottom_right_x, bottom_y],
+        ]
+    ]
+    coords = pixel_coords_to_canonical(points, img_shape=resolution)
+    return coords
+
+
+def draw_predefined_mask(
+    img, color=(0, 0, 0), mirror=True, gripper=True, finger=True, use_aa=False
+):
+    all_coords = list()
+    if mirror:
+        all_coords.extend(get_mirror_canonical_polygon())
+    if gripper:
+        all_coords.extend(get_gripper_canonical_polygon())
+    if finger:
+        all_coords.extend(get_finger_canonical_polygon())
+
+    for coords in all_coords:
+        pts = canonical_to_pixel_coords(coords, img.shape[:2])
+        pts = np.round(pts).astype(np.int32)
+        flag = cv2.LINE_AA if use_aa else cv2.LINE_8
+        cv2.fillPoly(img, [pts], color=color, lineType=flag)
+    return img
+
+
+def get_gripper_with_finger_mask(
+    img, height=0.37, top_width=0.25, bottom_width=1.4, color=(0, 0, 0)
+):
+    # image size
+    img_h = img.shape[0]
+    img_w = img.shape[1]
+
+    # calculate coordinates
+    top_y = 1.0 - height
+    bottom_y = 1.0
+    width = img_w / img_h
+    middle_x = width / 2.0
+    top_left_x = middle_x - top_width / 2.0
+    top_right_x = middle_x + top_width / 2.0
+    bottom_left_x = middle_x - bottom_width / 2.0
+    bottom_right_x = middle_x + bottom_width / 2.0
+
+    top_y *= img_h
+    bottom_y *= img_h
+    top_left_x *= img_h
+    top_right_x *= img_h
+    bottom_left_x *= img_h
+    bottom_right_x *= img_h
+
+    # create polygon points for opencv API
+    points = np.array(
+        [
+            [
+                [bottom_left_x, bottom_y],
+                [top_left_x, top_y],
+                [top_right_x, top_y],
+                [bottom_right_x, bottom_y],
+            ]
+        ],
+        dtype=np.int32,
+    )
+
+    img = cv2.fillPoly(img, points, color=color, lineType=cv2.LINE_AA)
+    return img
+
+
+def inpaint_tag(img, corners, tag_scale=1.4, n_samples=16):
+    # scale corners with respect to geometric center
+    center = np.mean(corners, axis=0)
+    scaled_corners = tag_scale * (corners - center) + center
+
+    # sample pixels on the boundary to obtain median color
+    sample_points = si.interp1d(
+        [0, 1, 2, 3, 4], list(scaled_corners) + [scaled_corners[0]], axis=0
+    )(np.linspace(0, 4, n_samples)).astype(np.int32)
+    sample_colors = img[
+        np.clip(sample_points[:, 1], 0, img.shape[0] - 1),
+        np.clip(sample_points[:, 0], 0, img.shape[1] - 1),
+    ]
+    median_color = np.median(sample_colors, axis=0).astype(img.dtype)
+
+    # draw tag with median color
+    img = cv2.fillPoly(
+        img, scaled_corners[None, ...].astype(np.int32), color=median_color.tolist()
+    )
+    return img
+
+
+# =========== other utils ====================
+def get_image_transform(
+    in_res, out_res, crop_ratio: float = 1.0, bgr_to_rgb: bool = False
+):
+    iw, ih = in_res
+    ow, oh = out_res
+    ch = round(ih * crop_ratio)
+    cw = round(ih * crop_ratio / oh * ow)
+    interp_method = cv2.INTER_AREA
+
+    w_slice_start = (iw - cw) // 2
+    w_slice = slice(w_slice_start, w_slice_start + cw)
+    h_slice_start = (ih - ch) // 2
+    h_slice = slice(h_slice_start, h_slice_start + ch)
+    c_slice = slice(None)
+    if bgr_to_rgb:
+        c_slice = slice(None, None, -1)
+
+    def transform(img: np.ndarray):
+        assert img.shape == ((ih, iw, 3))
+        # crop
+        img = img[h_slice, w_slice, c_slice]
+        # resize
+        img = cv2.resize(img, out_res, interpolation=interp_method)
+        return img
+
+    return transform

code/umi/common/exiftool_util.py

@@ -0,0 +1,14 @@
+from exiftool import ExifToolHelper
+
+
+def get_videos_metadata(
+    video_paths, keys=["QuickTime:CameraSerialNumber", "QuickTime:Model"]
+):
+    results = dict()
+    with ExifToolHelper() as et:
+        for meta in et.get_metadata(video_paths):
+            result = dict()
+            for key in keys:
+                result[key] = meta[key]
+            results[meta["SourceFile"]] = result
+    return results

code/umi/common/interpolation_util.py

@@ -0,0 +1,49 @@
+import numpy as np
+import scipy.interpolate as si
+import scipy.spatial.transform as st
+
+
+def get_interp1d(t, x):
+    gripper_interp = si.interp1d(
+        t, x, axis=0, bounds_error=False, fill_value=(x[0], x[-1])
+    )
+    return gripper_interp
+
+
+class PoseInterpolator:
+    def __init__(self, t, x):
+        pos = x[:, :3]
+        rot = st.Rotation.from_rotvec(x[:, 3:])
+        self.pos_interp = get_interp1d(t, pos)
+        self.rot_interp = st.Slerp(t, rot)
+
+    @property
+    def x(self):
+        return self.pos_interp.x
+
+    def __call__(self, t):
+        min_t = self.pos_interp.x[0]
+        max_t = self.pos_interp.x[-1]
+        t = np.clip(t, min_t, max_t)
+
+        pos = self.pos_interp(t)
+        rot = self.rot_interp(t)
+        rvec = rot.as_rotvec()
+        pose = np.concatenate([pos, rvec], axis=-1)
+        return pose
+
+
+def get_gripper_calibration_interpolator(aruco_measured_width, aruco_actual_width):
+    """
+    Assumes the minimum width in aruco_actual_width
+    is measured when the gripper is fully closed
+    and maximum width is when the gripper is fully opened
+    """
+    aruco_measured_width = np.array(aruco_measured_width)
+    aruco_actual_width = np.array(aruco_actual_width)
+    assert len(aruco_measured_width) == len(aruco_actual_width)
+    assert len(aruco_actual_width) >= 2
+    aruco_min_width = np.min(aruco_actual_width)
+    gripper_actual_width = aruco_actual_width - aruco_min_width
+    interp = get_interp1d(aruco_measured_width, gripper_actual_width)
+    return interp

code/umi/common/k3d_util.py

@@ -0,0 +1,33 @@
+import numpy as np
+import numba
+
+
+@numba.jit()
+def k3d_get_pose_axis(poses, axis_size_m=0.1):
+    # points in camera frame
+    points = np.zeros((4, 3), dtype=poses.dtype)
+    points[1, 0] = axis_size_m
+    points[2, 1] = axis_size_m
+    points[3, 2] = axis_size_m
+
+    n_poses = poses.shape[0]
+    out_verts = np.zeros((n_poses * 4, 3), dtype=poses.dtype)
+    out_idxs = np.zeros((n_poses * 3, 2), dtype=np.int64)
+    out_colors = np.zeros((n_poses * 4,), dtype=np.int64)
+    for i in range(n_poses):
+        this_pose = poses[i]
+        # convert points to world frame
+        this_verts = points @ this_pose[:3, :3].T + this_pose[:3, 3]
+        # fill in vert array
+        vert_idx_start = i * 4
+        out_verts[vert_idx_start : vert_idx_start + 4] = this_verts
+        # draw 3 lines for x,y,z axis
+        this_idxs = out_idxs[i * 3 : (i + 1) * 3]
+        this_idxs[0] = [0, 1]
+        this_idxs[1] = [0, 2]
+        this_idxs[2] = [0, 3]
+        this_idxs += vert_idx_start
+        # fill out vertex colors, rgb for xyz
+        out_colors[i * 4 : (i + 1) * 4] = [0xFFFFFF, 0xFF0000, 0x00FF00, 0x0000FF]
+
+    return out_verts, out_idxs, out_colors

code/umi/common/latency_util.py

@@ -0,0 +1,58 @@
+import numpy as np
+from scipy.interpolate import interp1d
+import scipy.signal as ss
+
+
+def regular_sample(x, t, t_samples):
+    spline = interp1d(x=t, y=x, bounds_error=False, fill_value=(x[0], x[-1]))
+    result = spline(t_samples)
+    return result
+
+
+def get_latency(
+    x_target,
+    t_target,
+    x_actual,
+    t_actual,
+    t_start=None,
+    t_end=None,
+    resample_dt=1 / 1000,
+    force_positive=False,
+):
+    assert len(x_target) == len(t_target)
+    assert len(x_actual) == len(t_actual)
+    if t_start is None:
+        t_start = max(t_target[0], t_actual[0])
+    if t_end is None:
+        t_end = min(t_target[-1], t_actual[-1])
+    n_samples = int((t_end - t_start) / resample_dt)
+    t_samples = np.arange(n_samples) * resample_dt + t_start
+    target_samples = regular_sample(x_target, t_target, t_samples)
+    actual_samples = regular_sample(x_actual, t_actual, t_samples)
+
+    # normalize samples to zero mean unit std
+    mean = np.mean(np.concatenate([target_samples, actual_samples]))
+    std = np.std(np.concatenate([target_samples, actual_samples]))
+    target_samples = (target_samples - mean) / std
+    actual_samples = (actual_samples - mean) / std
+
+    # cross correlation
+    correlation = ss.correlate(actual_samples, target_samples)
+    lags = ss.correlation_lags(len(actual_samples), len(target_samples))
+    t_lags = lags * resample_dt
+
+    latency = None
+    if force_positive:
+        latency = t_lags[np.argmax(correlation[t_lags >= 0])]
+    else:
+        latency = t_lags[np.argmax(correlation)]
+
+    info = {
+        "t_samples": t_samples,
+        "x_target": target_samples,
+        "x_actual": actual_samples,
+        "correlation": correlation,
+        "lags": t_lags,
+    }
+
+    return latency, info

code/umi/common/mocap_util.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+import pandas as pd
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+def get_mocap_start_datetime(csv_path):
+    with open(csv_path, "r") as f:
+        first_row = f.readline().split(",")
+    meta_dict = dict()
+    for i in range(len(first_row) // 2):
+        start = i * 2
+        end = start + 1
+        meta_dict[first_row[start]] = first_row[end]
+    start_timestamp_str = meta_dict["Capture Start Time"]
+    start_date = datetime.strptime(start_timestamp_str, r"%Y-%m-%d %I.%M.%S.%f %p")
+    return start_date
+
+
+def get_mocap_data(csv_path, rigid_body_name):
+    mocap_df = pd.read_csv(csv_path, skiprows=2, index_col=0, header=[1, 3, 4])
+    assert mocap_df.index[0] == 0
+    assert mocap_df.index[-1] == (len(mocap_df) - 1)
+    assert mocap_df.columns[0][-1] == "Time (Seconds)"
+
+    time_since_start = mocap_df.iloc[:, 0].to_numpy()
+    pos = np.zeros((len(mocap_df), 3))
+    pos[:, 0] = mocap_df[(rigid_body_name, "Position", "X")]
+    pos[:, 1] = mocap_df[(rigid_body_name, "Position", "Y")]
+    pos[:, 2] = mocap_df[(rigid_body_name, "Position", "Z")]
+
+    rot_quat = np.zeros((len(mocap_df), 4))
+    rot_quat[:, 0] = mocap_df[(rigid_body_name, "Rotation", "X")]
+    rot_quat[:, 1] = mocap_df[(rigid_body_name, "Rotation", "Y")]
+    rot_quat[:, 2] = mocap_df[(rigid_body_name, "Rotation", "Z")]
+    rot_quat[:, 3] = mocap_df[(rigid_body_name, "Rotation", "W")]
+    rot = Rotation.from_quat(rot_quat)
+
+    pose = np.zeros((pos.shape[0], 4, 4), dtype=pos.dtype)
+    pose[:, 3, 3] = 1
+    pose[:, :3, :3] = rot.as_matrix()
+    pose[:, :3, 3] = pos
+
+    result = {
+        "time_since_start": time_since_start,
+        "pose": pose,
+    }
+    return result

code/umi/common/nested_dict_util.py

@@ -0,0 +1,34 @@
+import functools
+
+
+def nested_dict_map(f, x):
+    """
+    Map f over all leaf of nested dict x
+    """
+
+    if not isinstance(x, dict):
+        return f(x)
+    y = dict()
+    for key, value in x.items():
+        y[key] = nested_dict_map(f, value)
+    return y
+
+
+def nested_dict_reduce(f, x):
+    """
+    Map f over all values of nested dict x, and reduce to a single value
+    """
+    if not isinstance(x, dict):
+        return x
+
+    reduced_values = list()
+    for value in x.values():
+        reduced_values.append(nested_dict_reduce(f, value))
+    y = functools.reduce(f, reduced_values)
+    return y
+
+
+def nested_dict_check(f, x):
+    bool_dict = nested_dict_map(f, x)
+    result = nested_dict_reduce(lambda x, y: x and y, bool_dict)
+    return result

code/umi/common/orb_slam_util.py

@@ -0,0 +1,46 @@
+import numpy as np
+import pandas as pd
+from scipy.spatial.transform import Rotation
+
+
+def load_tum_trajectory(tum_txt_path):
+    tum_traj_raw = np.loadtxt(tum_txt_path, delimiter=" ", dtype=np.float32)
+    if len(tum_traj_raw) == 0:
+        return {
+            "timestamp": np.array([]),
+            "pose": np.array([]),
+        }
+
+    timestamp_sec = tum_traj_raw[:, 0]
+    cam_pos = tum_traj_raw[:, 1:4]
+    cam_rot_quat_xyzw = tum_traj_raw[:, 4:8]
+    cam_rot = Rotation.from_quat(cam_rot_quat_xyzw)
+
+    cam_pose = np.zeros((cam_pos.shape[0], 4, 4), dtype=np.float32)
+    cam_pose[:, 3, 3] = 1
+    cam_pose[:, :3, 3] = cam_pos
+    cam_pose[:, :3, :3] = cam_rot.as_matrix()
+
+    result = {"timestamp": timestamp_sec, "pose": cam_pose}
+    return result
+
+
+def load_csv_trajectory(csv_path):
+    df = pd.read_csv(csv_path)
+    if (~df.is_lost).sum() == 0:
+        return {"raw_data": df}
+
+    valid_df = df.loc[~df.is_lost]
+
+    timestamp_sec = valid_df["timestamp"].to_numpy()
+    cam_pos = valid_df[["x", "y", "z"]].to_numpy()
+    cam_rot_quat_xyzw = valid_df[["q_x", "q_y", "q_z", "q_w"]].to_numpy()
+    cam_rot = Rotation.from_quat(cam_rot_quat_xyzw)
+
+    cam_pose = np.zeros((cam_pos.shape[0], 4, 4), dtype=np.float32)
+    cam_pose[:, 3, 3] = 1
+    cam_pose[:, :3, 3] = cam_pos
+    cam_pose[:, :3, :3] = cam_rot.as_matrix()
+
+    result = {"timestamp": timestamp_sec, "pose": cam_pose, "raw_data": df}
+    return result

code/umi/common/pose_trajectory_interpolator.py

@@ -0,0 +1,207 @@
+from typing import Union
+import numbers
+import numpy as np
+import scipy.interpolate as si
+import scipy.spatial.transform as st
+
+
+def rotation_distance(a: st.Rotation, b: st.Rotation) -> float:
+    return (b * a.inv()).magnitude()
+
+
+def pose_distance(start_pose, end_pose):
+    start_pose = np.array(start_pose)
+    end_pose = np.array(end_pose)
+    start_pos = start_pose[:3]
+    end_pos = end_pose[:3]
+    start_rot = st.Rotation.from_rotvec(start_pose[3:])
+    end_rot = st.Rotation.from_rotvec(end_pose[3:])
+    pos_dist = np.linalg.norm(end_pos - start_pos)
+    rot_dist = rotation_distance(start_rot, end_rot)
+    return pos_dist, rot_dist
+
+
+class PoseTrajectoryInterpolator:
+    def __init__(self, times: np.ndarray, poses: np.ndarray):
+        assert len(times) >= 1
+        assert len(poses) == len(times)
+        if not isinstance(times, np.ndarray):
+            times = np.array(times)
+        if not isinstance(poses, np.ndarray):
+            poses = np.array(poses)
+
+        if len(times) == 1:
+            # special treatment for single step interpolation
+            self.single_step = True
+            self._times = times
+            self._poses = poses
+        else:
+            self.single_step = False
+            assert np.all(times[1:] >= times[:-1])
+
+            pos = poses[:, :3]
+            rot = st.Rotation.from_rotvec(poses[:, 3:])
+
+            self.pos_interp = si.interp1d(times, pos, axis=0, assume_sorted=True)
+            self.rot_interp = st.Slerp(times, rot)
+
+    @property
+    def times(self) -> np.ndarray:
+        if self.single_step:
+            return self._times
+        else:
+            return self.pos_interp.x
+
+    @property
+    def poses(self) -> np.ndarray:
+        if self.single_step:
+            return self._poses
+        else:
+            n = len(self.times)
+            poses = np.zeros((n, 6))
+            poses[:, :3] = self.pos_interp.y
+            poses[:, 3:] = self.rot_interp(self.times).as_rotvec()
+            return poses
+
+    def trim(self, start_t: float, end_t: float) -> "PoseTrajectoryInterpolator":
+        assert start_t <= end_t
+        times = self.times
+        should_keep = (start_t < times) & (times < end_t)
+        keep_times = times[should_keep]
+        all_times = np.concatenate([[start_t], keep_times, [end_t]])
+        # remove duplicates, Slerp requires strictly increasing x
+        all_times = np.unique(all_times)
+        # interpolate
+        all_poses = self(all_times)
+        return PoseTrajectoryInterpolator(times=all_times, poses=all_poses)
+
+    def drive_to_waypoint(
+        self, pose, time, curr_time, max_pos_speed=np.inf, max_rot_speed=np.inf
+    ) -> "PoseTrajectoryInterpolator":
+        assert max_pos_speed > 0
+        assert max_rot_speed > 0
+        time = max(time, curr_time)
+
+        curr_pose = self(curr_time)
+        pos_dist, rot_dist = pose_distance(curr_pose, pose)
+        pos_min_duration = pos_dist / max_pos_speed
+        rot_min_duration = rot_dist / max_rot_speed
+        duration = time - curr_time
+        duration = max(duration, max(pos_min_duration, rot_min_duration))
+        assert duration >= 0
+        last_waypoint_time = curr_time + duration
+
+        # insert new pose
+        trimmed_interp = self.trim(curr_time, curr_time)
+        times = np.append(trimmed_interp.times, [last_waypoint_time], axis=0)
+        poses = np.append(trimmed_interp.poses, [pose], axis=0)
+
+        # create new interpolator
+        final_interp = PoseTrajectoryInterpolator(times, poses)
+        return final_interp
+
+    def schedule_waypoint(
+        self,
+        pose,
+        time,
+        max_pos_speed=np.inf,
+        max_rot_speed=np.inf,
+        curr_time=None,
+        last_waypoint_time=None,
+    ) -> "PoseTrajectoryInterpolator":
+        assert max_pos_speed > 0
+        assert max_rot_speed > 0
+        if last_waypoint_time is not None:
+            assert curr_time is not None
+
+        # trim current interpolator to between curr_time and last_waypoint_time
+        start_time = self.times[0]
+        end_time = self.times[-1]
+        assert start_time <= end_time
+
+        if curr_time is not None:
+            if time <= curr_time:
+                # if insert time is earlier than current time
+                # no effect should be done to the interpolator
+                return self
+            # now, curr_time < time
+            start_time = max(curr_time, start_time)
+
+            if last_waypoint_time is not None:
+                # if last_waypoint_time is earlier than start_time
+                # use start_time
+                if time <= last_waypoint_time:
+                    end_time = curr_time
+                else:
+                    end_time = max(last_waypoint_time, curr_time)
+            else:
+                end_time = curr_time
+
+        end_time = min(end_time, time)
+        start_time = min(start_time, end_time)
+        # end time should be the latest of all times except time
+        # after this we can assume order (proven by zhenjia, due to the 2 min operations)
+
+        # Constraints:
+        # start_time <= end_time <= time (proven by zhenjia)
+        # curr_time <= start_time (proven by zhenjia)
+        # curr_time <= time (proven by zhenjia)
+
+        # time can't change
+        # last_waypoint_time can't change
+        # curr_time can't change
+        assert start_time <= end_time
+        assert end_time <= time
+        if last_waypoint_time is not None:
+            if time <= last_waypoint_time:
+                assert end_time == curr_time
+            else:
+                assert end_time == max(last_waypoint_time, curr_time)
+
+        if curr_time is not None:
+            assert curr_time <= start_time
+            assert curr_time <= time
+
+        trimmed_interp = self.trim(start_time, end_time)
+        # after this, all waypoints in trimmed_interp is within start_time and end_time
+        # and is earlier than time
+
+        # determine speed
+        duration = time - end_time
+        end_pose = trimmed_interp(end_time)
+        pos_dist, rot_dist = pose_distance(pose, end_pose)
+        pos_min_duration = pos_dist / max_pos_speed
+        rot_min_duration = rot_dist / max_rot_speed
+        duration = max(duration, max(pos_min_duration, rot_min_duration))
+        assert duration >= 0
+        last_waypoint_time = end_time + duration
+
+        # insert new pose
+        times = np.append(trimmed_interp.times, [last_waypoint_time], axis=0)
+        poses = np.append(trimmed_interp.poses, [pose], axis=0)
+
+        # create new interpolator
+        final_interp = PoseTrajectoryInterpolator(times, poses)
+        return final_interp
+
+    def __call__(self, t: Union[numbers.Number, np.ndarray]) -> np.ndarray:
+        is_single = False
+        if isinstance(t, numbers.Number):
+            is_single = True
+            t = np.array([t])
+
+        pose = np.zeros((len(t), 6))
+        if self.single_step:
+            pose[:] = self._poses[0]
+        else:
+            start_time = self.times[0]
+            end_time = self.times[-1]
+            t = np.clip(t, start_time, end_time)
+
+            pose = np.zeros((len(t), 6))
+            pose[:, :3] = self.pos_interp(t)
+            pose[:, 3:] = self.rot_interp(t).as_rotvec()
+
+        if is_single:
+            pose = pose[0]
+        return pose

code/umi/common/pose_util.py

@@ -0,0 +1,132 @@
+import numpy as np
+import scipy.spatial.transform as st
+
+
+def pos_rot_to_mat(pos, rot):
+    shape = pos.shape[:-1]
+    mat = np.zeros(shape + (4, 4), dtype=pos.dtype)
+    mat[..., :3, 3] = pos
+    mat[..., :3, :3] = rot.as_matrix()
+    mat[..., 3, 3] = 1
+    return mat
+
+
+def mat_to_pos_rot(mat):
+    pos = (mat[..., :3, 3].T / mat[..., 3, 3].T).T
+    rot = st.Rotation.from_matrix(mat[..., :3, :3])
+    return pos, rot
+
+
+def pos_rot_to_pose(pos, rot):
+    shape = pos.shape[:-1]
+    pose = np.zeros(shape + (6,), dtype=pos.dtype)
+    pose[..., :3] = pos
+    pose[..., 3:] = rot.as_rotvec()
+    return pose
+
+
+def pose_to_pos_rot(pose):
+    pos = pose[..., :3]
+    rot = st.Rotation.from_rotvec(pose[..., 3:])
+    return pos, rot
+
+
+def pose_to_mat(pose):
+    return pos_rot_to_mat(*pose_to_pos_rot(pose))
+
+
+def mat_to_pose(mat):
+    return pos_rot_to_pose(*mat_to_pos_rot(mat))
+
+
+def transform_pose(tx, pose):
+    """
+    tx: tx_new_old
+    pose: tx_old_obj
+    result: tx_new_obj
+    """
+    pose_mat = pose_to_mat(pose)
+    tf_pose_mat = tx @ pose_mat
+    tf_pose = mat_to_pose(tf_pose_mat)
+    return tf_pose
+
+
+def transform_point(tx, point):
+    return point @ tx[:3, :3].T + tx[:3, 3]
+
+
+def project_point(k, point):
+    x = point @ k.T
+    uv = x[..., :2] / x[..., [2]]
+    return uv
+
+
+def apply_delta_pose(pose, delta_pose):
+    new_pose = np.zeros_like(pose)
+
+    # simple add for position
+    new_pose[:3] = pose[:3] + delta_pose[:3]
+
+    # matrix multiplication for rotation
+    rot = st.Rotation.from_rotvec(pose[3:])
+    drot = st.Rotation.from_rotvec(delta_pose[3:])
+    new_pose[3:] = (drot * rot).as_rotvec()
+
+    return new_pose
+
+
+def normalize(vec, tol=1e-7):
+    return vec / np.maximum(np.linalg.norm(vec), tol)
+
+
+def rot_from_directions(from_vec, to_vec):
+    from_vec = normalize(from_vec)
+    to_vec = normalize(to_vec)
+    axis = np.cross(from_vec, to_vec)
+    axis = normalize(axis)
+    angle = np.arccos(np.dot(from_vec, to_vec))
+    rotvec = axis * angle
+    rot = st.Rotation.from_rotvec(rotvec)
+    return rot
+
+
+def normalize(vec, eps=1e-12):
+    norm = np.linalg.norm(vec, axis=-1)
+    norm = np.maximum(norm, eps)
+    out = (vec.T / norm).T
+    return out
+
+
+def rot6d_to_mat(d6):
+    a1, a2 = d6[..., :3], d6[..., 3:]
+    b1 = normalize(a1)
+    b2 = a2 - np.sum(b1 * a2, axis=-1, keepdims=True) * b1
+    b2 = normalize(b2)
+    b3 = np.cross(b1, b2, axis=-1)
+    out = np.stack((b1, b2, b3), axis=-2)
+    return out
+
+
+def mat_to_rot6d(mat):
+    batch_dim = mat.shape[:-2]
+    out = mat[..., :2, :].copy().reshape(batch_dim + (6,))
+    return out
+
+
+def mat_to_pose10d(mat):
+    pos = mat[..., :3, 3]
+    rotmat = mat[..., :3, :3]
+    d6 = mat_to_rot6d(rotmat)
+    d10 = np.concatenate([pos, d6], axis=-1)
+    return d10
+
+
+def pose10d_to_mat(d10):
+    pos = d10[..., :3]
+    d6 = d10[..., 3:]
+    rotmat = rot6d_to_mat(d6)
+    out = np.zeros(d10.shape[:-1] + (4, 4), dtype=d10.dtype)
+    out[..., :3, :3] = rotmat
+    out[..., :3, 3] = pos
+    out[..., 3, 3] = 1
+    return out

code/umi/common/precise_sleep.py

@@ -0,0 +1,27 @@
+import time
+
+
+def precise_sleep(dt: float, slack_time: float = 0.001, time_func=time.monotonic):
+    """
+    Use hybrid of time.sleep and spinning to minimize jitter.
+    Sleep dt - slack_time seconds first, then spin for the rest.
+    """
+    t_start = time_func()
+    if dt > slack_time:
+        time.sleep(dt - slack_time)
+    t_end = t_start + dt
+    while time_func() < t_end:
+        pass
+    return
+
+
+def precise_wait(t_end: float, slack_time: float = 0.001, time_func=time.monotonic):
+    t_start = time_func()
+    t_wait = t_end - t_start
+    if t_wait > 0:
+        t_sleep = t_wait - slack_time
+        if t_sleep > 0:
+            time.sleep(t_sleep)
+        while time_func() < t_end:
+            pass
+    return

code/umi/common/timecode_util.py

@@ -0,0 +1,56 @@
+from typing import Union
+from fractions import Fraction
+import datetime
+import av
+
+
+def timecode_to_seconds(
+    timecode: str, frame_rate: Union[int, float, Fraction]
+) -> Union[float, Fraction]:
+    """
+    Convert non-skip frame timecode into seconds since midnight
+    """
+    # calculate whole frame rate
+    # 29.97 -> 30, 59.94 -> 60
+    int_frame_rate = round(frame_rate)
+
+    # parse timecode string
+    h, m, s, f = [int(x) for x in timecode.split(":")]
+
+    # calculate frames assuming whole frame rate (i.e. non-drop frame)
+    frames = (3600 * h + 60 * m + s) * int_frame_rate + f
+
+    # convert to seconds
+    seconds = frames / frame_rate
+    return seconds
+
+
+def stream_get_start_datetime(stream: av.stream.Stream) -> datetime.datetime:
+    """
+    Combines creation time and timecode to get high-precision
+    time for the first frame of a video.
+    """
+    # read metadata
+    frame_rate = stream.average_rate
+    tc = stream.metadata["timecode"]
+    creation_time = stream.metadata["creation_time"]
+
+    # get time within the day
+    seconds_since_midnight = float(
+        timecode_to_seconds(timecode=tc, frame_rate=frame_rate)
+    )
+    delta = datetime.timedelta(seconds=seconds_since_midnight)
+
+    # get dates
+    create_datetime = datetime.datetime.strptime(
+        creation_time, r"%Y-%m-%dT%H:%M:%S.%fZ"
+    )
+    create_datetime = create_datetime.replace(hour=0, minute=0, second=0, microsecond=0)
+    start_datetime = create_datetime + delta
+    return start_datetime
+
+
+def mp4_get_start_datetime(mp4_path: str) -> datetime.datetime:
+    with av.open(mp4_path) as container:
+        stream = container.streams.video[0]
+        return stream_get_start_datetime(stream=stream)

code/umi/common/timestamp_accumulator.py

@@ -0,0 +1,218 @@
+from typing import List, Tuple, Optional, Dict
+import math
+import numpy as np
+
+
+def get_accumulate_timestamp_idxs(
+    timestamps: List[float],
+    start_time: float,
+    dt: float,
+    eps: float = 1e-5,
+    next_global_idx: Optional[int] = 0,
+    allow_negative=False,
+) -> Tuple[List[int], List[int], int]:
+    """
+    For each dt window, choose the first timestamp in the window.
+    Assumes timestamps sorted. One timestamp might be chosen multiple times due to dropped frames.
+    next_global_idx should start at 0 normally, and then use the returned next_global_idx.
+    However, when overwiting previous values are desired, set last_global_idx to None.
+
+    Returns:
+    local_idxs: which index in the given timestamps array to chose from
+    global_idxs: the global index of each chosen timestamp
+    next_global_idx: used for next call.
+    """
+    local_idxs = list()
+    global_idxs = list()
+    for local_idx, ts in enumerate(timestamps):
+        # add eps * dt to timestamps so that when ts == start_time + k * dt
+        # is always recorded as kth element (avoiding floating point errors)
+        global_idx = math.floor((ts - start_time) / dt + eps)
+        if (not allow_negative) and (global_idx < 0):
+            continue
+        if next_global_idx is None:
+            next_global_idx = global_idx
+
+        n_repeats = max(0, global_idx - next_global_idx + 1)
+        for i in range(n_repeats):
+            local_idxs.append(local_idx)
+            global_idxs.append(next_global_idx + i)
+        next_global_idx += n_repeats
+    return local_idxs, global_idxs, next_global_idx
+
+
+def align_timestamps(
+    timestamps: List[float],
+    target_global_idxs: List[int],
+    start_time: float,
+    dt: float,
+    eps: float = 1e-5,
+):
+    if isinstance(target_global_idxs, np.ndarray):
+        target_global_idxs = target_global_idxs.tolist()
+    assert len(target_global_idxs) > 0
+
+    local_idxs, global_idxs, _ = get_accumulate_timestamp_idxs(
+        timestamps=timestamps,
+        start_time=start_time,
+        dt=dt,
+        eps=eps,
+        next_global_idx=target_global_idxs[0],
+        allow_negative=True,
+    )
+    if len(global_idxs) > len(target_global_idxs):
+        # if more steps available, truncate
+        global_idxs = global_idxs[: len(target_global_idxs)]
+        local_idxs = local_idxs[: len(target_global_idxs)]
+
+    if len(global_idxs) == 0:
+        import pdb
+
+        pdb.set_trace()
+
+    for i in range(len(target_global_idxs) - len(global_idxs)):
+        # if missing, repeat
+        local_idxs.append(len(timestamps) - 1)
+        global_idxs.append(global_idxs[-1] + 1)
+    assert global_idxs == target_global_idxs
+    assert len(local_idxs) == len(global_idxs)
+    return local_idxs
+
+
+class TimestampObsAccumulator:
+    def __init__(self, start_time: float, dt: float, eps: float = 1e-5):
+        self.start_time = start_time
+        self.dt = dt
+        self.eps = eps
+        self.obs_buffer = dict()
+        self.timestamp_buffer = None
+        self.next_global_idx = 0
+
+    def __len__(self):
+        return self.next_global_idx
+
+    @property
+    def data(self):
+        if self.timestamp_buffer is None:
+            return dict()
+        result = dict()
+        for key, value in self.obs_buffer.items():
+            result[key] = value[: len(self)]
+        return result
+
+    @property
+    def actual_timestamps(self):
+        if self.timestamp_buffer is None:
+            return np.array([])
+        return self.timestamp_buffer[: len(self)]
+
+    @property
+    def timestamps(self):
+        if self.timestamp_buffer is None:
+            return np.array([])
+        return self.start_time + np.arange(len(self)) * self.dt
+
+    def put(self, data: Dict[str, np.ndarray], timestamps: np.ndarray):
+        """
+        data:
+            key: T,*
+        """
+
+        local_idxs, global_idxs, self.next_global_idx = get_accumulate_timestamp_idxs(
+            timestamps=timestamps,
+            start_time=self.start_time,
+            dt=self.dt,
+            eps=self.eps,
+            next_global_idx=self.next_global_idx,
+        )
+
+        if len(global_idxs) > 0:
+            if self.timestamp_buffer is None:
+                # first allocation
+                self.obs_buffer = dict()
+                for key, value in data.items():
+                    self.obs_buffer[key] = np.zeros_like(value)
+                self.timestamp_buffer = np.zeros((len(timestamps),), dtype=np.float64)
+
+            this_max_size = global_idxs[-1] + 1
+            if this_max_size > len(self.timestamp_buffer):
+                # reallocate
+                new_size = max(this_max_size, len(self.timestamp_buffer) * 2)
+                for key in list(self.obs_buffer.keys()):
+                    new_shape = (new_size,) + self.obs_buffer[key].shape[1:]
+                    self.obs_buffer[key] = np.resize(self.obs_buffer[key], new_shape)
+                self.timestamp_buffer = np.resize(self.timestamp_buffer, (new_size))
+
+            # write data
+            for key, value in self.obs_buffer.items():
+                value[global_idxs] = data[key][local_idxs]
+            self.timestamp_buffer[global_idxs] = timestamps[local_idxs]
+
+
+class TimestampActionAccumulator:
+    def __init__(self, start_time: float, dt: float, eps: float = 1e-5):
+        """
+        Different from Obs accumulator, the action accumulator
+        allows overwriting previous values.
+        """
+        self.start_time = start_time
+        self.dt = dt
+        self.eps = eps
+        self.action_buffer = None
+        self.timestamp_buffer = None
+        self.size = 0
+
+    def __len__(self):
+        return self.size
+
+    @property
+    def actions(self):
+        if self.action_buffer is None:
+            return np.array([])
+        return self.action_buffer[: len(self)]
+
+    @property
+    def actual_timestamps(self):
+        if self.timestamp_buffer is None:
+            return np.array([])
+        return self.timestamp_buffer[: len(self)]
+
+    @property
+    def timestamps(self):
+        if self.timestamp_buffer is None:
+            return np.array([])
+        return self.start_time + np.arange(len(self)) * self.dt
+
+    def put(self, actions: np.ndarray, timestamps: np.ndarray):
+        """
+        Note: timestamps is the time when the action will be issued,
+        not when the action will be completed (target_timestamp)
+        """
+
+        local_idxs, global_idxs, _ = get_accumulate_timestamp_idxs(
+            timestamps=timestamps,
+            start_time=self.start_time,
+            dt=self.dt,
+            eps=self.eps,
+            # allows overwriting previous actions
+            next_global_idx=None,
+        )
+
+        if len(global_idxs) > 0:
+            if self.timestamp_buffer is None:
+                # first allocation
+                self.action_buffer = np.zeros_like(actions)
+                self.timestamp_buffer = np.zeros((len(actions),), dtype=np.float64)
+
+            this_max_size = global_idxs[-1] + 1
+            if this_max_size > len(self.timestamp_buffer):
+                # reallocate
+                new_size = max(this_max_size, len(self.timestamp_buffer) * 2)
+                new_shape = (new_size,) + self.action_buffer.shape[1:]
+                self.action_buffer = np.resize(self.action_buffer, new_shape)
+                self.timestamp_buffer = np.resize(self.timestamp_buffer, (new_size,))
+
+            # potentially rewrite old data (as expected)
+            self.action_buffer[global_idxs] = actions[local_idxs]
+            self.timestamp_buffer[global_idxs] = timestamps[local_idxs]
+            self.size = max(self.size, this_max_size)

code/umi/common/usb_util.py

@@ -0,0 +1,101 @@
+import os
+from subprocess import Popen, PIPE, DEVNULL
+import fcntl
+import pathlib
+
+
+def create_usb_list():
+    device_list = list()
+    lsusb_out = (
+        Popen(
+            "lsusb -v",
+            shell=True,
+            bufsize=64,
+            stdin=PIPE,
+            stdout=PIPE,
+            stderr=DEVNULL,
+            close_fds=True,
+        )
+        .stdout.read()
+        .strip()
+        .decode("utf-8")
+    )
+    usb_devices = lsusb_out.split("%s%s" % (os.linesep, os.linesep))
+    for device_categories in usb_devices:
+        if not device_categories:
+            continue
+        categories = device_categories.split(os.linesep)
+        device_stuff = categories[0].strip().split()
+        bus = device_stuff[1]
+        device = device_stuff[3][:-1]
+        device_dict = {"bus": bus, "device": device}
+        device_info = " ".join(device_stuff[6:])
+        device_dict["description"] = device_info
+        for category in categories:
+            if not category:
+                continue
+            categoryinfo = category.strip().split()
+            if categoryinfo[0] == "iManufacturer":
+                manufacturer_info = " ".join(categoryinfo[2:])
+                device_dict["manufacturer"] = manufacturer_info
+            if categoryinfo[0] == "iProduct":
+                device_info = " ".join(categoryinfo[2:])
+                device_dict["device"] = device_info
+        path = "/dev/bus/usb/%s/%s" % (bus, device)
+        device_dict["path"] = path
+
+        device_list.append(device_dict)
+    return device_list
+
+
+def reset_usb_device(dev_path):
+    USBDEVFS_RESET = 21780
+    try:
+        f = open(dev_path, "w", os.O_WRONLY)
+        fcntl.ioctl(f, USBDEVFS_RESET, 0)
+        print("Successfully reset %s" % dev_path)
+    except PermissionError as ex:
+        raise PermissionError('Try running "sudo chmod 777 {}"'.format(dev_path))
+
+
+def reset_all_elgato_devices():
+    """
+    Find and reset all Elgato capture cards.
+    Required to workaround a firmware bug.
+    """
+
+    # enumerate UBS device to find Elgato Capture Card
+    device_list = create_usb_list()
+
+    for dev in device_list:
+        if "Elgato" in dev["description"]:
+            dev_usb_path = dev["path"]
+            reset_usb_device(dev_usb_path)
+
+
+def get_sorted_v4l_paths(by_id=True):
+    """
+    If by_id, sort devices by device name + serial number (preserves device order)
+    else, sort devices by usb bus id (preserves usb port order)
+    """
+
+    dirname = "by-id"
+    if not by_id:
+        dirname = "by-path"
+    v4l_dir = pathlib.Path("/dev/v4l").joinpath(dirname)
+
+    valid_paths = list()
+    for dev_path in sorted(v4l_dir.glob("*video*")):
+        name = dev_path.name
+
+        # only keep devices ends with "index0"
+        # since they are the only valid video devices
+        index_str = name.split("-")[-1]
+        assert index_str.startswith("index")
+        index = int(index_str[5:])
+        if index == 0:
+            valid_paths.append(dev_path)
+
+    result = [str(x.absolute()) for x in valid_paths]
+
+    return result

code/umi/real_world/bimanual_umi_env.py

@@ -0,0 +1,695 @@
+from typing import Optional, List
+import pathlib
+import numpy as np
+import time
+import shutil
+import math
+from multiprocessing.managers import SharedMemoryManager
+from umi.real_world.rtde_interpolation_controller import RTDEInterpolationController
+from umi.real_world.wsg_controller import WSGController
+from umi.real_world.franka_interpolation_controller import FrankaInterpolationController
+from umi.real_world.multi_uvc_camera import MultiUvcCamera, VideoRecorder
+from diffusion_policy.common.timestamp_accumulator import (
+    TimestampActionAccumulator,
+    ObsAccumulator,
+)
+from umi.common.cv_util import draw_predefined_mask
+from umi.real_world.multi_camera_visualizer import MultiCameraVisualizer
+from diffusion_policy.common.replay_buffer import ReplayBuffer
+from diffusion_policy.common.cv2_util import get_image_transform, optimal_row_cols
+from umi.common.usb_util import reset_all_elgato_devices, get_sorted_v4l_paths
+from umi.common.pose_util import pose_to_pos_rot
+from umi.common.interpolation_util import get_interp1d, PoseInterpolator
+
+
+class BimanualUmiEnv:
+    def __init__(
+        self,
+        # required params
+        output_dir,
+        robots_config,  # list of dict[{robot_type: 'ur5', robot_ip: XXX, obs_latency: 0.0001, action_latency: 0.1, tcp_offset: 0.21}]
+        grippers_config,  # list of dict[{gripper_ip: XXX, gripper_port: 1000, obs_latency: 0.01, , action_latency: 0.1}]
+        # env params
+        frequency=20,
+        # obs
+        obs_image_resolution=(224, 224),
+        max_obs_buffer_size=60,
+        obs_float32=False,
+        camera_reorder=None,
+        no_mirror=False,
+        fisheye_converter=None,
+        mirror_swap=False,
+        # this latency compensates receive_timestamp
+        # all in seconds
+        camera_obs_latency=0.125,
+        # all in steps (relative to frequency)
+        camera_down_sample_steps=1,
+        robot_down_sample_steps=1,
+        gripper_down_sample_steps=1,
+        # all in steps (relative to frequency)
+        camera_obs_horizon=2,
+        robot_obs_horizon=2,
+        gripper_obs_horizon=2,
+        # action
+        max_pos_speed=0.25,
+        max_rot_speed=0.6,
+        init_joints=False,
+        # vis params
+        enable_multi_cam_vis=True,
+        multi_cam_vis_resolution=(960, 960),
+        # shared memory
+        shm_manager=None,
+    ):
+        output_dir = pathlib.Path(output_dir)
+        assert output_dir.parent.is_dir()
+        video_dir = output_dir.joinpath("videos")
+        video_dir.mkdir(parents=True, exist_ok=True)
+        zarr_path = str(output_dir.joinpath("replay_buffer.zarr").absolute())
+        replay_buffer = ReplayBuffer.create_from_path(zarr_path=zarr_path, mode="a")
+
+        if shm_manager is None:
+            shm_manager = SharedMemoryManager()
+            shm_manager.start()
+
+        # Find and reset all Elgato capture cards.
+        # Required to workaround a firmware bug.
+        reset_all_elgato_devices()
+
+        # Wait for all v4l cameras to be back online
+        time.sleep(0.1)
+        v4l_paths = get_sorted_v4l_paths()
+        if camera_reorder is not None:
+            paths = [v4l_paths[i] for i in camera_reorder]
+            v4l_paths = paths
+
+        # compute resolution for vis
+        rw, rh, col, row = optimal_row_cols(
+            n_cameras=len(v4l_paths),
+            in_wh_ratio=4 / 3,
+            max_resolution=multi_cam_vis_resolution,
+        )
+
+        # HACK: Separate video setting for each camera
+        # Elagto Cam Link 4k records at 4k 30fps
+        # Other capture card records at 720p 60fps
+        resolution = list()
+        capture_fps = list()
+        cap_buffer_size = list()
+        video_recorder = list()
+        transform = list()
+        vis_transform = list()
+        for path in v4l_paths:
+            if "Cam_Link_4K" in path:
+                res = (3840, 2160)
+                fps = 30
+                buf = 3
+                bit_rate = 6000 * 1000
+
+                def tf4k(data, input_res=res):
+                    img = data["color"]
+                    f = get_image_transform(
+                        input_res=input_res,
+                        output_res=obs_image_resolution,
+                        # obs output rgb
+                        bgr_to_rgb=True,
+                    )
+                    img = f(img)
+                    if obs_float32:
+                        img = img.astype(np.float32) / 255
+                    data["color"] = img
+                    return data
+
+                transform.append(tf4k)
+            else:
+                res = (1920, 1080)
+                fps = 60
+                buf = 1
+                bit_rate = 3000 * 1000
+
+                is_mirror = None
+                if mirror_swap:
+                    mirror_mask = np.ones((224, 224, 3), dtype=np.uint8)
+                    mirror_mask = draw_predefined_mask(
+                        mirror_mask,
+                        color=(0, 0, 0),
+                        mirror=True,
+                        gripper=False,
+                        finger=False,
+                    )
+                    is_mirror = mirror_mask[..., 0] == 0
+
+                def tf(data, input_res=res):
+                    img = data["color"]
+                    if fisheye_converter is None:
+                        f = get_image_transform(
+                            input_res=input_res,
+                            output_res=obs_image_resolution,
+                            # obs output rgb
+                            bgr_to_rgb=True,
+                        )
+                        img = np.ascontiguousarray(f(img))
+                        if is_mirror is not None:
+                            img[is_mirror] = img[:, ::-1, :][is_mirror]
+                        img = draw_predefined_mask(
+                            img,
+                            color=(0, 0, 0),
+                            mirror=no_mirror,
+                            gripper=True,
+                            finger=False,
+                            use_aa=True,
+                        )
+                    else:
+                        img = fisheye_converter.forward(img)
+                        img = img[..., ::-1]
+                    if obs_float32:
+                        img = img.astype(np.float32) / 255
+                    data["color"] = img
+                    return data
+
+                transform.append(tf)
+
+            resolution.append(res)
+            capture_fps.append(fps)
+            cap_buffer_size.append(buf)
+            video_recorder.append(
+                VideoRecorder.create_hevc_nvenc(
+                    fps=fps, input_pix_fmt="bgr24", bit_rate=bit_rate
+                )
+            )
+
+            def vis_tf(data, input_res=res):
+                img = data["color"]
+                f = get_image_transform(
+                    input_res=input_res, output_res=(rw, rh), bgr_to_rgb=False
+                )
+                img = f(img)
+                data["color"] = img
+                return data
+
+            vis_transform.append(vis_tf)
+
+        camera = MultiUvcCamera(
+            dev_video_paths=v4l_paths,
+            shm_manager=shm_manager,
+            resolution=resolution,
+            capture_fps=capture_fps,
+            # send every frame immediately after arrival
+            # ignores put_fps
+            put_downsample=False,
+            get_max_k=max_obs_buffer_size,
+            receive_latency=camera_obs_latency,
+            cap_buffer_size=cap_buffer_size,
+            transform=transform,
+            vis_transform=vis_transform,
+            video_recorder=video_recorder,
+            verbose=False,
+        )
+
+        multi_cam_vis = None
+        if enable_multi_cam_vis:
+            multi_cam_vis = MultiCameraVisualizer(
+                camera=camera, row=row, col=col, rgb_to_bgr=False
+            )
+
+        cube_diag = np.linalg.norm([1, 1, 1])
+        j_init = np.array([0, -90, -90, -90, 90, 0]) / 180 * np.pi
+        if not init_joints:
+            j_init = None
+
+        assert len(robots_config) == len(grippers_config)
+        robots: List[RTDEInterpolationController] = list()
+        grippers: List[WSGController] = list()
+        for rc in robots_config:
+            if rc["robot_type"].startswith("ur5"):
+                assert rc["robot_type"] in ["ur5", "ur5e"]
+                this_robot = RTDEInterpolationController(
+                    shm_manager=shm_manager,
+                    robot_ip=rc["robot_ip"],
+                    frequency=500 if rc["robot_type"] == "ur5e" else 125,
+                    lookahead_time=0.1,
+                    gain=300,
+                    max_pos_speed=max_pos_speed * cube_diag,
+                    max_rot_speed=max_rot_speed * cube_diag,
+                    launch_timeout=3,
+                    tcp_offset_pose=[0, 0, rc["tcp_offset"], 0, 0, 0],
+                    payload_mass=None,
+                    payload_cog=None,
+                    joints_init=j_init,
+                    joints_init_speed=1.05,
+                    soft_real_time=False,
+                    verbose=False,
+                    receive_keys=None,
+                    receive_latency=rc["robot_obs_latency"],
+                )
+            elif rc["robot_type"].startswith("franka"):
+                this_robot = FrankaInterpolationController(
+                    shm_manager=shm_manager,
+                    robot_ip=rc["robot_ip"],
+                    frequency=200,
+                    Kx_scale=1.0,
+                    Kxd_scale=np.array([2.0, 1.5, 2.0, 1.0, 1.0, 1.0]),
+                    verbose=False,
+                    receive_latency=rc["robot_obs_latency"],
+                )
+            else:
+                raise NotImplementedError()
+            robots.append(this_robot)
+
+        for gc in grippers_config:
+            this_gripper = WSGController(
+                shm_manager=shm_manager,
+                hostname=gc["gripper_ip"],
+                port=gc["gripper_port"],
+                receive_latency=gc["gripper_obs_latency"],
+                use_meters=True,
+            )
+
+            grippers.append(this_gripper)
+
+        self.camera = camera
+
+        self.robots = robots
+        self.robots_config = robots_config
+        self.grippers = grippers
+        self.grippers_config = grippers_config
+
+        self.multi_cam_vis = multi_cam_vis
+        self.frequency = frequency
+        self.max_obs_buffer_size = max_obs_buffer_size
+        self.max_pos_speed = max_pos_speed
+        self.max_rot_speed = max_rot_speed
+        # timing
+        self.camera_obs_latency = camera_obs_latency
+        self.camera_down_sample_steps = camera_down_sample_steps
+        self.robot_down_sample_steps = robot_down_sample_steps
+        self.gripper_down_sample_steps = gripper_down_sample_steps
+        self.camera_obs_horizon = camera_obs_horizon
+        self.robot_obs_horizon = robot_obs_horizon
+        self.gripper_obs_horizon = gripper_obs_horizon
+        # recording
+        self.output_dir = output_dir
+        self.video_dir = video_dir
+        self.replay_buffer = replay_buffer
+        # temp memory buffers
+        self.last_camera_data = None
+        # recording buffers
+        self.obs_accumulator = None
+        self.action_accumulator = None
+
+        self.start_time = None
+        self.last_time_step = 0
+
+    # ======== start-stop API =============
+    @property
+    def is_ready(self):
+        ready_flag = self.camera.is_ready
+        for robot in self.robots:
+            ready_flag = ready_flag and robot.is_ready
+        for gripper in self.grippers:
+            ready_flag = ready_flag and gripper.is_ready
+        return ready_flag
+
+    def start(self, wait=True):
+        self.camera.start(wait=False)
+        for robot in self.robots:
+            robot.start(wait=False)
+        for gripper in self.grippers:
+            gripper.start(wait=False)
+
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start(wait=False)
+        if wait:
+            self.start_wait()
+
+    def stop(self, wait=True):
+        self.end_episode()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop(wait=False)
+        for robot in self.robots:
+            robot.stop(wait=False)
+        for gripper in self.grippers:
+            gripper.stop(wait=False)
+        self.camera.stop(wait=False)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.camera.start_wait()
+        for robot in self.robots:
+            robot.start_wait()
+        for gripper in self.grippers:
+            gripper.start_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start_wait()
+
+    def stop_wait(self):
+        for robot in self.robots:
+            robot.stop_wait()
+        for gripper in self.grippers:
+            gripper.stop_wait()
+        self.camera.stop_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop_wait()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= async env API ===========
+    def get_obs(self) -> dict:
+        """
+        Timestamp alignment policy
+        We assume the cameras used for obs are always [0, k - 1], where k is the number of robots
+        All other cameras, find corresponding frame with the nearest timestamp
+        All low-dim observations, interpolate with respect to 'current' time
+        """
+
+        "observation dict"
+        assert self.is_ready
+
+        # get data
+        # 60 Hz, camera_calibrated_timestamp
+        k = (
+            math.ceil(
+                self.camera_obs_horizon
+                * self.camera_down_sample_steps
+                * (60 / self.frequency)
+            )
+            + 2
+        )  # here 2 is adjustable, typically 1 should be enough
+        # print('==>k  ', k, self.camera_obs_horizon, self.camera_down_sample_steps, self.frequency)
+        self.last_camera_data = self.camera.get(k=k, out=self.last_camera_data)
+
+        # both have more than n_obs_steps data
+        last_robots_data = list()
+        last_grippers_data = list()
+        # 125/500 hz, robot_receive_timestamp
+        for robot in self.robots:
+            last_robots_data.append(robot.get_all_state())
+        # 30 hz, gripper_receive_timestamp
+        for gripper in self.grippers:
+            last_grippers_data.append(gripper.get_all_state())
+
+        # select align_camera_idx
+        num_obs_cameras = len(self.robots)
+        align_camera_idx = None
+        running_best_error = np.inf
+
+        for camera_idx in range(num_obs_cameras):
+            this_error = 0
+            this_timestamp = self.last_camera_data[camera_idx]["timestamp"][-1]
+            for other_camera_idx in range(num_obs_cameras):
+                if other_camera_idx == camera_idx:
+                    continue
+                other_timestep_idx = -1
+                while True:
+                    if (
+                        self.last_camera_data[other_camera_idx]["timestamp"][
+                            other_timestep_idx
+                        ]
+                        < this_timestamp
+                    ):
+                        this_error += (
+                            this_timestamp
+                            - self.last_camera_data[other_camera_idx]["timestamp"][
+                                other_timestep_idx
+                            ]
+                        )
+                        break
+                    other_timestep_idx -= 1
+            if align_camera_idx is None or this_error < running_best_error:
+                running_best_error = this_error
+                align_camera_idx = camera_idx
+
+        last_timestamp = self.last_camera_data[align_camera_idx]["timestamp"][-1]
+        dt = 1 / self.frequency
+
+        # align camera obs timestamps
+        camera_obs_timestamps = last_timestamp - (
+            np.arange(self.camera_obs_horizon)[::-1]
+            * self.camera_down_sample_steps
+            * dt
+        )
+        camera_obs = dict()
+        for camera_idx, value in self.last_camera_data.items():
+            this_timestamps = value["timestamp"]
+            this_idxs = list()
+            for t in camera_obs_timestamps:
+                nn_idx = np.argmin(np.abs(this_timestamps - t))
+                # if np.abs(this_timestamps - t)[nn_idx] > 1.0 / 120 and camera_idx != 3:
+                #     print('ERROR!!!  ', camera_idx, len(this_timestamps), nn_idx, (this_timestamps - t)[nn_idx-1: nn_idx+2])
+                this_idxs.append(nn_idx)
+            # remap key
+            camera_obs[f"camera{camera_idx}_rgb"] = value["color"][this_idxs]
+
+        # obs_data to return (it only includes camera data at this stage)
+        obs_data = dict(camera_obs)
+
+        # include camera timesteps
+        obs_data["timestamp"] = camera_obs_timestamps
+
+        # align robot obs
+        robot_obs_timestamps = last_timestamp - (
+            np.arange(self.robot_obs_horizon)[::-1] * self.robot_down_sample_steps * dt
+        )
+        for robot_idx, last_robot_data in enumerate(last_robots_data):
+            robot_pose_interpolator = PoseInterpolator(
+                t=last_robot_data["robot_timestamp"], x=last_robot_data["ActualTCPPose"]
+            )
+            robot_pose = robot_pose_interpolator(robot_obs_timestamps)
+            robot_obs = {
+                f"robot{robot_idx}_eef_pos": robot_pose[..., :3],
+                f"robot{robot_idx}_eef_rot_axis_angle": robot_pose[..., 3:],
+            }
+            # update obs_data
+            obs_data.update(robot_obs)
+
+        # align gripper obs
+        gripper_obs_timestamps = last_timestamp - (
+            np.arange(self.gripper_obs_horizon)[::-1]
+            * self.gripper_down_sample_steps
+            * dt
+        )
+        for robot_idx, last_gripper_data in enumerate(last_grippers_data):
+            # align gripper obs
+            gripper_interpolator = get_interp1d(
+                t=last_gripper_data["gripper_timestamp"],
+                x=last_gripper_data["gripper_position"][..., None],
+            )
+            gripper_obs = {
+                f"robot{robot_idx}_gripper_width": gripper_interpolator(
+                    gripper_obs_timestamps
+                )
+            }
+
+            # update obs_data
+            obs_data.update(gripper_obs)
+
+        # accumulate obs
+        if self.obs_accumulator is not None:
+            for robot_idx, last_robot_data in enumerate(last_robots_data):
+                self.obs_accumulator.put(
+                    data={
+                        f"robot{robot_idx}_eef_pose": last_robot_data["ActualTCPPose"],
+                        f"robot{robot_idx}_joint_pos": last_robot_data["ActualQ"],
+                        f"robot{robot_idx}_joint_vel": last_robot_data["ActualQd"],
+                    },
+                    timestamps=last_robot_data["robot_timestamp"],
+                )
+
+            for robot_idx, last_gripper_data in enumerate(last_grippers_data):
+                self.obs_accumulator.put(
+                    data={
+                        f"robot{robot_idx}_gripper_width": last_gripper_data[
+                            "gripper_position"
+                        ][..., None]
+                    },
+                    timestamps=last_gripper_data["gripper_timestamp"],
+                )
+
+        return obs_data
+
+    def exec_actions(
+        self, actions: np.ndarray, timestamps: np.ndarray, compensate_latency=False
+    ):
+        assert self.is_ready
+        if not isinstance(actions, np.ndarray):
+            actions = np.array(actions)
+        if not isinstance(timestamps, np.ndarray):
+            timestamps = np.array(timestamps)
+
+        # convert action to pose
+        receive_time = time.time()
+        is_new = timestamps > receive_time
+        new_actions = actions[is_new]
+        new_timestamps = timestamps[is_new]
+
+        assert new_actions.shape[1] // len(self.robots) == 7
+        assert new_actions.shape[1] % len(self.robots) == 0
+
+        # schedule waypoints
+        for i in range(len(new_actions)):
+            for robot_idx, (robot, gripper, rc, gc) in enumerate(
+                zip(
+                    self.robots, self.grippers, self.robots_config, self.grippers_config
+                )
+            ):
+                r_latency = rc["robot_action_latency"] if compensate_latency else 0.0
+                g_latency = gc["gripper_action_latency"] if compensate_latency else 0.0
+                r_actions = new_actions[i, 7 * robot_idx + 0 : 7 * robot_idx + 6]
+                g_actions = new_actions[i, 7 * robot_idx + 6]
+                robot.schedule_waypoint(
+                    pose=r_actions, target_time=new_timestamps[i] - r_latency
+                )
+                gripper.schedule_waypoint(
+                    pos=g_actions, target_time=new_timestamps[i] - g_latency
+                )
+
+        # record actions
+        if self.action_accumulator is not None:
+            self.action_accumulator.put(new_actions, new_timestamps)
+
+    def get_robot_state(self):
+        return [robot.get_state() for robot in self.robots]
+
+    def get_gripper_state(self):
+        return [gripper.get_state() for gripper in self.grippers]
+
+    # recording API
+    def start_episode(self, start_time=None):
+        "Start recording and return first obs"
+        if start_time is None:
+            start_time = time.time()
+        self.start_time = start_time
+
+        assert self.is_ready
+
+        # prepare recording stuff
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        this_video_dir.mkdir(parents=True, exist_ok=True)
+        n_cameras = self.camera.n_cameras
+        video_paths = list()
+        for i in range(n_cameras):
+            video_paths.append(str(this_video_dir.joinpath(f"{i}.mp4").absolute()))
+
+        # start recording on camera
+        self.camera.restart_put(start_time=start_time)
+        self.camera.start_recording(video_path=video_paths, start_time=start_time)
+
+        # create accumulators
+        self.obs_accumulator = ObsAccumulator()
+        self.action_accumulator = TimestampActionAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        print(f"Episode {episode_id} started!")
+
+    def end_episode(self):
+        "Stop recording"
+        assert self.is_ready
+
+        # stop video recorder
+        self.camera.stop_recording()
+
+        # TODO
+        if self.obs_accumulator is not None:
+            # recording
+            assert self.action_accumulator is not None
+
+            # Since the only way to accumulate obs and action is by calling
+            # get_obs and exec_actions, which will be in the same thread.
+            # We don't need to worry new data come in here.
+            end_time = float("inf")
+            for key, value in self.obs_accumulator.timestamps.items():
+                end_time = min(end_time, value[-1])
+            end_time = min(end_time, self.action_accumulator.timestamps[-1])
+
+            actions = self.action_accumulator.actions
+            action_timestamps = self.action_accumulator.timestamps
+            n_steps = 0
+            if np.sum(self.action_accumulator.timestamps <= end_time) > 0:
+                n_steps = (
+                    np.nonzero(self.action_accumulator.timestamps <= end_time)[0][-1]
+                    + 1
+                )
+
+            if n_steps > 0:
+                timestamps = action_timestamps[:n_steps]
+                episode = {
+                    "timestamp": timestamps,
+                    "action": actions[:n_steps],
+                }
+                for robot_idx in range(len(self.robots)):
+                    robot_pose_interpolator = PoseInterpolator(
+                        t=np.array(
+                            self.obs_accumulator.timestamps[
+                                f"robot{robot_idx}_eef_pose"
+                            ]
+                        ),
+                        x=np.array(
+                            self.obs_accumulator.data[f"robot{robot_idx}_eef_pose"]
+                        ),
+                    )
+                    robot_pose = robot_pose_interpolator(timestamps)
+                    episode[f"robot{robot_idx}_eef_pos"] = robot_pose[:, :3]
+                    episode[f"robot{robot_idx}_eef_rot_axis_angle"] = robot_pose[:, 3:]
+                    joint_pos_interpolator = get_interp1d(
+                        np.array(
+                            self.obs_accumulator.timestamps[
+                                f"robot{robot_idx}_joint_pos"
+                            ]
+                        ),
+                        np.array(
+                            self.obs_accumulator.data[f"robot{robot_idx}_joint_pos"]
+                        ),
+                    )
+                    joint_vel_interpolator = get_interp1d(
+                        np.array(
+                            self.obs_accumulator.timestamps[
+                                f"robot{robot_idx}_joint_vel"
+                            ]
+                        ),
+                        np.array(
+                            self.obs_accumulator.data[f"robot{robot_idx}_joint_vel"]
+                        ),
+                    )
+                    episode[f"robot{robot_idx}_joint_pos"] = joint_pos_interpolator(
+                        timestamps
+                    )
+                    episode[f"robot{robot_idx}_joint_vel"] = joint_vel_interpolator(
+                        timestamps
+                    )
+
+                    gripper_interpolator = get_interp1d(
+                        t=np.array(
+                            self.obs_accumulator.timestamps[
+                                f"robot{robot_idx}_gripper_width"
+                            ]
+                        ),
+                        x=np.array(
+                            self.obs_accumulator.data[f"robot{robot_idx}_gripper_width"]
+                        ),
+                    )
+                    episode[f"robot{robot_idx}_gripper_width"] = gripper_interpolator(
+                        timestamps
+                    )
+
+                self.replay_buffer.add_episode(episode, compressors="disk")
+                episode_id = self.replay_buffer.n_episodes - 1
+                print(f"Episode {episode_id} saved!")
+
+            self.obs_accumulator = None
+            self.action_accumulator = None
+
+    def drop_episode(self):
+        self.end_episode()
+        self.replay_buffer.drop_episode()
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        if this_video_dir.exists():
+            shutil.rmtree(str(this_video_dir))
+        print(f"Episode {episode_id} dropped!")

code/umi/real_world/cmd_measure.lua

@@ -0,0 +1,76 @@
+-- Nicolas Alt, 2014-09-04
+-- Cheng Chi, 2023-07-27
+-- Command-and-measure script
+-- Tests showed about 30Hz rate
+require "socket"
+cmd.register(0xB0); -- Measure only
+cmd.register(0xB1); -- Position PD
+
+function hasbit(x, p)
+  return x % (p + p) >= p       
+end
+
+function send_state()
+    -- ==== Get measurements ====
+    state = gripper.state();
+    pos = mc.position();
+    speed = mc.speed();
+    force = mc.aforce();
+    time = socket.gettime();
+
+    if cmd.online() then
+        -- Only the lowest byte of state is sent!
+        cmd.send(id, etob(E_SUCCESS), state % 256, ntob(pos), ntob(speed), ntob(force), ntob(time));
+    end
+end
+
+function process()
+    id, payload = cmd.read();
+    
+    -- Position control
+    if id == 0xB1 then
+        -- get args
+        cmd_pos = bton({payload[2],payload[3],payload[4],payload[5]});
+        cmd_vel = bton({payload[6],payload[7],payload[8],payload[9]});
+        cmd_kp = bton({payload[10],payload[11],payload[12],payload[13]});
+        cmd_kd = bton({payload[14],payload[15],payload[16],payload[17]});
+        cmd_travel_force_limit = bton({payload[18],payload[19],payload[20],payload[21]});
+        cmd_blocked_force_limit = bton({payload[22],payload[23],payload[24],payload[25]});
+
+        -- get state
+        pos = mc.position();
+        vel = mc.speed();
+        
+        -- pd controller
+        e = cmd_pos - pos;
+        de = cmd_vel - vel;
+        act_vel = cmd_kp * e + cmd_kd * de;
+        
+        -- command
+        mc.speed(act_vel);
+        
+        -- force limit
+        if mc.blocked() then
+            mc.force(cmd_blocked_force_limit);
+        else
+            mc.force(cmd_travel_force_limit);
+        end
+    end
+    
+    --t_start = socket.gettime();
+    send_state();
+    --print(socket.gettime() - t_start);
+    
+end
+
+while true do
+    if cmd.online() then
+        -- process()
+        if not pcall(process) then
+            print("Error occured")
+            sleep(100)
+        end
+    else
+        sleep(100)
+    end
+end

code/umi/real_world/franka_interpolation_controller.py

@@ -0,0 +1,376 @@
+import os
+import time
+import enum
+import multiprocessing as mp
+from multiprocessing.managers import SharedMemoryManager
+import scipy.interpolate as si
+import scipy.spatial.transform as st
+import numpy as np
+
+from umi.shared_memory.shared_memory_queue import SharedMemoryQueue, Empty
+from umi.shared_memory.shared_memory_ring_buffer import SharedMemoryRingBuffer
+from umi.common.pose_trajectory_interpolator import PoseTrajectoryInterpolator
+from unified_video_action.common.precise_sleep import precise_wait
+import torch
+from umi.common.pose_util import pose_to_mat, mat_to_pose
+import zerorpc
+
+
+class Command(enum.Enum):
+    STOP = 0
+    SERVOL = 1
+    SCHEDULE_WAYPOINT = 2
+
+
+tx_flangerot90_tip = np.identity(4)
+tx_flangerot90_tip[:3, 3] = np.array([-0.0336, 0, 0.247])
+
+tx_flangerot45_flangerot90 = np.identity(4)
+tx_flangerot45_flangerot90[:3, :3] = st.Rotation.from_euler(
+    "x", [np.pi / 2]
+).as_matrix()
+
+tx_flange_flangerot45 = np.identity(4)
+tx_flange_flangerot45[:3, :3] = st.Rotation.from_euler("z", [np.pi / 4]).as_matrix()
+
+tx_flange_tip = tx_flange_flangerot45 @ tx_flangerot45_flangerot90 @ tx_flangerot90_tip
+tx_tip_flange = np.linalg.inv(tx_flange_tip)
+
+
+class FrankaInterface:
+    def __init__(self, ip="172.16.0.3", port=4242):
+        self.server = zerorpc.Client(heartbeat=20)
+        self.server.connect(f"tcp://{ip}:{port}")
+
+    def get_ee_pose(self):
+        flange_pose = np.array(self.server.get_ee_pose())
+        tip_pose = mat_to_pose(pose_to_mat(flange_pose) @ tx_flange_tip)
+        return tip_pose
+
+    def get_joint_positions(self):
+        return np.array(self.server.get_joint_positions())
+
+    def get_joint_velocities(self):
+        return np.array(self.server.get_joint_velocities())
+
+    def move_to_joint_positions(self, positions: np.ndarray, time_to_go: float):
+        self.server.move_to_joint_positions(positions.tolist(), time_to_go)
+
+    def start_cartesian_impedance(self, Kx: np.ndarray, Kxd: np.ndarray):
+        self.server.start_cartesian_impedance(Kx.tolist(), Kxd.tolist())
+
+    def update_desired_ee_pose(self, pose: np.ndarray):
+        self.server.update_desired_ee_pose(pose.tolist())
+
+    def terminate_current_policy(self):
+        self.server.terminate_current_policy()
+
+    def close(self):
+        self.server.close()
+
+
+class FrankaInterpolationController(mp.Process):
+    """
+    To ensure sending command to the robot with predictable latency
+    this controller need its separate process (due to python GIL)
+    """
+
+    def __init__(
+        self,
+        shm_manager: SharedMemoryManager,
+        robot_ip,
+        robot_port=4242,
+        frequency=1000,
+        Kx_scale=1.0,
+        Kxd_scale=1.0,
+        launch_timeout=3,
+        joints_init=None,
+        joints_init_duration=None,
+        soft_real_time=False,
+        verbose=False,
+        get_max_k=None,
+        receive_latency=0.0,
+    ):
+        """
+        robot_ip: the ip of the middle-layer controller (NUC)
+        frequency: 1000 for franka
+        Kx_scale: the scale of position gains
+        Kxd: the scale of velocity gains
+        soft_real_time: enables round-robin scheduling and real-time priority
+            requires running scripts/rtprio_setup.sh before hand.
+        """
+
+        if joints_init is not None:
+            joints_init = np.array(joints_init)
+            assert joints_init.shape == (7,)
+
+        super().__init__(name="FrankaPositionalController")
+        self.robot_ip = robot_ip
+        self.robot_port = robot_port
+        self.frequency = frequency
+        self.Kx = np.array([750.0, 750.0, 750.0, 15.0, 15.0, 15.0]) * Kx_scale
+        self.Kxd = np.array([37.0, 37.0, 37.0, 2.0, 2.0, 2.0]) * Kxd_scale
+        self.launch_timeout = launch_timeout
+        self.joints_init = joints_init
+        self.joints_init_duration = joints_init_duration
+        self.soft_real_time = soft_real_time
+        self.receive_latency = receive_latency
+        self.verbose = verbose
+
+        if get_max_k is None:
+            get_max_k = int(frequency * 5)
+
+        # build input queue
+        example = {
+            "cmd": Command.SERVOL.value,
+            "target_pose": np.zeros((6,), dtype=np.float64),
+            "duration": 0.0,
+            "target_time": 0.0,
+        }
+        input_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager, examples=example, buffer_size=256
+        )
+
+        # build ring buffer
+        receive_keys = [
+            ("ActualTCPPose", "get_ee_pose"),
+            ("ActualQ", "get_joint_positions"),
+            ("ActualQd", "get_joint_velocities"),
+        ]
+        example = dict()
+        for key, func_name in receive_keys:
+            if "joint" in func_name:
+                example[key] = np.zeros(7)
+            elif "ee_pose" in func_name:
+                example[key] = np.zeros(6)
+
+        example["robot_receive_timestamp"] = time.time()
+        example["robot_timestamp"] = time.time()
+        ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=example,
+            get_max_k=get_max_k,
+            get_time_budget=0.2,
+            put_desired_frequency=frequency,
+        )
+
+        self.ready_event = mp.Event()
+        self.input_queue = input_queue
+        self.ring_buffer = ring_buffer
+        self.receive_keys = receive_keys
+
+    # ========= launch method ===========
+    def start(self, wait=True):
+        super().start()
+        if wait:
+            self.start_wait()
+        if self.verbose:
+            print(
+                f"[FrankaPositionalController] Controller process spawned at {self.pid}"
+            )
+
+    def stop(self, wait=True):
+        message = {"cmd": Command.STOP.value}
+        self.input_queue.put(message)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.ready_event.wait(self.launch_timeout)
+        assert self.is_alive()
+
+    def stop_wait(self):
+        self.join()
+
+    @property
+    def is_ready(self):
+        return self.ready_event.is_set()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= command methods ============
+    def servoL(self, pose, duration=0.1):
+        """
+        duration: desired time to reach pose
+        """
+        assert self.is_alive()
+        assert duration >= (1 / self.frequency)
+        pose = np.array(pose)
+        assert pose.shape == (6,)
+
+        message = {
+            "cmd": Command.SERVOL.value,
+            "target_pose": pose,
+            "duration": duration,
+        }
+        self.input_queue.put(message)
+
+    def schedule_waypoint(self, pose, target_time):
+        pose = np.array(pose)
+        assert pose.shape == (6,)
+
+        message = {
+            "cmd": Command.SCHEDULE_WAYPOINT.value,
+            "target_pose": pose,
+            "target_time": target_time,
+        }
+        self.input_queue.put(message)
+
+    # ========= receive APIs =============
+    def get_state(self, k=None, out=None):
+        if k is None:
+            return self.ring_buffer.get(out=out)
+        else:
+            return self.ring_buffer.get_last_k(k=k, out=out)
+
+    def get_all_state(self):
+        return self.ring_buffer.get_all()
+
+    # ========= main loop in process ============
+    def run(self):
+        # enable soft real-time
+        if self.soft_real_time:
+            os.sched_setscheduler(0, os.SCHED_RR, os.sched_param(20))
+
+        # start polymetis interface
+        robot = FrankaInterface(self.robot_ip, self.robot_port)
+
+        try:
+            if self.verbose:
+                print(f"[FrankaPositionalController] Connect to robot: {self.robot_ip}")
+
+            # init pose
+            if self.joints_init is not None:
+                robot.move_to_joint_positions(
+                    positions=np.asarray(self.joints_init),
+                    time_to_go=self.joints_init_duration,
+                )
+
+            # main loop
+            dt = 1.0 / self.frequency
+            curr_pose = robot.get_ee_pose()
+
+            # use monotonic time to make sure the control loop never go backward
+            curr_t = time.monotonic()
+            last_waypoint_time = curr_t
+            pose_interp = PoseTrajectoryInterpolator(times=[curr_t], poses=[curr_pose])
+
+            # start franka cartesian impedance policy
+            robot.start_cartesian_impedance(Kx=self.Kx, Kxd=self.Kxd)
+
+            t_start = time.monotonic()
+            iter_idx = 0
+            keep_running = True
+            while keep_running:
+                # send command to robot
+                t_now = time.monotonic()
+                # diff = t_now - pose_interp.times[-1]
+                # if diff > 0:
+                #     print('extrapolate', diff)
+                tip_pose = pose_interp(t_now)
+                flange_pose = mat_to_pose(pose_to_mat(tip_pose) @ tx_tip_flange)
+
+                # send command to robot
+                robot.update_desired_ee_pose(flange_pose)
+
+                # update robot state
+                state = dict()
+                for key, func_name in self.receive_keys:
+                    state[key] = getattr(robot, func_name)()
+
+                t_recv = time.time()
+                state["robot_receive_timestamp"] = t_recv
+                state["robot_timestamp"] = t_recv - self.receive_latency
+                self.ring_buffer.put(state)
+
+                # fetch command from queue
+                try:
+                    # commands = self.input_queue.get_all()
+                    # n_cmd = len(commands['cmd'])
+                    # process at most 1 command per cycle to maintain frequency
+                    commands = self.input_queue.get_k(1)
+                    n_cmd = len(commands["cmd"])
+                except Empty:
+                    n_cmd = 0
+
+                # execute commands
+                for i in range(n_cmd):
+                    command = dict()
+                    for key, value in commands.items():
+                        command[key] = value[i]
+                    cmd = command["cmd"]
+
+                    if cmd == Command.STOP.value:
+                        keep_running = False
+                        # stop immediately, ignore later commands
+                        break
+                    elif cmd == Command.SERVOL.value:
+                        # since curr_pose always lag behind curr_target_pose
+                        # if we start the next interpolation with curr_pose
+                        # the command robot receive will have discontinouity
+                        # and cause jittery robot behavior.
+                        target_pose = command["target_pose"]
+                        duration = float(command["duration"])
+                        curr_time = t_now + dt
+                        t_insert = curr_time + duration
+                        pose_interp = pose_interp.drive_to_waypoint(
+                            pose=target_pose,
+                            time=t_insert,
+                            curr_time=curr_time,
+                        )
+                        last_waypoint_time = t_insert
+                        if self.verbose:
+                            print(
+                                "[FrankaPositionalController] New pose target:{} duration:{}s".format(
+                                    target_pose, duration
+                                )
+                            )
+                    elif cmd == Command.SCHEDULE_WAYPOINT.value:
+                        target_pose = command["target_pose"]
+                        target_time = float(command["target_time"])
+                        # translate global time to monotonic time
+                        target_time = time.monotonic() - time.time() + target_time
+                        curr_time = t_now + dt
+                        pose_interp = pose_interp.schedule_waypoint(
+                            pose=target_pose,
+                            time=target_time,
+                            curr_time=curr_time,
+                            last_waypoint_time=last_waypoint_time,
+                        )
+                        last_waypoint_time = target_time
+                    else:
+                        keep_running = False
+                        break
+
+                # regulate frequency
+                t_wait_util = t_start + (iter_idx + 1) * dt
+                precise_wait(t_wait_util, time_func=time.monotonic)
+
+                # first loop successful, ready to receive command
+                if iter_idx == 0:
+                    self.ready_event.set()
+                iter_idx += 1
+
+                if self.verbose:
+                    print(
+                        f"[FrankaPositionalController] Actual frequency {1/(time.monotonic() - t_now)}"
+                    )
+
+        finally:
+            # manditory cleanup
+            # terminate
+            print("\n\n\n\nterminate_current_policy\n\n\n\n\n")
+            robot.terminate_current_policy()
+            del robot
+            self.ready_event.set()
+
+            if self.verbose:
+                print(
+                    f"[FrankaPositionalController] Disconnected from robot: {self.robot_ip}"
+                )

code/umi/real_world/keystroke_counter.py

@@ -0,0 +1,48 @@
+from pynput.keyboard import Key, KeyCode, Listener
+from collections import defaultdict
+from threading import Lock
+
+
+class KeystrokeCounter(Listener):
+    def __init__(self):
+        self.key_count_map = defaultdict(lambda: 0)
+        self.key_press_list = list()
+        self.lock = Lock()
+        super().__init__(on_press=self.on_press, on_release=self.on_release)
+
+    def on_press(self, key):
+        with self.lock:
+            self.key_count_map[key] += 1
+            self.key_press_list.append(key)
+
+    def on_release(self, key):
+        pass
+
+    def clear(self):
+        with self.lock:
+            self.key_count_map = defaultdict(lambda: 0)
+            self.key_press_list = list()
+
+    def __getitem__(self, key):
+        with self.lock:
+            return self.key_count_map[key]
+
+    def get_press_events(self):
+        with self.lock:
+            events = list(self.key_press_list)
+            self.key_press_list = list()
+            return events
+
+
+if __name__ == "__main__":
+    import time
+
+    with KeystrokeCounter() as counter:
+        try:
+            while True:
+                print("Space:", counter[Key.space])
+                print("q:", counter[KeyCode(char="q")])
+                time.sleep(1 / 60)
+        except KeyboardInterrupt:
+            events = counter.get_press_events()
+            print(events)

code/umi/real_world/multi_camera_visualizer.py

@@ -0,0 +1,85 @@
+import time
+import multiprocessing as mp
+import numpy as np
+import cv2
+from threadpoolctl import threadpool_limits
+
+
+class MultiCameraVisualizer(mp.Process):
+    def __init__(
+        self,
+        camera,
+        row,
+        col,
+        window_name="Multi Cam Vis",
+        vis_fps=60,
+        fill_value=0,
+        rgb_to_bgr=True,
+    ):
+        super().__init__()
+        self.row = row
+        self.col = col
+        self.window_name = window_name
+        self.vis_fps = vis_fps
+        self.fill_value = fill_value
+        self.rgb_to_bgr = rgb_to_bgr
+        self.camera = camera
+        # shared variables
+        self.stop_event = mp.Event()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    def start(self, wait=False):
+        super().start()
+
+    def stop(self, wait=False):
+        self.stop_event.set()
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        pass
+
+    def stop_wait(self):
+        self.join()
+
+    def run(self):
+        cv2.setNumThreads(1)
+        threadpool_limits(1)
+        channel_slice = slice(None)
+        if self.rgb_to_bgr:
+            channel_slice = slice(None, None, -1)
+
+        vis_data = None
+        vis_img = None
+        while not self.stop_event.is_set():
+            vis_data = self.camera.get_vis(out=vis_data)
+            color = vis_data["color"]
+            N, H, W, C = color.shape
+            assert C == 3
+            oh = H * self.row
+            ow = W * self.col
+            if vis_img is None:
+                vis_img = np.full(
+                    (oh, ow, 3), fill_value=self.fill_value, dtype=np.uint8
+                )
+            for row in range(self.row):
+                for col in range(self.col):
+                    idx = col + row * self.col
+                    h_start = H * row
+                    h_end = h_start + H
+                    w_start = W * col
+                    w_end = w_start + W
+                    if idx < N:
+                        # opencv uses bgr
+                        vis_img[h_start:h_end, w_start:w_end] = color[
+                            idx, :, :, channel_slice
+                        ]
+            cv2.imshow(self.window_name, vis_img)
+            cv2.pollKey()
+            time.sleep(1 / self.vis_fps)

code/umi/real_world/multi_uvc_camera.py

@@ -0,0 +1,184 @@
+from typing import List, Optional, Union, Dict, Callable
+import numbers
+import copy
+import time
+import pathlib
+from multiprocessing.managers import SharedMemoryManager
+import numpy as np
+from umi.real_world.uvc_camera import UvcCamera
+from umi.real_world.video_recorder import VideoRecorder
+
+
+class MultiUvcCamera:
+    def __init__(
+        self,
+        # v4l2 device file path
+        # e.g. /dev/video0
+        # or /dev/v4l/by-id/usb-Elgato_Elgato_HD60_X_A00XB320216MTR-video-index0
+        dev_video_paths: List[str],
+        shm_manager: Optional[SharedMemoryManager] = None,
+        resolution=(1280, 720),
+        capture_fps=60,
+        put_fps=None,
+        put_downsample=True,
+        get_max_k=30,
+        receive_latency=0.0,
+        cap_buffer_size=1,
+        transform: Optional[Union[Callable[[Dict], Dict], List[Callable]]] = None,
+        vis_transform: Optional[Union[Callable[[Dict], Dict], List[Callable]]] = None,
+        recording_transform: Optional[
+            Union[Callable[[Dict], Dict], List[Callable]]
+        ] = None,
+        video_recorder: Optional[Union[VideoRecorder, List[VideoRecorder]]] = None,
+        verbose=False,
+    ):
+        super().__init__()
+
+        if shm_manager is None:
+            shm_manager = SharedMemoryManager()
+            shm_manager.start()
+        n_cameras = len(dev_video_paths)
+
+        resolution = repeat_to_list(resolution, n_cameras, tuple)
+        capture_fps = repeat_to_list(capture_fps, n_cameras, (int, float))
+        cap_buffer_size = repeat_to_list(cap_buffer_size, n_cameras, int)
+        transform = repeat_to_list(transform, n_cameras, Callable)
+        vis_transform = repeat_to_list(vis_transform, n_cameras, Callable)
+        recording_transform = repeat_to_list(recording_transform, n_cameras, Callable)
+        video_recorder = repeat_to_list(video_recorder, n_cameras, VideoRecorder)
+
+        cameras = dict()
+        for i, path in enumerate(dev_video_paths):
+            cameras[path] = UvcCamera(
+                shm_manager=shm_manager,
+                dev_video_path=path,
+                resolution=resolution[i],
+                capture_fps=capture_fps[i],
+                put_fps=put_fps,
+                put_downsample=put_downsample,
+                get_max_k=get_max_k,
+                receive_latency=receive_latency,
+                cap_buffer_size=cap_buffer_size[i],
+                transform=transform[i],
+                vis_transform=vis_transform[i],
+                recording_transform=recording_transform[i],
+                video_recorder=video_recorder[i],
+                verbose=verbose,
+            )
+
+        self.cameras = cameras
+        self.shm_manager = shm_manager
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    @property
+    def n_cameras(self):
+        return len(self.cameras)
+
+    @property
+    def is_ready(self):
+        is_ready = True
+        for camera in self.cameras.values():
+            if not camera.is_ready:
+                is_ready = False
+        return is_ready
+
+    def start(self, wait=True, put_start_time=None):
+        if put_start_time is None:
+            put_start_time = time.time()
+        for camera in self.cameras.values():
+            camera.start(wait=False, put_start_time=put_start_time)
+
+        if wait:
+            self.start_wait()
+
+    def stop(self, wait=True):
+        for camera in self.cameras.values():
+            camera.stop(wait=False)
+
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        for camera in self.cameras.values():
+            camera.start_wait()
+
+    def stop_wait(self):
+        for camera in self.cameras.values():
+            camera.join()
+
+    def get(self, k=None, out=None) -> Dict[int, Dict[str, np.ndarray]]:
+        """
+        Return order T,H,W,C
+        {
+            0: {
+                'rgb': (T,H,W,C),
+                'timestamp': (T,)
+            },
+            1: ...
+        }
+        """
+        if out is None:
+            out = dict()
+        for i, camera in enumerate(self.cameras.values()):
+            this_out = None
+            if i in out:
+                this_out = out[i]
+            this_out = camera.get(k=k, out=this_out)
+            out[i] = this_out
+        return out
+
+    def get_vis(self, out=None):
+        results = list()
+        for i, camera in enumerate(self.cameras.values()):
+            this_out = None
+            if out is not None:
+                this_out = dict()
+                for key, v in out.items():
+                    # use the slicing trick to maintain the array
+                    # when v is 1D
+                    this_out[key] = v[i : i + 1].reshape(v.shape[1:])
+            this_out = camera.get_vis(out=this_out)
+            if out is None:
+                results.append(this_out)
+        if out is None:
+            out = dict()
+            for key in results[0].keys():
+                out[key] = np.stack([x[key] for x in results])
+        return out
+
+    def start_recording(self, video_path: Union[str, List[str]], start_time: float):
+        if isinstance(video_path, str):
+            # directory
+            video_dir = pathlib.Path(video_path)
+            assert video_dir.parent.is_dir()
+            video_dir.mkdir(parents=True, exist_ok=True)
+            video_path = list()
+            for i in range(self.n_cameras):
+                video_path.append(str(video_dir.joinpath(f"{i}.mp4").absolute()))
+        assert len(video_path) == self.n_cameras
+
+        for i, camera in enumerate(self.cameras.values()):
+            camera.start_recording(video_path[i], start_time)
+
+    def stop_recording(self):
+        for i, camera in enumerate(self.cameras.values()):
+            camera.stop_recording()
+
+    def restart_put(self, start_time):
+        for camera in self.cameras.values():
+            camera.restart_put(start_time)
+
+
+def repeat_to_list(x, n: int, cls):
+    if x is None:
+        x = [None] * n
+    if isinstance(x, cls):
+        x = [copy.deepcopy(x) for _ in range(n)]
+    assert len(x) == n
+    return x

code/umi/real_world/real_env.py

@@ -0,0 +1,488 @@
+from typing import Optional
+import pathlib
+import numpy as np
+import time
+import shutil
+import math
+from multiprocessing.managers import SharedMemoryManager
+from umi.real_world.rtde_interpolation_controller import RTDEInterpolationController
+from umi.real_world.wsg_controller import WSGController
+from umi.real_world.multi_uvc_camera import MultiUvcCamera
+from umi.real_world.video_recorder import VideoRecorder
+from unified_video_action.common.timestamp_accumulator import (
+    TimestampObsAccumulator,
+    TimestampActionAccumulator,
+    align_timestamps,
+)
+from umi.real_world.multi_camera_visualizer import MultiCameraVisualizer
+from unified_video_action.common.replay_buffer import ReplayBuffer
+from unified_video_action.common.cv2_util import get_image_transform, optimal_row_cols
+from umi.common.usb_util import reset_all_elgato_devices, get_sorted_v4l_paths
+
+
+DEFAULT_OBS_KEY_MAP = {
+    # robot
+    "ActualTCPPose": "robot_eef_pose",
+    "ActualTCPSpeed": "robot_eef_pose_vel",
+    "ActualQ": "robot_joint",
+    "ActualQd": "robot_joint_vel",
+    # gripper
+    "gripper_position": "gripper_position",
+    "gripper_velocity": "gripper_velocity",
+    "gripper_force": "gripper_force",
+    # timestamps
+    "step_idx": "step_idx",
+    "timestamp": "timestamp",
+}
+
+
+class RealEnv:
+    def __init__(
+        self,
+        # required params
+        output_dir,
+        robot_ip,
+        gripper_ip,
+        gripper_port=1000,
+        # env params
+        frequency=10,
+        n_obs_steps=2,
+        # obs
+        obs_image_resolution=(256, 256),
+        max_obs_buffer_size=30,
+        obs_key_map=DEFAULT_OBS_KEY_MAP,
+        obs_float32=False,
+        # action
+        max_pos_speed=0.25,
+        max_rot_speed=0.6,
+        # robot
+        tcp_offset=0.13,
+        init_joints=False,
+        # video capture params
+        video_capture_fps=60,
+        video_capture_resolution=(1280, 720),
+        # saving params
+        record_raw_video=True,
+        thread_per_video=4,
+        video_crf=21,
+        # vis params
+        enable_multi_cam_vis=True,
+        multi_cam_vis_resolution=(1280, 720),
+        # shared memory
+        shm_manager=None,
+    ):
+        assert frequency <= video_capture_fps
+        output_dir = pathlib.Path(output_dir)
+        assert output_dir.parent.is_dir()
+        video_dir = output_dir.joinpath("videos")
+        video_dir.mkdir(parents=True, exist_ok=True)
+        zarr_path = str(output_dir.joinpath("replay_buffer.zarr").absolute())
+        replay_buffer = ReplayBuffer.create_from_path(zarr_path=zarr_path, mode="a")
+
+        if shm_manager is None:
+            shm_manager = SharedMemoryManager()
+            shm_manager.start()
+
+        # Find and reset all Elgato capture cards.
+        # Required to workaround a firmware bug.
+        reset_all_elgato_devices()
+
+        # Wait for all v4l cameras to be back online
+        time.sleep(0.1)
+        v4l_paths = get_sorted_v4l_paths()
+
+        color_tf = get_image_transform(
+            input_res=video_capture_resolution,
+            output_res=obs_image_resolution,
+            # obs output rgb
+            bgr_to_rgb=True,
+        )
+        color_transform = color_tf
+        if obs_float32:
+            color_transform = lambda x: color_tf(x).astype(np.float32) / 255
+
+        def transform(data):
+            data["color"] = color_transform(data["color"])
+            return data
+
+        rw, rh, col, row = optimal_row_cols(
+            n_cameras=len(v4l_paths),
+            in_wh_ratio=obs_image_resolution[0] / obs_image_resolution[1],
+            max_resolution=multi_cam_vis_resolution,
+        )
+        vis_color_transform = get_image_transform(
+            input_res=video_capture_resolution, output_res=(rw, rh), bgr_to_rgb=False
+        )
+
+        def vis_transform(data):
+            data["color"] = vis_color_transform(data["color"])
+            return data
+
+        recording_transfrom = None
+        recording_fps = video_capture_fps
+        recording_pix_fmt = "bgr24"
+        if not record_raw_video:
+            recording_transfrom = transform
+            recording_fps = frequency
+            recording_pix_fmt = "rgb24"
+
+        video_recorder = VideoRecorder.create_h264(
+            shm_manager=shm_manager,
+            fps=recording_fps,
+            codec="h264",
+            input_pix_fmt=recording_pix_fmt,
+            crf=video_crf,
+            thread_type="FRAME",
+            thread_count=thread_per_video,
+        )
+
+        camera = MultiUvcCamera(
+            dev_video_paths=v4l_paths,
+            shm_manager=shm_manager,
+            resolution=video_capture_resolution,
+            capture_fps=video_capture_fps,
+            put_fps=video_capture_fps,
+            # send every frame immediately after arrival
+            # ignores put_fps
+            put_downsample=False,
+            record_fps=recording_fps,
+            get_max_k=max_obs_buffer_size,
+            transform=transform,
+            vis_transform=vis_transform,
+            recording_transform=recording_transfrom,
+            video_recorder=video_recorder,
+            verbose=False,
+        )
+
+        multi_cam_vis = None
+        if enable_multi_cam_vis:
+            multi_cam_vis = MultiCameraVisualizer(
+                camera=camera, row=row, col=col, rgb_to_bgr=False
+            )
+
+        cube_diag = np.linalg.norm([1, 1, 1])
+        j_init = np.array([0, -90, -90, -90, 90, 0]) / 180 * np.pi
+        if not init_joints:
+            j_init = None
+
+        robot = RTDEInterpolationController(
+            shm_manager=shm_manager,
+            robot_ip=robot_ip,
+            frequency=500,  # UR5 CB3 RTDE
+            lookahead_time=0.1,
+            gain=300,
+            max_pos_speed=max_pos_speed * cube_diag,
+            max_rot_speed=max_rot_speed * cube_diag,
+            launch_timeout=3,
+            tcp_offset_pose=[0, 0, tcp_offset, 0, 0, 0],
+            payload_mass=None,
+            payload_cog=None,
+            joints_init=j_init,
+            joints_init_speed=1.05,
+            soft_real_time=False,
+            verbose=False,
+            receive_keys=None,
+            get_max_k=max_obs_buffer_size,
+        )
+
+        gripper = WSGController(
+            shm_manager=shm_manager,
+            hostname=gripper_ip,
+            port=gripper_port,
+        )
+
+        self.camera = camera
+        self.robot = robot
+        self.gripper = gripper
+        self.multi_cam_vis = multi_cam_vis
+        self.video_capture_fps = video_capture_fps
+        self.frequency = frequency
+        self.n_obs_steps = n_obs_steps
+        self.max_obs_buffer_size = max_obs_buffer_size
+        self.max_pos_speed = max_pos_speed
+        self.max_rot_speed = max_rot_speed
+        self.obs_key_map = obs_key_map
+        # recording
+        self.output_dir = output_dir
+        self.video_dir = video_dir
+        self.replay_buffer = replay_buffer
+        # temp memory buffers
+        self.last_camera_data = None
+        # recording buffers
+        self.robot_obs_accumulator = None
+        self.gripper_obs_accumulator = None
+        self.action_accumulator = None
+        self.stage_accumulator = None
+
+        self.start_time = None
+
+    # ======== start-stop API =============
+    @property
+    def is_ready(self):
+        return self.camera.is_ready and self.robot.is_ready and self.gripper.is_ready
+
+    def start(self, wait=True):
+        self.camera.start(wait=False)
+        self.gripper.start(wait=False)
+        self.robot.start(wait=False)
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start(wait=False)
+        if wait:
+            self.start_wait()
+
+    def stop(self, wait=True):
+        self.end_episode()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop(wait=False)
+        self.robot.stop(wait=False)
+        self.gripper.stop(wait=False)
+        self.camera.stop(wait=False)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.camera.start_wait()
+        self.gripper.start_wait()
+        self.robot.start_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start_wait()
+
+    def stop_wait(self):
+        self.robot.stop_wait()
+        self.gripper.stop_wait()
+        self.camera.stop_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop_wait()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= async env API ===========
+    def get_obs(self) -> dict:
+        "observation dict"
+        assert self.is_ready
+
+        # get data
+        # 30 Hz, camera_receive_timestamp
+        k = math.ceil(self.n_obs_steps * (self.video_capture_fps / self.frequency))
+        self.last_camera_data = self.camera.get(k=k, out=self.last_camera_data)
+
+        # 125 hz, robot_receive_timestamp
+        last_robot_data = self.robot.get_all_state()
+        # both have more than n_obs_steps data
+
+        # 30 hz, gripper_receive_timestamp
+        last_gripper_data = self.gripper.get_all_state()
+
+        # align camera obs timestamps
+        dt = 1 / self.frequency
+        last_timestamp = np.max(
+            [x["timestamp"][-1] for x in self.last_camera_data.values()]
+        )
+        obs_align_timestamps = last_timestamp - (np.arange(self.n_obs_steps)[::-1] * dt)
+
+        camera_obs = dict()
+        for camera_idx, value in self.last_camera_data.items():
+            this_timestamps = value["timestamp"]
+            this_idxs = list()
+            for t in obs_align_timestamps:
+                is_before_idxs = np.nonzero(this_timestamps < t)[0]
+                this_idx = 0
+                if len(is_before_idxs) > 0:
+                    this_idx = is_before_idxs[-1]
+                this_idxs.append(this_idx)
+            # remap key
+            camera_obs[f"camera_{camera_idx}"] = value["color"][this_idxs]
+
+        # align robot obs
+        robot_timestamps = last_robot_data["robot_receive_timestamp"]
+        this_timestamps = robot_timestamps
+        this_idxs = list()
+        for t in obs_align_timestamps:
+            is_before_idxs = np.nonzero(this_timestamps < t)[0]
+            this_idx = 0
+            if len(is_before_idxs) > 0:
+                this_idx = is_before_idxs[-1]
+            this_idxs.append(this_idx)
+
+        robot_obs_raw = dict()
+        for k, v in last_robot_data.items():
+            if k in self.obs_key_map:
+                robot_obs_raw[self.obs_key_map[k]] = v
+
+        robot_obs = dict()
+        for k, v in robot_obs_raw.items():
+            robot_obs[k] = v[this_idxs]
+
+        # align gripper obs
+        gripper_timestamps = last_gripper_data["gripper_receive_timestamp"]
+        this_timestamps = gripper_timestamps
+        this_idxs = list()
+        for t in obs_align_timestamps:
+            is_before_idxs = np.nonzero(this_timestamps < t)[0]
+            this_idx = 0
+            if len(is_before_idxs) > 0:
+                this_idx = is_before_idxs[-1]
+            this_idxs.append(this_idx)
+
+        gripper_obs_raw = dict()
+        for k, v in last_gripper_data.items():
+            if k in self.obs_key_map:
+                gripper_obs_raw[self.obs_key_map[k]] = v
+
+        gripper_obs = dict()
+        for k, v in gripper_obs_raw.items():
+            gripper_obs[k] = v[this_idxs]
+
+        # accumulate obs
+        if self.robot_obs_accumulator is not None:
+            self.robot_obs_accumulator.put(robot_obs_raw, robot_timestamps)
+        if self.gripper_obs_accumulator is not None:
+            self.gripper_obs_accumulator.put(gripper_obs_raw, gripper_timestamps)
+
+        # return obs
+        obs_data = dict(camera_obs)
+        obs_data.update(robot_obs)
+        obs_data.update(gripper_obs)
+        obs_data["timestamp"] = obs_align_timestamps
+        return obs_data
+
+    def exec_actions(
+        self,
+        actions: np.ndarray,
+        timestamps: np.ndarray,
+        stages: Optional[np.ndarray] = None,
+    ):
+        assert self.is_ready
+        if not isinstance(actions, np.ndarray):
+            actions = np.array(actions)
+        if not isinstance(timestamps, np.ndarray):
+            timestamps = np.array(timestamps)
+        if stages is None:
+            stages = np.zeros_like(timestamps, dtype=np.int64)
+        elif not isinstance(stages, np.ndarray):
+            stages = np.array(stages, dtype=np.int64)
+
+        # convert action to pose
+        receive_time = time.time()
+        is_new = timestamps > receive_time
+        new_actions = actions[is_new]
+        new_timestamps = timestamps[is_new]
+        new_stages = stages[is_new]
+
+        # schedule waypoints
+        for i in range(len(new_actions)):
+            r_actions = new_actions[i, :6]
+            g_actions = new_actions[i, 6:] + 1
+            self.robot.schedule_waypoint(pose=r_actions, target_time=new_timestamps[i])
+            self.gripper.schedule_waypoint(
+                pos=g_actions, target_time=new_timestamps[i] - 0.02
+            )
+
+        # record actions
+        if self.action_accumulator is not None:
+            self.action_accumulator.put(new_actions, new_timestamps)
+        if self.stage_accumulator is not None:
+            self.stage_accumulator.put(new_stages, new_timestamps)
+
+    def get_robot_state(self):
+        return self.robot.get_state()
+
+    # recording API
+    def start_episode(self, start_time=None):
+        "Start recording and return first obs"
+        if start_time is None:
+            start_time = time.time()
+        self.start_time = start_time
+
+        assert self.is_ready
+
+        # prepare recording stuff
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        this_video_dir.mkdir(parents=True, exist_ok=True)
+        n_cameras = self.camera.n_cameras
+        video_paths = list()
+        for i in range(n_cameras):
+            video_paths.append(str(this_video_dir.joinpath(f"{i}.mp4").absolute()))
+
+        # start recording on camera
+        self.camera.restart_put(start_time=start_time)
+        self.camera.start_recording(video_path=video_paths, start_time=start_time)
+
+        # create accumulators
+        self.robot_obs_accumulator = TimestampObsAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        self.gripper_obs_accumulator = TimestampObsAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        self.action_accumulator = TimestampActionAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        self.stage_accumulator = TimestampActionAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        print(f"Episode {episode_id} started!")
+
+    def end_episode(self):
+        "Stop recording"
+        assert self.is_ready
+
+        # stop video recorder
+        self.camera.stop_recording()
+
+        if self.robot_obs_accumulator is not None:
+            # recording
+            assert self.gripper_obs_accumulator is not None
+            assert self.action_accumulator is not None
+            assert self.stage_accumulator is not None
+
+            # Since the only way to accumulate obs and action is by calling
+            # get_obs and exec_actions, which will be in the same thread.
+            # We don't need to worry new data come in here.
+            robot_obs_data = self.robot_obs_accumulator.data
+            robot_obs_timestamps = self.robot_obs_accumulator.timestamps
+
+            gripper_obs_data = self.gripper_obs_accumulator.data
+            gripper_obs_timestamps = self.gripper_obs_accumulator.timestamps
+
+            actions = self.action_accumulator.actions
+            action_timestamps = self.action_accumulator.timestamps
+            stages = self.stage_accumulator.actions
+            n_steps = min(
+                len(robot_obs_timestamps),
+                len(gripper_obs_timestamps),
+                len(action_timestamps),
+            )
+            if n_steps > 0:
+                episode = dict()
+                episode["timestamp"] = robot_obs_timestamps[:n_steps]
+                episode["action"] = actions[:n_steps]
+                episode["stage"] = stages[:n_steps]
+                for key, value in robot_obs_data.items():
+                    episode[key] = value[:n_steps]
+                for key, value in gripper_obs_data.items():
+                    episode[key] = value[:n_steps]
+                self.replay_buffer.add_episode(episode, compressors="disk")
+                episode_id = self.replay_buffer.n_episodes - 1
+                print(f"Episode {episode_id} saved!")
+
+            self.robot_obs_accumulator = None
+            self.gripper_obs_accumulator = None
+            self.action_accumulator = None
+            self.stage_accumulator = None
+
+    def drop_episode(self):
+        self.end_episode()
+        self.replay_buffer.drop_episode()
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        if this_video_dir.exists():
+            shutil.rmtree(str(this_video_dir))
+        print(f"Episode {episode_id} dropped!")

code/umi/real_world/real_inference_util.py

@@ -0,0 +1,236 @@
+from typing import Dict, Callable, Tuple, List
+import numpy as np
+import collections
+from unified_video_action.common.cv2_util import get_image_transform
+from unified_video_action.common.pose_repr_util import (
+    compute_relative_pose,
+    convert_pose_mat_rep,
+)
+from umi.common.pose_util import (
+    pose_to_mat,
+    mat_to_pose,
+    mat_to_pose10d,
+    pose10d_to_mat,
+)
+from unified_video_action.model.common.rotation_transformer import RotationTransformer
+
+
+def get_real_obs_resolution(shape_meta: dict) -> Tuple[int, int]:
+    out_res = None
+    obs_shape_meta = shape_meta["obs"]
+    for key, attr in obs_shape_meta.items():
+        type = attr.get("type", "low_dim")
+        shape = attr.get("shape")
+        if type == "rgb":
+            co, ho, wo = shape
+            if out_res is None:
+                out_res = (wo, ho)
+            assert out_res == (wo, ho)
+    return out_res
+
+
+def get_real_obs_dict(
+    env_obs: Dict[str, np.ndarray],
+    shape_meta: dict,
+) -> Dict[str, np.ndarray]:
+    obs_dict_np = dict()
+    obs_shape_meta = shape_meta["obs"]
+    for key, attr in obs_shape_meta.items():
+        type = attr.get("type", "low_dim")
+        shape = attr.get("shape")
+        if type == "rgb":
+            this_imgs_in = env_obs[key]
+            t, hi, wi, ci = this_imgs_in.shape
+            co, ho, wo = shape
+            assert ci == co
+            out_imgs = this_imgs_in
+            if (ho != hi) or (wo != wi) or (this_imgs_in.dtype == np.uint8):
+                tf = get_image_transform(
+                    input_res=(wi, hi), output_res=(wo, ho), bgr_to_rgb=False
+                )
+                out_imgs = np.stack([tf(x) for x in this_imgs_in])
+                if this_imgs_in.dtype == np.uint8:
+                    out_imgs = out_imgs.astype(np.float32) / 255
+            # THWC to TCHW
+            obs_dict_np[key] = np.moveaxis(out_imgs, -1, 1)
+        elif type == "low_dim":
+            this_data_in = env_obs[key]
+            obs_dict_np[key] = this_data_in
+    return obs_dict_np
+
+
+def get_real_umi_obs_dict(
+    env_obs: Dict[str, np.ndarray],
+    shape_meta: dict,
+    obs_pose_repr: str = "abs",
+    tx_robot1_robot0: np.ndarray = None,
+    episode_start_pose: List[np.ndarray] = None,
+) -> Dict[str, np.ndarray]:
+    obs_dict_np = dict()
+    # process non-pose
+    obs_shape_meta = shape_meta["obs"]
+    robot_prefix_map = collections.defaultdict(list)
+    for key, attr in obs_shape_meta.items():
+        type = attr.get("type", "low_dim")
+        shape = attr.get("shape")
+        if type == "rgb":
+            this_imgs_in = env_obs[key]
+            t, hi, wi, ci = this_imgs_in.shape
+            co, ho, wo = shape
+            assert ci == co
+            out_imgs = this_imgs_in
+            if (ho != hi) or (wo != wi) or (this_imgs_in.dtype == np.uint8):
+                tf = get_image_transform(
+                    input_res=(wi, hi), output_res=(wo, ho), bgr_to_rgb=False
+                )
+                out_imgs = np.stack([tf(x) for x in this_imgs_in])
+                if this_imgs_in.dtype == np.uint8:
+                    out_imgs = out_imgs.astype(np.float32) / 255
+            # THWC to TCHW
+            obs_dict_np[key] = np.moveaxis(out_imgs, -1, 1)
+        elif type == "low_dim" and ("eef" not in key):
+            this_data_in = env_obs[key]
+            obs_dict_np[key] = this_data_in
+            # handle multi-robots
+            ks = key.split("_")
+            if ks[0].startswith("robot"):
+                robot_prefix_map[ks[0]].append(key)
+
+    # generate relative pose
+    for robot_prefix in robot_prefix_map.keys():
+        # convert pose to mat
+        pose_mat = pose_to_mat(
+            np.concatenate(
+                [
+                    env_obs[robot_prefix + "_eef_pos"],
+                    env_obs[robot_prefix + "_eef_rot_axis_angle"],
+                ],
+                axis=-1,
+            )
+        )
+
+        # solve reltaive obs
+        obs_pose_mat = convert_pose_mat_rep(
+            pose_mat, base_pose_mat=pose_mat[-1], pose_rep=obs_pose_repr, backward=False
+        )
+
+        obs_pose = mat_to_pose10d(obs_pose_mat)
+        obs_dict_np[robot_prefix + "_eef_pos"] = obs_pose[..., :3]
+        obs_dict_np[robot_prefix + "_eef_rot_axis_angle"] = obs_pose[..., 3:]
+
+    # generate pose relative to other robot
+    n_robots = len(robot_prefix_map)
+    for robot_id in range(n_robots):
+        # convert pose to mat
+        assert f"robot{robot_id}" in robot_prefix_map
+        tx_robota_tcpa = pose_to_mat(
+            np.concatenate(
+                [
+                    env_obs[f"robot{robot_id}_eef_pos"],
+                    env_obs[f"robot{robot_id}_eef_rot_axis_angle"],
+                ],
+                axis=-1,
+            )
+        )
+        for other_robot_id in range(n_robots):
+            if robot_id == other_robot_id:
+                continue
+            tx_robotb_tcpb = pose_to_mat(
+                np.concatenate(
+                    [
+                        env_obs[f"robot{other_robot_id}_eef_pos"],
+                        env_obs[f"robot{other_robot_id}_eef_rot_axis_angle"],
+                    ],
+                    axis=-1,
+                )
+            )
+            tx_robota_robotb = tx_robot1_robot0
+            if robot_id == 0:
+                tx_robota_robotb = np.linalg.inv(tx_robot1_robot0)
+            tx_robota_tcpb = tx_robota_robotb @ tx_robotb_tcpb
+
+            rel_obs_pose_mat = convert_pose_mat_rep(
+                tx_robota_tcpa,
+                base_pose_mat=tx_robota_tcpb[-1],
+                pose_rep="relative",
+                backward=False,
+            )
+            rel_obs_pose = mat_to_pose10d(rel_obs_pose_mat)
+            obs_dict_np[f"robot{robot_id}_eef_pos_wrt{other_robot_id}"] = rel_obs_pose[
+                :, :3
+            ]
+            obs_dict_np[f"robot{robot_id}_eef_rot_axis_angle_wrt{other_robot_id}"] = (
+                rel_obs_pose[:, 3:]
+            )
+
+    # generate relative pose with respect to episode start
+    if episode_start_pose is not None:
+        for robot_id in range(n_robots):
+            # convert pose to mat
+            pose_mat = pose_to_mat(
+                np.concatenate(
+                    [
+                        env_obs[f"robot{robot_id}_eef_pos"],
+                        env_obs[f"robot{robot_id}_eef_rot_axis_angle"],
+                    ],
+                    axis=-1,
+                )
+            )
+
+            # get start pose
+            start_pose = episode_start_pose[robot_id]
+            start_pose_mat = pose_to_mat(start_pose)
+            rel_obs_pose_mat = convert_pose_mat_rep(
+                pose_mat,
+                base_pose_mat=start_pose_mat,
+                pose_rep="relative",
+                backward=False,
+            )
+
+            rel_obs_pose = mat_to_pose10d(rel_obs_pose_mat)
+            # obs_dict_np[f'robot{robot_id}_eef_pos_wrt_start'] = rel_obs_pose[:,:3]
+            obs_dict_np[f"robot{robot_id}_eef_rot_axis_angle_wrt_start"] = rel_obs_pose[
+                :, 3:
+            ]
+
+    return obs_dict_np
+
+
+def get_real_umi_action(
+    action: np.ndarray, env_obs: Dict[str, np.ndarray], action_pose_repr: str = "abs"
+):
+
+    n_robots = int(action.shape[-1] // 10)
+    env_action = list()
+    for robot_idx in range(n_robots):
+        # convert pose to mat
+        pose_mat = pose_to_mat(
+            np.concatenate(
+                [
+                    env_obs[f"robot{robot_idx}_eef_pos"][-1],
+                    env_obs[f"robot{robot_idx}_eef_rot_axis_angle"][-1],
+                ],
+                axis=-1,
+            )
+        )
+
+        start = robot_idx * 10
+        action_pose10d = action[..., start : start + 9]
+        action_grip = action[..., start + 9 : start + 10]
+        action_pose_mat = pose10d_to_mat(action_pose10d)
+
+        # solve relative action
+        action_mat = convert_pose_mat_rep(
+            action_pose_mat,
+            base_pose_mat=pose_mat,
+            pose_rep=action_pose_repr,
+            backward=True,
+        )
+
+        # convert action to pose
+        action_pose = mat_to_pose(action_mat)
+        env_action.append(action_pose)
+        env_action.append(action_grip)
+
+    env_action = np.concatenate(env_action, axis=-1)
+    return env_action

code/umi/real_world/rtde_interpolation_controller.py

@@ -0,0 +1,376 @@
+import os
+import time
+import enum
+import multiprocessing as mp
+from multiprocessing.managers import SharedMemoryManager
+import scipy.interpolate as si
+import scipy.spatial.transform as st
+import numpy as np
+from rtde_control import RTDEControlInterface
+from rtde_receive import RTDEReceiveInterface
+from umi.shared_memory.shared_memory_queue import SharedMemoryQueue, Empty
+from umi.shared_memory.shared_memory_ring_buffer import SharedMemoryRingBuffer
+from umi.common.pose_trajectory_interpolator import PoseTrajectoryInterpolator
+from unified_video_action.common.precise_sleep import precise_wait
+
+
+class Command(enum.Enum):
+    STOP = 0
+    SERVOL = 1
+    SCHEDULE_WAYPOINT = 2
+
+
+class RTDEInterpolationController(mp.Process):
+    """
+    To ensure sending command to the robot with predictable latency
+    this controller need its separate process (due to python GIL)
+    """
+
+    def __init__(
+        self,
+        shm_manager: SharedMemoryManager,
+        robot_ip,
+        frequency=125,
+        lookahead_time=0.1,
+        gain=300,
+        max_pos_speed=0.25,  # 5% of max speed
+        max_rot_speed=0.16,  # 5% of max speed
+        launch_timeout=3,
+        tcp_offset_pose=None,
+        payload_mass=None,
+        payload_cog=None,
+        joints_init=None,
+        joints_init_speed=1.05,
+        soft_real_time=False,
+        verbose=False,
+        receive_keys=None,
+        get_max_k=None,
+        receive_latency=0.0,
+    ):
+        """
+        frequency: CB2=125, UR3e=500
+        lookahead_time: [0.03, 0.2]s smoothens the trajectory with this lookahead time
+        gain: [100, 2000] proportional gain for following target position
+        max_pos_speed: m/s
+        max_rot_speed: rad/s
+        tcp_offset_pose: 6d pose
+        payload_mass: float
+        payload_cog: 3d position, center of gravity
+        soft_real_time: enables round-robin scheduling and real-time priority
+            requires running scripts/rtprio_setup.sh before hand.
+
+        """
+        # verify
+        assert 0 < frequency <= 500
+        assert 0.03 <= lookahead_time <= 0.2
+        assert 100 <= gain <= 2000
+        assert 0 < max_pos_speed
+        assert 0 < max_rot_speed
+        if tcp_offset_pose is not None:
+            tcp_offset_pose = np.array(tcp_offset_pose)
+            assert tcp_offset_pose.shape == (6,)
+        if payload_mass is not None:
+            assert 0 <= payload_mass <= 5
+        if payload_cog is not None:
+            payload_cog = np.array(payload_cog)
+            assert payload_cog.shape == (3,)
+            assert payload_mass is not None
+        if joints_init is not None:
+            joints_init = np.array(joints_init)
+            assert joints_init.shape == (6,)
+
+        super().__init__(name="RTDEPositionalController")
+        self.robot_ip = robot_ip
+        self.frequency = frequency
+        self.lookahead_time = lookahead_time
+        self.gain = gain
+        self.max_pos_speed = max_pos_speed
+        self.max_rot_speed = max_rot_speed
+        self.launch_timeout = launch_timeout
+        self.tcp_offset_pose = tcp_offset_pose
+        self.payload_mass = payload_mass
+        self.payload_cog = payload_cog
+        self.joints_init = joints_init
+        self.joints_init_speed = joints_init_speed
+        self.soft_real_time = soft_real_time
+        self.receive_latency = receive_latency
+        self.verbose = verbose
+
+        if get_max_k is None:
+            get_max_k = int(frequency * 5)
+
+        # build input queue
+        example = {
+            "cmd": Command.SERVOL.value,
+            "target_pose": np.zeros((6,), dtype=np.float64),
+            "duration": 0.0,
+            "target_time": 0.0,
+        }
+        input_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager, examples=example, buffer_size=256
+        )
+
+        # build ring buffer
+        if receive_keys is None:
+            receive_keys = [
+                "ActualTCPPose",
+                "ActualTCPSpeed",
+                "ActualQ",
+                "ActualQd",
+                "TargetTCPPose",
+                "TargetTCPSpeed",
+                "TargetQ",
+                "TargetQd",
+            ]
+        rtde_r = RTDEReceiveInterface(hostname=robot_ip)
+        example = dict()
+        for key in receive_keys:
+            example[key] = np.array(getattr(rtde_r, "get" + key)())
+        example["robot_receive_timestamp"] = time.time()
+        example["robot_timestamp"] = time.time()
+        ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=example,
+            get_max_k=get_max_k,
+            get_time_budget=0.2,
+            put_desired_frequency=frequency,
+        )
+
+        self.ready_event = mp.Event()
+        self.input_queue = input_queue
+        self.ring_buffer = ring_buffer
+        self.receive_keys = receive_keys
+
+    # ========= launch method ===========
+    def start(self, wait=True):
+        super().start()
+        if wait:
+            self.start_wait()
+        if self.verbose:
+            print(
+                f"[RTDEPositionalController] Controller process spawned at {self.pid}"
+            )
+
+    def stop(self, wait=True):
+        message = {"cmd": Command.STOP.value}
+        self.input_queue.put(message)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.ready_event.wait(self.launch_timeout)
+        assert self.is_alive()
+
+    def stop_wait(self):
+        self.join()
+
+    @property
+    def is_ready(self):
+        return self.ready_event.is_set()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= command methods ============
+    def servoL(self, pose, duration=0.1):
+        """
+        duration: desired time to reach pose
+        """
+        assert self.is_alive()
+        assert duration >= (1 / self.frequency)
+        pose = np.array(pose)
+        assert pose.shape == (6,)
+
+        message = {
+            "cmd": Command.SERVOL.value,
+            "target_pose": pose,
+            "duration": duration,
+        }
+        self.input_queue.put(message)
+
+    def schedule_waypoint(self, pose, target_time):
+        pose = np.array(pose)
+        assert pose.shape == (6,)
+
+        message = {
+            "cmd": Command.SCHEDULE_WAYPOINT.value,
+            "target_pose": pose,
+            "target_time": target_time,
+        }
+        self.input_queue.put(message)
+
+    # ========= receive APIs =============
+    def get_state(self, k=None, out=None):
+        if k is None:
+            return self.ring_buffer.get(out=out)
+        else:
+            return self.ring_buffer.get_last_k(k=k, out=out)
+
+    def get_all_state(self):
+        return self.ring_buffer.get_all()
+
+    # ========= main loop in process ============
+    def run(self):
+        # enable soft real-time
+        if self.soft_real_time:
+            os.sched_setscheduler(0, os.SCHED_RR, os.sched_param(20))
+
+        # start rtde
+        robot_ip = self.robot_ip
+        rtde_c = RTDEControlInterface(hostname=robot_ip)
+        rtde_r = RTDEReceiveInterface(hostname=robot_ip)
+
+        try:
+            if self.verbose:
+                print(f"[RTDEPositionalController] Connect to robot: {robot_ip}")
+
+            # set parameters
+            if self.tcp_offset_pose is not None:
+                rtde_c.setTcp(self.tcp_offset_pose)
+            if self.payload_mass is not None:
+                if self.payload_cog is not None:
+                    assert rtde_c.setPayload(self.payload_mass, self.payload_cog)
+                else:
+                    assert rtde_c.setPayload(self.payload_mass)
+
+            # init pose
+            if self.joints_init is not None:
+                assert rtde_c.moveJ(self.joints_init, self.joints_init_speed, 1.4)
+
+            # main loop
+            dt = 1.0 / self.frequency
+            curr_pose = rtde_r.getActualTCPPose()
+            # use monotonic time to make sure the control loop never go backward
+            curr_t = time.monotonic()
+            last_waypoint_time = curr_t
+            pose_interp = PoseTrajectoryInterpolator(times=[curr_t], poses=[curr_pose])
+
+            t_start = time.monotonic()
+            iter_idx = 0
+            keep_running = True
+            while keep_running:
+                # start control iteration
+                # t_start = rtde_c.initPeriod()
+
+                # send command to robot
+                t_now = time.monotonic()
+                # diff = t_now - pose_interp.times[-1]
+                # if diff > 0:
+                #     print('extrapolate', diff)
+                pose_command = pose_interp(t_now)
+                vel = 0.5
+                acc = 0.5
+                assert rtde_c.servoL(
+                    pose_command,
+                    vel,
+                    acc,  # dummy, not used by ur5
+                    dt,
+                    self.lookahead_time,
+                    self.gain,
+                )
+
+                # update robot state
+                state = dict()
+                for key in self.receive_keys:
+                    state[key] = np.array(getattr(rtde_r, "get" + key)())
+                t_recv = time.time()
+                state["robot_receive_timestamp"] = t_recv
+                state["robot_timestamp"] = t_recv - self.receive_latency
+                self.ring_buffer.put(state)
+
+                # fetch command from queue
+                try:
+                    # commands = self.input_queue.get_all()
+                    # n_cmd = len(commands['cmd'])
+                    # process at most 1 command per cycle to maintain frequency
+                    commands = self.input_queue.get_k(1)
+                    n_cmd = len(commands["cmd"])
+                except Empty:
+                    n_cmd = 0
+
+                # execute commands
+                for i in range(n_cmd):
+                    command = dict()
+                    for key, value in commands.items():
+                        command[key] = value[i]
+                    cmd = command["cmd"]
+
+                    if cmd == Command.STOP.value:
+                        keep_running = False
+                        # stop immediately, ignore later commands
+                        break
+                    elif cmd == Command.SERVOL.value:
+                        # since curr_pose always lag behind curr_target_pose
+                        # if we start the next interpolation with curr_pose
+                        # the command robot receive will have discontinouity
+                        # and cause jittery robot behavior.
+                        target_pose = command["target_pose"]
+                        duration = float(command["duration"])
+                        curr_time = t_now + dt
+                        t_insert = curr_time + duration
+                        pose_interp = pose_interp.drive_to_waypoint(
+                            pose=target_pose,
+                            time=t_insert,
+                            curr_time=curr_time,
+                            max_pos_speed=self.max_pos_speed,
+                            max_rot_speed=self.max_rot_speed,
+                        )
+                        last_waypoint_time = t_insert
+                        if self.verbose:
+                            print(
+                                "[RTDEPositionalController] New pose target:{} duration:{}s".format(
+                                    target_pose, duration
+                                )
+                            )
+                    elif cmd == Command.SCHEDULE_WAYPOINT.value:
+                        target_pose = command["target_pose"]
+                        target_time = float(command["target_time"])
+                        # translate global time to monotonic time
+                        target_time = time.monotonic() - time.time() + target_time
+                        curr_time = t_now + dt
+                        pose_interp = pose_interp.schedule_waypoint(
+                            pose=target_pose,
+                            time=target_time,
+                            max_pos_speed=self.max_pos_speed,
+                            max_rot_speed=self.max_rot_speed,
+                            curr_time=curr_time,
+                            last_waypoint_time=last_waypoint_time,
+                        )
+                        last_waypoint_time = target_time
+                    else:
+                        keep_running = False
+                        break
+
+                # regulate frequency
+                # rtde_c.waitPeriod(t_start)
+                t_wait_util = t_start + (iter_idx + 1) * dt
+                precise_wait(t_wait_util, time_func=time.monotonic)
+
+                # first loop successful, ready to receive command
+                if iter_idx == 0:
+                    self.ready_event.set()
+                iter_idx += 1
+
+                if self.verbose:
+                    print(
+                        f"[RTDEPositionalController] Actual frequency {1/(time.monotonic() - t_now)}"
+                    )
+
+        finally:
+            # manditory cleanup
+            # decelerate
+            rtde_c.servoStop()
+
+            # terminate
+            rtde_c.stopScript()
+            rtde_c.disconnect()
+            rtde_r.disconnect()
+            self.ready_event.set()
+
+            if self.verbose:
+                print(f"[RTDEPositionalController] Disconnected from robot: {robot_ip}")

code/umi/real_world/spacemouse_shared_memory.py

@@ -0,0 +1,167 @@
+import multiprocessing as mp
+import numpy as np
+import time
+from spnav import (
+    spnav_open,
+    spnav_poll_event,
+    spnav_close,
+    SpnavMotionEvent,
+    SpnavButtonEvent,
+)
+from umi.shared_memory.shared_memory_ring_buffer import SharedMemoryRingBuffer
+
+
+class Spacemouse(mp.Process):
+    def __init__(
+        self,
+        shm_manager,
+        get_max_k=30,
+        frequency=200,
+        max_value=500,
+        deadzone=(0, 0, 0, 0, 0, 0),
+        dtype=np.float32,
+        n_buttons=2,
+    ):
+        """
+        Continuously listen to 3D connection space naviagtor events
+        and update the latest state.
+
+        max_value: {300, 500} 300 for wired version and 500 for wireless
+        deadzone: [0,1], number or tuple, axis with value lower than this value will stay at 0
+
+        front
+        z
+        ^   _
+        |  (O) space mouse
+        |
+        *----->x right
+        y
+        """
+        super().__init__()
+        if np.issubdtype(type(deadzone), np.number):
+            deadzone = np.full(6, fill_value=deadzone, dtype=dtype)
+        else:
+            deadzone = np.array(deadzone, dtype=dtype)
+        assert (deadzone >= 0).all()
+
+        # copied variables
+        self.frequency = frequency
+        self.max_value = max_value
+        self.dtype = dtype
+        self.deadzone = deadzone
+        self.n_buttons = n_buttons
+        # self.motion_event = SpnavMotionEvent([0,0,0], [0,0,0], 0)
+        # self.button_state = defaultdict(lambda: False)
+        self.tx_zup_spnav = np.array([[0, 0, -1], [1, 0, 0], [0, 1, 0]], dtype=dtype)
+
+        example = {
+            # 3 translation, 3 rotation, 1 period
+            "motion_event": np.zeros((7,), dtype=np.int64),
+            # left and right button
+            "button_state": np.zeros((n_buttons,), dtype=bool),
+            "receive_timestamp": time.time(),
+        }
+        ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=example,
+            get_max_k=get_max_k,
+            get_time_budget=0.2,
+            put_desired_frequency=frequency,
+        )
+
+        # shared variables
+        self.ready_event = mp.Event()
+        self.stop_event = mp.Event()
+        self.ring_buffer = ring_buffer
+
+    # ======= get state APIs ==========
+
+    def get_motion_state(self):
+        state = self.ring_buffer.get()
+        state = np.array(state["motion_event"][:6], dtype=self.dtype) / self.max_value
+        is_dead = (-self.deadzone < state) & (state < self.deadzone)
+        state[is_dead] = 0
+        return state
+
+    def get_motion_state_transformed(self):
+        """
+        Return in right-handed coordinate
+        z
+        *------>y right
+        |   _
+        |  (O) space mouse
+        v
+        x
+        back
+
+        """
+        state = self.get_motion_state()
+        tf_state = np.zeros_like(state)
+        tf_state[:3] = self.tx_zup_spnav @ state[:3]
+        tf_state[3:] = self.tx_zup_spnav @ state[3:]
+        return tf_state
+
+    def get_button_state(self):
+        state = self.ring_buffer.get()
+        return state["button_state"]
+
+    def is_button_pressed(self, button_id):
+        return self.get_button_state()[button_id]
+
+    # ========== start stop API ===========
+
+    def start(self, wait=True):
+        super().start()
+        if wait:
+            self.ready_event.wait()
+
+    def stop(self, wait=True):
+        self.stop_event.set()
+        if wait:
+            self.join()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= main loop ==========
+    def run(self):
+        spnav_open()
+        try:
+            motion_event = np.zeros((7,), dtype=np.int64)
+            button_state = np.zeros((self.n_buttons,), dtype=bool)
+            # send one message immediately so client can start reading
+            self.ring_buffer.put(
+                {
+                    "motion_event": motion_event,
+                    "button_state": button_state,
+                    "receive_timestamp": time.time(),
+                }
+            )
+            self.ready_event.set()
+
+            while not self.stop_event.is_set():
+                event = spnav_poll_event()
+                receive_timestamp = time.time()
+                if isinstance(event, SpnavMotionEvent):
+                    motion_event[:3] = event.translation
+                    motion_event[3:6] = event.rotation
+                    motion_event[6] = event.period
+                elif isinstance(event, SpnavButtonEvent):
+                    button_state[event.bnum] = event.press
+                else:
+                    # finish integrating this round of events
+                    # before sending over
+                    self.ring_buffer.put(
+                        {
+                            "motion_event": motion_event,
+                            "button_state": button_state,
+                            "receive_timestamp": receive_timestamp,
+                        }
+                    )
+                    time.sleep(1 / self.frequency)
+        finally:
+            spnav_close()

code/umi/real_world/umi_env.py

@@ -0,0 +1,603 @@
+from typing import Optional
+import pathlib
+import numpy as np
+import time
+import shutil
+import math
+import cv2
+from multiprocessing.managers import SharedMemoryManager
+from umi.real_world.rtde_interpolation_controller import RTDEInterpolationController
+from umi.real_world.wsg_controller import WSGController
+from umi.real_world.franka_interpolation_controller import FrankaInterpolationController
+from umi.real_world.multi_uvc_camera import MultiUvcCamera, VideoRecorder
+from unified_video_action.common.timestamp_accumulator import (
+    TimestampActionAccumulator,
+    ObsAccumulator,
+)
+from umi.common.cv_util import draw_predefined_mask, get_mirror_crop_slices
+from umi.real_world.multi_camera_visualizer import MultiCameraVisualizer
+from unified_video_action.common.replay_buffer import ReplayBuffer
+from unified_video_action.common.cv2_util import get_image_transform, optimal_row_cols
+from umi.common.usb_util import reset_all_elgato_devices, get_sorted_v4l_paths
+from umi.common.pose_util import pose_to_pos_rot
+from umi.common.interpolation_util import get_interp1d, PoseInterpolator
+
+
+class UmiEnv:
+    def __init__(
+        self,
+        # required params
+        output_dir,
+        robot_ip,
+        gripper_ip,
+        gripper_port=1000,
+        # env params
+        frequency=20,
+        robot_type="ur5",
+        # obs
+        obs_image_resolution=(224, 224),
+        max_obs_buffer_size=60,
+        obs_float32=False,
+        camera_reorder=None,
+        no_mirror=False,
+        fisheye_converter=None,
+        mirror_crop=False,
+        mirror_swap=False,
+        # timing
+        align_camera_idx=0,
+        # this latency compensates receive_timestamp
+        # all in seconds
+        camera_obs_latency=0.125,
+        robot_obs_latency=0.0001,
+        gripper_obs_latency=0.01,
+        robot_action_latency=0.1,
+        gripper_action_latency=0.1,
+        # all in steps (relative to frequency)
+        camera_down_sample_steps=1,
+        robot_down_sample_steps=1,
+        gripper_down_sample_steps=1,
+        # all in steps (relative to frequency)
+        camera_obs_horizon=2,
+        robot_obs_horizon=2,
+        gripper_obs_horizon=2,
+        # action
+        max_pos_speed=0.25,
+        max_rot_speed=0.6,
+        # robot
+        tcp_offset=0.21,
+        init_joints=False,
+        # vis params
+        enable_multi_cam_vis=True,
+        multi_cam_vis_resolution=(960, 960),
+        # shared memory
+        shm_manager=None,
+    ):
+        output_dir = pathlib.Path(output_dir)
+        assert output_dir.parent.is_dir()
+        video_dir = output_dir.joinpath("videos")
+        video_dir.mkdir(parents=True, exist_ok=True)
+        zarr_path = str(output_dir.joinpath("replay_buffer.zarr").absolute())
+        replay_buffer = ReplayBuffer.create_from_path(zarr_path=zarr_path, mode="a")
+
+        if shm_manager is None:
+            shm_manager = SharedMemoryManager()
+            shm_manager.start()
+
+        # Find and reset all Elgato capture cards.
+        # Required to workaround a firmware bug.
+        reset_all_elgato_devices()
+
+        # Wait for all v4l cameras to be back online
+        time.sleep(0.1)
+        v4l_paths = get_sorted_v4l_paths()
+        if camera_reorder is not None:
+            paths = [v4l_paths[i] for i in camera_reorder]
+            v4l_paths = paths
+
+        # compute resolution for vis
+        rw, rh, col, row = optimal_row_cols(
+            n_cameras=len(v4l_paths),
+            in_wh_ratio=4 / 3,
+            max_resolution=multi_cam_vis_resolution,
+        )
+
+        # HACK: Separate video setting for each camera
+        # Elagto Cam Link 4k records at 4k 30fps
+        # Other capture card records at 720p 60fps
+        resolution = list()
+        capture_fps = list()
+        cap_buffer_size = list()
+        video_recorder = list()
+        transform = list()
+        vis_transform = list()
+        for idx, path in enumerate(v4l_paths):
+            if "Cam_Link_4K" in path:
+                res = (3840, 2160)
+                fps = 30
+                buf = 3
+                bit_rate = 6000 * 1000
+
+                def tf4k(data, input_res=res):
+                    img = data["color"]
+                    f = get_image_transform(
+                        input_res=input_res,
+                        output_res=obs_image_resolution,
+                        # obs output rgb
+                        bgr_to_rgb=True,
+                    )
+                    img = f(img)
+                    if obs_float32:
+                        img = img.astype(np.float32) / 255
+                    data["color"] = img
+                    return data
+
+                transform.append(tf4k)
+            else:
+                res = (1920, 1080)
+                fps = 60
+                buf = 1
+                bit_rate = 3000 * 1000
+                stack_crop = (idx == 0) and mirror_crop
+                is_mirror = None
+                if mirror_swap:
+                    mirror_mask = np.ones((224, 224, 3), dtype=np.uint8)
+                    mirror_mask = draw_predefined_mask(
+                        mirror_mask,
+                        color=(0, 0, 0),
+                        mirror=True,
+                        gripper=False,
+                        finger=False,
+                    )
+                    is_mirror = mirror_mask[..., 0] == 0
+
+                def tf(data, input_res=res, stack_crop=stack_crop, is_mirror=is_mirror):
+                    img = data["color"]
+                    if fisheye_converter is None:
+                        crop_img = None
+                        if stack_crop:
+                            slices = get_mirror_crop_slices(img.shape[:2], left=False)
+                            crop = img[slices]
+                            crop_img = cv2.resize(crop, obs_image_resolution)
+                            crop_img = crop_img[:, ::-1, ::-1]  # bgr to rgb
+                        f = get_image_transform(
+                            input_res=input_res,
+                            output_res=obs_image_resolution,
+                            # obs output rgb
+                            bgr_to_rgb=True,
+                        )
+                        img = np.ascontiguousarray(f(img))
+                        if is_mirror is not None:
+                            img[is_mirror] = img[:, ::-1, :][is_mirror]
+                        img = draw_predefined_mask(
+                            img,
+                            color=(0, 0, 0),
+                            mirror=no_mirror,
+                            gripper=True,
+                            finger=False,
+                            use_aa=True,
+                        )
+                        if crop_img is not None:
+                            img = np.concatenate([img, crop_img], axis=-1)
+                    else:
+                        img = fisheye_converter.forward(img)
+                        img = img[..., ::-1]
+                    if obs_float32:
+                        img = img.astype(np.float32) / 255
+                    data["color"] = img
+                    return data
+
+                transform.append(tf)
+
+            resolution.append(res)
+            capture_fps.append(fps)
+            cap_buffer_size.append(buf)
+            video_recorder.append(
+                VideoRecorder.create_hevc_nvenc(
+                    fps=fps, input_pix_fmt="bgr24", bit_rate=bit_rate
+                )
+            )
+
+            def vis_tf(data, input_res=res):
+                img = data["color"]
+                f = get_image_transform(
+                    input_res=input_res, output_res=(rw, rh), bgr_to_rgb=False
+                )
+                img = f(img)
+                data["color"] = img
+                return data
+
+            vis_transform.append(vis_tf)
+
+        camera = MultiUvcCamera(
+            dev_video_paths=v4l_paths,
+            shm_manager=shm_manager,
+            resolution=resolution,
+            capture_fps=capture_fps,
+            # send every frame immediately after arrival
+            # ignores put_fps
+            put_downsample=False,
+            get_max_k=max_obs_buffer_size,
+            receive_latency=camera_obs_latency,
+            cap_buffer_size=cap_buffer_size,
+            transform=transform,
+            vis_transform=vis_transform,
+            video_recorder=video_recorder,
+            verbose=False,
+        )
+
+        multi_cam_vis = None
+        if enable_multi_cam_vis:
+            multi_cam_vis = MultiCameraVisualizer(
+                camera=camera, row=row, col=col, rgb_to_bgr=False
+            )
+
+        cube_diag = np.linalg.norm([1, 1, 1])
+        j_init = np.array([0, -90, -90, -90, 90, 0]) / 180 * np.pi
+        if not init_joints:
+            j_init = None
+
+        if robot_type.startswith("ur5"):
+            robot = RTDEInterpolationController(
+                shm_manager=shm_manager,
+                robot_ip=robot_ip,
+                frequency=500,  # UR5 CB3 RTDE
+                lookahead_time=0.1,
+                gain=300,
+                max_pos_speed=max_pos_speed * cube_diag,
+                max_rot_speed=max_rot_speed * cube_diag,
+                launch_timeout=3,
+                tcp_offset_pose=[0, 0, tcp_offset, 0, 0, 0],
+                payload_mass=None,
+                payload_cog=None,
+                joints_init=j_init,
+                joints_init_speed=1.05,
+                soft_real_time=False,
+                verbose=False,
+                receive_keys=None,
+                receive_latency=robot_obs_latency,
+            )
+        elif robot_type.startswith("franka"):
+            robot = FrankaInterpolationController(
+                shm_manager=shm_manager,
+                robot_ip=robot_ip,
+                frequency=200,
+                Kx_scale=1.0,
+                Kxd_scale=np.array([2.0, 1.5, 2.0, 1.0, 1.0, 1.0]),
+                verbose=False,
+                receive_latency=robot_obs_latency,
+            )
+
+        gripper = WSGController(
+            shm_manager=shm_manager,
+            hostname=gripper_ip,
+            port=gripper_port,
+            receive_latency=gripper_obs_latency,
+            use_meters=True,
+        )
+
+        self.camera = camera
+        self.robot = robot
+        self.gripper = gripper
+        self.multi_cam_vis = multi_cam_vis
+        self.frequency = frequency
+        self.max_obs_buffer_size = max_obs_buffer_size
+        self.max_pos_speed = max_pos_speed
+        self.max_rot_speed = max_rot_speed
+        self.mirror_crop = mirror_crop
+        # timing
+        self.align_camera_idx = align_camera_idx
+        self.camera_obs_latency = camera_obs_latency
+        self.robot_obs_latency = robot_obs_latency
+        self.gripper_obs_latency = gripper_obs_latency
+        self.robot_action_latency = robot_action_latency
+        self.gripper_action_latency = gripper_action_latency
+        self.camera_down_sample_steps = camera_down_sample_steps
+        self.robot_down_sample_steps = robot_down_sample_steps
+        self.gripper_down_sample_steps = gripper_down_sample_steps
+        self.camera_obs_horizon = camera_obs_horizon
+        self.robot_obs_horizon = robot_obs_horizon
+        self.gripper_obs_horizon = gripper_obs_horizon
+        # recording
+        self.output_dir = output_dir
+        self.video_dir = video_dir
+        self.replay_buffer = replay_buffer
+        # temp memory buffers
+        self.last_camera_data = None
+        # recording buffers
+        self.obs_accumulator = None
+        self.action_accumulator = None
+
+        self.start_time = None
+
+    # ======== start-stop API =============
+    @property
+    def is_ready(self):
+        return self.camera.is_ready and self.robot.is_ready and self.gripper.is_ready
+
+    def start(self, wait=True):
+        self.camera.start(wait=False)
+        self.gripper.start(wait=False)
+        self.robot.start(wait=False)
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start(wait=False)
+        if wait:
+            self.start_wait()
+
+    def stop(self, wait=True):
+        self.end_episode()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop(wait=False)
+        self.robot.stop(wait=False)
+        self.gripper.stop(wait=False)
+        self.camera.stop(wait=False)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.camera.start_wait()
+        self.gripper.start_wait()
+        self.robot.start_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.start_wait()
+
+    def stop_wait(self):
+        self.robot.stop_wait()
+        self.gripper.stop_wait()
+        self.camera.stop_wait()
+        if self.multi_cam_vis is not None:
+            self.multi_cam_vis.stop_wait()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= async env API ===========
+    def get_obs(self) -> dict:
+        """
+        Timestamp alignment policy
+        'current' time is the last timestamp of align_camera_idx
+        All other cameras, find corresponding frame with the nearest timestamp
+        All low-dim observations, interpolate with respect to 'current' time
+        """
+
+        "observation dict"
+        assert self.is_ready
+
+        # get data
+        # 60 Hz, camera_calibrated_timestamp
+        k = math.ceil(
+            self.camera_obs_horizon
+            * self.camera_down_sample_steps
+            * (60 / self.frequency)
+        )
+        self.last_camera_data = self.camera.get(k=k, out=self.last_camera_data)
+
+        # 125/500 hz, robot_receive_timestamp
+        last_robot_data = self.robot.get_all_state()
+        # both have more than n_obs_steps data
+
+        # 30 hz, gripper_receive_timestamp
+        last_gripper_data = self.gripper.get_all_state()
+
+        last_timestamp = self.last_camera_data[self.align_camera_idx]["timestamp"][-1]
+        dt = 1 / self.frequency
+
+        # align camera obs timestamps
+        camera_obs_timestamps = last_timestamp - (
+            np.arange(self.camera_obs_horizon)[::-1]
+            * self.camera_down_sample_steps
+            * dt
+        )
+        camera_obs = dict()
+        for camera_idx, value in self.last_camera_data.items():
+            this_timestamps = value["timestamp"]
+            this_idxs = list()
+            for t in camera_obs_timestamps:
+                nn_idx = np.argmin(np.abs(this_timestamps - t))
+                this_idxs.append(nn_idx)
+            # remap key
+            if camera_idx == 0 and self.mirror_crop:
+                camera_obs["camera0_rgb"] = value["color"][..., :3][this_idxs]
+                camera_obs["camera0_rgb_mirror_crop"] = value["color"][..., 3:][
+                    this_idxs
+                ]
+            else:
+                camera_obs[f"camera{camera_idx}_rgb"] = value["color"][this_idxs]
+
+        # align robot obs
+        robot_obs_timestamps = last_timestamp - (
+            np.arange(self.robot_obs_horizon)[::-1] * self.robot_down_sample_steps * dt
+        )
+        robot_pose_interpolator = PoseInterpolator(
+            t=last_robot_data["robot_timestamp"], x=last_robot_data["ActualTCPPose"]
+        )
+        robot_pose = robot_pose_interpolator(robot_obs_timestamps)
+        robot_obs = {
+            "robot0_eef_pos": robot_pose[..., :3],
+            "robot0_eef_rot_axis_angle": robot_pose[..., 3:],
+        }
+
+        # align gripper obs
+        gripper_obs_timestamps = last_timestamp - (
+            np.arange(self.gripper_obs_horizon)[::-1]
+            * self.gripper_down_sample_steps
+            * dt
+        )
+        gripper_interpolator = get_interp1d(
+            t=last_gripper_data["gripper_timestamp"],
+            x=last_gripper_data["gripper_position"][..., None],
+        )
+        gripper_obs = {
+            "robot0_gripper_width": gripper_interpolator(gripper_obs_timestamps)
+        }
+
+        # accumulate obs
+        if self.obs_accumulator is not None:
+            self.obs_accumulator.put(
+                data={
+                    "robot0_eef_pose": last_robot_data["ActualTCPPose"],
+                    "robot0_joint_pos": last_robot_data["ActualQ"],
+                    "robot0_joint_vel": last_robot_data["ActualQd"],
+                },
+                timestamps=last_robot_data["robot_timestamp"],
+            )
+            self.obs_accumulator.put(
+                data={
+                    "robot0_gripper_width": last_gripper_data["gripper_position"][
+                        ..., None
+                    ]
+                },
+                timestamps=last_gripper_data["gripper_timestamp"],
+            )
+
+        # return obs
+        obs_data = dict(camera_obs)
+        obs_data.update(robot_obs)
+        obs_data.update(gripper_obs)
+        obs_data["timestamp"] = camera_obs_timestamps
+
+        return obs_data
+
+    def exec_actions(
+        self, actions: np.ndarray, timestamps: np.ndarray, compensate_latency=False
+    ):
+        assert self.is_ready
+        if not isinstance(actions, np.ndarray):
+            actions = np.array(actions)
+        if not isinstance(timestamps, np.ndarray):
+            timestamps = np.array(timestamps)
+
+        # convert action to pose
+        receive_time = time.time()
+        is_new = timestamps > receive_time
+        new_actions = actions[is_new]
+        new_timestamps = timestamps[is_new]
+
+        r_latency = self.robot_action_latency if compensate_latency else 0.0
+        g_latency = self.gripper_action_latency if compensate_latency else 0.0
+
+        # schedule waypoints
+        for i in range(len(new_actions)):
+            r_actions = new_actions[i, :6]
+            g_actions = new_actions[i, 6:]
+            self.robot.schedule_waypoint(
+                pose=r_actions, target_time=new_timestamps[i] - r_latency
+            )
+            self.gripper.schedule_waypoint(
+                pos=g_actions, target_time=new_timestamps[i] - g_latency
+            )
+
+        # record actions
+        if self.action_accumulator is not None:
+            self.action_accumulator.put(new_actions, new_timestamps)
+
+    def get_robot_state(self):
+        return self.robot.get_state()
+
+    # recording API
+    def start_episode(self, start_time=None):
+        "Start recording and return first obs"
+        if start_time is None:
+            start_time = time.time()
+        self.start_time = start_time
+
+        assert self.is_ready
+
+        # prepare recording stuff
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        this_video_dir.mkdir(parents=True, exist_ok=True)
+        n_cameras = self.camera.n_cameras
+        video_paths = list()
+        for i in range(n_cameras):
+            video_paths.append(str(this_video_dir.joinpath(f"{i}.mp4").absolute()))
+
+        # start recording on camera
+        self.camera.restart_put(start_time=start_time)
+        self.camera.start_recording(video_path=video_paths, start_time=start_time)
+
+        # create accumulators
+        self.obs_accumulator = ObsAccumulator()
+        self.action_accumulator = TimestampActionAccumulator(
+            start_time=start_time, dt=1 / self.frequency
+        )
+        print(f"Episode {episode_id} started!")
+
+    def end_episode(self):
+        "Stop recording"
+        assert self.is_ready
+
+        # stop video recorder
+        self.camera.stop_recording()
+
+        # TODO
+        if self.obs_accumulator is not None:
+            # recording
+            assert self.action_accumulator is not None
+
+            # Since the only way to accumulate obs and action is by calling
+            # get_obs and exec_actions, which will be in the same thread.
+            # We don't need to worry new data come in here.
+            end_time = float("inf")
+            for key, value in self.obs_accumulator.timestamps.items():
+                end_time = min(end_time, value[-1])
+            end_time = min(end_time, self.action_accumulator.timestamps[-1])
+
+            actions = self.action_accumulator.actions
+            action_timestamps = self.action_accumulator.timestamps
+            n_steps = 0
+            if np.sum(self.action_accumulator.timestamps <= end_time) > 0:
+                n_steps = (
+                    np.nonzero(self.action_accumulator.timestamps <= end_time)[0][-1]
+                    + 1
+                )
+
+            if n_steps > 0:
+                timestamps = action_timestamps[:n_steps]
+                episode = {
+                    "timestamp": timestamps,
+                    "action": actions[:n_steps],
+                }
+                robot_pose_interpolator = PoseInterpolator(
+                    t=np.array(self.obs_accumulator.timestamps["robot0_eef_pose"]),
+                    x=np.array(self.obs_accumulator.data["robot0_eef_pose"]),
+                )
+                robot_pose = robot_pose_interpolator(timestamps)
+                episode["robot0_eef_pos"] = robot_pose[:, :3]
+                episode["robot0_eef_rot_axis_angle"] = robot_pose[:, 3:]
+                joint_pos_interpolator = get_interp1d(
+                    np.array(self.obs_accumulator.timestamps["robot0_joint_pos"]),
+                    np.array(self.obs_accumulator.data["robot0_joint_pos"]),
+                )
+                joint_vel_interpolator = get_interp1d(
+                    np.array(self.obs_accumulator.timestamps["robot0_joint_vel"]),
+                    np.array(self.obs_accumulator.data["robot0_joint_vel"]),
+                )
+                episode["robot0_joint_pos"] = joint_pos_interpolator(timestamps)
+                episode["robot0_joint_vel"] = joint_vel_interpolator(timestamps)
+
+                gripper_interpolator = get_interp1d(
+                    t=np.array(self.obs_accumulator.timestamps["robot0_gripper_width"]),
+                    x=np.array(self.obs_accumulator.data["robot0_gripper_width"]),
+                )
+                episode["robot0_gripper_width"] = gripper_interpolator(timestamps)
+
+                self.replay_buffer.add_episode(episode, compressors="disk")
+                episode_id = self.replay_buffer.n_episodes - 1
+                print(f"Episode {episode_id} saved!")
+
+            self.obs_accumulator = None
+            self.action_accumulator = None
+
+    def drop_episode(self):
+        self.end_episode()
+        self.replay_buffer.drop_episode()
+        episode_id = self.replay_buffer.n_episodes
+        this_video_dir = self.video_dir.joinpath(str(episode_id))
+        if this_video_dir.exists():
+            shutil.rmtree(str(this_video_dir))
+        print(f"Episode {episode_id} dropped!")

code/umi/real_world/uvc_camera.py

@@ -0,0 +1,330 @@
+from typing import Optional, Callable, Dict
+import enum
+import time
+import cv2
+import numpy as np
+import multiprocessing as mp
+from threadpoolctl import threadpool_limits
+from multiprocessing.managers import SharedMemoryManager
+from umi.common.timestamp_accumulator import get_accumulate_timestamp_idxs
+from umi.shared_memory.shared_memory_ring_buffer import SharedMemoryRingBuffer
+from umi.shared_memory.shared_memory_queue import SharedMemoryQueue, Full, Empty
+from umi.real_world.video_recorder import VideoRecorder
+from umi.common.usb_util import reset_usb_device
+
+
+class Command(enum.Enum):
+    RESTART_PUT = 0
+    START_RECORDING = 1
+    STOP_RECORDING = 2
+
+
+class UvcCamera(mp.Process):
+    """
+    Call umi.common.usb_util.reset_all_elgato_devices
+    if you are using Elgato capture cards.
+    Required to workaround firmware bugs.
+    """
+
+    MAX_PATH_LENGTH = 4096  # linux path has a limit of 4096 bytes
+
+    def __init__(
+        self,
+        shm_manager: SharedMemoryManager,
+        # v4l2 device file path
+        # e.g. /dev/video0
+        # or /dev/v4l/by-id/usb-Elgato_Elgato_HD60_X_A00XB320216MTR-video-index0
+        dev_video_path,
+        resolution=(1280, 720),
+        capture_fps=60,
+        put_fps=None,
+        put_downsample=True,
+        get_max_k=30,
+        receive_latency=0.0,
+        cap_buffer_size=1,
+        num_threads=2,
+        transform: Optional[Callable[[Dict], Dict]] = None,
+        vis_transform: Optional[Callable[[Dict], Dict]] = None,
+        recording_transform: Optional[Callable[[Dict], Dict]] = None,
+        video_recorder: Optional[VideoRecorder] = None,
+        verbose=False,
+    ):
+        super().__init__()
+
+        if put_fps is None:
+            put_fps = capture_fps
+
+        # create ring buffer
+        resolution = tuple(resolution)
+        shape = resolution[::-1]
+        examples = {"color": np.empty(shape=shape + (3,), dtype=np.uint8)}
+        examples["camera_capture_timestamp"] = 0.0
+        examples["camera_receive_timestamp"] = 0.0
+        examples["timestamp"] = 0.0
+        examples["step_idx"] = 0
+
+        vis_ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=(
+                examples if vis_transform is None else vis_transform(dict(examples))
+            ),
+            get_max_k=1,
+            get_time_budget=0.2,
+            put_desired_frequency=capture_fps,
+        )
+
+        ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=examples if transform is None else transform(dict(examples)),
+            get_max_k=get_max_k,
+            get_time_budget=0.2,
+            put_desired_frequency=put_fps,
+        )
+
+        # create command queue
+        examples = {
+            "cmd": Command.RESTART_PUT.value,
+            "put_start_time": 0.0,
+            "video_path": np.array("a" * self.MAX_PATH_LENGTH),
+            "recording_start_time": 0.0,
+        }
+
+        command_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager, examples=examples, buffer_size=128
+        )
+
+        # create video recorder
+        if video_recorder is None:
+            # default to nvenc GPU encoder
+            video_recorder = VideoRecorder.create_hevc_nvenc(
+                shm_manager=shm_manager,
+                fps=capture_fps,
+                input_pix_fmt="bgr24",
+                bit_rate=6000 * 1000,
+            )
+        assert video_recorder.fps == capture_fps
+
+        # copied variables
+        self.shm_manager = shm_manager
+        self.dev_video_path = dev_video_path
+        self.resolution = resolution
+        self.capture_fps = capture_fps
+        self.put_fps = put_fps
+        self.put_downsample = put_downsample
+        self.receive_latency = receive_latency
+        self.cap_buffer_size = cap_buffer_size
+        self.transform = transform
+        self.vis_transform = vis_transform
+        self.recording_transform = recording_transform
+        self.video_recorder = video_recorder
+        self.verbose = verbose
+        self.put_start_time = None
+        self.num_threads = num_threads
+
+        # shared variables
+        self.stop_event = mp.Event()
+        self.ready_event = mp.Event()
+        self.ring_buffer = ring_buffer
+        self.vis_ring_buffer = vis_ring_buffer
+        self.command_queue = command_queue
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= user API ===========
+    def start(self, wait=True, put_start_time=None):
+        self.put_start_time = put_start_time
+        shape = self.resolution[::-1]
+        data_example = np.empty(shape=shape + (3,), dtype=np.uint8)
+        self.video_recorder.start(
+            shm_manager=self.shm_manager, data_example=data_example
+        )
+        # must start video recorder first to create share memories
+        super().start()
+        if wait:
+            self.start_wait()
+
+    def stop(self, wait=True):
+        self.video_recorder.stop()
+        self.stop_event.set()
+        if wait:
+            self.end_wait()
+
+    def start_wait(self):
+        self.ready_event.wait()
+        self.video_recorder.start_wait()
+
+    def end_wait(self):
+        self.join()
+        self.video_recorder.end_wait()
+
+    @property
+    def is_ready(self):
+        return self.ready_event.is_set()
+
+    def get(self, k=None, out=None):
+        if k is None:
+            return self.ring_buffer.get(out=out)
+        else:
+            return self.ring_buffer.get_last_k(k, out=out)
+
+    def get_vis(self, out=None):
+        return self.vis_ring_buffer.get(out=out)
+
+    def start_recording(self, video_path: str, start_time: float = -1):
+        path_len = len(video_path.encode("utf-8"))
+        if path_len > self.MAX_PATH_LENGTH:
+            raise RuntimeError("video_path too long.")
+        self.command_queue.put(
+            {
+                "cmd": Command.START_RECORDING.value,
+                "video_path": video_path,
+                "recording_start_time": start_time,
+            }
+        )
+
+    def stop_recording(self):
+        self.command_queue.put({"cmd": Command.STOP_RECORDING.value})
+
+    def restart_put(self, start_time):
+        self.command_queue.put(
+            {"cmd": Command.RESTART_PUT.value, "put_start_time": start_time}
+        )
+
+    # ========= interval API ===========
+    def run(self):
+        # limit threads
+        threadpool_limits(self.num_threads)
+        cv2.setNumThreads(self.num_threads)
+
+        # open VideoCapture
+        cap = cv2.VideoCapture(self.dev_video_path, cv2.CAP_V4L2)
+
+        try:
+            # set resolution and fps
+            w, h = self.resolution
+            fps = self.capture_fps
+            cap.set(cv2.CAP_PROP_FRAME_WIDTH, w)
+            cap.set(cv2.CAP_PROP_FRAME_HEIGHT, h)
+            # set fps
+            cap.set(cv2.CAP_PROP_BUFFERSIZE, self.cap_buffer_size)
+            cap.set(cv2.CAP_PROP_FPS, fps)
+
+            # put frequency regulation
+            put_idx = None
+            put_start_time = self.put_start_time
+            if put_start_time is None:
+                put_start_time = time.time()
+
+            # reuse frame buffer
+            iter_idx = 0
+            t_start = time.time()
+            while not self.stop_event.is_set():
+                ts = time.time()
+                ret = cap.grab()
+                assert ret
+
+                # directly write into shared memory to avoid copy
+                frame = self.video_recorder.get_img_buffer()
+                ret, frame = cap.retrieve(frame)
+                t_recv = time.time()
+                assert ret
+                mt_cap = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000
+                t_cap = mt_cap - time.monotonic() + time.time()
+                t_cal = t_recv - self.receive_latency  # calibrated latency
+
+                # record frame
+                if self.video_recorder.is_ready():
+                    self.video_recorder.write_img_buffer(frame, frame_time=t_cal)
+
+                data = dict()
+                data["camera_receive_timestamp"] = t_recv
+                data["camera_capture_timestamp"] = t_cap
+                data["color"] = frame
+
+                # apply transform
+                put_data = data
+                if self.transform is not None:
+                    put_data = self.transform(dict(data))
+
+                if self.put_downsample:
+                    # put frequency regulation
+                    local_idxs, global_idxs, put_idx = get_accumulate_timestamp_idxs(
+                        timestamps=[t_cal],
+                        start_time=put_start_time,
+                        dt=1 / self.put_fps,
+                        # this is non in first iteration
+                        # and then replaced with a concrete number
+                        next_global_idx=put_idx,
+                        # continue to pump frames even if not started.
+                        # start_time is simply used to align timestamps.
+                        allow_negative=True,
+                    )
+
+                    for step_idx in global_idxs:
+                        put_data["step_idx"] = step_idx
+                        put_data["timestamp"] = t_cal
+                        self.ring_buffer.put(put_data, wait=False)
+                else:
+                    step_idx = int((t_cal - put_start_time) * self.put_fps)
+                    put_data["step_idx"] = step_idx
+                    put_data["timestamp"] = t_cal
+                    self.ring_buffer.put(put_data, wait=False)
+
+                # signal ready
+                if iter_idx == 0:
+                    self.ready_event.set()
+
+                # put to vis
+                vis_data = data
+                if self.vis_transform == self.transform:
+                    vis_data = put_data
+                elif self.vis_transform is not None:
+                    vis_data = self.vis_transform(dict(data))
+                self.vis_ring_buffer.put(vis_data, wait=False)
+
+                # perf
+                t_end = time.time()
+                duration = t_end - t_start
+                frequency = np.round(1 / duration, 1)
+                t_start = t_end
+                if self.verbose:
+                    print(f"[UvcCamera {self.dev_video_path}] FPS {frequency}")
+
+                # fetch command from queue
+                try:
+                    commands = self.command_queue.get_all()
+                    n_cmd = len(commands["cmd"])
+                except Empty:
+                    n_cmd = 0
+
+                # execute commands
+                for i in range(n_cmd):
+                    command = dict()
+                    for key, value in commands.items():
+                        command[key] = value[i]
+                    cmd = command["cmd"]
+                    if cmd == Command.RESTART_PUT.value:
+                        put_idx = None
+                        put_start_time = command["put_start_time"]
+                    elif cmd == Command.START_RECORDING.value:
+                        video_path = str(command["video_path"])
+                        start_time = command["recording_start_time"]
+                        if start_time < 0:
+                            start_time = None
+                        self.video_recorder.start_recording(
+                            video_path, start_time=start_time
+                        )
+                    elif cmd == Command.STOP_RECORDING.value:
+                        self.video_recorder.stop_recording()
+
+                iter_idx += 1
+        finally:
+            self.video_recorder.stop()
+            # When everything done, release the capture
+            cap.release()

code/umi/real_world/video_recorder.py

@@ -0,0 +1,286 @@
+from typing import Optional, Callable, Generator
+import numpy as np
+import av
+import time
+import enum
+import multiprocessing as mp
+from multiprocessing.managers import SharedMemoryManager
+from unified_video_action.shared_memory.shared_memory_queue import (
+    SharedMemoryQueue,
+    Full,
+    Empty,
+)
+from umi.common.timestamp_accumulator import get_accumulate_timestamp_idxs
+
+
+class VideoRecorder(mp.Process):
+    MAX_PATH_LENGTH = 4096  # linux path has a limit of 4096 bytes
+
+    class Command(enum.Enum):
+        START_RECORDING = 0
+        STOP_RECORDING = 1
+
+    def __init__(
+        self,
+        fps,
+        codec,
+        input_pix_fmt,
+        buffer_size=128,
+        no_repeat=False,
+        # options for codec
+        **kwargs
+    ):
+        self.fps = fps
+        self.codec = codec
+        self.input_pix_fmt = input_pix_fmt
+        self.buffer_size = buffer_size
+        self.no_repeat = no_repeat
+        self.kwargs = kwargs
+
+        self.img_queue = None
+        self.cmd_queue = None
+        self.stop_event = None
+        self.ready_event = None
+        self.is_started = False
+        self.shape = None
+
+        self._reset_state()
+
+    # ======== custom constructors =======
+    @classmethod
+    def create_h264(
+        cls,
+        fps,
+        codec="h264",
+        input_pix_fmt="rgb24",
+        output_pix_fmt="yuv420p",
+        crf=18,
+        profile="high",
+        **kwargs
+    ):
+        obj = cls(
+            fps=fps,
+            codec=codec,
+            input_pix_fmt=input_pix_fmt,
+            pix_fmt=output_pix_fmt,
+            options={"crf": str(crf), "profile": profile},
+            **kwargs
+        )
+        return obj
+
+    @classmethod
+    def create_hevc_nvenc(
+        cls,
+        fps,
+        codec="hevc_nvenc",
+        input_pix_fmt="rgb24",
+        output_pix_fmt="yuv420p",
+        bit_rate=6000 * 1000,
+        options={"tune": "ll", "preset": "p1"},
+        **kwargs
+    ):
+        obj = cls(
+            fps=fps,
+            codec=codec,
+            input_pix_fmt=input_pix_fmt,
+            pix_fmt=output_pix_fmt,
+            bit_rate=bit_rate,
+            options=options,
+            **kwargs
+        )
+        return obj
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= user API ===========
+    def start(self, shm_manager: SharedMemoryManager, data_example: np.ndarray):
+        super().__init__()
+        self.ready_event = mp.Event()
+        self.stop_event = mp.Event()
+        self.img_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager,
+            examples={"img": data_example, "repeat": 1},
+            buffer_size=self.buffer_size,
+        )
+        self.cmd_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager,
+            examples={
+                "cmd": self.Command.START_RECORDING.value,
+                "video_path": np.array("a" * self.MAX_PATH_LENGTH),
+            },
+            buffer_size=self.buffer_size,
+        )
+        self.shape = data_example.shape
+        self.is_started = True
+        super().start()
+
+    def stop(self):
+        self.stop_event.set()
+
+    def start_wait(self):
+        self.ready_event.wait()
+
+    def end_wait(self):
+        self.join()
+
+    def is_ready(self):
+        return (
+            (self.start_time is not None)
+            and (self.ready_event.is_set())
+            and (not self.stop_event.is_set())
+        )
+
+    def start_recording(self, video_path: str, start_time: float = -1):
+        path_len = len(video_path.encode("utf-8"))
+        if path_len > self.MAX_PATH_LENGTH:
+            raise RuntimeError("video_path too long.")
+        self.start_time = start_time
+        self.cmd_queue.put(
+            {"cmd": self.Command.START_RECORDING.value, "video_path": video_path}
+        )
+
+    def stop_recording(self):
+        self.cmd_queue.put({"cmd": self.Command.STOP_RECORDING.value})
+        self._reset_state()
+
+    def write_frame(self, img: np.ndarray, frame_time=None):
+        if not self.is_ready():
+            raise RuntimeError("Must run start() before writing!")
+
+        n_repeats = 1
+        if (not self.no_repeat) and (self.start_time is not None):
+            local_idxs, global_idxs, self.next_global_idx = (
+                get_accumulate_timestamp_idxs(
+                    # only one timestamp
+                    timestamps=[frame_time],
+                    start_time=self.start_time,
+                    dt=1 / self.fps,
+                    next_global_idx=self.next_global_idx,
+                )
+            )
+            # number of apperance means repeats
+            n_repeats = len(local_idxs)
+
+        self.img_queue.put({"img": img, "repeat": n_repeats})
+
+    def get_img_buffer(self):
+        """
+        Get view to the next img queue memory
+        for zero-copy writing
+        """
+        data = self.img_queue.get_next_view()
+        img = data["img"]
+        return img
+
+    def write_img_buffer(self, img: np.ndarray, frame_time=None):
+        """
+        Must be used with the buffer returned by get_img_buffer
+        for zero-copy writing
+        """
+        if not self.is_ready():
+            raise RuntimeError("Must run start() before writing!")
+
+        n_repeats = 1
+        if (not self.no_repeat) and (self.start_time is not None):
+            local_idxs, global_idxs, self.next_global_idx = (
+                get_accumulate_timestamp_idxs(
+                    # only one timestamp
+                    timestamps=[frame_time],
+                    start_time=self.start_time,
+                    dt=1 / self.fps,
+                    next_global_idx=self.next_global_idx,
+                )
+            )
+            # number of apperance means repeats
+            n_repeats = len(local_idxs)
+
+        self.img_queue.put_next_view({"img": img, "repeat": n_repeats})
+
+    # ========= interval API ===========
+    def _reset_state(self):
+        self.start_time = None
+        self.next_global_idx = 0
+
+    def run(self):
+        # I'm sorry it has to be this complicated...
+        self.ready_event.set()
+        while not self.stop_event.is_set():
+            video_path = None
+            # ========= stopped state ============
+            while (video_path is None) and (not self.stop_event.is_set()):
+                try:
+                    commands = self.cmd_queue.get_all()
+                    for i in range(len(commands["cmd"])):
+                        cmd = commands["cmd"][i]
+                        if cmd == self.Command.START_RECORDING.value:
+                            video_path = str(commands["video_path"][i])
+                        elif cmd == self.Command.STOP_RECORDING.value:
+                            video_path = None
+                        else:
+                            raise RuntimeError("Unknown command: ", cmd)
+                except Empty:
+                    time.sleep(0.1 / self.fps)
+            if self.stop_event.is_set():
+                break
+            assert video_path is not None
+            # ========= recording state ==========
+            with av.open(video_path, mode="w") as container:
+                stream = container.add_stream(self.codec, rate=self.fps)
+                h, w, c = self.shape
+                stream.width = w
+                stream.height = h
+                codec_context = stream.codec_context
+                for k, v in self.kwargs.items():
+                    setattr(codec_context, k, v)
+
+                # loop
+                while not self.stop_event.is_set():
+                    try:
+                        command = self.cmd_queue.get()
+                        cmd = int(command["cmd"])
+                        if cmd == self.Command.STOP_RECORDING.value:
+                            break
+                        elif cmd == self.Command.START_RECORDING.value:
+                            continue
+                        else:
+                            raise RuntimeError("Unknown command: ", cmd)
+                    except Empty:
+                        pass
+
+                    try:
+                        with self.img_queue.get_view() as data:
+                            img = data["img"]
+                            repeat = data["repeat"]
+                            frame = av.VideoFrame.from_ndarray(
+                                img, format=self.input_pix_fmt
+                            )
+                        for _ in range(repeat):
+                            for packet in stream.encode(frame):
+                                container.mux(packet)
+                    except Empty:
+                        time.sleep(0.1 / self.fps)
+
+                # Flush queue
+                try:
+                    while not self.img_queue.empty():
+                        with self.img_queue.get_view() as data:
+                            img = data["img"]
+                            repeat = data["repeat"]
+                            frame = av.VideoFrame.from_ndarray(
+                                img, format=self.input_pix_fmt
+                            )
+                        for _ in range(repeat):
+                            for packet in stream.encode(frame):
+                                container.mux(packet)
+                except Empty:
+                    pass
+
+                # Flush stream
+                for packet in stream.encode():
+                    container.mux(packet)

code/umi/real_world/wsg_binary_driver.py

@@ -0,0 +1,631 @@
+from typing import Union, Optional
+import socket
+import enum
+import struct
+
+CRC_TABLE_CCITT16 = [
+    0x0000,
+    0x1021,
+    0x2042,
+    0x3063,
+    0x4084,
+    0x50A5,
+    0x60C6,
+    0x70E7,
+    0x8108,
+    0x9129,
+    0xA14A,
+    0xB16B,
+    0xC18C,
+    0xD1AD,
+    0xE1CE,
+    0xF1EF,
+    0x1231,
+    0x0210,
+    0x3273,
+    0x2252,
+    0x52B5,
+    0x4294,
+    0x72F7,
+    0x62D6,
+    0x9339,
+    0x8318,
+    0xB37B,
+    0xA35A,
+    0xD3BD,
+    0xC39C,
+    0xF3FF,
+    0xE3DE,
+    0x2462,
+    0x3443,
+    0x0420,
+    0x1401,
+    0x64E6,
+    0x74C7,
+    0x44A4,
+    0x5485,
+    0xA56A,
+    0xB54B,
+    0x8528,
+    0x9509,
+    0xE5EE,
+    0xF5CF,
+    0xC5AC,
+    0xD58D,
+    0x3653,
+    0x2672,
+    0x1611,
+    0x0630,
+    0x76D7,
+    0x66F6,
+    0x5695,
+    0x46B4,
+    0xB75B,
+    0xA77A,
+    0x9719,
+    0x8738,
+    0xF7DF,
+    0xE7FE,
+    0xD79D,
+    0xC7BC,
+    0x48C4,
+    0x58E5,
+    0x6886,
+    0x78A7,
+    0x0840,
+    0x1861,
+    0x2802,
+    0x3823,
+    0xC9CC,
+    0xD9ED,
+    0xE98E,
+    0xF9AF,
+    0x8948,
+    0x9969,
+    0xA90A,
+    0xB92B,
+    0x5AF5,
+    0x4AD4,
+    0x7AB7,
+    0x6A96,
+    0x1A71,
+    0x0A50,
+    0x3A33,
+    0x2A12,
+    0xDBFD,
+    0xCBDC,
+    0xFBBF,
+    0xEB9E,
+    0x9B79,
+    0x8B58,
+    0xBB3B,
+    0xAB1A,
+    0x6CA6,
+    0x7C87,
+    0x4CE4,
+    0x5CC5,
+    0x2C22,
+    0x3C03,
+    0x0C60,
+    0x1C41,
+    0xEDAE,
+    0xFD8F,
+    0xCDEC,
+    0xDDCD,
+    0xAD2A,
+    0xBD0B,
+    0x8D68,
+    0x9D49,
+    0x7E97,
+    0x6EB6,
+    0x5ED5,
+    0x4EF4,
+    0x3E13,
+    0x2E32,
+    0x1E51,
+    0x0E70,
+    0xFF9F,
+    0xEFBE,
+    0xDFDD,
+    0xCFFC,
+    0xBF1B,
+    0xAF3A,
+    0x9F59,
+    0x8F78,
+    0x9188,
+    0x81A9,
+    0xB1CA,
+    0xA1EB,
+    0xD10C,
+    0xC12D,
+    0xF14E,
+    0xE16F,
+    0x1080,
+    0x00A1,
+    0x30C2,
+    0x20E3,
+    0x5004,
+    0x4025,
+    0x7046,
+    0x6067,
+    0x83B9,
+    0x9398,
+    0xA3FB,
+    0xB3DA,
+    0xC33D,
+    0xD31C,
+    0xE37F,
+    0xF35E,
+    0x02B1,
+    0x1290,
+    0x22F3,
+    0x32D2,
+    0x4235,
+    0x5214,
+    0x6277,
+    0x7256,
+    0xB5EA,
+    0xA5CB,
+    0x95A8,
+    0x8589,
+    0xF56E,
+    0xE54F,
+    0xD52C,
+    0xC50D,
+    0x34E2,
+    0x24C3,
+    0x14A0,
+    0x0481,
+    0x7466,
+    0x6447,
+    0x5424,
+    0x4405,
+    0xA7DB,
+    0xB7FA,
+    0x8799,
+    0x97B8,
+    0xE75F,
+    0xF77E,
+    0xC71D,
+    0xD73C,
+    0x26D3,
+    0x36F2,
+    0x0691,
+    0x16B0,
+    0x6657,
+    0x7676,
+    0x4615,
+    0x5634,
+    0xD94C,
+    0xC96D,
+    0xF90E,
+    0xE92F,
+    0x99C8,
+    0x89E9,
+    0xB98A,
+    0xA9AB,
+    0x5844,
+    0x4865,
+    0x7806,
+    0x6827,
+    0x18C0,
+    0x08E1,
+    0x3882,
+    0x28A3,
+    0xCB7D,
+    0xDB5C,
+    0xEB3F,
+    0xFB1E,
+    0x8BF9,
+    0x9BD8,
+    0xABBB,
+    0xBB9A,
+    0x4A75,
+    0x5A54,
+    0x6A37,
+    0x7A16,
+    0x0AF1,
+    0x1AD0,
+    0x2AB3,
+    0x3A92,
+    0xFD2E,
+    0xED0F,
+    0xDD6C,
+    0xCD4D,
+    0xBDAA,
+    0xAD8B,
+    0x9DE8,
+    0x8DC9,
+    0x7C26,
+    0x6C07,
+    0x5C64,
+    0x4C45,
+    0x3CA2,
+    0x2C83,
+    0x1CE0,
+    0x0CC1,
+    0xEF1F,
+    0xFF3E,
+    0xCF5D,
+    0xDF7C,
+    0xAF9B,
+    0xBFBA,
+    0x8FD9,
+    0x9FF8,
+    0x6E17,
+    0x7E36,
+    0x4E55,
+    0x5E74,
+    0x2E93,
+    0x3EB2,
+    0x0ED1,
+    0x1EF0,
+]
+
+
+def checksum_update_crc16(data: bytes, crc: int = 0xFFFF):
+    for b in data:
+        crc = CRC_TABLE_CCITT16[(crc ^ b) & 0x00FF] ^ (crc >> 8)
+    return crc
+
+
+class StatusCode(enum.IntEnum):
+    E_SUCCESS = 0
+    E_NOT_AVAILABLE = 1
+    E_NO_SENSOR = 2
+    E_NOT_INITIALIZED = 3
+    E_ALREADY_RUNNING = 4
+    E_FEATURE_NOT_SUPPORTED = 5
+    E_INCONSISTENT_DATA = 6
+    E_TIMEOUT = 7
+    E_READ_ERROR = 8
+    E_WRITE_ERROR = 9
+    E_INSUFFICIENT_RESOURCES = 10
+    E_CHECKSUM_ERROR = 11
+    E_NO_PARAM_EXPECTED = 12
+    E_NOT_ENOUGH_PARAMS = 13
+    E_CMD_UNKNOWN = 14
+    E_CMD_FORMAT_ERROR = 15
+    E_ACCESS_DENIED = 16
+    E_ALREADY_OPEN = 17
+    E_CMD_FAILED = 18
+    E_CMD_ABORTED = 19
+    E_INVALID_HANDLE = 20
+    E_NOT_FOUND = 21
+    E_NOT_OPEN = 22
+    E_IO_ERROR = 23
+    E_INVALID_PARAMETER = 24
+    E_INDEX_OUT_OF_BOUNDS = 25
+    E_CMD_PENDING = 26
+    E_OVERRUN = 27
+    RANGE_ERROR = 28
+    E_AXIS_BLOCKED = 29
+    E_FILE_EXIST = 30
+
+
+class CommandId(enum.IntEnum):
+    Disconnect = 0x07
+    Homing = 0x20
+    PrePosition = 0x21
+    Stop = 0x22
+    FastStop = 0x23
+    AckFastStop = 0x24
+
+
+def args_to_bytes(*args, int_bytes=1):
+    buf = list()
+    for arg in args:
+        if isinstance(arg, float):
+            # little endian 32bit float
+            buf.append(struct.pack("<f", arg))
+        elif isinstance(arg, int):
+            buf.append(arg.to_bytes(length=int_bytes, byteorder="little"))
+        elif isinstance(arg, str):
+            buf.append(arg.encode("ascii"))
+        else:
+            raise RuntimeError(f"Unsupported type {type(arg)}")
+    result = b"".join(buf)
+    return result
+
+
+class WSGBinaryDriver:
+    def __init__(self, hostname="192.168.0.103", port=1000):
+        self.hostname = hostname
+        self.port = port
+        self.tcp_sock = None
+
+    def start(self):
+        self.tcp_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.tcp_sock.connect((self.hostname, self.port))
+        # self.ack_fast_stop()
+
+    def stop(self):
+        self.stop_cmd()
+        self.disconnect()
+        self.tcp_sock.close()
+        return
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ================= low level API ================
+
+    def msg_send(self, cmd_id: int, payload: bytes):
+        preamble_b = 0xAA.to_bytes(1, "little") * 3
+        cmd_b = int(cmd_id).to_bytes(1, "little")
+        size_b = len(payload).to_bytes(2, "little")
+        msg_b = preamble_b + cmd_b + size_b + payload
+        checksum_b = checksum_update_crc16(msg_b).to_bytes(2, "little")
+        msg_b += checksum_b
+        return self.tcp_sock.send(msg_b)
+
+    def msg_receive(self) -> dict:
+        # syncing
+        sync = 0
+        while sync != 3:
+            res = self.tcp_sock.recv(1)
+            if res == 0xAA.to_bytes(1, "little"):
+                sync += 1
+
+        # read header
+        cmd_id_b = self.tcp_sock.recv(1)
+        cmd_id = int.from_bytes(cmd_id_b, "little")
+
+        # read size
+        size_b = self.tcp_sock.recv(2)
+        size = int.from_bytes(size_b, "little")
+
+        # read payload
+        payload_b = self.tcp_sock.recv(size)
+        status_code = int.from_bytes(payload_b[:2], "little")
+
+        parameters_b = payload_b[2:]
+
+        # read checksum
+        checksum_b = self.tcp_sock.recv(2)
+
+        # correct checksum ends in zero
+        header_checksum = 0x50F5
+        msg_checksum = checksum_update_crc16(
+            cmd_id_b + size_b + payload_b + checksum_b, crc=header_checksum
+        )
+        if msg_checksum != 0:
+            raise RuntimeError("Corrupted packet received from WSG")
+
+        result = {
+            "command_id": cmd_id,
+            "status_code": status_code,
+            "payload_bytes": parameters_b,
+        }
+        return result
+
+    def cmd_submit(
+        self,
+        cmd_id: int,
+        payload: bytes = b"",
+        pending: bool = True,
+        ignore_other=False,
+    ):
+        res = self.msg_send(cmd_id, payload)
+        if res < 0:
+            raise RuntimeError("Message send failed.")
+
+        # receive response, repeat if pending
+        msg = None
+        keep_running = True
+        while keep_running:
+            msg = self.msg_receive()
+            if ignore_other and msg["command_id"] != cmd_id:
+                continue
+
+            if msg["command_id"] != cmd_id:
+                raise RuntimeError(
+                    "Response ID ({:02X}) does not match submitted command ID ({:02X})\n".format(
+                        msg["command_id"], cmd_id
+                    )
+                )
+            if pending:
+                status = msg["status_code"]
+            keep_running = pending and status == StatusCode.E_CMD_PENDING.value
+        return msg
+
+    # ============== mid level API ================
+
+    def act(self, cmd: CommandId, *args, wait=True, ignore_other=False):
+        msg = self.cmd_submit(
+            cmd_id=cmd.value,
+            payload=args_to_bytes(*args),
+            pending=wait,
+            ignore_other=ignore_other,
+        )
+        msg["command_id"] = CommandId(msg["command_id"])
+        msg["status_code"] = StatusCode(msg["status_code"])
+
+        status = msg["status_code"]
+        if status != StatusCode.E_SUCCESS:
+            raise RuntimeError(f"Command {cmd} not successful: {status}")
+        return msg
+
+    # =============== high level API ===============
+
+    def disconnect(self):
+        # use msg_send to no wait for response
+        return self.msg_send(CommandId.Disconnect.value, b"")
+
+    def homing(self, positive_direction=True, wait=True):
+        arg = 0
+        if positive_direction is None:
+            arg = 0
+        elif positive_direction:
+            arg = 1
+        else:
+            arg = 2
+
+        return self.act(CommandId.Homing, arg, wait=wait)
+
+    def pre_position(
+        self, width: float, speed: float, clamp_on_block: bool = True, wait=True
+    ):
+        flag = 0
+        if clamp_on_block:
+            flag = 0
+        else:
+            flag = 1
+
+        return self.act(
+            CommandId.PrePosition, flag, float(width), float(speed), wait=wait
+        )
+
+    def ack_fault(self):
+        return self.act(CommandId.AckFastStop, "ack", wait=False, ignore_other=True)
+
+    def stop_cmd(self):
+        return self.act(CommandId.Stop, wait=False, ignore_other=True)
+
+    def custom_script(self, cmd_id: int, *args):
+        # Custom payload format:
+        # 0:	Unused
+        # 1..4	float
+        # .... one float each
+        payload_args = [0]
+        for arg in args:
+            payload_args.append(float(arg))
+        payload = args_to_bytes(*payload_args, int_bytes=1)
+
+        # send message
+        msg = self.cmd_submit(cmd_id=cmd_id, payload=payload, pending=False)
+        status = StatusCode(msg["status_code"])
+        response_payload = msg["payload_bytes"]
+        if status == StatusCode.E_CMD_UNKNOWN:
+            raise RuntimeError(
+                "Command unknown - make sure script (cmd_measure.lua) is running"
+            )
+        if status != StatusCode.E_SUCCESS:
+            raise RuntimeError("Command failed")
+        if len(response_payload) != 17:
+            raise RuntimeError(
+                "Response payload incorrect (",
+                "".join("{:02X}".format(b) for b in response_payload),
+                ")",
+            )
+
+        # parse payload
+        state = response_payload[0]
+        values = list()
+        for i in range(4):
+            start = i * 4 + 1
+            end = start + 4
+            values.append(struct.unpack("<f", response_payload[start:end])[0])
+
+        info = {
+            "state": state,
+            "position": values[0],
+            "velocity": values[1],
+            "force_motor": values[2],
+            "measure_timestamp": values[3],
+            "is_moving": (state & 0x02) != 0,
+        }
+        # info = {
+        #     'state': 0,
+        #     'position': 100.,
+        #     'velocity': 0.,
+        #     'force_motor': 0.,
+        #     'is_moving': 0.
+        # }
+        return info
+
+    def script_query(self):
+        return self.custom_script(0xB0)
+
+    def script_position_pd(
+        self,
+        position: float,
+        velocity: float,
+        kp: float = 15.0,
+        kd: float = 1e-3,
+        travel_force_limit: float = 80.0,
+        blocked_force_limit: float = None,
+    ):
+        if blocked_force_limit is None:
+            blocked_force_limit = travel_force_limit
+        assert kp > 0
+        assert kd >= 0
+        return self.custom_script(
+            0xB1, position, velocity, kp, kd, travel_force_limit, blocked_force_limit
+        )
+
+
+def test():
+    import numpy as np
+    import time
+
+    with WSGBinaryDriver(
+        hostname="wsg50-00004544.internal.tri.global", port=1000
+    ) as wsg:
+        # ACK
+        # msg = wsg.cmd_submit(0x24, bytearray([0x61, 0x63, 0x6B]))
+        msg = wsg.ack_fault()
+        print(msg)
+
+        # HOME
+        # msg = wsg.cmd_submit(0x20, bytearray([0x01]))
+        msg = wsg.homing()
+        print(msg)
+        # time.sleep(1.0)
+
+        # msg = wsg.pre_position(0, 150)
+        # print(msg)
+        # time.sleep(1.0)
+
+        T = 2
+        dt = 1 / 30
+        pos = np.linspace(0.0, 110.0, int(T / dt))[::-1]
+        vel = np.diff(pos) / dt
+        vel = np.append(vel, vel[-1])
+
+        t_start = time.time()
+        for i in range(len(pos)):
+            p = pos[i]
+            v = vel[i]
+            print(p, v)
+            info = wsg.script_position(position=p, dt=dt)
+            print(info)
+
+            t_end = t_start + i * dt
+            t_sleep = t_end - time.time()
+            print(t_sleep)
+            if t_sleep > 0:
+                time.sleep(t_sleep)
+        print(time.time() - t_start)
+        # cmd_id_b, payload_b, checksum_b = wsg.msg_receive()
+        # cmd_id_b, payload_b, checksum_b = wsg.msg_receive()
+        time.sleep(3.0)
+
+        T = 2
+        dt = 1 / 30
+        pos = np.linspace(0.0, 110.0, int(T / dt))
+        vel = np.diff(pos) / dt
+        vel = np.append(vel, vel[-1])
+
+        t_start = time.time()
+        for i in range(len(pos)):
+            p = pos[i]
+            v = vel[i]
+            print(p, v)
+            info = wsg.script_position(position=p, dt=dt)
+            print(info)
+
+            t_end = t_start + i * dt
+            t_sleep = t_end - time.time()
+            print(t_sleep)
+            if t_sleep > 0:
+                time.sleep(t_sleep)
+        print(time.time() - t_start)
+
+        # wsg.msg_send(0x30, bytearray([0x00, 0x00, 0x00, 0x00, 0x16, 0x43]))
+        # cmd_id_b, payload_b, checksum_b = wsg.msg_receive()
+        # time.sleep(1.0)

code/umi/real_world/wsg_controller.py

@@ -0,0 +1,241 @@
+import os
+import time
+import enum
+import multiprocessing as mp
+from multiprocessing.managers import SharedMemoryManager
+from umi.shared_memory.shared_memory_queue import SharedMemoryQueue, Empty
+from umi.shared_memory.shared_memory_ring_buffer import SharedMemoryRingBuffer
+from umi.common.precise_sleep import precise_wait
+from umi.real_world.wsg_binary_driver import WSGBinaryDriver
+from umi.common.pose_trajectory_interpolator import PoseTrajectoryInterpolator
+
+
+class Command(enum.Enum):
+    SHUTDOWN = 0
+    SCHEDULE_WAYPOINT = 1
+    RESTART_PUT = 2
+
+
+class WSGController(mp.Process):
+    def __init__(
+        self,
+        shm_manager: SharedMemoryManager,
+        hostname,
+        port=1000,
+        frequency=30,
+        home_to_open=True,
+        move_max_speed=200.0,
+        get_max_k=None,
+        command_queue_size=1024,
+        launch_timeout=3,
+        receive_latency=0.0,
+        use_meters=False,
+        verbose=False,
+    ):
+        super().__init__(name="WSGController")
+        self.hostname = hostname
+        self.port = port
+        self.frequency = frequency
+        self.home_to_open = home_to_open
+        self.move_max_speed = move_max_speed
+        self.launch_timeout = launch_timeout
+        self.receive_latency = receive_latency
+        self.scale = 1000.0 if use_meters else 1.0
+        self.verbose = verbose
+
+        if get_max_k is None:
+            get_max_k = int(frequency * 10)
+
+        # build input queue
+        example = {
+            "cmd": Command.SCHEDULE_WAYPOINT.value,
+            "target_pos": 0.0,
+            "target_time": 0.0,
+        }
+        input_queue = SharedMemoryQueue.create_from_examples(
+            shm_manager=shm_manager, examples=example, buffer_size=command_queue_size
+        )
+
+        # build ring buffer
+        example = {
+            "gripper_state": 0,
+            "gripper_position": 0.0,
+            "gripper_velocity": 0.0,
+            "gripper_force": 0.0,
+            "gripper_measure_timestamp": time.time(),
+            "gripper_receive_timestamp": time.time(),
+            "gripper_timestamp": time.time(),
+        }
+        ring_buffer = SharedMemoryRingBuffer.create_from_examples(
+            shm_manager=shm_manager,
+            examples=example,
+            get_max_k=get_max_k,
+            get_time_budget=0.2,
+            put_desired_frequency=frequency,
+        )
+
+        self.ready_event = mp.Event()
+        self.input_queue = input_queue
+        self.ring_buffer = ring_buffer
+
+    # ========= launch method ===========
+    def start(self, wait=True):
+        super().start()
+        if wait:
+            self.start_wait()
+        if self.verbose:
+            print(f"[WSGController] Controller process spawned at {self.pid}")
+
+    def stop(self, wait=True):
+        message = {"cmd": Command.SHUTDOWN.value}
+        self.input_queue.put(message)
+        if wait:
+            self.stop_wait()
+
+    def start_wait(self):
+        self.ready_event.wait(self.launch_timeout)
+        assert self.is_alive()
+
+    def stop_wait(self):
+        self.join()
+
+    @property
+    def is_ready(self):
+        return self.ready_event.is_set()
+
+    # ========= context manager ===========
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+    # ========= command methods ============
+    def schedule_waypoint(self, pos: float, target_time: float):
+        message = {
+            "cmd": Command.SCHEDULE_WAYPOINT.value,
+            "target_pos": pos,
+            "target_time": target_time,
+        }
+        self.input_queue.put(message)
+
+    def restart_put(self, start_time):
+        self.input_queue.put(
+            {"cmd": Command.RESTART_PUT.value, "target_time": start_time}
+        )
+
+    # ========= receive APIs =============
+    def get_state(self, k=None, out=None):
+        if k is None:
+            return self.ring_buffer.get(out=out)
+        else:
+            return self.ring_buffer.get_last_k(k=k, out=out)
+
+    def get_all_state(self):
+        return self.ring_buffer.get_all()
+
+    # ========= main loop in process ============
+    def run(self):
+        # start connection
+        try:
+            with WSGBinaryDriver(hostname=self.hostname, port=self.port) as wsg:
+
+                # home gripper to initialize
+                wsg.ack_fault()
+                wsg.homing(positive_direction=self.home_to_open, wait=True)
+
+                # get initial
+                curr_info = wsg.script_query()
+                curr_pos = curr_info["position"]
+                # curr_pos = 100.0
+                curr_t = time.monotonic()
+                last_waypoint_time = curr_t
+                pose_interp = PoseTrajectoryInterpolator(
+                    times=[curr_t], poses=[[curr_pos, 0, 0, 0, 0, 0]]
+                )
+
+                keep_running = True
+                t_start = time.monotonic()
+                iter_idx = 0
+                while keep_running:
+                    # command gripper
+                    t_now = time.monotonic()
+                    dt = 1 / self.frequency
+                    t_target = t_now
+                    target_pos = pose_interp(t_target)[0]
+                    target_vel = (target_pos - pose_interp(t_target - dt)[0]) / dt
+                    # print('controller', target_pos, target_vel)
+                    info = wsg.script_position_pd(
+                        position=target_pos, velocity=target_vel
+                    )
+                    # time.sleep(1e-3)
+
+                    # get state from robot
+                    state = {
+                        "gripper_state": info["state"],
+                        "gripper_position": info["position"] / self.scale,
+                        "gripper_velocity": info["velocity"] / self.scale,
+                        "gripper_force": info["force_motor"],
+                        "gripper_measure_timestamp": info["measure_timestamp"],
+                        "gripper_receive_timestamp": time.time(),
+                        "gripper_timestamp": time.time() - self.receive_latency,
+                    }
+                    self.ring_buffer.put(state)
+
+                    # fetch command from queue
+                    try:
+                        commands = self.input_queue.get_all()
+                        n_cmd = len(commands["cmd"])
+                    except Empty:
+                        n_cmd = 0
+
+                    # execute commands
+                    for i in range(n_cmd):
+                        command = dict()
+                        for key, value in commands.items():
+                            command[key] = value[i]
+                        cmd = command["cmd"]
+
+                        if cmd == Command.SHUTDOWN.value:
+                            keep_running = False
+                            # stop immediately, ignore later commands
+                            break
+                        elif cmd == Command.SCHEDULE_WAYPOINT.value:
+                            target_pos = command["target_pos"] * self.scale
+                            target_time = command["target_time"]
+                            # translate global time to monotonic time
+                            target_time = time.monotonic() - time.time() + target_time
+                            curr_time = t_now
+                            pose_interp = pose_interp.schedule_waypoint(
+                                pose=[target_pos, 0, 0, 0, 0, 0],
+                                time=target_time,
+                                max_pos_speed=self.move_max_speed,
+                                max_rot_speed=self.move_max_speed,
+                                curr_time=curr_time,
+                                last_waypoint_time=last_waypoint_time,
+                            )
+                            last_waypoint_time = target_time
+                        elif cmd == Command.RESTART_PUT.value:
+                            t_start = (
+                                command["target_time"] - time.time() + time.monotonic()
+                            )
+                            iter_idx = 1
+                        else:
+                            keep_running = False
+                            break
+
+                    # first loop successful, ready to receive command
+                    if iter_idx == 0:
+                        self.ready_event.set()
+                    iter_idx += 1
+
+                    # regulate frequency
+                    dt = 1 / self.frequency
+                    t_end = t_start + dt * iter_idx
+                    precise_wait(t_end=t_end, time_func=time.monotonic)
+
+        finally:
+            self.ready_event.set()
+            if self.verbose:
+                print(f"[WSGController] Disconnected from robot: {self.hostname}")