From ce37e636dc87d087ac565cccac3bbfa9447c174b Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 25 Jun 2026 15:00:21 +0200 Subject: [PATCH 01/87] fix: compatibility with mujoco 3.10.0 --- python/rcs/sim/composer.py | 61 ++++++++++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 15 deletions(-) diff --git a/python/rcs/sim/composer.py b/python/rcs/sim/composer.py index 2a6ebe6e..687160fc 100644 --- a/python/rcs/sim/composer.py +++ b/python/rcs/sim/composer.py @@ -53,10 +53,15 @@ def _find_site(self, name: str) -> Optional[mujoco._specs.MjsSite]: return None def _find_body(self, name: str) -> Optional[mujoco._specs.MjsBody]: - try: - return self.spec.find_body(name) - except ValueError: - return None + if hasattr(self.spec, "find_body"): + try: + return self.spec.find_body(name) + except ValueError: + return None + for body in self.spec.bodies: + if body.name == name: + return body + return None def _find_camera(self, name: str) -> Optional[mujoco._specs.MjsCamera]: for camera in self.spec.cameras: @@ -68,6 +73,30 @@ def _apply_pose(self, body: mujoco._specs.MjsBody, pose: Pose): body.pos = list(pose.translation()) body.quat = list(pose.rotation_q_wxyz()) + def _attach_to_frame(self, frame: mujoco._specs.MjsFrame, child_spec: mujoco.MjSpec, prefix: str): + """Attach a child spec to a frame across MuJoCo model-editing API versions.""" + if hasattr(frame, "attach"): + return frame.attach(child_spec, prefix, "") + return self.spec.attach(child_spec, frame=frame, prefix=prefix, suffix="") + + def _attach_spec_body_to_site( + self, + site: mujoco._specs.MjsSite, + child_spec: mujoco.MjSpec, + body: mujoco._specs.MjsBody, + prefix: str, + ) -> mujoco._specs.MjsBody: + """Attach a body to a site across MuJoCo model-editing API versions.""" + if hasattr(site, "attach"): + return site.attach(body, prefix, "") + body_name = body.name + self.spec.attach(child_spec, prefix=prefix, suffix="", site=site) + attached_body = self._find_body(f"{prefix}{body_name}") + if attached_body is None: + msg = f"Could not find attached body '{prefix}{body_name}' after site attachment." + raise ValueError(msg) + return attached_body + def _prefixed_free_joint_names(self, spec: mujoco.MjSpec, prefix: str) -> list[str]: free_joint_type = int(mujoco.mjtJoint.mjJNT_FREE) return [f"{prefix}{joint.name}" for joint in spec.joints if joint.name and int(joint.type) == free_joint_type] @@ -102,9 +131,10 @@ def add_camera( msg = f"Attachment site '{site_name}' not found." raise ValueError(msg) - camera_mount = mujoco.MjSpec().worldbody.add_body() + camera_spec = mujoco.MjSpec() + camera_mount = camera_spec.worldbody.add_body() camera_mount.name = "mount" - camera_mount = attachment_site.attach(camera_mount, f"{name}_", "") + camera_mount = self._attach_spec_body_to_site(attachment_site, camera_spec, camera_mount, f"{name}_") self._apply_pose(camera_mount, pose) @@ -137,6 +167,7 @@ def add_camera_xml( if root_body is None: msg = f"Camera MJCF '{xml_path}' must contain a root body." raise ValueError(msg) + root_body_name = root_body.name camera_names = [camera.name for camera in camera_spec.cameras] if len(camera_names) != 1 or camera_names[0] is None: @@ -147,8 +178,8 @@ def add_camera_xml( if robot_prefix is None: attach_frame = self.spec.worldbody.add_frame() - attach_frame.attach(camera_spec, prefix, "") - attached_root_name = f"{prefix}{root_body.name}" + self._attach_to_frame(attach_frame, camera_spec, prefix) + attached_root_name = f"{prefix}{root_body_name}" attached_root = self._find_body(attached_root_name) if attached_root is None: msg = f"Could not find camera root body '{attached_root_name}' after attachment." @@ -161,7 +192,7 @@ def add_camera_xml( msg = f"Attachment site '{site_name}' not found." raise ValueError(msg) - attached_root = attachment_site.attach(root_body, prefix, "") + attached_root = self._attach_spec_body_to_site(attachment_site, camera_spec, root_body, prefix) self._apply_pose(attached_root, pose) @@ -186,13 +217,13 @@ def add_robot(self, xml_path: str, prefix: str, pose: Pose | None = None) -> muj child_spec = mujoco.MjSpec.from_file(xml_path) self._resolve_asset_paths(child_spec, xml_path) + child_root_name = child_spec.worldbody.first_body().name # 1. Use a frame to attach the child spec (most comprehensive) frame = self.spec.worldbody.add_frame() - frame.attach(child_spec, prefix, "") + self._attach_to_frame(frame, child_spec, prefix) # 2. Identify the robot root body (it was prefixed) - child_root_name = child_spec.worldbody.first_body().name prefixed_root_name = f"{prefix}{child_root_name}" robot_root = self._find_body(prefixed_root_name) @@ -229,7 +260,7 @@ def add_gripper( self._resolve_asset_paths(gripper_spec, xml_path) gripper_root = gripper_spec.worldbody.first_body() - gripper_root = attachment_site.attach(gripper_root, gripper_prefix, "") + gripper_root = self._attach_spec_body_to_site(attachment_site, gripper_spec, gripper_root, gripper_prefix) self._apply_pose(gripper_root, pose) if gripper_prefix: self._gravcomp_prefixes.add(gripper_prefix) @@ -261,7 +292,7 @@ def add_object_robot_frame( self.register_root_relative_replay_free_joints(self._prefixed_free_joint_names(object_spec, object_prefix)) object_root = object_spec.worldbody.first_body() - object_root = attachment_site.attach(object_root, object_prefix, "") + object_root = self._attach_spec_body_to_site(attachment_site, object_spec, object_root, object_prefix) self._apply_pose(object_root, pose) return object_root @@ -288,13 +319,13 @@ def add_object_world_frame( self._resolve_asset_paths(child_spec, xml_path) if register_root_relative_replay_free_joints: self.register_root_relative_replay_free_joints(self._prefixed_free_joint_names(child_spec, object_prefix)) + child_root_name = child_spec.worldbody.first_body().name # Attach using a frame frame = self.spec.worldbody.add_frame() - frame.attach(child_spec, object_prefix, "") + self._attach_to_frame(frame, child_spec, object_prefix) # Identify the root of the added object - child_root_name = child_spec.worldbody.first_body().name prefixed_root_name = f"{object_prefix}{child_root_name}" obj_root = self._find_body(prefixed_root_name) if not obj_root: From 152afddcfaaa6a8ce8009062396407dcadc042b6 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 25 Jun 2026 15:00:28 +0200 Subject: [PATCH 02/87] feat: add rcs_taxim --- extensions/rcs_taxim/README.md | 11 ++ extensions/rcs_taxim/pyproject.toml | 27 +++ .../rcs_taxim/src/rcs_taxim/__init__.py | 1 + .../rcs_taxim/src/rcs_taxim/creators.py | 157 ++++++++++++++++++ .../rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 120 +++++++++++++ 5 files changed, 316 insertions(+) create mode 100644 extensions/rcs_taxim/README.md create mode 100644 extensions/rcs_taxim/pyproject.toml create mode 100644 extensions/rcs_taxim/src/rcs_taxim/__init__.py create mode 100644 extensions/rcs_taxim/src/rcs_taxim/creators.py create mode 100644 extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py diff --git a/extensions/rcs_taxim/README.md b/extensions/rcs_taxim/README.md new file mode 100644 index 00000000..2625c78d --- /dev/null +++ b/extensions/rcs_taxim/README.md @@ -0,0 +1,11 @@ +# RCS Taxim Extension + +This extension provides integration with the [Taxim](https://github.com/Robo-Touch/Taxim) tactile sensor simulator. + +It ports the tactile pick-up example onto the current RCS scene/config stack by swapping in a TAXIM-equipped Franka hand while reusing the current FR3 pick setup. + +## Installation + +```shell +pip install -ve extensions/rcs_taxim +``` diff --git a/extensions/rcs_taxim/pyproject.toml b/extensions/rcs_taxim/pyproject.toml new file mode 100644 index 00000000..9019067b --- /dev/null +++ b/extensions/rcs_taxim/pyproject.toml @@ -0,0 +1,27 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" + +[project] +name = "rcs_taxim" +version = "0.6.3" +description = "RCS integration of mujoco-taxim" +dependencies = [ + "rcs>=0.6.3", + "omegaconf", + "mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@956b7d05e1f28d6d186eb1d386f4c13d7b014308", +] +readme = "README.md" +maintainers = [ + { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, +] +authors = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] +requires-python = ">=3.10" + +[tool.black] +line-length = 120 +target-version = ["py310"] + +[tool.isort] +profile = "black" diff --git a/extensions/rcs_taxim/src/rcs_taxim/__init__.py b/extensions/rcs_taxim/src/rcs_taxim/__init__.py new file mode 100644 index 00000000..63af8876 --- /dev/null +++ b/extensions/rcs_taxim/src/rcs_taxim/__init__.py @@ -0,0 +1 @@ +__version__ = "0.6.3" diff --git a/extensions/rcs_taxim/src/rcs_taxim/creators.py b/extensions/rcs_taxim/src/rcs_taxim/creators.py new file mode 100644 index 00000000..0f3febb3 --- /dev/null +++ b/extensions/rcs_taxim/src/rcs_taxim/creators.py @@ -0,0 +1,157 @@ +from __future__ import annotations + +import copy +from pathlib import Path +from typing import Any + +import gymnasium as gym +import numpy as np +from rcs._core.common import GripperType, Pose +from rcs._core.sim import SimCameraConfig, SimGripperConfig +from rcs.envs.base import ControlMode, RelativeTo +from rcs.envs.configs import EmptyWorldFR3 +from rcs_taxim.taxim_wrapper import TaximSimWrapper + +import rcs + +_TAXIM_GRIPPER_TYPE = GripperType("TaximDigit") + + +def _digit_model_path() -> Path: + return Path(rcs.RCS_PREFIX, "assets", "sensors", "digit", "digit.xml") + + +def _prefixed(name: str) -> str: + return f"gripper{name}" + + +def _make_camera_cfgs( + base_cfgs: dict[str, SimCameraConfig], + cam_list: tuple[str, ...], + resolution: tuple[int, int] | None, + frame_rate: int, +) -> dict[str, SimCameraConfig]: + camera_cfgs: dict[str, SimCameraConfig] = {} + for cam in cam_list: + if cam not in base_cfgs: + available = ", ".join(sorted(base_cfgs)) + msg = f"Unknown camera {cam!r}. Available cameras: {available}" + raise ValueError(msg) + cfg = copy.deepcopy(base_cfgs[cam]) + if resolution is not None: + cfg.resolution_width = resolution[0] + cfg.resolution_height = resolution[1] + if frame_rate > 0: + cfg.frame_rate = frame_rate + camera_cfgs[cam] = cfg + return camera_cfgs + + +def _taxim_gripper_cfg() -> SimGripperConfig: + return SimGripperConfig( + epsilon_inner=0.005, + epsilon_outer=0.005, + seconds_between_callbacks=0.1, + ignored_collision_geoms=[], + collision_geoms=[ + "finger_a_left", + "finger_b_left", + "finger_c_left", + "finger_1_left", + "finger_a_right", + "finger_b_right", + "finger_c_right", + "finger_1_right", + ], + collision_geoms_fingers=[ + "finger_a_left", + "finger_b_left", + "finger_c_left", + "finger_1_left", + "finger_a_right", + "finger_b_right", + "finger_c_right", + "finger_1_right", + ], + joints=["finger_joint1", "finger_joint2"], + max_joint_width=0.04, + min_joint_width=0.0, + actuator="hand_actuator", + max_actuator_width=255.0, + min_actuator_width=0.0, + gripper_type=_TAXIM_GRIPPER_TYPE, + ) + + +class FR3TaximSimplePickUpSimEnvCreator: + def __call__( + self, + render_mode: str = "human", + control_mode: ControlMode = ControlMode.CARTESIAN_TRPY, + resolution: tuple[int, int] | None = None, + frame_rate: int = 0, + delta_actions: bool = True, + cam_list: tuple[str, ...] | None = None, + taxim_kwargs: dict[str, Any] | None = None, + **kwargs: Any, + ) -> gym.Env: + binary_gripper = kwargs.pop("binary_gripper", True) + home_on_reset = kwargs.pop("home_on_reset", True) + max_relative_movement = kwargs.pop("max_relative_movement", None) + if kwargs: + unexpected = ", ".join(sorted(kwargs)) + msg = f"Unexpected keyword arguments: {unexpected}" + raise TypeError(msg) + + rcs.GRIPPER_PATHS[_TAXIM_GRIPPER_TYPE] = str(_digit_model_path()) + + scene = EmptyWorldFR3() + cfg = scene.config() + cfg.control_mode = control_mode + cfg.headless = render_mode != "human" + cfg.sim_cfg.realtime = render_mode == "human" + cfg.sim_cfg.async_control = render_mode == "human" + cfg.sim_cfg.frequency = 30 + cfg.wrapper_cfg.binary_gripper = binary_gripper + cfg.wrapper_cfg.home_on_reset = home_on_reset + cfg.max_relative_movement = ( + max_relative_movement if max_relative_movement is not None else (0.2, np.deg2rad(45)) + ) + cfg.relative_to = RelativeTo.LAST_STEP if delta_actions else RelativeTo.NONE + if not delta_actions: + cfg.max_relative_movement = None + cfg.gripper_cfgs = {"robot": _taxim_gripper_cfg()} + cfg.gripper_offsets = None + cfg.root_frame_objects = { + "": ( + rcs.OBJECT_PATHS["green_cube"], + Pose(translation=np.array([0.5, 0.0, 0.05]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), + ) + } + + cam_list = tuple(cam_list or ()) + if cam_list: + cfg.camera_cfgs = _make_camera_cfgs(cfg.camera_cfgs or {}, cam_list, resolution, frame_rate) + cfg.camera_adds = ( + {name: cfg.camera_adds[name] for name in cam_list} if cfg.camera_adds is not None else None + ) + else: + cfg.camera_cfgs = None + cfg.camera_adds = None + + env = scene.create_env(cfg) + merged_taxim_kwargs: dict[str, Any] = { + "taxim_sites": [_prefixed("left_taxim_pad"), _prefixed("right_taxim_pad")], + "taxim_pad_geoms": [_prefixed("finger_1_left"), _prefixed("finger_1_right")], + "target_geom_mesh_dict": {"_box_geom": "_box_geom"}, + "taxim_sensor_type": "digit", + "taxim_fps": 60, + "enable_depth": True, + "visualize": False, + } + if taxim_kwargs is not None: + merged_taxim_kwargs.update(taxim_kwargs) + env = TaximSimWrapper(env, **merged_taxim_kwargs) + if render_mode == "human": + env.get_wrapper_attr("sim").open_gui() + return env diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py new file mode 100644 index 00000000..f6de3023 --- /dev/null +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -0,0 +1,120 @@ +import copy +from typing import Any + +import gymnasium as gym +import numpy as np + + +class TaximSimWrapper(gym.Wrapper): + """Wrapper to render TAXIM tactile observations alongside regular RCS observations.""" + + def __init__( + self, + env: gym.Env, + taxim_sites: list[str], + taxim_pad_geoms: list[str], + target_geom_mesh_dict: dict[str, str], + taxim_sensor_type: str = "digit", + taxim_bg_idx: int = 0, + taxim_bg_randomize: bool = False, + enable_depth: bool = False, + taxim_fps: int = 60, + visualize: bool = False, + ): + super().__init__(env) + self.taxim_sensors: list[Any] = [] + self.model = self.env.get_wrapper_attr("sim").model + self.data = self.env.get_wrapper_attr("sim").data + self.last_tactile_frames: dict[str, dict[str, dict[str, Any]]] = {} + + self.taxim_sites = taxim_sites + self.taxim_pad_geoms = taxim_pad_geoms + self.target_geom_mesh_dict = target_geom_mesh_dict + self.taxim_sensor_type = taxim_sensor_type + self.taxim_bg_idx = taxim_bg_idx + self.taxim_bg_randomize = taxim_bg_randomize + self.taxim_fps = taxim_fps + self.taxim_last_render = -1.0 + self.enable_depth = enable_depth + self.initialized = False + self.visualize = visualize + + self.observation_space = copy.deepcopy(env.observation_space) + if not isinstance(self.observation_space, gym.spaces.Dict): + msg = "Expected wrapped observation space to be a gym.spaces.Dict." + raise TypeError(msg) + + frame_spaces = self.observation_space.spaces.get("frames") + if frame_spaces is None: + frame_spaces = gym.spaces.Dict({}) + self.observation_space.spaces["frames"] = frame_spaces + if not isinstance(frame_spaces, gym.spaces.Dict): + msg = "Expected frames observation space to be a gym.spaces.Dict." + raise TypeError(msg) + + tactile_space: dict[str, gym.Space[Any]] = { + "rgb": gym.spaces.Dict( + { + "data": gym.spaces.Box(low=0, high=255, shape=(320, 240, 3), dtype=np.uint8), + } + ) + } + if self.enable_depth: + tactile_space["depth"] = gym.spaces.Dict( + { + "data": gym.spaces.Box(low=-np.inf, high=np.inf, shape=(320, 240), dtype=np.float64), + } + ) + frame_spaces.spaces.update( + {f"tactile_{site}": gym.spaces.Dict(copy.deepcopy(tactile_space)) for site in self.taxim_sites} + ) + + def _ensure_initialized(self) -> None: + if self.initialized: + return + from TaximSensor import TaximSensor + + for site, pad_geom in zip(self.taxim_sites, self.taxim_pad_geoms, strict=True): + sensor = TaximSensor(resize=(240, 320), sensor_type=self.taxim_sensor_type, preprocess_bg=False) + sensor.add_camera_mujoco(site, self.model, self.data) + sensor.change_bg(self.taxim_bg_idx) + for geom, mesh in self.target_geom_mesh_dict.items(): + sensor.add_geom_mujoco(geom, self.model, self.data, mesh) + sensor.set_sensor_pad_geom(pad_geom) + self.taxim_sensors.append(sensor) + self.initialized = True + + def _render_tactile_frames(self, visualize: bool) -> dict[str, dict[str, dict[str, Any]]]: + frames: dict[str, dict[str, dict[str, Any]]] = {} + for site, sensor in zip(self.taxim_sites, self.taxim_sensors, strict=True): + rgb, depth, _ = sensor.render_taxim(self.model, self.data, visualize=visualize) + tactile_obs: dict[str, dict[str, Any]] = {"rgb": {"data": rgb}} + if self.enable_depth: + tactile_obs["depth"] = {"data": depth} + frames[f"tactile_{site}"] = tactile_obs + return frames + + def _update_obs(self, obs: dict[str, Any]) -> None: + frames = obs.setdefault("frames", {}) + for site, tactile_obs in self.last_tactile_frames.items(): + frames[site] = copy.deepcopy(tactile_obs) + + def reset( + self, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + obs, info = super().reset(seed=seed, options=options) + self._ensure_initialized() + self.taxim_last_render = -1.0 + self.last_tactile_frames = self._render_tactile_frames(visualize=False) + self._update_obs(obs) + return obs, info + + def step(self, action: dict[str, Any]): + obs, reward, done, truncated, info = super().step(action) + self._ensure_initialized() + if self.taxim_last_render + (1 / self.taxim_fps) <= self.data.time: + self.last_tactile_frames = self._render_tactile_frames(visualize=self.visualize) + self.taxim_last_render = self.data.time + + self._update_obs(obs) + return obs, reward, done, truncated, info From d10cd51618e8d311628572a1e82645b76891e9b4 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 25 Jun 2026 17:37:45 +0200 Subject: [PATCH 03/87] feat: working taxim demo with robotiq gripper --- .../rcs_taxim/examples/grasp_digit_demo.py | 105 ++++++++++++++++++ .../rcs_taxim/src/rcs_taxim/creators.py | 56 ++++------ .../rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 2 +- 3 files changed, 125 insertions(+), 38 deletions(-) create mode 100644 extensions/rcs_taxim/examples/grasp_digit_demo.py diff --git a/extensions/rcs_taxim/examples/grasp_digit_demo.py b/extensions/rcs_taxim/examples/grasp_digit_demo.py new file mode 100644 index 00000000..5db4c679 --- /dev/null +++ b/extensions/rcs_taxim/examples/grasp_digit_demo.py @@ -0,0 +1,105 @@ +import logging +from typing import Any, cast + +import gymnasium as gym +import mujoco +import numpy as np +from rcs._core.common import Pose +from rcs._core.sim import SimRobot +from rcs.envs.base import GripperWrapper + +logger = logging.getLogger(__name__) +logger.setLevel(logging.INFO) + + +def _progress(iterable): + try: + from tqdm import tqdm + except ImportError: + return iterable + return tqdm(iterable) + + +class PickUpDemo: + def __init__(self, env: gym.Env): + self.env = env + self._robot = cast(SimRobot, self.env.get_wrapper_attr("robot")["robot"]) + self.home_pose = self._robot.get_cartesian_position() + + def _action(self, pose: Pose, gripper: list[float]) -> dict[str, Any]: + return {"robot": {"xyzrpy": pose.xyzrpy(), "gripper": gripper}} + + def get_object_pose(self, geom_name: str) -> Pose: + model = self.env.get_wrapper_attr("sim").model + data = self.env.get_wrapper_attr("sim").data + + geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) + obj_pose_world_coordinates = Pose( + translation=data.geom_xpos[geom_id], rotation=data.geom_xmat[geom_id].reshape(3, 3) + ) * Pose(rpy_vector=np.array([0, 0, np.pi]), translation=np.array([0.0, 0.0, 0.0])) + return self._robot.to_pose_in_robot_coordinates(obj_pose_world_coordinates) + + def generate_waypoints(self, start_pose: Pose, end_pose: Pose, num_waypoints: int) -> list[Pose]: + return [start_pose.interpolate(end_pose, i / num_waypoints) for i in range(num_waypoints + 1)] + + def step(self, action: dict[str, Any]) -> dict[str, Any]: + return self.env.step(action)[0] + + def plan_linear_motion(self, geom_name: str, delta_up: float, num_waypoints: int = 20) -> list[Pose]: + end_eff_pose = self._robot.get_cartesian_position() + goal_pose = self.get_object_pose(geom_name=geom_name) + goal_pose *= Pose(translation=np.array([0, 0, delta_up]), quaternion=np.array([1, 0, 0, 0])) + return self.generate_waypoints(end_eff_pose, goal_pose, num_waypoints=num_waypoints) + + def execute_motion( + self, waypoints: list[Pose], gripper: list[float] = GripperWrapper.BINARY_GRIPPER_OPEN + ) -> dict[str, Any]: + obs: dict[str, Any] = {} + for waypoint in waypoints: + obs = self.step(self._action(waypoint, gripper)) + return obs + + def approach(self, geom_name: str): + waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=0.2, num_waypoints=60) + self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) + + def grasp(self, geom_name: str): + waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=-0.005, num_waypoints=60) + self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) + + for _ in range(4): + self.step(self._action(self._robot.get_cartesian_position(), GripperWrapper.BINARY_GRIPPER_CLOSED)) + + waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=0.2, num_waypoints=60) + self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_CLOSED) + + def move_home(self): + end_eff_pose = self._robot.get_cartesian_position() + waypoints = self.generate_waypoints(end_eff_pose, self.home_pose, num_waypoints=60) + self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_CLOSED) + + def pickup(self, geom_name: str): + self.approach(geom_name) + self.grasp(geom_name) + self.move_home() + + +def main(): + try: + from rcs_taxim.creators import FR3TaximSimplePickUpSimEnvCreator + except ImportError as exc: + msg = "This example requires the rcs_taxim extension, install it with `pip install -e extensions/rcs_taxim`." + raise ImportError(msg) from exc + + env_fact = FR3TaximSimplePickUpSimEnvCreator() + env = env_fact(render_mode="human", delta_actions=False) + + for _ in _progress(range(100)): + env.reset() + controller = PickUpDemo(env) + controller.pickup("_box_geom") + env.close() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/extensions/rcs_taxim/src/rcs_taxim/creators.py b/extensions/rcs_taxim/src/rcs_taxim/creators.py index 0f3febb3..e56f4f22 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/creators.py +++ b/extensions/rcs_taxim/src/rcs_taxim/creators.py @@ -14,11 +14,11 @@ import rcs -_TAXIM_GRIPPER_TYPE = GripperType("TaximDigit") +_TAXIM_GRIPPER_TYPE = GripperType("Robotiq2F85Digit") def _digit_model_path() -> Path: - return Path(rcs.RCS_PREFIX, "assets", "sensors", "digit", "digit.xml") + return Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") def _prefixed(name: str) -> str: @@ -49,38 +49,20 @@ def _make_camera_cfgs( def _taxim_gripper_cfg() -> SimGripperConfig: return SimGripperConfig( - epsilon_inner=0.005, - epsilon_outer=0.005, - seconds_between_callbacks=0.1, - ignored_collision_geoms=[], - collision_geoms=[ - "finger_a_left", - "finger_b_left", - "finger_c_left", - "finger_1_left", - "finger_a_right", - "finger_b_right", - "finger_c_right", - "finger_1_right", - ], - collision_geoms_fingers=[ - "finger_a_left", - "finger_b_left", - "finger_c_left", - "finger_1_left", - "finger_a_right", - "finger_b_right", - "finger_c_right", - "finger_1_right", - ], - joints=["finger_joint1", "finger_joint2"], - max_joint_width=0.04, - min_joint_width=0.0, - actuator="hand_actuator", - max_actuator_width=255.0, - min_actuator_width=0.0, - gripper_type=_TAXIM_GRIPPER_TYPE, - ) + epsilon_inner=0.005, + epsilon_outer=0.005, + seconds_between_callbacks=0.1, + ignored_collision_geoms=[], + collision_geoms=[], + collision_geoms_fingers=[], + joints=["right_driver_joint", "left_driver_joint"], + max_joint_width=0.005, + min_joint_width=1.0, + actuator="fingers_actuator", + max_actuator_width=0, + min_actuator_width=255, + gripper_type=_TAXIM_GRIPPER_TYPE, + ) class FR3TaximSimplePickUpSimEnvCreator: @@ -141,13 +123,13 @@ def __call__( env = scene.create_env(cfg) merged_taxim_kwargs: dict[str, Any] = { - "taxim_sites": [_prefixed("left_taxim_pad"), _prefixed("right_taxim_pad")], - "taxim_pad_geoms": [_prefixed("finger_1_left"), _prefixed("finger_1_right")], + "taxim_sites": [_prefixed("left_digit_pad"), _prefixed("right_digit_pad")], + "taxim_pad_geoms": [_prefixed("left_digit_pad"), _prefixed("right_digit_pad")], "target_geom_mesh_dict": {"_box_geom": "_box_geom"}, "taxim_sensor_type": "digit", "taxim_fps": 60, "enable_depth": True, - "visualize": False, + "visualize": True, } if taxim_kwargs is not None: merged_taxim_kwargs.update(taxim_kwargs) diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index f6de3023..6b264f0a 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -87,7 +87,7 @@ def _ensure_initialized(self) -> None: def _render_tactile_frames(self, visualize: bool) -> dict[str, dict[str, dict[str, Any]]]: frames: dict[str, dict[str, dict[str, Any]]] = {} for site, sensor in zip(self.taxim_sites, self.taxim_sensors, strict=True): - rgb, depth, _ = sensor.render_taxim(self.model, self.data, visualize=visualize) + rgb, depth, _ = sensor.render_taxim(self.model, self.data, visualize=self.visualize, cycle_bg=self.taxim_bg_randomize) tactile_obs: dict[str, dict[str, Any]] = {"rgb": {"data": rgb}} if self.enable_depth: tactile_obs["depth"] = {"data": depth} From 0b6380e67f41c01eb842332f305b9294bbb1c070 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 25 Jun 2026 17:38:01 +0200 Subject: [PATCH 04/87] fix: remove misplaced tactile sensor demo --- examples/fr3/grasp_digit_demo.py | 98 -------------------------------- 1 file changed, 98 deletions(-) delete mode 100644 examples/fr3/grasp_digit_demo.py diff --git a/examples/fr3/grasp_digit_demo.py b/examples/fr3/grasp_digit_demo.py deleted file mode 100644 index c90fccad..00000000 --- a/examples/fr3/grasp_digit_demo.py +++ /dev/null @@ -1,98 +0,0 @@ -import logging -from typing import Any, cast - -import gymnasium as gym -import mujoco -import numpy as np -from rcs._core.common import Pose -from rcs._core.sim import SimRobot -from rcs.envs.base import GripperWrapper -from rcs_tacto.creators import FR3TactoSimplePickUpSimEnvCreator -from tqdm import tqdm - -logger = logging.getLogger(__name__) -logger.setLevel(logging.INFO) - - -class PickUpDemo: - def __init__(self, env: gym.Env): - self.env = env - self._robot = cast(SimRobot, self.env.get_wrapper_attr("robot")) - self.home_pose = self._robot.get_cartesian_position() - - def _action(self, pose: Pose, gripper: list[float]) -> dict[str, Any]: - return {"xyzrpy": pose.xyzrpy(), "gripper": gripper} - - def get_object_pose(self, geom_name) -> Pose: - model = self.env.get_wrapper_attr("sim").model - data = self.env.get_wrapper_attr("sim").data - - geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) - obj_pose_world_coordinates = Pose( - translation=data.geom_xpos[geom_id], rotation=data.geom_xmat[geom_id].reshape(3, 3) - ) - return self._robot.to_pose_in_robot_coordinates(obj_pose_world_coordinates) - - def generate_waypoints(self, start_pose: Pose, end_pose: Pose, num_waypoints: int) -> list[Pose]: - waypoints = [] - for i in range(num_waypoints + 1): - t = i / (num_waypoints) - waypoints.append(start_pose.interpolate(end_pose, t)) - return waypoints - - def step(self, action: dict) -> dict: - return self.env.step(action)[0] - - def plan_linear_motion(self, geom_name: str, delta_up: float, num_waypoints: int = 200) -> list[Pose]: - end_eff_pose = self._robot.get_cartesian_position() - goal_pose = self.get_object_pose(geom_name=geom_name) - goal_pose *= Pose(translation=np.array([0, 0, delta_up]), quaternion=np.array([1, 0, 0, 0])) # type: ignore - return self.generate_waypoints(end_eff_pose, goal_pose, num_waypoints=num_waypoints) - - def execute_motion(self, waypoints: list[Pose], gripper: list[float] = GripperWrapper.BINARY_GRIPPER_OPEN) -> dict: - for i in range(len(waypoints)): - obs = self.step(self._action(waypoints[i], gripper)) - return obs - - def approach(self, geom_name: str): - waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=0.2, num_waypoints=5) - self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) - - def grasp(self, geom_name: str): - - waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=-0.01, num_waypoints=15) - self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) - - self.step(self._action(Pose(), GripperWrapper.BINARY_GRIPPER_CLOSED)) - - waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=0.2, num_waypoints=15) - self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_CLOSED) - - def move_home(self): - end_eff_pose = self._robot.get_cartesian_position() - waypoints = self.generate_waypoints(end_eff_pose, self.home_pose, num_waypoints=10) - self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_CLOSED) - - def pickup(self, geom_name: str): - self.approach(geom_name) - self.grasp(geom_name) - self.move_home() - - -def main(): - env_fact = FR3TactoSimplePickUpSimEnvCreator() - env = env_fact( - render_mode="human", - delta_actions=False, - ) - - for _ in tqdm(range(100)): - # reset the environment - env.reset() - controller = PickUpDemo(env) - controller.pickup("yellow_box_geom") - env.close() - - -if __name__ == "__main__": - main() From 84890b50805247b7684e8df3b10f55a9f1264aea Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 25 Jun 2026 18:47:56 +0200 Subject: [PATCH 05/87] WIP: implementation of StableBaselines3 PPO --- extensions/rcs_sb3/README.md | 34 +++ extensions/rcs_sb3/pyproject.toml | 20 ++ extensions/rcs_sb3/run_test.py | 256 ++++++++++++++++++++ extensions/rcs_sb3/src/rcs_sb3/__init__.py | 15 ++ extensions/rcs_sb3/src/rcs_sb3/interface.py | 50 ++++ extensions/rcs_sb3/src/rcs_sb3/ppo.py | 19 ++ extensions/rcs_sb3/src/rcs_sb3/sb3.py | 121 +++++++++ extensions/rcs_sb3/src/rcs_sb3/wrappers.py | 149 ++++++++++++ extensions/rcs_sb3/tests/test_wrappers.py | 69 ++++++ 9 files changed, 733 insertions(+) create mode 100644 extensions/rcs_sb3/README.md create mode 100644 extensions/rcs_sb3/pyproject.toml create mode 100644 extensions/rcs_sb3/run_test.py create mode 100644 extensions/rcs_sb3/src/rcs_sb3/__init__.py create mode 100644 extensions/rcs_sb3/src/rcs_sb3/interface.py create mode 100644 extensions/rcs_sb3/src/rcs_sb3/ppo.py create mode 100644 extensions/rcs_sb3/src/rcs_sb3/sb3.py create mode 100644 extensions/rcs_sb3/src/rcs_sb3/wrappers.py create mode 100644 extensions/rcs_sb3/tests/test_wrappers.py diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md new file mode 100644 index 00000000..29131ef5 --- /dev/null +++ b/extensions/rcs_sb3/README.md @@ -0,0 +1,34 @@ +# rcs_sb3 + +Stable-Baselines3 integration for RCS Gymnasium environments. + +The package keeps SB3-specific code behind a small algorithm interface so another +RL backend can be added later without changing the environment creation code. + +```python +from rcs_sb3 import SB3PPO, SB3PPOConfig + +trainer = SB3PPO(SB3PPOConfig(total_timesteps=100_000)) +model = trainer.build(env) +trainer.learn() +``` + +For runtime control, load or build the algorithm and insert it into the RCS +wrapper stack: + +```python +ppo = SB3PPO.load("ppo_rcs_model") +env = ppo.as_wrapper(env) + +obs, info = env.reset() +obs, reward, terminated, truncated, info = env.step() +``` + +`StableBaselines3PolicyWrapper` stores the latest observation returned by the +wrapped RCS stack. On each `step()`, it asks the SB3 model for an action, converts +that action back into the RCS action dict, and passes it down to the robot layer. + +By default, `SB3PPO.build()` prepares environments with `StableBaselines3Wrapper`, +which flattens RCS dict actions and optionally flattens dict observations for +`MlpPolicy`. Use `policy="MultiInputPolicy"` and `flatten_observations=False` +when you want SB3 to consume dictionary observations directly. diff --git a/extensions/rcs_sb3/pyproject.toml b/extensions/rcs_sb3/pyproject.toml new file mode 100644 index 00000000..28eb8745 --- /dev/null +++ b/extensions/rcs_sb3/pyproject.toml @@ -0,0 +1,20 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" + +[project] +name = "rcs_sb3" +version = "0.7.1" +description = "Stable-Baselines3 integration for RCS environments" +dependencies = ["rcs>=0.7.1", "stable-baselines3>=2.3.0"] +readme = "README.md" +maintainers = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] +authors = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] +requires-python = ">=3.11" + +[tool.black] +line-length = 120 +target-version = ["py310"] + +[tool.isort] +profile = "black" diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py new file mode 100644 index 00000000..75fad715 --- /dev/null +++ b/extensions/rcs_sb3/run_test.py @@ -0,0 +1,256 @@ +"""Smoke-test the RCS SB3 policy wrapper on a simulated FR3 + Taxim stack. + +This does not train PPO. It uses a tiny SB3-like zero model with a ``predict`` +method to verify the runtime pipeline: + + RCS + Taxim observations -> policy wrapper -> generated action dict -> robot wrappers +""" + +from __future__ import annotations + +import argparse +from pathlib import Path +from typing import Any + +import gymnasium as gym +import mujoco +import numpy as np +from rcs._core.common import GripperType, Pose +from rcs._core.sim import SimGripperConfig +from rcs.envs.base import ControlMode, RelativeTo +from rcs.envs.configs import EmptyWorldFR3 +from rcs_sb3 import StableBaselines3PolicyWrapper +from rcs_taxim.taxim_wrapper import TaximSimWrapper + +import rcs + +_TAXIM_GRIPPER_TYPE = GripperType("Robotiq2F85Digit") +_TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") +_ROBOT_NAME = "robot" +_CUBE_GEOM = "_box_geom" + + +def _zero_closed_action(space: gym.Space) -> dict[str, Any]: + action = space.sample() + + def visit(value: Any) -> None: + if isinstance(value, dict): + if "gripper" in value: + value["gripper"] = np.array([0.0], dtype=np.float32) + for child in value.values(): + visit(child) + elif isinstance(value, np.ndarray): + value[...] = 0 + + visit(action) + return action + + +def _taxim_gripper_cfg() -> SimGripperConfig: + return SimGripperConfig( + epsilon_inner=0.005, + epsilon_outer=0.005, + seconds_between_callbacks=0.1, + ignored_collision_geoms=[], + collision_geoms=[], + collision_geoms_fingers=[], + joints=["right_driver_joint", "left_driver_joint"], + max_joint_width=0.005, + min_joint_width=1.0, + actuator="fingers_actuator", + max_actuator_width=0, + min_actuator_width=255, + gripper_type=_TAXIM_GRIPPER_TYPE, + ) + + +class ZeroSB3Model: + """Minimal SB3-compatible model for pipeline testing.""" + + def __init__(self, action_space: gym.Space): + self.action_space = action_space + + def predict( + self, + observation: Any, + state: Any = None, + episode_start: np.ndarray | None = None, + deterministic: bool = False, + ) -> tuple[dict[str, np.ndarray], Any]: + del observation, episode_start, deterministic + return _zero_closed_action(self.action_space), state + + +class StartGraspedWrapper(gym.Wrapper): + """Close the gripper after reset so the episode starts with the object held.""" + + def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10): + super().__init__(env) + self.settle_steps = settle_steps + self.post_gravity_settle_steps = post_gravity_settle_steps + + def _closed_gripper_hold_action(self) -> dict[str, Any]: + return _zero_closed_action(self.env.action_space) + + def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: + cfg = gripper.get_config() + actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) + if actuator_id < 0: + msg = f"Could not find gripper actuator {cfg.actuator!r}." + raise ValueError(msg) + ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width + ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] + sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + sim = self.env.get_wrapper_attr("sim") + gravity = np.array(sim.model.opt.gravity, copy=True) + + # CoverWrapper steps the simulation during reset. Disable gravity before + # the wrapped reset so the cube does not fall before we can close. + sim.model.opt.gravity[:] = 0 + obs, info = self.env.reset(seed=seed, options=options) + + robot = self.env.get_wrapper_attr("robot") + gripper = self.env.get_wrapper_attr("gripper") + if isinstance(robot, dict): + robot = robot["robot"] + if isinstance(gripper, dict): + gripper = gripper["robot"] + hold_joints = robot.get_joint_position().copy() + + try: + for step_idx in range(self.settle_steps): + width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) + self._command_gripper_width(sim, gripper, width) + robot.set_joint_position(hold_joints) + sim.step(1) + finally: + sim.model.opt.gravity[:] = gravity + + gripper.grasp() + for _ in range(self.post_gravity_settle_steps): + robot.set_joint_position(hold_joints) + gripper.grasp() + sim.step(1) + + obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) + if terminated or truncated: + obs, info = self.env.reset(seed=seed, options=options) + sim.sync_gui() + return obs, info + + +def make_franka_taxim_sim_env( + *, + render_mode: str, + visualize_taxim: bool, + enable_depth: bool, + start_grasped: bool, + grasp_settle_steps: int, + post_gravity_settle_steps: int, +) -> gym.Env: + rcs.GRIPPER_PATHS[_TAXIM_GRIPPER_TYPE] = str(_TAXIM_GRIPPER_XML) + + scene = EmptyWorldFR3() + cfg = scene.config() + cfg.control_mode = ControlMode.JOINTS + cfg.headless = render_mode != "human" + cfg.sim_cfg.realtime = render_mode == "human" + cfg.sim_cfg.async_control = render_mode == "human" + cfg.sim_cfg.frequency = 30 + cfg.wrapper_cfg.binary_gripper = True + cfg.wrapper_cfg.home_on_reset = True + cfg.max_relative_movement = np.deg2rad(5) + cfg.relative_to = RelativeTo.LAST_STEP + cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} + cfg.gripper_offsets = None + cfg.root_frame_objects = { + "": ( + rcs.OBJECT_PATHS["green_cube"], + Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), + ) + } + cfg.robot_cfgs[_ROBOT_NAME].tcp_offset = rcs.GRIPPER_OFFSETS[rcs.common.GripperType("Robotiq2F85")] + q_home = cfg.robot_cfgs[_ROBOT_NAME].q_home.copy() + q_home[-1] = -1.571 + cfg.robot_cfgs[_ROBOT_NAME].q_home = q_home + cfg.camera_cfgs = None + cfg.camera_adds = None + + env = scene.create_env(cfg) + env = TaximSimWrapper( + env, + taxim_sites=["gripperleft_digit_pad", "gripperright_digit_pad"], + taxim_pad_geoms=["gripperleft_digit_pad", "gripperright_digit_pad"], + target_geom_mesh_dict={_CUBE_GEOM: _CUBE_GEOM}, + taxim_sensor_type="digit", + taxim_fps=60, + enable_depth=enable_depth, + visualize=visualize_taxim, + ) + if start_grasped: + env = StartGraspedWrapper( + env, + settle_steps=grasp_settle_steps, + post_gravity_settle_steps=post_gravity_settle_steps, + ) + if render_mode == "human": + env.get_wrapper_attr("sim").open_gui() + return env + + +def main() -> None: + parser = argparse.ArgumentParser(description="Run a zero-policy SB3 wrapper smoke test in FR3 + Taxim simulation.") + parser.add_argument("--steps", type=int, default=20) + parser.add_argument("--seed", type=int, default=0) + parser.add_argument("--gui", action="store_true", help="Open the MuJoCo GUI.") + parser.add_argument("--visualize-taxim", action="store_true", help="Show nonblocking Taxim tactile windows.") + parser.add_argument("--disable-taxim-depth", action="store_true", help="Do not include Taxim depth frames.") + parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") + parser.add_argument("--grasp-settle-steps", type=int, default=30) + parser.add_argument("--post-gravity-settle-steps", type=int, default=10) + args = parser.parse_args() + + env = make_franka_taxim_sim_env( + render_mode="human" if args.gui else "rgb_array", + visualize_taxim=args.visualize_taxim, + enable_depth=not args.disable_taxim_depth, + start_grasped=not args.no_start_grasped, + grasp_settle_steps=args.grasp_settle_steps, + post_gravity_settle_steps=args.post_gravity_settle_steps, + ) + + zero_model = ZeroSB3Model(env.action_space) + env = StableBaselines3PolicyWrapper( + env, + zero_model, + deterministic=False, + flatten_actions=False, + flatten_observations=True, + ) + + obs, info = env.reset(seed=args.seed) + print(f"reset: obs_keys={list(obs.keys())}, info_keys={list(info.keys())}") + + for step_idx in range(args.steps): + obs, reward, terminated, truncated, info = env.step() + action = info.get(StableBaselines3PolicyWrapper.ACTION_INFO_KEY) + action_keys = list(action.keys()) if isinstance(action, dict) else type(action).__name__ + frame_keys = list(obs.get("frames", {}).keys()) if isinstance(obs, dict) else [] + print( + f"step={step_idx:03d} reward={reward:.3f} " + f"terminated={terminated} truncated={truncated} " + f"action_keys={action_keys} frame_keys={frame_keys}" + ) + if terminated or truncated: + obs, info = env.reset() + print(f"reset: obs_keys={list(obs.keys())}, info_keys={list(info.keys())}") + + env.close() + + +if __name__ == "__main__": + main() diff --git a/extensions/rcs_sb3/src/rcs_sb3/__init__.py b/extensions/rcs_sb3/src/rcs_sb3/__init__.py new file mode 100644 index 00000000..b3211d6b --- /dev/null +++ b/extensions/rcs_sb3/src/rcs_sb3/__init__.py @@ -0,0 +1,15 @@ +from rcs_sb3.interface import AlgorithmInterface +from rcs_sb3.ppo import SB3PPO, SB3PPOConfig +from rcs_sb3.sb3 import SB3AlgorithmConfig, StableBaselines3Algorithm +from rcs_sb3.wrappers import FlattenActionWrapper, StableBaselines3PolicyWrapper, StableBaselines3Wrapper + +__all__ = [ + "AlgorithmInterface", + "FlattenActionWrapper", + "SB3AlgorithmConfig", + "SB3PPO", + "SB3PPOConfig", + "StableBaselines3Wrapper", + "StableBaselines3PolicyWrapper", + "StableBaselines3Algorithm", +] diff --git a/extensions/rcs_sb3/src/rcs_sb3/interface.py b/extensions/rcs_sb3/src/rcs_sb3/interface.py new file mode 100644 index 00000000..d9f1b62d --- /dev/null +++ b/extensions/rcs_sb3/src/rcs_sb3/interface.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from pathlib import Path +from typing import Any + +import gymnasium as gym + + +class AlgorithmInterface(ABC): + """Framework-neutral interface for trainable RL algorithms.""" + + @abstractmethod + def as_wrapper(self, env: gym.Env) -> gym.Wrapper: + """Return an RCS wrapper that injects policy actions into the stack.""" + + @abstractmethod + def make_training_env(self, env: gym.Env) -> gym.Env: + """Return the environment prepared for training in the underlying RL framework.""" + + @abstractmethod + def build(self, env: gym.Env) -> Any: + """Create and store a model for the wrapped environment.""" + + @abstractmethod + def action(self, observation: Any, deterministic: bool | None = None) -> Any: + """Generate one environment action from an observation.""" + + @abstractmethod + def learn(self, total_timesteps: int | None = None, **kwargs: Any) -> Any: + """Train the model.""" + + @abstractmethod + def predict( + self, + observation: Any, + state: Any = None, + episode_start: Any = None, + deterministic: bool = False, + ) -> tuple[Any, Any]: + """Predict the next action from an observation.""" + + @abstractmethod + def save(self, path: str | Path) -> None: + """Save the current model.""" + + @classmethod + @abstractmethod + def load(cls, path: str | Path, env: gym.Env | None = None, **kwargs: Any) -> "AlgorithmInterface": + """Load a model into an algorithm implementation.""" diff --git a/extensions/rcs_sb3/src/rcs_sb3/ppo.py b/extensions/rcs_sb3/src/rcs_sb3/ppo.py new file mode 100644 index 00000000..4e605db9 --- /dev/null +++ b/extensions/rcs_sb3/src/rcs_sb3/ppo.py @@ -0,0 +1,19 @@ +from __future__ import annotations + +from dataclasses import dataclass + +from stable_baselines3 import PPO + +from rcs_sb3.sb3 import SB3AlgorithmConfig, StableBaselines3Algorithm + + +@dataclass +class SB3PPOConfig(SB3AlgorithmConfig): + """Configuration for Stable-Baselines3 PPO.""" + + +class SB3PPO(StableBaselines3Algorithm): + """PPO implementation behind the framework-neutral algorithm interface.""" + + algorithm_cls = PPO + config_cls = SB3PPOConfig diff --git a/extensions/rcs_sb3/src/rcs_sb3/sb3.py b/extensions/rcs_sb3/src/rcs_sb3/sb3.py new file mode 100644 index 00000000..d63eb47f --- /dev/null +++ b/extensions/rcs_sb3/src/rcs_sb3/sb3.py @@ -0,0 +1,121 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any, ClassVar, Type + +import gymnasium as gym +from stable_baselines3.common.base_class import BaseAlgorithm + +from rcs_sb3.interface import AlgorithmInterface +from rcs_sb3.wrappers import StableBaselines3PolicyWrapper, StableBaselines3Wrapper + + +@dataclass +class SB3AlgorithmConfig: + """Configuration shared by Stable-Baselines3 algorithms.""" + + policy: str = "MlpPolicy" + total_timesteps: int = 100_000 + flatten_actions: bool = True + flatten_observations: bool = True + deterministic_actions: bool = True + preserve_external_actions: bool = True + model_kwargs: dict[str, Any] = field(default_factory=dict) + learn_kwargs: dict[str, Any] = field(default_factory=dict) + + +class StableBaselines3Algorithm(AlgorithmInterface): + """Base class for Stable-Baselines3-backed algorithms.""" + + algorithm_cls: ClassVar[Type[BaseAlgorithm]] + config_cls: ClassVar[type[SB3AlgorithmConfig]] = SB3AlgorithmConfig + + def __init__(self, config: SB3AlgorithmConfig | None = None, model: BaseAlgorithm | None = None): + self.config = config if config is not None else self.config_cls() + self.model = model + self.env: gym.Env | None = None + + def as_wrapper(self, env: gym.Env) -> gym.Wrapper: + if self.model is None: + msg = "Call build(env) or load(path, env=env) before creating the RCS policy wrapper." + raise RuntimeError(msg) + return StableBaselines3PolicyWrapper( + env, + self.model, + deterministic=self.config.deterministic_actions, + flatten_actions=self.config.flatten_actions, + flatten_observations=self.config.flatten_observations, + preserve_external_actions=self.config.preserve_external_actions, + ) + + def make_training_env(self, env: gym.Env) -> gym.Env: + return StableBaselines3Wrapper( + env, + flatten_actions=self.config.flatten_actions, + flatten_observations=self.config.flatten_observations, + ) + + def wrap_env(self, env: gym.Env) -> gym.Env: + """Backward-compatible alias for ``make_training_env``.""" + return self.make_training_env(env) + + def build(self, env: gym.Env) -> BaseAlgorithm: + self.env = self.make_training_env(env) + self.model = self.algorithm_cls(self.config.policy, self.env, **self.config.model_kwargs) + return self.model + + def action(self, observation: Any, deterministic: bool | None = None) -> Any: + if self.model is None: + msg = "Call build(env) or load(path, env=env) before action()." + raise RuntimeError(msg) + action, _ = self.predict( + observation, + deterministic=self.config.deterministic_actions if deterministic is None else deterministic, + ) + return action + + def learn(self, total_timesteps: int | None = None, **kwargs: Any) -> BaseAlgorithm: + if self.model is None: + msg = "Call build(env) or load(path, env=env) before learn()." + raise RuntimeError(msg) + learn_kwargs = {**self.config.learn_kwargs, **kwargs} + return self.model.learn(total_timesteps=total_timesteps or self.config.total_timesteps, **learn_kwargs) + + def predict( + self, + observation: Any, + state: Any = None, + episode_start: Any = None, + deterministic: bool = False, + ) -> tuple[Any, Any]: + if self.model is None: + msg = "Call build(env) or load(path, env=env) before predict()." + raise RuntimeError(msg) + return self.model.predict( + observation, + state=state, + episode_start=episode_start, + deterministic=deterministic, + ) + + def save(self, path: str | Path) -> None: + if self.model is None: + msg = "Call build(env) or load(path, env=env) before save()." + raise RuntimeError(msg) + self.model.save(path) + + @classmethod + def load(cls, path: str | Path, env: gym.Env | None = None, **kwargs: Any) -> "StableBaselines3Algorithm": + config = kwargs.pop("config", None) or cls.config_cls() + wrapped_env = None + if env is not None: + wrapped_env = StableBaselines3Wrapper( + env, + flatten_actions=config.flatten_actions, + flatten_observations=config.flatten_observations, + ) + model = cls.algorithm_cls.load(path, env=wrapped_env, **kwargs) + instance = cls(config=config, model=model) + instance.env = wrapped_env + return instance diff --git a/extensions/rcs_sb3/src/rcs_sb3/wrappers.py b/extensions/rcs_sb3/src/rcs_sb3/wrappers.py new file mode 100644 index 00000000..20014097 --- /dev/null +++ b/extensions/rcs_sb3/src/rcs_sb3/wrappers.py @@ -0,0 +1,149 @@ +from __future__ import annotations + +import copy +from typing import Any + +import gymnasium as gym +import numpy as np +from gymnasium.spaces import Box, Dict as DictSpace +from gymnasium.spaces import utils as space_utils + + +class FlattenActionWrapper(gym.ActionWrapper): + """Expose a flat Box action space while forwarding unflattened actions to RCS.""" + + def __init__(self, env: gym.Env): + super().__init__(env) + if not isinstance(env.action_space, DictSpace): + msg = "FlattenActionWrapper expects a gymnasium.spaces.Dict action space." + raise TypeError(msg) + + flat_space = space_utils.flatten_space(env.action_space) + if not isinstance(flat_space, Box): + msg = "Stable-Baselines3 requires flattenable continuous RCS actions." + raise TypeError(msg) + self.action_space = Box( + low=np.asarray(flat_space.low, dtype=np.float32), + high=np.asarray(flat_space.high, dtype=np.float32), + dtype=np.float32, + ) + + def action(self, action: np.ndarray) -> dict[str, Any]: + return space_utils.unflatten(self.env.action_space, np.asarray(action, dtype=self.action_space.dtype)) + + +class StableBaselines3Wrapper(gym.Wrapper): + """Prepare an RCS environment for Stable-Baselines3 training. + + RCS environments commonly expose dict action spaces. Stable-Baselines3 + policies do not accept dict actions, so this wrapper flattens them into a + single continuous Box. Dict observations are flattened by default for + ``MlpPolicy``. Set ``flatten_observations=False`` for ``MultiInputPolicy``. + """ + + def __init__( + self, + env: gym.Env, + *, + flatten_actions: bool = True, + flatten_observations: bool = True, + ): + if flatten_actions and isinstance(env.action_space, DictSpace): + env = FlattenActionWrapper(env) + if flatten_observations and isinstance(env.observation_space, DictSpace): + env = gym.wrappers.FlattenObservation(env) + super().__init__(env) + + +class StableBaselines3PolicyWrapper(gym.Wrapper): + """RCS control wrapper that generates actions with a Stable-Baselines3 model. + + The wrapper keeps the last fully assembled observation returned by lower RCS + wrappers. On each ``step()``, it predicts a policy action from that stored + observation, merges the prediction into the incoming action dict, and passes + the result down toward the robot wrapper. + """ + + ACTION_INFO_KEY = "sb3_action" + + def __init__( + self, + env: gym.Env, + model: Any, + *, + deterministic: bool = True, + flatten_actions: bool = True, + flatten_observations: bool = True, + preserve_external_actions: bool = True, + action_info_key: str | None = ACTION_INFO_KEY, + ): + super().__init__(env) + self.model = model + self.deterministic = deterministic + self.flatten_actions = flatten_actions + self.flatten_observations = flatten_observations + self.preserve_external_actions = preserve_external_actions + self.action_info_key = action_info_key + self._last_observation: Any | None = None + self._policy_state: Any = None + self._episode_start = True + + def _model_observation(self, observation: Any) -> Any: + if self.flatten_observations and isinstance(self.env.observation_space, DictSpace): + return space_utils.flatten(self.env.observation_space, observation).astype(np.float32) + return observation + + def _env_action(self, action: Any) -> Any: + if self.flatten_actions and isinstance(self.env.action_space, DictSpace): + return space_utils.unflatten(self.env.action_space, np.asarray(action, dtype=np.float32)) + return action + + def policy_action(self, observation: Any | None = None, deterministic: bool | None = None) -> Any: + observation = self._last_observation if observation is None else observation + if observation is None: + msg = "Call reset() before requesting a policy action." + raise RuntimeError(msg) + action, self._policy_state = self.model.predict( + self._model_observation(observation), + state=self._policy_state, + episode_start=np.array([self._episode_start]), + deterministic=self.deterministic if deterministic is None else deterministic, + ) + self._episode_start = False + return self._env_action(action) + + def _merge_actions(self, external_action: Any, policy_action: Any) -> Any: + if not isinstance(policy_action, dict): + return policy_action + if external_action is None: + return policy_action + if not isinstance(external_action, dict): + msg = "External action must be a dict when the policy produces dict actions." + raise TypeError(msg) + merged_action = copy.deepcopy(policy_action) + if self.preserve_external_actions: + merged_action.update(external_action) + else: + merged_action = copy.deepcopy(external_action) + merged_action.update(policy_action) + return merged_action + + def step(self, action: dict[str, Any] | None = None): + generated_action = self.policy_action() + env_action = self._merge_actions(action, generated_action) + observation, reward, terminated, truncated, info = self.env.step(env_action) + self._last_observation = observation + self._episode_start = terminated or truncated + if self.action_info_key is not None: + info = dict(info) + info[self.action_info_key] = copy.deepcopy(generated_action) + return observation, reward, terminated, truncated, info + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[Any, dict[str, Any]]: + observation, info = self.env.reset(seed=seed, options=options) + self._last_observation = observation + self._policy_state = None + self._episode_start = True + return observation, info diff --git a/extensions/rcs_sb3/tests/test_wrappers.py b/extensions/rcs_sb3/tests/test_wrappers.py new file mode 100644 index 00000000..1208b4a0 --- /dev/null +++ b/extensions/rcs_sb3/tests/test_wrappers.py @@ -0,0 +1,69 @@ +import gymnasium as gym +import numpy as np + +from rcs_sb3 import SB3PPO, SB3PPOConfig, StableBaselines3PolicyWrapper, StableBaselines3Wrapper + + +class DummyRCSEnv(gym.Env): + def __init__(self): + self.action_space = gym.spaces.Dict( + { + "joints": gym.spaces.Box(low=-1.0, high=1.0, shape=(2,), dtype=np.float64), + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ) + self.observation_space = gym.spaces.Dict( + { + "joints": gym.spaces.Box(low=-10.0, high=10.0, shape=(2,), dtype=np.float64), + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ) + self.last_action = None + + def step(self, action): + self.last_action = action + return {"joints": np.zeros(2), "gripper": np.ones(1)}, 0.0, False, False, {} + + def reset(self, *, seed=None, options=None): + super().reset(seed=seed) + return {"joints": np.zeros(2), "gripper": np.ones(1)}, {} + + +class FakeSB3Model: + def predict(self, observation, state=None, episode_start=None, deterministic=False): + assert observation.shape == (3,) + return np.array([0.25, -0.25, 1.0], dtype=np.float32), state + + +def test_stable_baselines3_wrapper_flattens_dict_action_and_observation_spaces(): + env = DummyRCSEnv() + wrapped = StableBaselines3Wrapper(env) + + assert isinstance(wrapped.action_space, gym.spaces.Box) + assert isinstance(wrapped.observation_space, gym.spaces.Box) + + wrapped.step(np.array([0.5, -0.5, 1.0], dtype=np.float32)) + + assert set(env.last_action.keys()) == {"joints", "gripper"} + np.testing.assert_allclose(env.last_action["joints"], np.array([0.5, -0.5])) + np.testing.assert_allclose(env.last_action["gripper"], np.array([1.0])) + + +def test_policy_wrapper_generates_action_from_last_observation(): + env = DummyRCSEnv() + wrapped = StableBaselines3PolicyWrapper(env, FakeSB3Model()) + + wrapped.reset() + _, _, _, _, info = wrapped.step() + + np.testing.assert_allclose(env.last_action["joints"], np.array([0.25, -0.25])) + np.testing.assert_allclose(env.last_action["gripper"], np.array([1.0])) + np.testing.assert_allclose(info["sb3_action"]["joints"], np.array([0.25, -0.25])) + + +def test_ppo_build_uses_wrapped_env_without_training(): + env = DummyRCSEnv() + trainer = SB3PPO(SB3PPOConfig(model_kwargs={"n_steps": 2, "batch_size": 2})) + model = trainer.build(env) + + assert model.env is not None From 1f3a69d592ac98cb523d4b5dbb2c3ea33ab99bfa Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 10:11:51 +0200 Subject: [PATCH 06/87] wip: add readme instruction for starting sb3 --- extensions/rcs_sb3/README.md | 77 ++++++++++++++++++----------- extensions/rcs_sb3/run_test.py | 35 +++++++++++-- extensions/rcs_sb3/textures.json | 0 extensions/rcs_taxim/pyproject.toml | 2 +- pyproject.toml | 6 +-- 5 files changed, 84 insertions(+), 36 deletions(-) create mode 100644 extensions/rcs_sb3/textures.json diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md index 29131ef5..1aada9b1 100644 --- a/extensions/rcs_sb3/README.md +++ b/extensions/rcs_sb3/README.md @@ -1,34 +1,53 @@ # rcs_sb3 -Stable-Baselines3 integration for RCS Gymnasium environments. +Entry: `run_test.py` -The package keeps SB3-specific code behind a small algorithm interface so another -RL backend can be added later without changing the environment creation code. -```python -from rcs_sb3 import SB3PPO, SB3PPOConfig - -trainer = SB3PPO(SB3PPOConfig(total_timesteps=100_000)) -model = trainer.build(env) -trainer.learn() +Installation: ``` - -For runtime control, load or build the algorithm and insert it into the RCS -wrapper stack: - -```python -ppo = SB3PPO.load("ppo_rcs_model") -env = ppo.as_wrapper(env) - -obs, info = env.reset() -obs, reward, terminated, truncated, info = env.step() -``` - -`StableBaselines3PolicyWrapper` stores the latest observation returned by the -wrapped RCS stack. On each `step()`, it asks the SB3 model for an action, converts -that action back into the RCS action dict, and passes it down to the robot layer. - -By default, `SB3PPO.build()` prepares environments with `StableBaselines3Wrapper`, -which flattens RCS dict actions and optionally flattens dict observations for -`MlpPolicy`. Use `policy="MultiInputPolicy"` and `flatten_observations=False` -when you want SB3 to consume dictionary observations directly. +git clone git@github.com:RobotControlStack/robot-control-stack.git + +git checkout jin/sb3 + +# Install RCS +conda create -n rcs12 python=3.12 +conda activate rcs12 +conda install -c conda-forge urdfdom urdfdom_headers glfw + +# or sudo apt install $(cat debian_deps.txt) +pip install 'pip>=25.1' +pip install --group build_deps +sudo apt install liburdfdom-dev + +# install rcs +pip install -ve . + +## Install the dependencies for sb3 +# clone and install norm2tex main branch +git clone git@github.com:utn-air/norm2tex.git + +pip install -e . + +# clone and install mujoco-taxim norm2tex branch +git clone git@github.com:utn-air/mujoco-taxim.git + +git checkout norm2tex +pip install -e . + +# install rcs_taxim + +pip install -e extensions/rcs_taxim + +# finally install rcs-sb3 + +pip install -e extensions/rcs_sb3 + +# now try running the run_test.py +python run_test.py --gui --visualize-taxim --steps 1000 + +`` + +## To-do +- Add json file interpreter for feeding geom-texture png files into mujoco-taxim for easier management +- Make the textures for the cube +- Investigate parallelization \ No newline at end of file diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index 75fad715..80a85983 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -21,6 +21,7 @@ from rcs.envs.configs import EmptyWorldFR3 from rcs_sb3 import StableBaselines3PolicyWrapper from rcs_taxim.taxim_wrapper import TaximSimWrapper +from stable_baselines3 import PPO import rcs @@ -64,8 +65,13 @@ def _taxim_gripper_cfg() -> SimGripperConfig: ) -class ZeroSB3Model: - """Minimal SB3-compatible model for pipeline testing.""" +class ZeroSB3Model(PPO): + """PPO-shaped zero-action model for pipeline testing. + + This deliberately does not call ``PPO.__init__`` yet: the smoke test only + needs the runtime ``predict`` surface, while keeping this class as the local + starting point for a real PPO-backed implementation. + """ def __init__(self, action_space: gym.Space): self.action_space = action_space @@ -208,7 +214,7 @@ def main() -> None: parser.add_argument("--seed", type=int, default=0) parser.add_argument("--gui", action="store_true", help="Open the MuJoCo GUI.") parser.add_argument("--visualize-taxim", action="store_true", help="Show nonblocking Taxim tactile windows.") - parser.add_argument("--disable-taxim-depth", action="store_true", help="Do not include Taxim depth frames.") + parser.add_argument("--disable-taxim-depth", type=bool, default=True, help="Do not include Taxim depth frames.") parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") parser.add_argument("--grasp-settle-steps", type=int, default=30) parser.add_argument("--post-gravity-settle-steps", type=int, default=10) @@ -237,6 +243,29 @@ def main() -> None: for step_idx in range(args.steps): obs, reward, terminated, truncated, info = env.step() + # # Save some images to disk for visual inspection. + # if step_idx == 0: + # frames = obs.get("frames", {}) + # for site, tactile_obs in frames.items(): + # rgb = tactile_obs.get("rgb", {}).get("data") + # if rgb is not None: + # from PIL import Image + # rgb_path = Path(f"taxim_{site}_rgb.png") + # print(f"Saving {rgb_path}") + # Image.fromarray(rgb).save(rgb_path) + # depth = tactile_obs.get("depth", {}).get("data") + # # Normalize then repeat to 3 channels for saving as PNG. + # depth = depth.astype(np.float32) + # depth_min, depth_max = np.nanmin(depth), np.nanmax(depth) + + # if depth is not None: + # if depth_max > depth_min: + # gt_vis = np.repeat(depth[:, :, np.newaxis], 3, axis=2) + # div = 1 if np.max(gt_vis) == 0 else np.max(gt_vis) + # gt_vis = (gt_vis / div * 255).astype(np.uint8) + # depth_path = Path(f"taxim_{site}_depth.png") + # print(f"Saving {depth_path}") + # Image.fromarray(gt_vis).save(depth_path) action = info.get(StableBaselines3PolicyWrapper.ACTION_INFO_KEY) action_keys = list(action.keys()) if isinstance(action, dict) else type(action).__name__ frame_keys = list(obs.get("frames", {}).keys()) if isinstance(obs, dict) else [] diff --git a/extensions/rcs_sb3/textures.json b/extensions/rcs_sb3/textures.json new file mode 100644 index 00000000..e69de29b diff --git a/extensions/rcs_taxim/pyproject.toml b/extensions/rcs_taxim/pyproject.toml index 9019067b..cc6df942 100644 --- a/extensions/rcs_taxim/pyproject.toml +++ b/extensions/rcs_taxim/pyproject.toml @@ -9,7 +9,7 @@ description = "RCS integration of mujoco-taxim" dependencies = [ "rcs>=0.6.3", "omegaconf", - "mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@956b7d05e1f28d6d186eb1d386f4c13d7b014308", + #"mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@956b7d05e1f28d6d186eb1d386f4c13d7b014308", ] readme = "README.md" maintainers = [ diff --git a/pyproject.toml b/pyproject.toml index ca7d0c3d..f2355a90 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ requires = [ "pybind11", "cmake", "ninja", - "mujoco==3.2.6", + "mujoco>=3.3.5", "pin==3.7.0", ] build-backend = "scikit_build_core.build" @@ -37,7 +37,7 @@ dependencies = [ "rpyc~=6.0.2", "pyarrow", "simplejpeg", - "mujoco==3.2.6", + "mujoco>=3.3.5", "pin==3.7.0", "greenlet", "duckdb", @@ -72,7 +72,7 @@ dev = [ "cmake", ] build_deps = [ - "mujoco==3.2.6", + "mujoco>=3.3.5", "pin==3.7.0", ] From 855c223e7fd5f5c3f3beae00ace2acb518711e88 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 10:16:43 +0200 Subject: [PATCH 07/87] fix: don't flatten obs by default --- extensions/rcs_sb3/run_test.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index 80a85983..5e66ed89 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -83,6 +83,7 @@ def predict( episode_start: np.ndarray | None = None, deterministic: bool = False, ) -> tuple[dict[str, np.ndarray], Any]: + breakpoint() del observation, episode_start, deterministic return _zero_closed_action(self.action_space), state @@ -235,7 +236,7 @@ def main() -> None: zero_model, deterministic=False, flatten_actions=False, - flatten_observations=True, + flatten_observations=False, ) obs, info = env.reset(seed=args.seed) From 240405c1cd839b8720399a75c699f72303d49426 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 12:00:38 +0200 Subject: [PATCH 08/87] feat: add proper spaces for training and inference with parallelization option --- extensions/rcs_sb3/README.md | 9 +- extensions/rcs_sb3/run_test.py | 218 +++++++++++++++------ extensions/rcs_sb3/src/rcs_sb3/wrappers.py | 85 ++++++++ 3 files changed, 245 insertions(+), 67 deletions(-) diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md index 1aada9b1..83c5c605 100644 --- a/extensions/rcs_sb3/README.md +++ b/extensions/rcs_sb3/README.md @@ -1,6 +1,9 @@ # rcs_sb3 -Entry: `run_test.py` +- Entry: `run_test.py`\ +- training: `run_test.py --mode train --num-envs --total-timesteps --n-steps --batch-size ` + - setting `--num-envs 0` runs it on the main thread for breakpointing +- inference: `run_test.py --mode infer --infer-steps 100` Installation: @@ -50,4 +53,6 @@ python run_test.py --gui --visualize-taxim --steps 1000 ## To-do - Add json file interpreter for feeding geom-texture png files into mujoco-taxim for easier management - Make the textures for the cube -- Investigate parallelization \ No newline at end of file +- Investigate parallelization (Done) +- Add wrapper for truncation condition +- Add wrapper for reward calculation \ No newline at end of file diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index 5e66ed89..e783429a 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -1,7 +1,6 @@ """Smoke-test the RCS SB3 policy wrapper on a simulated FR3 + Taxim stack. -This does not train PPO. It uses a tiny SB3-like zero model with a ``predict`` -method to verify the runtime pipeline: +This uses a tiny PPO model to verify the runtime pipeline: RCS + Taxim observations -> policy wrapper -> generated action dict -> robot wrappers """ @@ -15,22 +14,29 @@ import gymnasium as gym import mujoco import numpy as np +from gymnasium.spaces import Dict as DictSpace from rcs._core.common import GripperType, Pose from rcs._core.sim import SimGripperConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3 -from rcs_sb3 import StableBaselines3PolicyWrapper +from rcs_sb3 import StableBaselines3PolicyWrapper, StableBaselines3Wrapper from rcs_taxim.taxim_wrapper import TaximSimWrapper from stable_baselines3 import PPO +from stable_baselines3.common.vec_env import SubprocVecEnv + import rcs -_TAXIM_GRIPPER_TYPE = GripperType("Robotiq2F85Digit") +_TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" _TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") _ROBOT_NAME = "robot" _CUBE_GEOM = "_box_geom" +def _taxim_gripper_type() -> GripperType: + return GripperType(_TAXIM_GRIPPER_TYPE_ID) + + def _zero_closed_action(space: gym.Space) -> dict[str, Any]: action = space.sample() @@ -61,31 +67,26 @@ def _taxim_gripper_cfg() -> SimGripperConfig: actuator="fingers_actuator", max_actuator_width=0, min_actuator_width=255, - gripper_type=_TAXIM_GRIPPER_TYPE, + gripper_type=_taxim_gripper_type(), ) -class ZeroSB3Model(PPO): - """PPO-shaped zero-action model for pipeline testing. +class DummySB3Model(PPO): + """PPO subclass used as the starting point for real SB3 training logic.""" - This deliberately does not call ``PPO.__init__`` yet: the smoke test only - needs the runtime ``predict`` surface, while keeping this class as the local - starting point for a real PPO-backed implementation. - """ + def __init__(self, *args: Any, **kwargs: Any): + super().__init__(*args, **kwargs) - def __init__(self, action_space: gym.Space): - self.action_space = action_space - def predict( - self, - observation: Any, - state: Any = None, - episode_start: np.ndarray | None = None, - deterministic: bool = False, - ) -> tuple[dict[str, np.ndarray], Any]: - breakpoint() - del observation, episode_start, deterministic - return _zero_closed_action(self.action_space), state +def make_zero_sb3_model(env: gym.Env, args: argparse.Namespace) -> DummySB3Model: + return DummySB3Model( + "MultiInputPolicy", + env, + n_steps=args.n_steps, + batch_size=args.batch_size, + seed=args.seed, + verbose=1, + ) class StartGraspedWrapper(gym.Wrapper): @@ -159,7 +160,7 @@ def make_franka_taxim_sim_env( grasp_settle_steps: int, post_gravity_settle_steps: int, ) -> gym.Env: - rcs.GRIPPER_PATHS[_TAXIM_GRIPPER_TYPE] = str(_TAXIM_GRIPPER_XML) + rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) scene = EmptyWorldFR3() cfg = scene.config() @@ -209,29 +210,22 @@ def make_franka_taxim_sim_env( return env -def main() -> None: - parser = argparse.ArgumentParser(description="Run a zero-policy SB3 wrapper smoke test in FR3 + Taxim simulation.") - parser.add_argument("--steps", type=int, default=20) - parser.add_argument("--seed", type=int, default=0) - parser.add_argument("--gui", action="store_true", help="Open the MuJoCo GUI.") - parser.add_argument("--visualize-taxim", action="store_true", help="Show nonblocking Taxim tactile windows.") - parser.add_argument("--disable-taxim-depth", type=bool, default=True, help="Do not include Taxim depth frames.") - parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") - parser.add_argument("--grasp-settle-steps", type=int, default=30) - parser.add_argument("--post-gravity-settle-steps", type=int, default=10) - args = parser.parse_args() - - env = make_franka_taxim_sim_env( +def make_inference_env(args: argparse.Namespace) -> gym.Env: + raw_env = make_franka_taxim_sim_env( render_mode="human" if args.gui else "rgb_array", visualize_taxim=args.visualize_taxim, - enable_depth=not args.disable_taxim_depth, + enable_depth=args.enable_taxim_depth, start_grasped=not args.no_start_grasped, grasp_settle_steps=args.grasp_settle_steps, post_gravity_settle_steps=args.post_gravity_settle_steps, ) - - zero_model = ZeroSB3Model(env.action_space) - env = StableBaselines3PolicyWrapper( + env = StableBaselines3Wrapper( + raw_env, + flatten_actions=False, + flatten_observations=False, + ) + zero_model = make_zero_sb3_model(env, args) + return StableBaselines3PolicyWrapper( env, zero_model, deterministic=False, @@ -239,34 +233,14 @@ def main() -> None: flatten_observations=False, ) + +def run_inference_smoke(args: argparse.Namespace) -> None: + env = make_inference_env(args) obs, info = env.reset(seed=args.seed) print(f"reset: obs_keys={list(obs.keys())}, info_keys={list(info.keys())}") - for step_idx in range(args.steps): + for step_idx in range(args.infer_steps): obs, reward, terminated, truncated, info = env.step() - # # Save some images to disk for visual inspection. - # if step_idx == 0: - # frames = obs.get("frames", {}) - # for site, tactile_obs in frames.items(): - # rgb = tactile_obs.get("rgb", {}).get("data") - # if rgb is not None: - # from PIL import Image - # rgb_path = Path(f"taxim_{site}_rgb.png") - # print(f"Saving {rgb_path}") - # Image.fromarray(rgb).save(rgb_path) - # depth = tactile_obs.get("depth", {}).get("data") - # # Normalize then repeat to 3 channels for saving as PNG. - # depth = depth.astype(np.float32) - # depth_min, depth_max = np.nanmin(depth), np.nanmax(depth) - - # if depth is not None: - # if depth_max > depth_min: - # gt_vis = np.repeat(depth[:, :, np.newaxis], 3, axis=2) - # div = 1 if np.max(gt_vis) == 0 else np.max(gt_vis) - # gt_vis = (gt_vis / div * 255).astype(np.uint8) - # depth_path = Path(f"taxim_{site}_depth.png") - # print(f"Saving {depth_path}") - # Image.fromarray(gt_vis).save(depth_path) action = info.get(StableBaselines3PolicyWrapper.ACTION_INFO_KEY) action_keys = list(action.keys()) if isinstance(action, dict) else type(action).__name__ frame_keys = list(obs.get("frames", {}).keys()) if isinstance(obs, dict) else [] @@ -282,5 +256,119 @@ def main() -> None: env.close() +def make_train_env( + rank: int, + seed: int, + start_grasped: bool, + grasp_settle_steps: int, + post_gravity_settle_steps: int, +): + def _init(): + env = make_franka_taxim_sim_env( + render_mode="rgb_array", + visualize_taxim=False, + enable_depth=False, + start_grasped=start_grasped, + grasp_settle_steps=grasp_settle_steps, + post_gravity_settle_steps=post_gravity_settle_steps, + ) + env.reset(seed=seed + rank) + return env + + return _init + + +def make_sb3_train_env( + rank: int, + seed: int, + start_grasped: bool, + grasp_settle_steps: int, + post_gravity_settle_steps: int, +): + raw_env_fn = make_train_env( + rank, + seed, + start_grasped, + grasp_settle_steps, + post_gravity_settle_steps, + ) + + def _init(): + return StableBaselines3Wrapper( + raw_env_fn(), + flatten_actions=False, + flatten_observations=False, + ) + + return _init + + +def run_training_smoke(args: argparse.Namespace) -> None: + if args.num_envs < 0: + msg = "--num-envs must be >= 0. Use 0 for single-process breakpoint debugging." + raise ValueError(msg) + + if args.num_envs == 0: + train_env = make_sb3_train_env( + 0, + args.seed, + not args.no_start_grasped, + args.grasp_settle_steps, + args.post_gravity_settle_steps, + )() + else: + train_env = SubprocVecEnv( + [ + make_sb3_train_env( + rank, + args.seed, + not args.no_start_grasped, + args.grasp_settle_steps, + args.post_gravity_settle_steps, + ) + for rank in range(args.num_envs) + ], + start_method="spawn", + ) + try: + if isinstance(train_env.action_space, DictSpace): + msg = ( + "Raw RCS envs expose Dict action spaces, but SB3 PPO does not support Dict actions. " + "Expected make_sb3_train_env to adapt actions before constructing PPO." + ) + raise TypeError(msg) + model = make_zero_sb3_model(train_env, args) + model.learn(total_timesteps=args.total_timesteps) + finally: + train_env.close() + + +def main() -> None: + parser = argparse.ArgumentParser(description="Smoke-test RCS + Taxim with SB3.") + parser.add_argument("--mode", choices=("infer", "train"), default="infer") + parser.add_argument("--seed", type=int, default=0) + parser.add_argument("--enable-taxim-depth", action="store_true") + parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") + parser.add_argument("--grasp-settle-steps", type=int, default=30) + parser.add_argument("--post-gravity-settle-steps", type=int, default=10) + + # Inference mode args + parser.add_argument("--infer-steps", type=int, default=20, help="Inference smoke-test steps.") + parser.add_argument("--gui", action="store_true", help="Open the MuJoCo GUI for inference mode.") + parser.add_argument("--visualize-taxim", action="store_true", help="Show nonblocking Taxim tactile windows.") + + # Training mode args + parser.add_argument("--num-envs", type=int, default=2, help="Parallel env count for train mode. Use 0 to disable subprocess vectorization for debugging.",) + parser.add_argument("--total-timesteps", type=int, default=32) + parser.add_argument("--n-steps", type=int, default=8) + parser.add_argument("--batch-size", type=int, default=16) + args = parser.parse_args() + + if args.mode == "infer": + run_inference_smoke(args) + else: + run_training_smoke(args) + + if __name__ == "__main__": main() diff --git a/extensions/rcs_sb3/src/rcs_sb3/wrappers.py b/extensions/rcs_sb3/src/rcs_sb3/wrappers.py index 20014097..5a6082aa 100644 --- a/extensions/rcs_sb3/src/rcs_sb3/wrappers.py +++ b/extensions/rcs_sb3/src/rcs_sb3/wrappers.py @@ -31,6 +31,87 @@ def __init__(self, env: gym.Env): def action(self, action: np.ndarray) -> dict[str, Any]: return space_utils.unflatten(self.env.action_space, np.asarray(action, dtype=self.action_space.dtype)) +class TaximSB3ObservationWrapper(gym.ObservationWrapper): + def __init__( + self, + env: gym.Env, + *, + left_frame_key: str = "tactile_gripperleft_digit_pad", + right_frame_key: str = "tactile_gripperright_digit_pad", + ): + super().__init__(env) + self.left_frame_key = left_frame_key + self.right_frame_key = right_frame_key + + left_space = env.observation_space["frames"][left_frame_key]["rgb"]["data"] + h, w, c = left_space.shape + + gripper_space = env.observation_space["robot"]["gripper"] + + state_space = copy.deepcopy(env.observation_space) + del state_space.spaces["frames"] + + self._state_space = state_space + flat_state_space = space_utils.flatten_space(state_space) + + self.observation_space = gym.spaces.Dict( + { + "left_rgb": gym.spaces.Box(0, 255, shape=(c, h, w), dtype=np.uint8), + "right_rgb": gym.spaces.Box(0, 255, shape=(c, h, w), dtype=np.uint8), + "state": gripper_space + } + ) + + def observation(self, obs): + left_rgb = obs["frames"][self.left_frame_key]["rgb"]["data"] + right_rgb = obs["frames"][self.right_frame_key]["rgb"]["data"] + gripper_state = obs['robot']['gripper'] + state_obs = copy.deepcopy(obs) + del state_obs["frames"] + + return { + "left_rgb": np.transpose(left_rgb, (2, 0, 1)), + "right_rgb": np.transpose(right_rgb, (2, 0, 1)), + "state": gripper_state, + } + +class GripperOnlyActionWrapper(gym.ActionWrapper): + def __init__( + self, + env: gym.Env, + *, + robot_key: str = "robot", + gripper_key: str = "gripper", + joints_key: str = "joints", + ): + super().__init__(env) + self.robot_key = robot_key + self.gripper_key = gripper_key + self.joints_key = joints_key + + robot_action_space = env.action_space[robot_key] + self._robot_action_space = robot_action_space + + gripper_space = robot_action_space[gripper_key] + self.action_space = gym.spaces.Box( + low=np.asarray(gripper_space.low, dtype=np.float32), + high=np.asarray(gripper_space.high, dtype=np.float32), + shape=gripper_space.shape, + dtype=np.float32, + ) + + def action(self, action: np.ndarray) -> dict[str, Any]: + robot_action = self._robot_action_space.sample() + + for key, space in self._robot_action_space.spaces.items(): + if isinstance(space, gym.spaces.Box): + robot_action[key] = np.zeros(space.shape, dtype=space.dtype) + + robot_action[self.gripper_key] = np.asarray(action, dtype=np.float32) + + return { + self.robot_key: robot_action, + } class StableBaselines3Wrapper(gym.Wrapper): """Prepare an RCS environment for Stable-Baselines3 training. @@ -50,8 +131,12 @@ def __init__( ): if flatten_actions and isinstance(env.action_space, DictSpace): env = FlattenActionWrapper(env) + elif not flatten_actions and isinstance(env.action_space, DictSpace): + env = GripperOnlyActionWrapper(env) if flatten_observations and isinstance(env.observation_space, DictSpace): env = gym.wrappers.FlattenObservation(env) + elif not flatten_observations and isinstance(env.observation_space, DictSpace): + env = TaximSB3ObservationWrapper(env) super().__init__(env) From a76910484b36cd89c6be855dec89973e7fb84aac Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 13:14:15 +0200 Subject: [PATCH 09/87] feat: add mesh-based box --- extensions/rcs_sb3/README.md | 2 +- extensions/rcs_sb3/run_test.py | 7 +++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md index 83c5c605..77dfa42b 100644 --- a/extensions/rcs_sb3/README.md +++ b/extensions/rcs_sb3/README.md @@ -4,7 +4,7 @@ - training: `run_test.py --mode train --num-envs --total-timesteps --n-steps --batch-size ` - setting `--num-envs 0` runs it on the main thread for breakpointing - inference: `run_test.py --mode infer --infer-steps 100` - +- Change the paths of the variables `_BOX_XML` and `_TAXIM_GRIPPER_XML` accordingly Installation: ``` diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index e783429a..1a19dd89 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -29,8 +29,10 @@ _TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" _TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") +_BOX_XML = "/home/sbien/Documents/Development/V2T/norm2tex/grasp_assets/box/box.xml" _ROBOT_NAME = "robot" _CUBE_GEOM = "_box_geom" +_CUBE_MESH = "_box_mesh" def _taxim_gripper_type() -> GripperType: @@ -177,7 +179,8 @@ def make_franka_taxim_sim_env( cfg.gripper_offsets = None cfg.root_frame_objects = { "": ( - rcs.OBJECT_PATHS["green_cube"], + # rcs.OBJECT_PATHS["green_cube"], + _BOX_XML, Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), ) } @@ -193,7 +196,7 @@ def make_franka_taxim_sim_env( env, taxim_sites=["gripperleft_digit_pad", "gripperright_digit_pad"], taxim_pad_geoms=["gripperleft_digit_pad", "gripperright_digit_pad"], - target_geom_mesh_dict={_CUBE_GEOM: _CUBE_GEOM}, + target_geom_mesh_dict={_CUBE_GEOM: _CUBE_MESH}, taxim_sensor_type="digit", taxim_fps=60, enable_depth=enable_depth, From cbccdf16d4f3f5e219fe15a107199ede5f053263 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 18:38:36 +0200 Subject: [PATCH 10/87] feat: add norm2tex material piping --- extensions/rcs_sb3/README.md | 8 ++- extensions/rcs_sb3/fabric_textures.json | 11 ++++ extensions/rcs_sb3/run_test.py | 60 ++++++++++++++++++- extensions/rcs_sb3/textures.json | 0 .../rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 7 ++- 5 files changed, 80 insertions(+), 6 deletions(-) create mode 100644 extensions/rcs_sb3/fabric_textures.json delete mode 100644 extensions/rcs_sb3/textures.json diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md index 77dfa42b..3e2b71b6 100644 --- a/extensions/rcs_sb3/README.md +++ b/extensions/rcs_sb3/README.md @@ -4,7 +4,8 @@ - training: `run_test.py --mode train --num-envs --total-timesteps --n-steps --batch-size ` - setting `--num-envs 0` runs it on the main thread for breakpointing - inference: `run_test.py --mode infer --infer-steps 100` -- Change the paths of the variables `_BOX_XML` and `_TAXIM_GRIPPER_XML` accordingly +- Change the paths of the variables `_BOX_XML`, `_TAXIM_GRIPPER_XML` and `_NORM2TEX_DIR` accordingly +- To enable textures, you need to pass the flag `--with-textures` with the generated files (`_uv,_normal,_color`) in `norm2tex/grasp_assets/box/assets`; without the flag, it should just run the "smooth" version. Installation: ``` @@ -51,8 +52,9 @@ python run_test.py --gui --visualize-taxim --steps 1000 `` ## To-do -- Add json file interpreter for feeding geom-texture png files into mujoco-taxim for easier management -- Make the textures for the cube +- Add json file interpreter for feeding geom-texture png files into mujoco-taxim for easier management (Done) +- Make the textures for the cube (Done, for now) +- Enable norm2tex (Done) - Investigate parallelization (Done) - Add wrapper for truncation condition - Add wrapper for reward calculation \ No newline at end of file diff --git a/extensions/rcs_sb3/fabric_textures.json b/extensions/rcs_sb3/fabric_textures.json new file mode 100644 index 00000000..55510ad4 --- /dev/null +++ b/extensions/rcs_sb3/fabric_textures.json @@ -0,0 +1,11 @@ +[ + { + "path": "grasp_assets/box/assets/box_Fabric__h4hxz9d_uv.obj" + }, + { + "path": "grasp_assets/box/assets/box_Fabric_b679sa95_uv.obj" + }, + { + "path": "grasp_assets/box/assets/box_Fabric_qol_921__uv.obj" + } +] \ No newline at end of file diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index 1a19dd89..d4d7524a 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -23,13 +23,14 @@ from rcs_taxim.taxim_wrapper import TaximSimWrapper from stable_baselines3 import PPO from stable_baselines3.common.vec_env import SubprocVecEnv - +import os import rcs _TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" _TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") _BOX_XML = "/home/sbien/Documents/Development/V2T/norm2tex/grasp_assets/box/box.xml" +_NORM2TEX_DIR = Path("/home/sbien/Documents/Development/V2T/norm2tex") _ROBOT_NAME = "robot" _CUBE_GEOM = "_box_geom" _CUBE_MESH = "_box_mesh" @@ -152,6 +153,40 @@ def reset( sim.sync_gui() return obs, info +def _make_obj_xml_from_mesh_path(mesh_path: Path) -> str: + material_type = mesh_path.name.split('/')[-1].split('_')[1].lower() + # TODO: Depending on material type, different friction and mass + + mesh_name = mesh_path.name.split('/')[-1] + xml_path = mesh_path.parent.parent / f"{mesh_name.split('.')[0]}.xml" + source_xml_path = mesh_path.parent.parent / "box.xml" + + # Open xml, replace box.obj with mesh name, and write to new xml path + with open(source_xml_path, 'r') as f: + xml_content = f.read() + xml_content = xml_content.replace("box.obj", mesh_name) + if xml_path.exists(): + os.remove(xml_path) + with open(xml_path, 'w') as f: + f.write(xml_content) + return str(xml_path) + +def _get_normal_map_path_from_mesh_path(mesh_path: Path) -> Path: + # assert that the normal map exists + normal_name = mesh_path.stem.split('.')[0][:-3] + "_normal.png" + normal_path = mesh_path.parent / normal_name + assert normal_path.exists(), f"Normal map {normal_path} does not exist." + print(f"Normal map {normal_path} exists. Preparing Taxim texture...") + return normal_path + +def _select_random_texture(): + # Randomly select a box material from the json files + json_dir = Path(__file__).parent + json_files = ["fabric_textures.json",] + with open(json_dir / np.random.choice(json_files), 'r') as f: + import json + texture_dict = json.load(f) + return Path(os.path.join(_NORM2TEX_DIR, np.random.choice(texture_dict)['path'])) def make_franka_taxim_sim_env( *, @@ -161,6 +196,7 @@ def make_franka_taxim_sim_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + uv_obj_path: Path | None = None, ) -> gym.Env: rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) @@ -177,10 +213,20 @@ def make_franka_taxim_sim_env( cfg.relative_to = RelativeTo.LAST_STEP cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} cfg.gripper_offsets = None + + + # Prepare the box XML and normal map as input if argument is given + box_xml_path = _BOX_XML + target_normal_map_dict = None + if uv_obj_path is not None: + box_xml_path = _make_obj_xml_from_mesh_path(uv_obj_path) + box_normal_map_path = _get_normal_map_path_from_mesh_path(uv_obj_path) + target_normal_map_dict = {_CUBE_GEOM: str(box_normal_map_path)} + cfg.root_frame_objects = { "": ( # rcs.OBJECT_PATHS["green_cube"], - _BOX_XML, + box_xml_path, Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), ) } @@ -197,6 +243,7 @@ def make_franka_taxim_sim_env( taxim_sites=["gripperleft_digit_pad", "gripperright_digit_pad"], taxim_pad_geoms=["gripperleft_digit_pad", "gripperright_digit_pad"], target_geom_mesh_dict={_CUBE_GEOM: _CUBE_MESH}, + target_geom_normal_map_dict=target_normal_map_dict, taxim_sensor_type="digit", taxim_fps=60, enable_depth=enable_depth, @@ -214,6 +261,7 @@ def make_franka_taxim_sim_env( def make_inference_env(args: argparse.Namespace) -> gym.Env: + raw_env = make_franka_taxim_sim_env( render_mode="human" if args.gui else "rgb_array", visualize_taxim=args.visualize_taxim, @@ -221,6 +269,7 @@ def make_inference_env(args: argparse.Namespace) -> gym.Env: start_grasped=not args.no_start_grasped, grasp_settle_steps=args.grasp_settle_steps, post_gravity_settle_steps=args.post_gravity_settle_steps, + uv_obj_path=_select_random_texture() if args.with_texture else None, ) env = StableBaselines3Wrapper( raw_env, @@ -265,6 +314,7 @@ def make_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + with_texture: bool = False ): def _init(): env = make_franka_taxim_sim_env( @@ -274,6 +324,7 @@ def _init(): start_grasped=start_grasped, grasp_settle_steps=grasp_settle_steps, post_gravity_settle_steps=post_gravity_settle_steps, + uv_obj_path=_select_random_texture() if with_texture else None ) env.reset(seed=seed + rank) return env @@ -287,6 +338,7 @@ def make_sb3_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + with_texture: bool = False ): raw_env_fn = make_train_env( rank, @@ -294,6 +346,7 @@ def make_sb3_train_env( start_grasped, grasp_settle_steps, post_gravity_settle_steps, + with_texture=with_texture ) def _init(): @@ -318,6 +371,7 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, + with_texture=args.with_texture )() else: train_env = SubprocVecEnv( @@ -328,6 +382,7 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, + with_texture=args.with_texture ) for rank in range(args.num_envs) ], @@ -354,6 +409,7 @@ def main() -> None: parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") parser.add_argument("--grasp-settle-steps", type=int, default=30) parser.add_argument("--post-gravity-settle-steps", type=int, default=10) + parser.add_argument("--with-texture", action="store_true", help="Use a random texture for the box object.") # Inference mode args parser.add_argument("--infer-steps", type=int, default=20, help="Inference smoke-test steps.") diff --git a/extensions/rcs_sb3/textures.json b/extensions/rcs_sb3/textures.json deleted file mode 100644 index e69de29b..00000000 diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index 6b264f0a..2ca3851e 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -14,6 +14,7 @@ def __init__( taxim_sites: list[str], taxim_pad_geoms: list[str], target_geom_mesh_dict: dict[str, str], + target_geom_normal_map_dict: dict[str, str] | None = None, taxim_sensor_type: str = "digit", taxim_bg_idx: int = 0, taxim_bg_randomize: bool = False, @@ -30,6 +31,7 @@ def __init__( self.taxim_sites = taxim_sites self.taxim_pad_geoms = taxim_pad_geoms self.target_geom_mesh_dict = target_geom_mesh_dict + self.target_geom_normal_map_dict = target_geom_normal_map_dict self.taxim_sensor_type = taxim_sensor_type self.taxim_bg_idx = taxim_bg_idx self.taxim_bg_randomize = taxim_bg_randomize @@ -79,7 +81,10 @@ def _ensure_initialized(self) -> None: sensor.add_camera_mujoco(site, self.model, self.data) sensor.change_bg(self.taxim_bg_idx) for geom, mesh in self.target_geom_mesh_dict.items(): - sensor.add_geom_mujoco(geom, self.model, self.data, mesh) + normal_map_path = None + if self.target_geom_normal_map_dict is not None and geom in self.target_geom_normal_map_dict: + normal_map_path = self.target_geom_normal_map_dict[geom] + sensor.add_geom_mujoco(geom, self.model, self.data, mesh, normal_map_path=normal_map_path) sensor.set_sensor_pad_geom(pad_geom) self.taxim_sensors.append(sensor) self.initialized = True From e6a0b3e7eb0685f35a46cf553b4a945bbdc251db Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 19:08:03 +0200 Subject: [PATCH 11/87] WIP: run_ablate for physics check --- extensions/rcs_sb3/run_ablate.py | 452 +++++++++++++++++++++++++++++++ 1 file changed, 452 insertions(+) create mode 100644 extensions/rcs_sb3/run_ablate.py diff --git a/extensions/rcs_sb3/run_ablate.py b/extensions/rcs_sb3/run_ablate.py new file mode 100644 index 00000000..c00f866b --- /dev/null +++ b/extensions/rcs_sb3/run_ablate.py @@ -0,0 +1,452 @@ +"""Grid-search box physics parameters and record grasp slippage. + +The environment setup mirrors ``run_test.py`` but swaps in generated box XML +files with different MuJoCo friction/density values. Each rollout starts with +``StartGraspedWrapper`` so the box is already held, then commands a fixed +gripper width while recording the box z-position over time. Taxim rendering is +intentionally skipped because it does not affect these physics measurements. +""" + +from __future__ import annotations + +import argparse +import csv +import itertools +from pathlib import Path +from typing import Any + +import gymnasium as gym +import mujoco +import numpy as np +import rcs +from rcs._core.common import GripperType, Pose +from rcs._core.sim import SimGripperConfig +from rcs.envs.base import ControlMode, RelativeTo +from rcs.envs.configs import EmptyWorldFR3 + +_TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" +_TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") +_BOX_XML = "/home/sbien/Documents/Development/V2T/norm2tex/grasp_assets/box/box.xml" +_ROBOT_NAME = "robot" +_SOURCE_FRICTION = 'friction="1 0.3 0.1"' +_SOURCE_DENSITY = 'density="50"' +_BOX_BODY_NAMES = ("_box_body", "box_body") +_BOX_JOINT_NAMES = ("_box_joint", "box_joint") +_CONTROL_FREQUENCY_HZ = 30.0 + + +def _taxim_gripper_type() -> GripperType: + return GripperType(_TAXIM_GRIPPER_TYPE_ID) + + +def _zero_closed_action(space: gym.Space) -> dict[str, Any]: + return _make_gripper_width_action(space, 0.0) + + +def _taxim_gripper_cfg() -> SimGripperConfig: + return SimGripperConfig( + epsilon_inner=0.005, + epsilon_outer=0.005, + seconds_between_callbacks=0.1, + ignored_collision_geoms=[], + collision_geoms=[], + collision_geoms_fingers=[], + joints=["right_driver_joint", "left_driver_joint"], + max_joint_width=0.005, + min_joint_width=1.0, + actuator="fingers_actuator", + max_actuator_width=0, + min_actuator_width=255, + gripper_type=_taxim_gripper_type(), + ) + + +def _float_list(value: str) -> list[float]: + return [float(item.strip()) for item in value.split(",") if item.strip()] + + +def _format_float(value: float) -> str: + return f"{value:.6g}" + + +def _format_filename_float(value: float) -> str: + return _format_float(value).replace("-", "m").replace(".", "p") + + +def _format_friction(friction: tuple[float, float, float]) -> str: + return " ".join(_format_float(value) for value in friction) + + +def _make_gripper_width_action(space: gym.Space, width: float) -> dict[str, Any]: + action = space.sample() + + def visit(value: Any) -> None: + if isinstance(value, dict): + for key, child in value.items(): + if key == "gripper": + value[key] = np.array([width], dtype=np.float32) + continue + visit(child) + elif isinstance(value, np.ndarray): + value[...] = 0 + + visit(action) + return action + + +def _extract_gripper_width(action: Any) -> float | None: + if isinstance(action, dict): + if "gripper" in action: + return float(np.asarray(action["gripper"]).reshape(-1)[0]) + for value in action.values(): + width = _extract_gripper_width(value) + if width is not None: + return width + return None + + +def _write_box_xml( + *, + source_xml: Path, + friction: tuple[float, float, float], + density: float, +) -> Path: + xml_content = source_xml.read_text() + if _SOURCE_FRICTION not in xml_content: + msg = f"Expected {_SOURCE_FRICTION!r} in {source_xml}." + raise ValueError(msg) + if _SOURCE_DENSITY not in xml_content: + msg = f"Expected {_SOURCE_DENSITY!r} in {source_xml}." + raise ValueError(msg) + + xml_content = xml_content.replace(_SOURCE_FRICTION, f'friction="{_format_friction(friction)}"') + xml_content = xml_content.replace(_SOURCE_DENSITY, f'density="{_format_float(density)}"') + + stem_values = [*friction, density] + stem = "_".join(_format_filename_float(value) for value in stem_values) + xml_path = source_xml.parent / f"box_{stem}.xml" + xml_path.write_text(xml_content) + return xml_path + + +class BoxZRecorderWrapper(gym.Wrapper): + """Append one CSV row per reset/step with the box z-position.""" + + FIELDNAMES = ( + "run_id", + "phase", + "step", + "time_s", + "seed", + "friction_slide", + "friction_spin", + "friction_roll", + "density", + "commanded_gripper_width", + "box_z", + "z_drop_from_reset", + "slipped", + "terminated", + "truncated", + "reward", + ) + + def __init__( + self, + env: gym.Env, + *, + csv_path: Path, + metadata: dict[str, Any], + slip_threshold: float, + ): + super().__init__(env) + self.csv_path = csv_path + self.metadata = metadata + self.slip_threshold = slip_threshold + self.step_idx = 0 + self.reset_z: float | None = None + + self.csv_path.parent.mkdir(parents=True, exist_ok=True) + self._needs_header = not self.csv_path.exists() or self.csv_path.stat().st_size == 0 + + def _box_z(self) -> float: + sim = self.env.get_wrapper_attr("sim") + for joint_name in _BOX_JOINT_NAMES: + joint_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_JOINT, joint_name) + if joint_id >= 0: + return float(np.asarray(sim.data.joint(joint_name).qpos)[2]) + + for body_name in _BOX_BODY_NAMES: + body_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_BODY, body_name) + if body_id >= 0: + return float(sim.data.xpos[body_id, 2]) + + msg = f"Could not find box joint/body using names {_BOX_JOINT_NAMES} / {_BOX_BODY_NAMES}." + raise ValueError(msg) + + def _append_row( + self, + *, + phase: str, + step: int, + commanded_gripper_width: float | None, + reward: float | None = None, + terminated: bool = False, + truncated: bool = False, + ) -> None: + box_z = self._box_z() + if self.reset_z is None: + self.reset_z = box_z + z_drop = self.reset_z - box_z + row = { + **self.metadata, + "phase": phase, + "step": step, + "time_s": max(step, 0) / _CONTROL_FREQUENCY_HZ, + "commanded_gripper_width": commanded_gripper_width, + "box_z": box_z, + "z_drop_from_reset": z_drop, + "slipped": z_drop >= self.slip_threshold, + "terminated": terminated, + "truncated": truncated, + "reward": reward, + } + with self.csv_path.open("a", newline="") as f: + writer = csv.DictWriter(f, fieldnames=self.FIELDNAMES) + if self._needs_header: + writer.writeheader() + self._needs_header = False + writer.writerow(row) + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + obs, info = self.env.reset(seed=seed, options=options) + self.step_idx = 0 + self.reset_z = None + self._append_row(phase="reset", step=-1, commanded_gripper_width=None) + return obs, info + + def step(self, action: Any): + obs, reward, terminated, truncated, info = self.env.step(action) + self._append_row( + phase="step", + step=self.step_idx, + commanded_gripper_width=_extract_gripper_width(action), + reward=float(reward), + terminated=bool(terminated), + truncated=bool(truncated), + ) + self.step_idx += 1 + return obs, reward, terminated, truncated, info + + +class StartGraspedWrapper(gym.Wrapper): + """Close the gripper after reset so the episode starts with the object held.""" + + def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10): + super().__init__(env) + self.settle_steps = settle_steps + self.post_gravity_settle_steps = post_gravity_settle_steps + + def _closed_gripper_hold_action(self) -> dict[str, Any]: + return _zero_closed_action(self.env.action_space) + + def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: + cfg = gripper.get_config() + actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) + if actuator_id < 0: + msg = f"Could not find gripper actuator {cfg.actuator!r}." + raise ValueError(msg) + ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width + ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] + sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + sim = self.env.get_wrapper_attr("sim") + gravity = np.array(sim.model.opt.gravity, copy=True) + + sim.model.opt.gravity[:] = 0 + obs, info = self.env.reset(seed=seed, options=options) + + robot = self.env.get_wrapper_attr("robot") + gripper = self.env.get_wrapper_attr("gripper") + if isinstance(robot, dict): + robot = robot[_ROBOT_NAME] + if isinstance(gripper, dict): + gripper = gripper[_ROBOT_NAME] + hold_joints = robot.get_joint_position().copy() + + try: + for step_idx in range(self.settle_steps): + width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) + self._command_gripper_width(sim, gripper, width) + robot.set_joint_position(hold_joints) + sim.step(1) + finally: + sim.model.opt.gravity[:] = gravity + + gripper.grasp() + for _ in range(self.post_gravity_settle_steps): + robot.set_joint_position(hold_joints) + gripper.grasp() + sim.step(1) + + obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) + if terminated or truncated: + obs, info = self.env.reset(seed=seed, options=options) + sim.sync_gui() + return obs, info + + +def make_franka_sim_env_without_taxim( + *, + box_xml_path: Path, + render_mode: str, + start_grasped: bool, + grasp_settle_steps: int, + post_gravity_settle_steps: int, +) -> gym.Env: + rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) + + scene = EmptyWorldFR3() + cfg = scene.config() + cfg.control_mode = ControlMode.JOINTS + cfg.headless = render_mode != "human" + cfg.sim_cfg.realtime = render_mode == "human" + cfg.sim_cfg.async_control = render_mode == "human" + cfg.sim_cfg.frequency = int(_CONTROL_FREQUENCY_HZ) + cfg.wrapper_cfg.binary_gripper = True + cfg.wrapper_cfg.home_on_reset = True + cfg.max_relative_movement = np.deg2rad(5) + cfg.relative_to = RelativeTo.LAST_STEP + cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} + cfg.gripper_offsets = None + cfg.root_frame_objects = { + "": ( + str(box_xml_path), + Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), + ) + } + cfg.robot_cfgs[_ROBOT_NAME].tcp_offset = rcs.GRIPPER_OFFSETS[rcs.common.GripperType("Robotiq2F85")] + q_home = cfg.robot_cfgs[_ROBOT_NAME].q_home.copy() + q_home[-1] = -1.571 + cfg.robot_cfgs[_ROBOT_NAME].q_home = q_home + cfg.camera_cfgs = None + cfg.camera_adds = None + + env = scene.create_env(cfg) + if start_grasped: + env = StartGraspedWrapper( + env, + settle_steps=grasp_settle_steps, + post_gravity_settle_steps=post_gravity_settle_steps, + ) + if render_mode == "human": + env.get_wrapper_attr("sim").open_gui() + return env + + +def make_ablation_env( + *, + box_xml_path: Path, + args: argparse.Namespace, + metadata: dict[str, Any], + csv_path: Path, +) -> gym.Env: + env = make_franka_sim_env_without_taxim( + box_xml_path=box_xml_path, + render_mode="human" if args.gui else "rgb_array", + start_grasped=True, + grasp_settle_steps=args.grasp_settle_steps, + post_gravity_settle_steps=args.post_gravity_settle_steps, + ) + return BoxZRecorderWrapper( + env, + csv_path=csv_path, + metadata=metadata, + slip_threshold=args.slip_threshold, + ) + + +def run_ablation(args: argparse.Namespace) -> None: + output_dir = args.output_dir.expanduser().resolve() + csv_path = output_dir / "box_z_records.csv" + source_xml = Path(_BOX_XML) + + friction_grid = itertools.product( + args.friction_slide_values, + args.friction_spin_values, + args.friction_roll_values, + ) + run_idx = 0 + for friction_values, density, gripper_width in itertools.product( + friction_grid, + args.density_values, + args.gripper_widths, + ): + friction = tuple(float(value) for value in friction_values) + run_id = f"run_{run_idx:04d}" + box_xml_path = _write_box_xml( + source_xml=source_xml, + friction=friction, + density=float(density), + ) + metadata = { + "run_id": run_id, + "seed": args.seed + run_idx, + "friction_slide": friction[0], + "friction_spin": friction[1], + "friction_roll": friction[2], + "density": float(density), + } + + print( + f"{run_id}: friction={_format_friction(friction)} " + f"density={_format_float(float(density))} width={_format_float(float(gripper_width))}" + ) + env = make_ablation_env( + box_xml_path=box_xml_path, + args=args, + metadata=metadata, + csv_path=csv_path, + ) + try: + env.reset(seed=args.seed + run_idx) + action = _make_gripper_width_action(env.action_space, float(gripper_width)) + for _ in range(args.steps): + _, _, terminated, truncated, _ = env.step(action) + if args.stop_on_done and (terminated or truncated): + break + finally: + env.close() + run_idx += 1 + + print(f"Wrote {run_idx} ablation rollouts to {csv_path}") + + +def main() -> None: + parser = argparse.ArgumentParser(description="Ablate box friction/density and record z slippage.") + parser.add_argument("--seed", type=int, default=0) + parser.add_argument("--output-dir", type=Path, default=Path("ablation_runs")) + parser.add_argument("--steps", type=int, default=120) + parser.add_argument("--slip-threshold", type=float, default=0.01, help="Meters of z-drop counted as slipped.") + parser.add_argument("--stop-on-done", action="store_true") + parser.add_argument("--gui", action="store_true") + parser.add_argument("--grasp-settle-steps", type=int, default=30) + parser.add_argument("--post-gravity-settle-steps", type=int, default=10) + + parser.add_argument("--friction-slide-values", type=_float_list, default=[0.25, 0.5, 1.0, 2.0]) + parser.add_argument("--friction-spin-values", type=_float_list, default=[0.3]) + parser.add_argument("--friction-roll-values", type=_float_list, default=[0.1]) + parser.add_argument("--density-values", type=_float_list, default=[50.0]) + parser.add_argument("--gripper-widths", type=_float_list, default=[0.0, 0.25, 0.5, 0.75, 1.0]) + + args = parser.parse_args() + run_ablation(args) + + +if __name__ == "__main__": + main() From 25d37724b13d54f229252cf69ffae99272aed54d Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sat, 27 Jun 2026 21:30:41 +0200 Subject: [PATCH 12/87] feat: somewhat working ablation script --- extensions/rcs_sb3/plot_ablation.py | 216 ++++++++++++++++++++++++ extensions/rcs_sb3/run_ablate.py | 249 ++++++++++++++++++++++------ 2 files changed, 412 insertions(+), 53 deletions(-) create mode 100644 extensions/rcs_sb3/plot_ablation.py diff --git a/extensions/rcs_sb3/plot_ablation.py b/extensions/rcs_sb3/plot_ablation.py new file mode 100644 index 00000000..dee15a1d --- /dev/null +++ b/extensions/rcs_sb3/plot_ablation.py @@ -0,0 +1,216 @@ +"""Plot parameterized box slip ablation CSV files. + +Each input CSV is expected to use the filename written by ``run_ablate.py``: + + box_z_records_____seed_.csv + +Older files without the ``_seed_`` suffix are also supported; for those, +the seed is read from the CSV contents. + +One fixed-axis PNG is written per CSV so images can be compared directly. +""" + +from __future__ import annotations + +import argparse +import csv +import re +from dataclasses import dataclass +from pathlib import Path + +_CSV_RE = re.compile( + r"^box_z_records_" + r"(?P[^_]+)_" + r"(?P[^_]+)_" + r"(?P[^_]+)_" + r"(?P[^_]+)" + r"(?:_seed_(?P-?\d+))?\.csv$" +) + + +@dataclass(frozen=True) +class AblationParams: + friction_slide: float + friction_spin: float + friction_roll: float + density: float + seed: int + + +def _parse_filename_float(value: str) -> float: + return float(value.replace("m", "-").replace("p", ".")) + + +def _parse_csv_params(csv_path: Path) -> AblationParams: + match = _CSV_RE.match(csv_path.name) + if match is None: + msg = f"Could not parse ablation parameters from {csv_path.name!r}." + raise ValueError(msg) + + seed = match.group("seed") + return AblationParams( + friction_slide=_parse_filename_float(match.group("friction_slide")), + friction_spin=_parse_filename_float(match.group("friction_spin")), + friction_roll=_parse_filename_float(match.group("friction_roll")), + density=_parse_filename_float(match.group("density")), + seed=int(seed) if seed is not None else _read_seed_from_csv(csv_path), + ) + + +def _read_seed_from_csv(csv_path: Path) -> int: + with csv_path.open(newline="") as f: + reader = csv.DictReader(f) + for row in reader: + seed = row.get("seed") + if seed not in (None, ""): + return int(seed) + + msg = f"Could not find a seed column value in {csv_path}." + raise ValueError(msg) + + +def _read_ablation_csv(csv_path: Path) -> tuple[list[int], list[float], list[float]]: + steps: list[int] = [] + z_drops: list[float] = [] + gripper_widths: list[float] = [] + + with csv_path.open(newline="") as f: + reader = csv.DictReader(f) + for row in reader: + if row["phase"] != "step": + continue + steps.append(int(row["step"])) + z_drops.append(float(row["z_drop_from_reset"])) + gripper_widths.append(float(row["commanded_gripper_width"])) + + if not steps: + msg = f"No step rows found in {csv_path}." + raise ValueError(msg) + return steps, z_drops, gripper_widths + + +def _first_slip( + *, + steps: list[int], + z_drops: list[float], + gripper_widths: list[float], + slip_threshold: float, +) -> tuple[int, float] | None: + for step, z_drop, gripper_width in zip(steps, z_drops, gripper_widths, strict=True): + if z_drop >= slip_threshold: + return step, gripper_width + return None + + +def _plot_csv( + *, + csv_path: Path, + png_path: Path, + params: AblationParams, + x_limit: int, + y_min: float, + y_max: float, + slip_threshold: float, +) -> None: + try: + import matplotlib.pyplot as plt + except ModuleNotFoundError as exc: + msg = "plot_ablation.py requires matplotlib. Install it in the Python environment used for plotting." + raise SystemExit(msg) from exc + + steps, z_drops, gripper_widths = _read_ablation_csv(csv_path) + first_slip = _first_slip( + steps=steps, + z_drops=z_drops, + gripper_widths=gripper_widths, + slip_threshold=slip_threshold, + ) + + fig, ax = plt.subplots(figsize=(12, 6), dpi=160) + ax.plot(steps, z_drops, color="#1f77b4", linewidth=1.8, label="z drop from reset") + ax.axhline( + slip_threshold, + color="#d62728", + linestyle="--", + linewidth=1.2, + label=f"slip threshold ({slip_threshold:g} m)", + ) + + ax.set_xlim(0, x_limit) + ax.set_ylim(y_min, y_max) + ax.set_xlabel("control step") + ax.set_ylabel("z drop from reset (m)") + ax.grid(True, alpha=0.25) + + gripper_ax = ax.twinx() + gripper_ax.plot( + steps, + gripper_widths, + color="#2ca02c", + linewidth=1.0, + alpha=0.65, + label="commanded gripper width", + ) + gripper_ax.set_ylim(0.0, 1.0) + gripper_ax.set_ylabel("commanded gripper width") + + slip_text = ( + f"first slip: step {first_slip[0]}, width {first_slip[1]:.3f}" + if first_slip is not None + else "first slip: none" + ) + title = ( + "Box slip ablation\n" + f"friction=({params.friction_slide:g}, {params.friction_spin:g}, {params.friction_roll:g}), " + f"density={params.density:g}, seed={params.seed}; {slip_text}" + ) + ax.set_title(title) + + lines, labels = ax.get_legend_handles_labels() + gripper_lines, gripper_labels = gripper_ax.get_legend_handles_labels() + ax.legend(lines + gripper_lines, labels + gripper_labels, loc="upper right") + + png_path.parent.mkdir(parents=True, exist_ok=True) + fig.tight_layout() + fig.savefig(png_path) + plt.close(fig) + + +def plot_ablation(args: argparse.Namespace) -> None: + input_dir = args.input_dir.expanduser().resolve() + output_dir = args.output_dir.expanduser().resolve() + csv_paths = sorted(path for path in input_dir.glob("box_z_records_*.csv") if _CSV_RE.match(path.name)) + if not csv_paths: + msg = f"No parameterized ablation CSV files found in {input_dir}." + raise FileNotFoundError(msg) + + for csv_path in csv_paths: + params = _parse_csv_params(csv_path) + png_path = output_dir / f"{csv_path.stem}.png" + _plot_csv( + csv_path=csv_path, + png_path=png_path, + params=params, + x_limit=args.x_limit, + y_min=args.y_min, + y_max=args.y_max, + slip_threshold=args.slip_threshold, + ) + print(f"Wrote {png_path}") + + +def main() -> None: + parser = argparse.ArgumentParser(description="Plot fixed-axis box slip ablation CSV files.") + parser.add_argument("--input-dir", type=Path, default=Path("ablation_runs")) + parser.add_argument("--output-dir", type=Path, default=Path("ablation_plots")) + parser.add_argument("--x-limit", type=int, default=3500) + parser.add_argument("--y-min", type=float, default=-0.005) + parser.add_argument("--y-max", type=float, default=0.05) + parser.add_argument("--slip-threshold", type=float, default=0.01) + + args = parser.parse_args() + plot_ablation(args) + + +if __name__ == "__main__": + main() diff --git a/extensions/rcs_sb3/run_ablate.py b/extensions/rcs_sb3/run_ablate.py index c00f866b..1c72283c 100644 --- a/extensions/rcs_sb3/run_ablate.py +++ b/extensions/rcs_sb3/run_ablate.py @@ -2,16 +2,18 @@ The environment setup mirrors ``run_test.py`` but swaps in generated box XML files with different MuJoCo friction/density values. Each rollout starts with -``StartGraspedWrapper`` so the box is already held, then commands a fixed -gripper width while recording the box z-position over time. Taxim rendering is -intentionally skipped because it does not affect these physics measurements. +``StartGraspedWrapper`` so the box is already held, then opens the gripper in +small increments while recording the box z-position over time. Taxim rendering +is intentionally skipped because it does not affect these physics measurements. """ from __future__ import annotations import argparse +import concurrent.futures import csv import itertools +import os from pathlib import Path from typing import Any @@ -32,7 +34,9 @@ _SOURCE_DENSITY = 'density="50"' _BOX_BODY_NAMES = ("_box_body", "box_body") _BOX_JOINT_NAMES = ("_box_joint", "box_joint") +_GRIPPER_PAD_GEOM_NAME_PART = "digit_pad" _CONTROL_FREQUENCY_HZ = 30.0 +_GRIPPER_OPEN_STEP = 0.01 def _taxim_gripper_type() -> GripperType: @@ -77,6 +81,11 @@ def _format_friction(friction: tuple[float, float, float]) -> str: return " ".join(_format_float(value) for value in friction) +def _gripper_opening_schedule() -> list[float]: + step_count = round(1.0 / _GRIPPER_OPEN_STEP) + return [idx / step_count for idx in range(step_count + 1)] + + def _make_gripper_width_action(space: gym.Space, width: float) -> dict[str, Any]: action = space.sample() @@ -129,6 +138,43 @@ def _write_box_xml( return xml_path +def _make_gripper_pad_friction_neutral(env: gym.Env) -> None: + sim = env.get_wrapper_attr("sim") + changed_geom_names = [] + for geom_id in range(sim.model.ngeom): + geom_name = mujoco.mj_id2name(sim.model, mujoco.mjtObj.mjOBJ_GEOM, geom_id) + if geom_name is None or _GRIPPER_PAD_GEOM_NAME_PART not in geom_name: + continue + + sim.model.geom_friction[geom_id, :] = 0.0 + changed_geom_names.append(geom_name) + + if not changed_geom_names: + msg = f"Could not find gripper pad geoms containing {_GRIPPER_PAD_GEOM_NAME_PART!r}." + raise ValueError(msg) + + +def _box_z_csv_path( + *, + output_dir: Path, + friction: tuple[float, float, float], + density: float, + seed: int, +) -> Path: + stem_values = [*friction, density] + param_stem = "_".join(_format_filename_float(value) for value in stem_values) + return output_dir / f"box_z_records_{param_stem}.csv" + + +def _format_width_schedule(gripper_widths: list[float]) -> str: + if not gripper_widths: + return "none" + return ( + f"{_format_float(gripper_widths[0])}..{_format_float(gripper_widths[-1])} " + f"step={_format_float(_GRIPPER_OPEN_STEP)}" + ) + + class BoxZRecorderWrapper(gym.Wrapper): """Append one CSV row per reset/step with the box z-position.""" @@ -142,6 +188,9 @@ class BoxZRecorderWrapper(gym.Wrapper): "friction_spin", "friction_roll", "density", + "loaded_friction_slide", + "loaded_friction_spin", + "loaded_friction_roll", "commanded_gripper_width", "box_z", "z_drop_from_reset", @@ -167,7 +216,8 @@ def __init__( self.reset_z: float | None = None self.csv_path.parent.mkdir(parents=True, exist_ok=True) - self._needs_header = not self.csv_path.exists() or self.csv_path.stat().st_size == 0 + self.csv_path.unlink(missing_ok=True) + self._needs_header = True def _box_z(self) -> float: sim = self.env.get_wrapper_attr("sim") @@ -184,6 +234,17 @@ def _box_z(self) -> float: msg = f"Could not find box joint/body using names {_BOX_JOINT_NAMES} / {_BOX_BODY_NAMES}." raise ValueError(msg) + def _box_geom_friction(self) -> tuple[float, float, float]: + sim = self.env.get_wrapper_attr("sim") + for geom_name in ("_box_geom", "box_geom"): + geom_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) + if geom_id >= 0: + friction = sim.model.geom_friction[geom_id] + return float(friction[0]), float(friction[1]), float(friction[2]) + + msg = "Could not find box geom using names ('_box_geom', 'box_geom')." + raise ValueError(msg) + def _append_row( self, *, @@ -195,6 +256,7 @@ def _append_row( truncated: bool = False, ) -> None: box_z = self._box_z() + loaded_friction = self._box_geom_friction() if self.reset_z is None: self.reset_z = box_z z_drop = self.reset_z - box_z @@ -203,6 +265,9 @@ def _append_row( "phase": phase, "step": step, "time_s": max(step, 0) / _CONTROL_FREQUENCY_HZ, + "loaded_friction_slide": loaded_friction[0], + "loaded_friction_spin": loaded_friction[1], + "loaded_friction_roll": loaded_friction[2], "commanded_gripper_width": commanded_gripper_width, "box_z": box_z, "z_drop_from_reset": z_drop, @@ -294,9 +359,6 @@ def reset( gripper.grasp() sim.step(1) - obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) - if terminated or truncated: - obs, info = self.env.reset(seed=seed, options=options) sim.sync_gui() return obs, info @@ -318,7 +380,7 @@ def make_franka_sim_env_without_taxim( cfg.sim_cfg.realtime = render_mode == "human" cfg.sim_cfg.async_control = render_mode == "human" cfg.sim_cfg.frequency = int(_CONTROL_FREQUENCY_HZ) - cfg.wrapper_cfg.binary_gripper = True + cfg.wrapper_cfg.binary_gripper = False cfg.wrapper_cfg.home_on_reset = True cfg.max_relative_movement = np.deg2rad(5) cfg.relative_to = RelativeTo.LAST_STEP @@ -338,6 +400,7 @@ def make_franka_sim_env_without_taxim( cfg.camera_adds = None env = scene.create_env(cfg) + _make_gripper_pad_friction_neutral(env) if start_grasped: env = StartGraspedWrapper( env, @@ -371,78 +434,158 @@ def make_ablation_env( ) -def run_ablation(args: argparse.Namespace) -> None: - output_dir = args.output_dir.expanduser().resolve() - csv_path = output_dir / "box_z_records.csv" - source_xml = Path(_BOX_XML) - +def _make_ablation_jobs(args: argparse.Namespace) -> list[tuple[int, tuple[float, float, float], float]]: friction_grid = itertools.product( args.friction_slide_values, args.friction_spin_values, args.friction_roll_values, ) - run_idx = 0 - for friction_values, density, gripper_width in itertools.product( - friction_grid, - args.density_values, - args.gripper_widths, - ): + jobs = [] + for run_idx, (friction_values, density) in enumerate(itertools.product(friction_grid, args.density_values)): friction = tuple(float(value) for value in friction_values) - run_id = f"run_{run_idx:04d}" - box_xml_path = _write_box_xml( - source_xml=source_xml, - friction=friction, - density=float(density), - ) - metadata = { - "run_id": run_id, - "seed": args.seed + run_idx, - "friction_slide": friction[0], - "friction_spin": friction[1], - "friction_roll": friction[2], - "density": float(density), - } + jobs.append((run_idx, friction, float(density))) + return jobs - print( - f"{run_id}: friction={_format_friction(friction)} " - f"density={_format_float(float(density))} width={_format_float(float(gripper_width))}" - ) - env = make_ablation_env( - box_xml_path=box_xml_path, - args=args, - metadata=metadata, - csv_path=csv_path, - ) - try: - env.reset(seed=args.seed + run_idx) - action = _make_gripper_width_action(env.action_space, float(gripper_width)) + +def _num_parallel_envs(args: argparse.Namespace, job_count: int) -> int: + if job_count == 0 or args.gui: + return 1 + if args.num_envs <= 0: + return min(job_count, os.cpu_count() or 1) + return min(job_count, args.num_envs) + + +def _run_ablation_job( + run_idx: int, + friction: tuple[float, float, float], + density: float, + args: argparse.Namespace, + output_dir: Path, + source_xml: Path, + gripper_widths: list[float], +) -> Path: + run_id = f"run_{run_idx:04d}" + seed = args.seed + run_idx + box_xml_path = _write_box_xml( + source_xml=source_xml, + friction=friction, + density=density, + ) + csv_path = _box_z_csv_path( + output_dir=output_dir, + friction=friction, + density=density, + seed=seed, + ) + metadata = { + "run_id": run_id, + "seed": seed, + "friction_slide": friction[0], + "friction_spin": friction[1], + "friction_roll": friction[2], + "density": density, + } + + env = make_ablation_env( + box_xml_path=box_xml_path, + args=args, + metadata=metadata, + csv_path=csv_path, + ) + try: + env.reset(seed=seed) + done = False + for gripper_width in gripper_widths: + action = _make_gripper_width_action(env.action_space, gripper_width) for _ in range(args.steps): _, _, terminated, truncated, _ = env.step(action) if args.stop_on_done and (terminated or truncated): + done = True break - finally: - env.close() - run_idx += 1 + if done: + break + finally: + env.close() + + return csv_path - print(f"Wrote {run_idx} ablation rollouts to {csv_path}") + +def _print_job_start(run_idx: int, friction: tuple[float, float, float], density: float, csv_path: Path) -> None: + print( + f"run_{run_idx:04d}: friction={_format_friction(friction)} " + f"density={_format_float(density)} csv={csv_path}" + ) + + +def run_ablation(args: argparse.Namespace) -> None: + output_dir = args.output_dir.expanduser().resolve() + source_xml = Path(_BOX_XML) + gripper_widths = _gripper_opening_schedule() + jobs = _make_ablation_jobs(args) + num_envs = _num_parallel_envs(args, len(jobs)) + + print(f"Running {len(jobs)} ablation rollouts with {num_envs} parallel environment(s).") + print(f"Gripper schedule: {_format_width_schedule(gripper_widths)}") + if args.gui and args.num_envs not in (0, 1): + print("--gui uses one environment even when --num-envs requests more.") + + if num_envs == 1: + for run_idx, friction, density in jobs: + csv_path = _box_z_csv_path( + output_dir=output_dir, + friction=friction, + density=density, + seed=args.seed + run_idx, + ) + _print_job_start(run_idx, friction, density, csv_path) + _run_ablation_job(run_idx, friction, density, args, output_dir, source_xml, gripper_widths) + else: + with concurrent.futures.ProcessPoolExecutor(max_workers=num_envs) as executor: + future_to_job = {} + for run_idx, friction, density in jobs: + csv_path = _box_z_csv_path( + output_dir=output_dir, + friction=friction, + density=density, + seed=args.seed + run_idx, + ) + _print_job_start(run_idx, friction, density, csv_path) + future = executor.submit( + _run_ablation_job, + run_idx, + friction, + density, + args, + output_dir, + source_xml, + gripper_widths, + ) + future_to_job[future] = (run_idx, csv_path) + + for future in concurrent.futures.as_completed(future_to_job): + run_idx, csv_path = future_to_job[future] + future.result() + print(f"run_{run_idx:04d}: wrote {csv_path}") + + print(f"Wrote {len(jobs)} ablation rollouts to {output_dir}") def main() -> None: parser = argparse.ArgumentParser(description="Ablate box friction/density and record z slippage.") parser.add_argument("--seed", type=int, default=0) parser.add_argument("--output-dir", type=Path, default=Path("ablation_runs")) - parser.add_argument("--steps", type=int, default=120) + parser.add_argument("--steps", type=int, default=30, help="Settling steps to run after each gripper width command.") + parser.add_argument("--num-envs", type=int, default=0, help="Parallel environments to run. Use 0 for all CPU cores.") parser.add_argument("--slip-threshold", type=float, default=0.01, help="Meters of z-drop counted as slipped.") parser.add_argument("--stop-on-done", action="store_true") parser.add_argument("--gui", action="store_true") parser.add_argument("--grasp-settle-steps", type=int, default=30) parser.add_argument("--post-gravity-settle-steps", type=int, default=10) - parser.add_argument("--friction-slide-values", type=_float_list, default=[0.25, 0.5, 1.0, 2.0]) + parser.add_argument("--friction-slide-values", type=_float_list, default=[0,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1])#, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]) parser.add_argument("--friction-spin-values", type=_float_list, default=[0.3]) parser.add_argument("--friction-roll-values", type=_float_list, default=[0.1]) parser.add_argument("--density-values", type=_float_list, default=[50.0]) - parser.add_argument("--gripper-widths", type=_float_list, default=[0.0, 0.25, 0.5, 0.75, 1.0]) args = parser.parse_args() run_ablation(args) From 15ae623221f707b90034fe62559fa65871cbaa52 Mon Sep 17 00:00:00 2001 From: deboliveira Date: Sun, 28 Jun 2026 18:29:25 +0000 Subject: [PATCH 13/87] add docker container and ppo reward --- .devcontainer/devcontainer.json | 41 +++ Dockerfile | 46 +++ extensions/rcs_sb3/run_test.py | 100 ++----- .../rcs_sb3/tests/test_video_recording.py | 50 ++++ python/rcs/envs/tasks.py | 231 +++++++++++++-- python/tests/test_taxim_hold_open_task.py | 269 ++++++++++++++++++ 6 files changed, 644 insertions(+), 93 deletions(-) create mode 100644 .devcontainer/devcontainer.json create mode 100644 Dockerfile create mode 100644 extensions/rcs_sb3/tests/test_video_recording.py create mode 100644 python/tests/test_taxim_hold_open_task.py diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 00000000..dd4a5767 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,41 @@ +{ + "name": "rcs", + "build": { + "dockerfile": "../Dockerfile" + }, + "remoteUser": "vscode", + "runArgs": [ + "--gpus", + "all", + "--name", + "rcs", + "--ipc=host", + "--network=host", + "--env=DISPLAY=${localEnv:DISPLAY}", + "--env=XAUTHORITY=/tmp/.Xauthority", + "--volume=${localEnv:HOME}/.Xauthority:/tmp/.Xauthority:ro", + "--volume=/tmp/.X11-unix:/tmp/.X11-unix:rw" + ], + "shutdownAction": "stopContainer", + "postStartCommand": "bash -lc 'grep -qxF \"source /home/vscode/venv/bin/activate\" ~/.bashrc || echo \"source /home/vscode/venv/bin/activate\" >> ~/.bashrc'", + "customizations": { + "vscode": { + "settings": { + "terminal.integrated.defaultProfile.linux": "bash", + "python.defaultInterpreterPath": "/home/vscode/venv/bin/python" + }, + "extensions": [ + "charliermarsh.ruff", + "eamodio.gitlens", + "ms-python.debugpy", + "ms-python.python", + "ms-python.vscode-pylance", + "ms-python.vscode-python-envs", + "openai.chatgpt" + ] + } + }, + "mounts": [ + "source=/mnt/disk_air_fast_2/scannetpp,target=/workspaces/datasets,type=bind" + ], +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..b5d276a7 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,46 @@ +# Chose the base image from https://hub.docker.com/ +FROM nvidia/cuda:13.1.2-cudnn-devel-ubuntu24.04 + +# Set variables +ARG USERNAME=vscode +ARG USER_UID=1001 +ARG USER_GID=$USER_UID + +# Avoid interactive dialog +ARG DEBIAN_FRONTEND=noninteractive +ENV TZ=Etc/UTC + +# Create new user +RUN groupadd --gid $USER_GID $USERNAME \ + && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME \ + # + # [Optional] Add sudo support. Omit if you don't need to install software after connecting. + && apt-get update \ + && apt-get install -y sudo \ + && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \ + && chmod 0440 /etc/sudoers.d/$USERNAME + +# ******************************************************** +# * Anything else you want to do like clean up goes here * +# ******************************************************** + +# For example, install python 3.12, git and curl +RUN apt-get install -y tzdata +RUN apt-get install -y software-properties-common +RUN add-apt-repository ppa:deadsnakes/ppa +RUN apt update && apt install -y python3.11 python3.11-venv python3.11-dev curl liblz4-dev git libgl1-mesa-dev cmake build-essential +RUN apt install -y ffmpeg ca-certificates cmake curl git libgl1 libglib2.0-0 libglfw3-dev libpoco-dev ninja-build liburdfdom-dev + +# [Optional] Set the default user. Omit if you want to keep the default as root. +USER $USERNAME +WORKDIR /workspaces + +# Install python dependencies and renderpy +COPY . /workspaces +RUN python3.11 -m venv /home/$USERNAME/venv +RUN /home/$USERNAME/venv/bin/pip install --upgrade pip +RUN /home/$USERNAME/venv/bin/pip install --upgrade setuptools wheel ninja setuptools>=45 scikit-build-core>=0.3.3 mujoco>=3.3.5 pin==3.7.0 pybind11 cmake +RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -ve . +RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e extensions/rcs_sb3 +RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e extensions/rcs_taxim +RUN cd norm2tex && /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e . \ No newline at end of file diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index d4d7524a..d9f714ab 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -19,6 +19,7 @@ from rcs._core.sim import SimGripperConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3 +from rcs.envs.tasks import TaximPickHoldOpenTaskConfig from rcs_sb3 import StableBaselines3PolicyWrapper, StableBaselines3Wrapper from rcs_taxim.taxim_wrapper import TaximSimWrapper from stable_baselines3 import PPO @@ -26,11 +27,12 @@ import os import rcs +import rcs.envs.tasks as _taxim_tasks # noqa: F401 _TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" -_TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") -_BOX_XML = "/home/sbien/Documents/Development/V2T/norm2tex/grasp_assets/box/box.xml" -_NORM2TEX_DIR = Path("/home/sbien/Documents/Development/V2T/norm2tex") +_TAXIM_GRIPPER_XML = Path("/workspaces/robot-control-stack/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") +_BOX_XML = "/workspaces/robot-control-stack/norm2tex/grasp_assets/box/box.xml" +_NORM2TEX_DIR = Path("/workspaces/robot-control-stack/norm2tex") _ROBOT_NAME = "robot" _CUBE_GEOM = "_box_geom" _CUBE_MESH = "_box_mesh" @@ -92,67 +94,6 @@ def make_zero_sb3_model(env: gym.Env, args: argparse.Namespace) -> DummySB3Model ) -class StartGraspedWrapper(gym.Wrapper): - """Close the gripper after reset so the episode starts with the object held.""" - - def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10): - super().__init__(env) - self.settle_steps = settle_steps - self.post_gravity_settle_steps = post_gravity_settle_steps - - def _closed_gripper_hold_action(self) -> dict[str, Any]: - return _zero_closed_action(self.env.action_space) - - def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: - cfg = gripper.get_config() - actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) - if actuator_id < 0: - msg = f"Could not find gripper actuator {cfg.actuator!r}." - raise ValueError(msg) - ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width - ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] - sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - sim = self.env.get_wrapper_attr("sim") - gravity = np.array(sim.model.opt.gravity, copy=True) - - # CoverWrapper steps the simulation during reset. Disable gravity before - # the wrapped reset so the cube does not fall before we can close. - sim.model.opt.gravity[:] = 0 - obs, info = self.env.reset(seed=seed, options=options) - - robot = self.env.get_wrapper_attr("robot") - gripper = self.env.get_wrapper_attr("gripper") - if isinstance(robot, dict): - robot = robot["robot"] - if isinstance(gripper, dict): - gripper = gripper["robot"] - hold_joints = robot.get_joint_position().copy() - - try: - for step_idx in range(self.settle_steps): - width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) - self._command_gripper_width(sim, gripper, width) - robot.set_joint_position(hold_joints) - sim.step(1) - finally: - sim.model.opt.gravity[:] = gravity - - gripper.grasp() - for _ in range(self.post_gravity_settle_steps): - robot.set_joint_position(hold_joints) - gripper.grasp() - sim.step(1) - - obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) - if terminated or truncated: - obs, info = self.env.reset(seed=seed, options=options) - sim.sync_gui() - return obs, info - def _make_obj_xml_from_mesh_path(mesh_path: Path) -> str: material_type = mesh_path.name.split('/')[-1].split('_')[1].lower() # TODO: Depending on material type, different friction and mass @@ -196,6 +137,8 @@ def make_franka_taxim_sim_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + max_episode_steps: int, + hold_bonus: float, uv_obj_path: Path | None = None, ) -> gym.Env: rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) @@ -213,6 +156,13 @@ def make_franka_taxim_sim_env( cfg.relative_to = RelativeTo.LAST_STEP cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} cfg.gripper_offsets = None + cfg.task_cfg = TaximPickHoldOpenTaskConfig( + robot_name=_ROBOT_NAME, + grasp_settle_steps=grasp_settle_steps, + post_gravity_settle_steps=post_gravity_settle_steps, + max_episode_steps=max_episode_steps, + hold_bonus=hold_bonus, + ) # Prepare the box XML and normal map as input if argument is given @@ -249,12 +199,6 @@ def make_franka_taxim_sim_env( enable_depth=enable_depth, visualize=visualize_taxim, ) - if start_grasped: - env = StartGraspedWrapper( - env, - settle_steps=grasp_settle_steps, - post_gravity_settle_steps=post_gravity_settle_steps, - ) if render_mode == "human": env.get_wrapper_attr("sim").open_gui() return env @@ -269,6 +213,8 @@ def make_inference_env(args: argparse.Namespace) -> gym.Env: start_grasped=not args.no_start_grasped, grasp_settle_steps=args.grasp_settle_steps, post_gravity_settle_steps=args.post_gravity_settle_steps, + max_episode_steps=args.max_episode_steps, + hold_bonus=args.hold_bonus, uv_obj_path=_select_random_texture() if args.with_texture else None, ) env = StableBaselines3Wrapper( @@ -314,6 +260,8 @@ def make_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + max_episode_steps: int, + hold_bonus: float, with_texture: bool = False ): def _init(): @@ -324,6 +272,8 @@ def _init(): start_grasped=start_grasped, grasp_settle_steps=grasp_settle_steps, post_gravity_settle_steps=post_gravity_settle_steps, + max_episode_steps=max_episode_steps, + hold_bonus=hold_bonus, uv_obj_path=_select_random_texture() if with_texture else None ) env.reset(seed=seed + rank) @@ -338,6 +288,8 @@ def make_sb3_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, + max_episode_steps: int, + hold_bonus: float, with_texture: bool = False ): raw_env_fn = make_train_env( @@ -346,6 +298,8 @@ def make_sb3_train_env( start_grasped, grasp_settle_steps, post_gravity_settle_steps, + max_episode_steps, + hold_bonus, with_texture=with_texture ) @@ -371,6 +325,8 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, + args.max_episode_steps, + args.hold_bonus, with_texture=args.with_texture )() else: @@ -382,6 +338,8 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, + args.max_episode_steps, + args.hold_bonus, with_texture=args.with_texture ) for rank in range(args.num_envs) @@ -410,6 +368,8 @@ def main() -> None: parser.add_argument("--grasp-settle-steps", type=int, default=30) parser.add_argument("--post-gravity-settle-steps", type=int, default=10) parser.add_argument("--with-texture", action="store_true", help="Use a random texture for the box object.") + parser.add_argument("--max-episode-steps", type=int, default=100, help="Truncate the hold-open task after this many steps.") + parser.add_argument("--hold-bonus", type=float, default=1.0, help="Reward added while the cube stays held and the gripper stays open.") # Inference mode args parser.add_argument("--infer-steps", type=int, default=20, help="Inference smoke-test steps.") diff --git a/extensions/rcs_sb3/tests/test_video_recording.py b/extensions/rcs_sb3/tests/test_video_recording.py new file mode 100644 index 00000000..6fc8f9fd --- /dev/null +++ b/extensions/rcs_sb3/tests/test_video_recording.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +from pathlib import Path +import sys + +REPO_ROOT = Path(__file__).resolve().parents[3] +for candidate in (REPO_ROOT / "python", REPO_ROOT / "extensions" / "rcs_sb3", REPO_ROOT / "extensions" / "rcs_sb3" / "src"): + sys.path.insert(0, str(candidate)) + +import cv2 +import numpy as np + +from run_test import _EpisodeVideoWriter, _compose_video_frame + + +def test_compose_video_frame_and_write_mp4(tmp_path: Path): + obs = { + "frames": { + "head": {"rgb": {"data": np.full((240, 320, 3), (0, 0, 255), dtype=np.uint8)}}, + "tactile_gripperleft_digit_pad": { + "rgb": {"data": np.full((240, 320, 3), (255, 0, 0), dtype=np.uint8)} + }, + "tactile_gripperright_digit_pad": { + "rgb": {"data": np.full((240, 320, 3), (0, 255, 0), dtype=np.uint8)} + }, + } + } + composed = _compose_video_frame(obs) + + assert composed.shape == (240, 960, 3) + assert composed.dtype == np.uint8 + + video_path = tmp_path / "taxim_inference.mp4" + writer = _EpisodeVideoWriter(video_path, fps=30.0) + writer.write(composed) + writer.write(composed) + writer.close() + + assert video_path.exists() + assert video_path.stat().st_size > 0 + + cap = cv2.VideoCapture(str(video_path)) + try: + ok, frame = cap.read() + assert ok is True + assert frame is not None + assert frame.shape[0] == 240 + assert frame.shape[1] == 960 + finally: + cap.release() diff --git a/python/rcs/envs/tasks.py b/python/rcs/envs/tasks.py index db44ca8b..c1aac2de 100644 --- a/python/rcs/envs/tasks.py +++ b/python/rcs/envs/tasks.py @@ -2,6 +2,7 @@ from typing import Any import gymnasium as gym +import mujoco import numpy as np from rcs.envs.base import GripperWrapper from rcs.envs.scenes import BaseTaskConfig, SimEnvCreatorConfig, Task @@ -23,12 +24,8 @@ class PickObjSuccessWrapper(gym.Wrapper): def __init__(self, env, robot_name: str, shared2world: rcs.common.Pose, obj_joint_name="box_joint"): super().__init__(env) - # assert isinstance(self.get_wrapper_attr("robot"), sim.SimRobot), "Robot must be a sim.SimRobot instance." - # self._robot = cast(sim.SimRobot, self.get_wrapper_attr("robot")) self.sim = self.env.get_wrapper_attr("sim") self.obj_joint_name = obj_joint_name - - # self.home_pose = self._robot.get_cartesian_position() self._gripper_closing = 0 self.robot_name = robot_name self._gripper = self.get_wrapper_attr("gripper")[self.robot_name] @@ -49,22 +46,14 @@ def step(self, action: dict[str, Any]): # type: ignore self._gripper_closing = 0 obj_pose_in_world = rcs.common.Pose(translation=self.sim.data.joint(self.obj_joint_name).qpos[:3]) - - # obj_pose = self._robot.to_pose_in_robot_coordinates(obj_pose) - obj_pose_in_shared = self.shared2world.inverse() * obj_pose_in_world - - # tcp_to_obj_dist = np.linalg.norm(obj_pose.translation() - self._robot.get_cartesian_position().translation()) tcp_to_obj_dist = np.linalg.norm(obj_pose_in_shared.translation() - obs[self.robot_name]["tquat"][:3]) - obj_to_goal_dist = 0.10 - min(obj_pose_in_shared.translation()[-1], 0.10) - # obj_to_goal_dist = np.linalg.norm(cube_pose.translation() - self.home_pose.translation()) - # NOTE: 4 depends on the time passing between each step. is_grasped = ( - self._gripper_closing >= 4 # gripper is closing since more than 4 steps - and gripper_closed # command is still close - and tcp_to_obj_dist <= 0.01 # tcp to cube center is max 1cm + self._gripper_closing >= 4 + and gripper_closed + and tcp_to_obj_dist <= 0.01 ) success = obj_to_goal_dist <= 0.022 and info[self.robot_name]["is_grasped"] movement = np.linalg.norm(self.sim.data.qvel) @@ -80,10 +69,156 @@ def step(self, action: dict[str, Any]): # type: ignore def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = None): obs, info = super().reset() - # self.home_pose = self._robot.get_cartesian_position() return obs, info +class StartGraspedWrapper(gym.Wrapper): + """Start the episode with the cube already held by the gripper.""" + + def __init__( + self, + env: gym.Env, + robot_name: str, + obj_joint_name: str, + settle_steps: int = 30, + post_gravity_settle_steps: int = 10, + start_cube_offset: rcs.common.Pose | None = None, + ): + super().__init__(env) + self.robot_name = robot_name + self.obj_joint_name = obj_joint_name + self.settle_steps = settle_steps + self.post_gravity_settle_steps = post_gravity_settle_steps + self.start_cube_offset = start_cube_offset or rcs.common.Pose() + + def _closed_gripper_hold_action(self) -> dict[str, Any]: + action = self.env.action_space.sample() + + def visit(value: Any) -> None: + if isinstance(value, dict): + if "gripper" in value: + value["gripper"] = np.array([0.0], dtype=np.float32) + for child in value.values(): + visit(child) + elif isinstance(value, np.ndarray): + value[...] = 0 + + visit(action) + return action + + def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: + cfg = gripper.get_config() + actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) + if actuator_id < 0: + msg = f"Could not find gripper actuator {cfg.actuator!r}." + raise ValueError(msg) + ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width + ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] + sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) + + def _set_object_pose(self, sim: Any, pose: rcs.common.Pose) -> None: + sim.data.joint(self.obj_joint_name).qpos = np.append(pose.translation(), pose.rotation_q_wxyz()) + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + sim = self.env.get_wrapper_attr("sim") + gravity = np.array(sim.model.opt.gravity, copy=True) + + sim.model.opt.gravity[:] = 0 + obs, info = self.env.reset(seed=seed, options=options) + + robot = self.env.get_wrapper_attr("robot") + gripper = self.env.get_wrapper_attr("gripper") + if isinstance(robot, dict): + robot = robot[self.robot_name] + if isinstance(gripper, dict): + gripper = gripper[self.robot_name] + hold_joints = robot.get_joint_position().copy() + + try: + pregrasp_pose = robot.get_cartesian_position() * self.start_cube_offset + self._set_object_pose(sim, pregrasp_pose) + for step_idx in range(self.settle_steps): + width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) + self._command_gripper_width(sim, gripper, width) + robot.set_joint_position(hold_joints) + self._set_object_pose(sim, pregrasp_pose) + sim.step(1) + finally: + sim.model.opt.gravity[:] = gravity + + gripper.grasp() + for _ in range(self.post_gravity_settle_steps): + robot.set_joint_position(hold_joints) + self._set_object_pose(sim, pregrasp_pose) + gripper.grasp() + sim.step(1) + + obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) + if terminated or truncated: + obs, info = self.env.reset(seed=seed, options=options) + sim.sync_gui() + return obs, info + + +class MinOpenHoldRewardWrapper(gym.Wrapper): + """Reward holding the cube while keeping the gripper as open as possible.""" + + def __init__( + self, + env: gym.Env, + *, + robot_name: str, + obj_joint_name: str, + drop_z_threshold: float = 0.02, + hold_bonus: float = 1.0, + max_episode_steps: int = 100, + ): + super().__init__(env) + self.robot_name = robot_name + self.obj_joint_name = obj_joint_name + self.drop_z_threshold = drop_z_threshold + self.hold_bonus = hold_bonus + self.max_episode_steps = max_episode_steps + self._start_obj_z: float | None = None + self._step_count = 0 + + def _object_z(self) -> float: + sim = self.env.get_wrapper_attr("sim") + return float(np.asarray(sim.data.joint(self.obj_joint_name).qpos).reshape(-1)[2]) + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + obs, info = super().reset(seed=seed, options=options) + self._start_obj_z = self._object_z() + self._step_count = 0 + return obs, info + + def step(self, action: dict[str, Any]): # type: ignore[override] + obs, _, terminated, truncated, info = super().step(action) + self._step_count += 1 + gripper_width = float(info.get("gripper_width", 0.0)) + is_grasped = bool(info.get("is_grasped", False)) + obj_z = self._object_z() + dropped = self._start_obj_z is not None and obj_z < self._start_obj_z - self.drop_z_threshold + + if dropped or not is_grasped: + reward = 0.0 + terminated = True + else: + reward = self.hold_bonus + gripper_width + truncated = truncated or self._step_count >= self.max_episode_steps + + info["hold_open_reward"] = reward + info["object_z"] = obj_z + info["start_object_z"] = self._start_obj_z + info["is_dropped"] = dropped or not is_grasped + info["step_count"] = self._step_count + return obs, reward, terminated, truncated, info + + class RandomSquareObjPos(gym.Wrapper): """Wrapper to an object in a simulated environment in a random spot inside a defined square. @@ -110,19 +245,14 @@ def reset( self, *, seed: int | None = None, options: dict[str, Any] | None = None ) -> tuple[dict[str, Any], dict[str, Any]]: - # place randomly in square pos_x = self.np_random.uniform(-self.x_width / 2, self.x_width / 2) pos_y = self.np_random.uniform(-self.y_width / 2, self.y_width / 2) if self.include_rotation: - # 1. Sample a random angle between 0 and 2*pi (360 degrees) theta = self.np_random.uniform(0, 2 * np.pi) - - # 2. Convert the angle to a unit quaternion for the Z-axis qw = np.cos(theta / 2) qz = np.sin(theta / 2) else: - # No rotation (Identity quaternion) qw = 1.0 qz = 0.0 @@ -131,12 +261,10 @@ def reset( ) pose_in_world_frame = self.center2world * pose_in_center_frame - # qpos array format for a free joint: [x, y, z, qw, qx, qy, qz] self.get_wrapper_attr("sim").data.joint(self.obj_joint_name).qpos = np.append( pose_in_world_frame.translation(), pose_in_world_frame.rotation_q_wxyz() ) - # reset of remaining stack, must happen after our reset! return super().reset(seed=seed, options=options) @@ -182,3 +310,60 @@ def add_task_env(cfg: PickTaskConfig, env: gym.Env, _simulation: Sim, env_cfg: S rcs.TASKS["pick"] = PickTask + + +@dataclass(kw_only=True) +class TaximPickHoldOpenTaskConfig(BaseTaskConfig): + robot_name: str + object_center_to_root_frame: rcs.common.Pose = field( + default_factory=lambda: rcs.common.Pose( + translation=np.array([0.5, 0.0, 0.05]), quaternion=np.array([0, 0, 0, 1]) + ) + ) + object_xml = rcs.OBJECT_PATHS["green_cube"] + object_joint: str = "box_joint" + prefix: str = "TaximHoldOpenTask_" + grasp_settle_steps: int = 30 + post_gravity_settle_steps: int = 10 + drop_z_threshold: float = 0.02 + hold_bonus: float = 1.0 + max_episode_steps: int = 100 + start_cube_offset: rcs.common.Pose = field(default_factory=rcs.common.Pose) + task_id: str = "taxim_pick_hold_open" + + +class TaximPickHoldOpenTask(Task[TaximPickHoldOpenTaskConfig]): + @staticmethod + def add_task_mujoco(cfg: TaximPickHoldOpenTaskConfig, composer: ModelComposer, env_cfg: SimEnvCreatorConfig): + object2world = cfg.object_center_to_root_frame * env_cfg.root_frame_to_world + composer.add_object_world_frame( + cfg.object_xml, + object_prefix=cfg.prefix, + pose=object2world, + register_root_relative_replay_free_joints=True, + ) + + @staticmethod + def add_task_env( + cfg: TaximPickHoldOpenTaskConfig, env: gym.Env, _simulation: Sim, env_cfg: SimEnvCreatorConfig + ) -> gym.Env: + object_joint = cfg.prefix + cfg.object_joint + env = StartGraspedWrapper( + env, + robot_name=cfg.robot_name, + obj_joint_name=object_joint, + settle_steps=cfg.grasp_settle_steps, + post_gravity_settle_steps=cfg.post_gravity_settle_steps, + start_cube_offset=cfg.start_cube_offset, + ) + return MinOpenHoldRewardWrapper( + env, + robot_name=cfg.robot_name, + obj_joint_name=object_joint, + drop_z_threshold=cfg.drop_z_threshold, + hold_bonus=cfg.hold_bonus, + max_episode_steps=cfg.max_episode_steps, + ) + + +rcs.TASKS["taxim_pick_hold_open"] = TaximPickHoldOpenTask diff --git a/python/tests/test_taxim_hold_open_task.py b/python/tests/test_taxim_hold_open_task.py new file mode 100644 index 00000000..95a866ab --- /dev/null +++ b/python/tests/test_taxim_hold_open_task.py @@ -0,0 +1,269 @@ +from __future__ import annotations + +from pathlib import Path +import sys + +REPO_ROOT = Path(__file__).resolve().parents[2] +for candidate in (REPO_ROOT / "python", REPO_ROOT / "extensions" / "rcs_sb3" / "src"): + sys.path.insert(0, str(candidate)) + +import gymnasium as gym +import numpy as np + +from rcs.envs.tasks import MinOpenHoldRewardWrapper +from rcs_sb3.wrappers import TaximSB3ObservationWrapper + + +class _FakeJoint: + def __init__(self, qpos: np.ndarray): + self.qpos = qpos + + +class _FakeData: + def __init__(self, qpos: np.ndarray): + self._joint = _FakeJoint(qpos) + + def joint(self, _name: str) -> _FakeJoint: + return self._joint + + +class _FakeSim: + def __init__(self, qpos: np.ndarray): + self.data = _FakeData(qpos) + + +class _HoldEnv(gym.Env): + def __init__(self, qpos: np.ndarray, *, gripper_width: float, is_grasped: bool): + self.sim = _FakeSim(qpos) + self.action_space = gym.spaces.Dict( + { + "robot": gym.spaces.Dict( + { + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ) + } + ) + self.observation_space = gym.spaces.Dict( + { + "robot": gym.spaces.Dict( + { + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ) + } + ) + self._gripper_width = gripper_width + self._is_grasped = is_grasped + + def get_wrapper_attr(self, name: str): + return getattr(self, name) + + def reset(self, *, seed=None, options=None): + super().reset(seed=seed) + return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, {} + + def step(self, action): + obs = {"robot": {"gripper": np.array([1.0], dtype=np.float32)}} + info = {"gripper_width": self._gripper_width, "is_grasped": self._is_grasped} + return obs, 0.0, False, False, info + + +class _TaximObsEnv(gym.Env): + def __init__(self): + self.action_space = gym.spaces.Dict( + { + "robot": gym.spaces.Dict( + { + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ) + } + ) + self.observation_space = gym.spaces.Dict( + { + "frames": gym.spaces.Dict( + { + "tactile_left": gym.spaces.Dict( + { + "rgb": gym.spaces.Dict( + {"data": gym.spaces.Box(low=0, high=255, shape=(240, 320, 3), dtype=np.uint8)} + ) + } + ), + "tactile_right": gym.spaces.Dict( + { + "rgb": gym.spaces.Dict( + {"data": gym.spaces.Box(low=0, high=255, shape=(240, 320, 3), dtype=np.uint8)} + ) + } + ), + } + ), + "robot": gym.spaces.Dict( + { + "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), + } + ), + } + ) + + def reset(self, *, seed=None, options=None): + super().reset(seed=seed) + obs = { + "frames": { + "tactile_left": {"rgb": {"data": np.zeros((240, 320, 3), dtype=np.uint8)}}, + "tactile_right": {"rgb": {"data": np.zeros((240, 320, 3), dtype=np.uint8)}}, + }, + "robot": {"gripper": np.array([1.0], dtype=np.float32)}, + } + return obs, {} + + def step(self, action): + obs, _ = self.reset() + return obs, 0.0, False, False, {} + + +class _FakeTaximWrapper(gym.Wrapper): + def __init__(self, env): + super().__init__(env) + self.observation_space = env.observation_space + + def observation(self, obs): + return obs + + +def test_min_open_hold_reward_prefers_more_open_gripper_when_holding(): + closed_env = MinOpenHoldRewardWrapper( + _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.25, is_grasped=True), + robot_name="robot", + obj_joint_name="box_joint", + ) + open_env = MinOpenHoldRewardWrapper( + _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=True), + robot_name="robot", + obj_joint_name="box_joint", + ) + + closed_env.reset() + _, closed_reward, *_ = closed_env.step({"robot": {"gripper": np.array([0.25], dtype=np.float32)}}) + + open_env.reset() + _, open_reward, *_ = open_env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) + + assert open_reward > closed_reward + + +def test_min_open_hold_reward_penalizes_drops(): + dropped_env = MinOpenHoldRewardWrapper( + _HoldEnv(np.array([0.0, 0.0, 0.45, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=False), + robot_name="robot", + obj_joint_name="box_joint", + ) + + dropped_env.reset() + _, reward, terminated, _, info = dropped_env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) + + assert reward == 0.0 + assert terminated is True + assert info["is_dropped"] is True + + +def test_min_open_hold_reward_truncates_after_100_steps(): + env = MinOpenHoldRewardWrapper( + _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=True), + robot_name="robot", + obj_joint_name="box_joint", + max_episode_steps=7, + ) + + env.reset() + truncated = False + for _ in range(7): + _, reward, terminated, truncated, _ = env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) + assert reward > 0.0 + assert terminated is False + assert truncated is True + + +class _ResetRobot: + def __init__(self): + self._pose = None + + def get_joint_position(self): + return np.zeros(7) + + def get_cartesian_position(self): + return _Pose() + + def set_joint_position(self, _q): + pass + + +class _Pose: + def __mul__(self, other): + return other + + def translation(self): + return np.array([0.0, 0.0, 0.6]) + + def rotation_q_wxyz(self): + return np.array([1.0, 0.0, 0.0, 0.0]) + + +def test_taxim_observation_wrapper_exposes_tactile_images_to_actor(): + wrapped = TaximSB3ObservationWrapper(_FakeTaximWrapper(_TaximObsEnv()), left_frame_key="tactile_left", right_frame_key="tactile_right") + + obs, _ = wrapped.reset() + + assert set(obs) == {"left_rgb", "right_rgb", "state"} + assert obs["left_rgb"].shape == (3, 240, 320) + assert obs["right_rgb"].shape == (3, 240, 320) + assert obs["state"].shape == (1,) + + +def test_task_reset_places_cube_in_home_grasp_pose(): + from rcs.envs.tasks import StartGraspedWrapper + + class _FakeActuatorModel: + actuator_ctrlrange = np.array([[0.0, 1.0]]) + + class _FakeSim2: + def __init__(self): + self.model = _FakeActuatorModel() + self.data = type("D", (), {"ctrl": np.zeros(1), "joint": lambda self_, _name: type("J", (), {"qpos": np.zeros(7)})()})() + + def step(self, _n): + pass + + def sync_gui(self): + pass + + class _FakeGripper: + def get_config(self): + return type("C", (), {"actuator": "gripper", "max_actuator_width": 1.0, "min_actuator_width": 0.0})() + + def grasp(self): + pass + + class _HomeEnv(gym.Env): + def __init__(self): + self.sim = _FakeSim2() + self.action_space = gym.spaces.Dict({"robot": gym.spaces.Dict({"gripper": gym.spaces.Box(0.0, 1.0, (1,), np.float32)})}) + self.observation_space = self.action_space + self._robot = _ResetRobot() + self._gripper = {"robot": _FakeGripper()} + + def get_wrapper_attr(self, name): + return getattr(self, name) + + def reset(self, *, seed=None, options=None): + return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, {} + + def step(self, action): + return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, 0.0, False, False, {} + + wrapped = StartGraspedWrapper(_HomeEnv(), robot_name="robot", obj_joint_name="box_joint") + obs, info = wrapped.reset() + assert obs["robot"]["gripper"].shape == (1,) + assert isinstance(info, dict) From 132aabf89215861804d931bc946fc25e00f68c09 Mon Sep 17 00:00:00 2001 From: deboliveira Date: Mon, 29 Jun 2026 09:28:56 +0000 Subject: [PATCH 14/87] undo changes and add step to startgrasp wrapper --- extensions/rcs_sb3/run_test.py | 131 ++++++++++++++---- python/rcs/envs/tasks.py | 233 ++++----------------------------- 2 files changed, 127 insertions(+), 237 deletions(-) diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py index d9f714ab..be31cffb 100644 --- a/extensions/rcs_sb3/run_test.py +++ b/extensions/rcs_sb3/run_test.py @@ -19,7 +19,6 @@ from rcs._core.sim import SimGripperConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3 -from rcs.envs.tasks import TaximPickHoldOpenTaskConfig from rcs_sb3 import StableBaselines3PolicyWrapper, StableBaselines3Wrapper from rcs_taxim.taxim_wrapper import TaximSimWrapper from stable_baselines3 import PPO @@ -27,7 +26,6 @@ import os import rcs -import rcs.envs.tasks as _taxim_tasks # noqa: F401 _TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" _TAXIM_GRIPPER_XML = Path("/workspaces/robot-control-stack/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") @@ -94,6 +92,102 @@ def make_zero_sb3_model(env: gym.Env, args: argparse.Namespace) -> DummySB3Model ) +class StartGraspedWrapper(gym.Wrapper): + """Close the gripper after reset so the episode starts with the object held.""" + + def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10, drop_z_threshold: float = 0.1, hold_bonus: float = 1.0, max_steps: int = 100): + super().__init__(env) + self.settle_steps = settle_steps + self.post_gravity_settle_steps = post_gravity_settle_steps + self.drop_z_threshold = drop_z_threshold + self.hold_bonus = hold_bonus + self._step_count = 0 + self._start_obj_z: float | None = None + self.max_step_count = max_steps + + def _closed_gripper_hold_action(self) -> dict[str, Any]: + return _zero_closed_action(self.env.action_space) + + def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: + cfg = gripper.get_config() + actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) + if actuator_id < 0: + msg = f"Could not find gripper actuator {cfg.actuator!r}." + raise ValueError(msg) + ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width + ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] + sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) + + def _object_z(self) -> float: + return float(np.asarray(self.sim.data.joint("_box_joint").qpos).reshape(-1)[2]) + + def step(self, action: dict[str, Any]) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]: + obs, _, terminated, truncated, info = self.env.step(action) + obj_z = self._object_z() + self._step_count += 1 + gripper_width = info["robot"]["gripper_width"] + dropped = self._start_obj_z is not None and obj_z < self._start_obj_z - self.drop_z_threshold + + if dropped: + reward = 0.0 + terminated = True + else: + reward = (self.hold_bonus + (1 - gripper_width)) / 2 + truncated = truncated or self._step_count >= self.max_step_count + + info["rl_result"] = { + "reward": reward, + "terminated": terminated, + "truncated": truncated, + "gripper_width": gripper_width, + "dropped": dropped, + } + return obs, reward, terminated, truncated, info + + + def reset( + self, *, seed: int | None = None, options: dict[str, Any] | None = None + ) -> tuple[dict[str, Any], dict[str, Any]]: + sim = self.env.get_wrapper_attr("sim") + gravity = np.array(sim.model.opt.gravity, copy=True) + + # CoverWrapper steps the simulation during reset. Disable gravity before + # the wrapped reset so the cube does not fall before we can close. + sim.model.opt.gravity[:] = 0 + obs, info = self.env.reset(seed=seed, options=options) + self._step_count = 0 + + robot = self.env.get_wrapper_attr("robot") + gripper = self.env.get_wrapper_attr("gripper") + if isinstance(robot, dict): + robot = robot["robot"] + if isinstance(gripper, dict): + gripper = gripper["robot"] + hold_joints = robot.get_joint_position().copy() + + try: + for step_idx in range(self.settle_steps): + width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) + self._command_gripper_width(sim, gripper, width) + robot.set_joint_position(hold_joints) + sim.step(1) + finally: + sim.model.opt.gravity[:] = gravity + + gripper.grasp() + for _ in range(self.post_gravity_settle_steps): + robot.set_joint_position(hold_joints) + gripper.grasp() + sim.step(1) + + self._start_obj_z = self._object_z() + + obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) + if terminated or truncated: + obs, info = self.env.reset(seed=seed, options=options) + sim.sync_gui() + return obs, info + def _make_obj_xml_from_mesh_path(mesh_path: Path) -> str: material_type = mesh_path.name.split('/')[-1].split('_')[1].lower() # TODO: Depending on material type, different friction and mass @@ -137,8 +231,6 @@ def make_franka_taxim_sim_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, - max_episode_steps: int, - hold_bonus: float, uv_obj_path: Path | None = None, ) -> gym.Env: rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) @@ -156,13 +248,6 @@ def make_franka_taxim_sim_env( cfg.relative_to = RelativeTo.LAST_STEP cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} cfg.gripper_offsets = None - cfg.task_cfg = TaximPickHoldOpenTaskConfig( - robot_name=_ROBOT_NAME, - grasp_settle_steps=grasp_settle_steps, - post_gravity_settle_steps=post_gravity_settle_steps, - max_episode_steps=max_episode_steps, - hold_bonus=hold_bonus, - ) # Prepare the box XML and normal map as input if argument is given @@ -199,6 +284,12 @@ def make_franka_taxim_sim_env( enable_depth=enable_depth, visualize=visualize_taxim, ) + if start_grasped: + env = StartGraspedWrapper( + env, + settle_steps=grasp_settle_steps, + post_gravity_settle_steps=post_gravity_settle_steps, + ) if render_mode == "human": env.get_wrapper_attr("sim").open_gui() return env @@ -213,8 +304,6 @@ def make_inference_env(args: argparse.Namespace) -> gym.Env: start_grasped=not args.no_start_grasped, grasp_settle_steps=args.grasp_settle_steps, post_gravity_settle_steps=args.post_gravity_settle_steps, - max_episode_steps=args.max_episode_steps, - hold_bonus=args.hold_bonus, uv_obj_path=_select_random_texture() if args.with_texture else None, ) env = StableBaselines3Wrapper( @@ -260,8 +349,6 @@ def make_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, - max_episode_steps: int, - hold_bonus: float, with_texture: bool = False ): def _init(): @@ -272,8 +359,6 @@ def _init(): start_grasped=start_grasped, grasp_settle_steps=grasp_settle_steps, post_gravity_settle_steps=post_gravity_settle_steps, - max_episode_steps=max_episode_steps, - hold_bonus=hold_bonus, uv_obj_path=_select_random_texture() if with_texture else None ) env.reset(seed=seed + rank) @@ -288,8 +373,6 @@ def make_sb3_train_env( start_grasped: bool, grasp_settle_steps: int, post_gravity_settle_steps: int, - max_episode_steps: int, - hold_bonus: float, with_texture: bool = False ): raw_env_fn = make_train_env( @@ -298,8 +381,6 @@ def make_sb3_train_env( start_grasped, grasp_settle_steps, post_gravity_settle_steps, - max_episode_steps, - hold_bonus, with_texture=with_texture ) @@ -325,8 +406,6 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, - args.max_episode_steps, - args.hold_bonus, with_texture=args.with_texture )() else: @@ -338,8 +417,6 @@ def run_training_smoke(args: argparse.Namespace) -> None: not args.no_start_grasped, args.grasp_settle_steps, args.post_gravity_settle_steps, - args.max_episode_steps, - args.hold_bonus, with_texture=args.with_texture ) for rank in range(args.num_envs) @@ -368,8 +445,6 @@ def main() -> None: parser.add_argument("--grasp-settle-steps", type=int, default=30) parser.add_argument("--post-gravity-settle-steps", type=int, default=10) parser.add_argument("--with-texture", action="store_true", help="Use a random texture for the box object.") - parser.add_argument("--max-episode-steps", type=int, default=100, help="Truncate the hold-open task after this many steps.") - parser.add_argument("--hold-bonus", type=float, default=1.0, help="Reward added while the cube stays held and the gripper stays open.") # Inference mode args parser.add_argument("--infer-steps", type=int, default=20, help="Inference smoke-test steps.") @@ -390,4 +465,4 @@ def main() -> None: if __name__ == "__main__": - main() + main() \ No newline at end of file diff --git a/python/rcs/envs/tasks.py b/python/rcs/envs/tasks.py index c1aac2de..a96ee408 100644 --- a/python/rcs/envs/tasks.py +++ b/python/rcs/envs/tasks.py @@ -2,7 +2,6 @@ from typing import Any import gymnasium as gym -import mujoco import numpy as np from rcs.envs.base import GripperWrapper from rcs.envs.scenes import BaseTaskConfig, SimEnvCreatorConfig, Task @@ -24,8 +23,12 @@ class PickObjSuccessWrapper(gym.Wrapper): def __init__(self, env, robot_name: str, shared2world: rcs.common.Pose, obj_joint_name="box_joint"): super().__init__(env) + # assert isinstance(self.get_wrapper_attr("robot"), sim.SimRobot), "Robot must be a sim.SimRobot instance." + # self._robot = cast(sim.SimRobot, self.get_wrapper_attr("robot")) self.sim = self.env.get_wrapper_attr("sim") self.obj_joint_name = obj_joint_name + + # self.home_pose = self._robot.get_cartesian_position() self._gripper_closing = 0 self.robot_name = robot_name self._gripper = self.get_wrapper_attr("gripper")[self.robot_name] @@ -46,14 +49,22 @@ def step(self, action: dict[str, Any]): # type: ignore self._gripper_closing = 0 obj_pose_in_world = rcs.common.Pose(translation=self.sim.data.joint(self.obj_joint_name).qpos[:3]) + + # obj_pose = self._robot.to_pose_in_robot_coordinates(obj_pose) + obj_pose_in_shared = self.shared2world.inverse() * obj_pose_in_world + + # tcp_to_obj_dist = np.linalg.norm(obj_pose.translation() - self._robot.get_cartesian_position().translation()) tcp_to_obj_dist = np.linalg.norm(obj_pose_in_shared.translation() - obs[self.robot_name]["tquat"][:3]) + obj_to_goal_dist = 0.10 - min(obj_pose_in_shared.translation()[-1], 0.10) + # obj_to_goal_dist = np.linalg.norm(cube_pose.translation() - self.home_pose.translation()) + # NOTE: 4 depends on the time passing between each step. is_grasped = ( - self._gripper_closing >= 4 - and gripper_closed - and tcp_to_obj_dist <= 0.01 + self._gripper_closing >= 4 # gripper is closing since more than 4 steps + and gripper_closed # command is still close + and tcp_to_obj_dist <= 0.01 # tcp to cube center is max 1cm ) success = obj_to_goal_dist <= 0.022 and info[self.robot_name]["is_grasped"] movement = np.linalg.norm(self.sim.data.qvel) @@ -69,156 +80,10 @@ def step(self, action: dict[str, Any]): # type: ignore def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = None): obs, info = super().reset() + # self.home_pose = self._robot.get_cartesian_position() return obs, info -class StartGraspedWrapper(gym.Wrapper): - """Start the episode with the cube already held by the gripper.""" - - def __init__( - self, - env: gym.Env, - robot_name: str, - obj_joint_name: str, - settle_steps: int = 30, - post_gravity_settle_steps: int = 10, - start_cube_offset: rcs.common.Pose | None = None, - ): - super().__init__(env) - self.robot_name = robot_name - self.obj_joint_name = obj_joint_name - self.settle_steps = settle_steps - self.post_gravity_settle_steps = post_gravity_settle_steps - self.start_cube_offset = start_cube_offset or rcs.common.Pose() - - def _closed_gripper_hold_action(self) -> dict[str, Any]: - action = self.env.action_space.sample() - - def visit(value: Any) -> None: - if isinstance(value, dict): - if "gripper" in value: - value["gripper"] = np.array([0.0], dtype=np.float32) - for child in value.values(): - visit(child) - elif isinstance(value, np.ndarray): - value[...] = 0 - - visit(action) - return action - - def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: - cfg = gripper.get_config() - actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) - if actuator_id < 0: - msg = f"Could not find gripper actuator {cfg.actuator!r}." - raise ValueError(msg) - ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width - ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] - sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) - - def _set_object_pose(self, sim: Any, pose: rcs.common.Pose) -> None: - sim.data.joint(self.obj_joint_name).qpos = np.append(pose.translation(), pose.rotation_q_wxyz()) - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - sim = self.env.get_wrapper_attr("sim") - gravity = np.array(sim.model.opt.gravity, copy=True) - - sim.model.opt.gravity[:] = 0 - obs, info = self.env.reset(seed=seed, options=options) - - robot = self.env.get_wrapper_attr("robot") - gripper = self.env.get_wrapper_attr("gripper") - if isinstance(robot, dict): - robot = robot[self.robot_name] - if isinstance(gripper, dict): - gripper = gripper[self.robot_name] - hold_joints = robot.get_joint_position().copy() - - try: - pregrasp_pose = robot.get_cartesian_position() * self.start_cube_offset - self._set_object_pose(sim, pregrasp_pose) - for step_idx in range(self.settle_steps): - width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) - self._command_gripper_width(sim, gripper, width) - robot.set_joint_position(hold_joints) - self._set_object_pose(sim, pregrasp_pose) - sim.step(1) - finally: - sim.model.opt.gravity[:] = gravity - - gripper.grasp() - for _ in range(self.post_gravity_settle_steps): - robot.set_joint_position(hold_joints) - self._set_object_pose(sim, pregrasp_pose) - gripper.grasp() - sim.step(1) - - obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) - if terminated or truncated: - obs, info = self.env.reset(seed=seed, options=options) - sim.sync_gui() - return obs, info - - -class MinOpenHoldRewardWrapper(gym.Wrapper): - """Reward holding the cube while keeping the gripper as open as possible.""" - - def __init__( - self, - env: gym.Env, - *, - robot_name: str, - obj_joint_name: str, - drop_z_threshold: float = 0.02, - hold_bonus: float = 1.0, - max_episode_steps: int = 100, - ): - super().__init__(env) - self.robot_name = robot_name - self.obj_joint_name = obj_joint_name - self.drop_z_threshold = drop_z_threshold - self.hold_bonus = hold_bonus - self.max_episode_steps = max_episode_steps - self._start_obj_z: float | None = None - self._step_count = 0 - - def _object_z(self) -> float: - sim = self.env.get_wrapper_attr("sim") - return float(np.asarray(sim.data.joint(self.obj_joint_name).qpos).reshape(-1)[2]) - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - obs, info = super().reset(seed=seed, options=options) - self._start_obj_z = self._object_z() - self._step_count = 0 - return obs, info - - def step(self, action: dict[str, Any]): # type: ignore[override] - obs, _, terminated, truncated, info = super().step(action) - self._step_count += 1 - gripper_width = float(info.get("gripper_width", 0.0)) - is_grasped = bool(info.get("is_grasped", False)) - obj_z = self._object_z() - dropped = self._start_obj_z is not None and obj_z < self._start_obj_z - self.drop_z_threshold - - if dropped or not is_grasped: - reward = 0.0 - terminated = True - else: - reward = self.hold_bonus + gripper_width - truncated = truncated or self._step_count >= self.max_episode_steps - - info["hold_open_reward"] = reward - info["object_z"] = obj_z - info["start_object_z"] = self._start_obj_z - info["is_dropped"] = dropped or not is_grasped - info["step_count"] = self._step_count - return obs, reward, terminated, truncated, info - - class RandomSquareObjPos(gym.Wrapper): """Wrapper to an object in a simulated environment in a random spot inside a defined square. @@ -245,14 +110,19 @@ def reset( self, *, seed: int | None = None, options: dict[str, Any] | None = None ) -> tuple[dict[str, Any], dict[str, Any]]: + # place randomly in square pos_x = self.np_random.uniform(-self.x_width / 2, self.x_width / 2) pos_y = self.np_random.uniform(-self.y_width / 2, self.y_width / 2) if self.include_rotation: + # 1. Sample a random angle between 0 and 2*pi (360 degrees) theta = self.np_random.uniform(0, 2 * np.pi) + + # 2. Convert the angle to a unit quaternion for the Z-axis qw = np.cos(theta / 2) qz = np.sin(theta / 2) else: + # No rotation (Identity quaternion) qw = 1.0 qz = 0.0 @@ -261,10 +131,12 @@ def reset( ) pose_in_world_frame = self.center2world * pose_in_center_frame + # qpos array format for a free joint: [x, y, z, qw, qx, qy, qz] self.get_wrapper_attr("sim").data.joint(self.obj_joint_name).qpos = np.append( pose_in_world_frame.translation(), pose_in_world_frame.rotation_q_wxyz() ) + # reset of remaining stack, must happen after our reset! return super().reset(seed=seed, options=options) @@ -309,61 +181,4 @@ def add_task_env(cfg: PickTaskConfig, env: gym.Env, _simulation: Sim, env_cfg: S ) -rcs.TASKS["pick"] = PickTask - - -@dataclass(kw_only=True) -class TaximPickHoldOpenTaskConfig(BaseTaskConfig): - robot_name: str - object_center_to_root_frame: rcs.common.Pose = field( - default_factory=lambda: rcs.common.Pose( - translation=np.array([0.5, 0.0, 0.05]), quaternion=np.array([0, 0, 0, 1]) - ) - ) - object_xml = rcs.OBJECT_PATHS["green_cube"] - object_joint: str = "box_joint" - prefix: str = "TaximHoldOpenTask_" - grasp_settle_steps: int = 30 - post_gravity_settle_steps: int = 10 - drop_z_threshold: float = 0.02 - hold_bonus: float = 1.0 - max_episode_steps: int = 100 - start_cube_offset: rcs.common.Pose = field(default_factory=rcs.common.Pose) - task_id: str = "taxim_pick_hold_open" - - -class TaximPickHoldOpenTask(Task[TaximPickHoldOpenTaskConfig]): - @staticmethod - def add_task_mujoco(cfg: TaximPickHoldOpenTaskConfig, composer: ModelComposer, env_cfg: SimEnvCreatorConfig): - object2world = cfg.object_center_to_root_frame * env_cfg.root_frame_to_world - composer.add_object_world_frame( - cfg.object_xml, - object_prefix=cfg.prefix, - pose=object2world, - register_root_relative_replay_free_joints=True, - ) - - @staticmethod - def add_task_env( - cfg: TaximPickHoldOpenTaskConfig, env: gym.Env, _simulation: Sim, env_cfg: SimEnvCreatorConfig - ) -> gym.Env: - object_joint = cfg.prefix + cfg.object_joint - env = StartGraspedWrapper( - env, - robot_name=cfg.robot_name, - obj_joint_name=object_joint, - settle_steps=cfg.grasp_settle_steps, - post_gravity_settle_steps=cfg.post_gravity_settle_steps, - start_cube_offset=cfg.start_cube_offset, - ) - return MinOpenHoldRewardWrapper( - env, - robot_name=cfg.robot_name, - obj_joint_name=object_joint, - drop_z_threshold=cfg.drop_z_threshold, - hold_bonus=cfg.hold_bonus, - max_episode_steps=cfg.max_episode_steps, - ) - - -rcs.TASKS["taxim_pick_hold_open"] = TaximPickHoldOpenTask +rcs.TASKS["pick"] = PickTask \ No newline at end of file From bd560eff4b12ac16ac67b6d8d0393e95c819895f Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Wed, 8 Jul 2026 10:02:03 +0200 Subject: [PATCH 15/87] remove deprecated sb3 package --- extensions/rcs_sb3/README.md | 60 -- extensions/rcs_sb3/fabric_textures.json | 11 - extensions/rcs_sb3/plot_ablation.py | 216 ------- extensions/rcs_sb3/pyproject.toml | 20 - extensions/rcs_sb3/run_ablate.py | 595 ------------------ extensions/rcs_sb3/run_test.py | 468 -------------- extensions/rcs_sb3/src/rcs_sb3/__init__.py | 15 - extensions/rcs_sb3/src/rcs_sb3/interface.py | 50 -- extensions/rcs_sb3/src/rcs_sb3/ppo.py | 19 - extensions/rcs_sb3/src/rcs_sb3/sb3.py | 121 ---- extensions/rcs_sb3/src/rcs_sb3/wrappers.py | 234 ------- .../rcs_sb3/tests/test_video_recording.py | 50 -- extensions/rcs_sb3/tests/test_wrappers.py | 69 -- 13 files changed, 1928 deletions(-) delete mode 100644 extensions/rcs_sb3/README.md delete mode 100644 extensions/rcs_sb3/fabric_textures.json delete mode 100644 extensions/rcs_sb3/plot_ablation.py delete mode 100644 extensions/rcs_sb3/pyproject.toml delete mode 100644 extensions/rcs_sb3/run_ablate.py delete mode 100644 extensions/rcs_sb3/run_test.py delete mode 100644 extensions/rcs_sb3/src/rcs_sb3/__init__.py delete mode 100644 extensions/rcs_sb3/src/rcs_sb3/interface.py delete mode 100644 extensions/rcs_sb3/src/rcs_sb3/ppo.py delete mode 100644 extensions/rcs_sb3/src/rcs_sb3/sb3.py delete mode 100644 extensions/rcs_sb3/src/rcs_sb3/wrappers.py delete mode 100644 extensions/rcs_sb3/tests/test_video_recording.py delete mode 100644 extensions/rcs_sb3/tests/test_wrappers.py diff --git a/extensions/rcs_sb3/README.md b/extensions/rcs_sb3/README.md deleted file mode 100644 index 3e2b71b6..00000000 --- a/extensions/rcs_sb3/README.md +++ /dev/null @@ -1,60 +0,0 @@ -# rcs_sb3 - -- Entry: `run_test.py`\ -- training: `run_test.py --mode train --num-envs --total-timesteps --n-steps --batch-size ` - - setting `--num-envs 0` runs it on the main thread for breakpointing -- inference: `run_test.py --mode infer --infer-steps 100` -- Change the paths of the variables `_BOX_XML`, `_TAXIM_GRIPPER_XML` and `_NORM2TEX_DIR` accordingly -- To enable textures, you need to pass the flag `--with-textures` with the generated files (`_uv,_normal,_color`) in `norm2tex/grasp_assets/box/assets`; without the flag, it should just run the "smooth" version. - -Installation: -``` -git clone git@github.com:RobotControlStack/robot-control-stack.git - -git checkout jin/sb3 - -# Install RCS -conda create -n rcs12 python=3.12 -conda activate rcs12 -conda install -c conda-forge urdfdom urdfdom_headers glfw - -# or sudo apt install $(cat debian_deps.txt) -pip install 'pip>=25.1' -pip install --group build_deps -sudo apt install liburdfdom-dev - -# install rcs -pip install -ve . - -## Install the dependencies for sb3 -# clone and install norm2tex main branch -git clone git@github.com:utn-air/norm2tex.git - -pip install -e . - -# clone and install mujoco-taxim norm2tex branch -git clone git@github.com:utn-air/mujoco-taxim.git - -git checkout norm2tex -pip install -e . - -# install rcs_taxim - -pip install -e extensions/rcs_taxim - -# finally install rcs-sb3 - -pip install -e extensions/rcs_sb3 - -# now try running the run_test.py -python run_test.py --gui --visualize-taxim --steps 1000 - -`` - -## To-do -- Add json file interpreter for feeding geom-texture png files into mujoco-taxim for easier management (Done) -- Make the textures for the cube (Done, for now) -- Enable norm2tex (Done) -- Investigate parallelization (Done) -- Add wrapper for truncation condition -- Add wrapper for reward calculation \ No newline at end of file diff --git a/extensions/rcs_sb3/fabric_textures.json b/extensions/rcs_sb3/fabric_textures.json deleted file mode 100644 index 55510ad4..00000000 --- a/extensions/rcs_sb3/fabric_textures.json +++ /dev/null @@ -1,11 +0,0 @@ -[ - { - "path": "grasp_assets/box/assets/box_Fabric__h4hxz9d_uv.obj" - }, - { - "path": "grasp_assets/box/assets/box_Fabric_b679sa95_uv.obj" - }, - { - "path": "grasp_assets/box/assets/box_Fabric_qol_921__uv.obj" - } -] \ No newline at end of file diff --git a/extensions/rcs_sb3/plot_ablation.py b/extensions/rcs_sb3/plot_ablation.py deleted file mode 100644 index dee15a1d..00000000 --- a/extensions/rcs_sb3/plot_ablation.py +++ /dev/null @@ -1,216 +0,0 @@ -"""Plot parameterized box slip ablation CSV files. - -Each input CSV is expected to use the filename written by ``run_ablate.py``: - - box_z_records_____seed_.csv - -Older files without the ``_seed_`` suffix are also supported; for those, -the seed is read from the CSV contents. - -One fixed-axis PNG is written per CSV so images can be compared directly. -""" - -from __future__ import annotations - -import argparse -import csv -import re -from dataclasses import dataclass -from pathlib import Path - -_CSV_RE = re.compile( - r"^box_z_records_" - r"(?P[^_]+)_" - r"(?P[^_]+)_" - r"(?P[^_]+)_" - r"(?P[^_]+)" - r"(?:_seed_(?P-?\d+))?\.csv$" -) - - -@dataclass(frozen=True) -class AblationParams: - friction_slide: float - friction_spin: float - friction_roll: float - density: float - seed: int - - -def _parse_filename_float(value: str) -> float: - return float(value.replace("m", "-").replace("p", ".")) - - -def _parse_csv_params(csv_path: Path) -> AblationParams: - match = _CSV_RE.match(csv_path.name) - if match is None: - msg = f"Could not parse ablation parameters from {csv_path.name!r}." - raise ValueError(msg) - - seed = match.group("seed") - return AblationParams( - friction_slide=_parse_filename_float(match.group("friction_slide")), - friction_spin=_parse_filename_float(match.group("friction_spin")), - friction_roll=_parse_filename_float(match.group("friction_roll")), - density=_parse_filename_float(match.group("density")), - seed=int(seed) if seed is not None else _read_seed_from_csv(csv_path), - ) - - -def _read_seed_from_csv(csv_path: Path) -> int: - with csv_path.open(newline="") as f: - reader = csv.DictReader(f) - for row in reader: - seed = row.get("seed") - if seed not in (None, ""): - return int(seed) - - msg = f"Could not find a seed column value in {csv_path}." - raise ValueError(msg) - - -def _read_ablation_csv(csv_path: Path) -> tuple[list[int], list[float], list[float]]: - steps: list[int] = [] - z_drops: list[float] = [] - gripper_widths: list[float] = [] - - with csv_path.open(newline="") as f: - reader = csv.DictReader(f) - for row in reader: - if row["phase"] != "step": - continue - steps.append(int(row["step"])) - z_drops.append(float(row["z_drop_from_reset"])) - gripper_widths.append(float(row["commanded_gripper_width"])) - - if not steps: - msg = f"No step rows found in {csv_path}." - raise ValueError(msg) - return steps, z_drops, gripper_widths - - -def _first_slip( - *, - steps: list[int], - z_drops: list[float], - gripper_widths: list[float], - slip_threshold: float, -) -> tuple[int, float] | None: - for step, z_drop, gripper_width in zip(steps, z_drops, gripper_widths, strict=True): - if z_drop >= slip_threshold: - return step, gripper_width - return None - - -def _plot_csv( - *, - csv_path: Path, - png_path: Path, - params: AblationParams, - x_limit: int, - y_min: float, - y_max: float, - slip_threshold: float, -) -> None: - try: - import matplotlib.pyplot as plt - except ModuleNotFoundError as exc: - msg = "plot_ablation.py requires matplotlib. Install it in the Python environment used for plotting." - raise SystemExit(msg) from exc - - steps, z_drops, gripper_widths = _read_ablation_csv(csv_path) - first_slip = _first_slip( - steps=steps, - z_drops=z_drops, - gripper_widths=gripper_widths, - slip_threshold=slip_threshold, - ) - - fig, ax = plt.subplots(figsize=(12, 6), dpi=160) - ax.plot(steps, z_drops, color="#1f77b4", linewidth=1.8, label="z drop from reset") - ax.axhline( - slip_threshold, - color="#d62728", - linestyle="--", - linewidth=1.2, - label=f"slip threshold ({slip_threshold:g} m)", - ) - - ax.set_xlim(0, x_limit) - ax.set_ylim(y_min, y_max) - ax.set_xlabel("control step") - ax.set_ylabel("z drop from reset (m)") - ax.grid(True, alpha=0.25) - - gripper_ax = ax.twinx() - gripper_ax.plot( - steps, - gripper_widths, - color="#2ca02c", - linewidth=1.0, - alpha=0.65, - label="commanded gripper width", - ) - gripper_ax.set_ylim(0.0, 1.0) - gripper_ax.set_ylabel("commanded gripper width") - - slip_text = ( - f"first slip: step {first_slip[0]}, width {first_slip[1]:.3f}" - if first_slip is not None - else "first slip: none" - ) - title = ( - "Box slip ablation\n" - f"friction=({params.friction_slide:g}, {params.friction_spin:g}, {params.friction_roll:g}), " - f"density={params.density:g}, seed={params.seed}; {slip_text}" - ) - ax.set_title(title) - - lines, labels = ax.get_legend_handles_labels() - gripper_lines, gripper_labels = gripper_ax.get_legend_handles_labels() - ax.legend(lines + gripper_lines, labels + gripper_labels, loc="upper right") - - png_path.parent.mkdir(parents=True, exist_ok=True) - fig.tight_layout() - fig.savefig(png_path) - plt.close(fig) - - -def plot_ablation(args: argparse.Namespace) -> None: - input_dir = args.input_dir.expanduser().resolve() - output_dir = args.output_dir.expanduser().resolve() - csv_paths = sorted(path for path in input_dir.glob("box_z_records_*.csv") if _CSV_RE.match(path.name)) - if not csv_paths: - msg = f"No parameterized ablation CSV files found in {input_dir}." - raise FileNotFoundError(msg) - - for csv_path in csv_paths: - params = _parse_csv_params(csv_path) - png_path = output_dir / f"{csv_path.stem}.png" - _plot_csv( - csv_path=csv_path, - png_path=png_path, - params=params, - x_limit=args.x_limit, - y_min=args.y_min, - y_max=args.y_max, - slip_threshold=args.slip_threshold, - ) - print(f"Wrote {png_path}") - - -def main() -> None: - parser = argparse.ArgumentParser(description="Plot fixed-axis box slip ablation CSV files.") - parser.add_argument("--input-dir", type=Path, default=Path("ablation_runs")) - parser.add_argument("--output-dir", type=Path, default=Path("ablation_plots")) - parser.add_argument("--x-limit", type=int, default=3500) - parser.add_argument("--y-min", type=float, default=-0.005) - parser.add_argument("--y-max", type=float, default=0.05) - parser.add_argument("--slip-threshold", type=float, default=0.01) - - args = parser.parse_args() - plot_ablation(args) - - -if __name__ == "__main__": - main() diff --git a/extensions/rcs_sb3/pyproject.toml b/extensions/rcs_sb3/pyproject.toml deleted file mode 100644 index 28eb8745..00000000 --- a/extensions/rcs_sb3/pyproject.toml +++ /dev/null @@ -1,20 +0,0 @@ -[build-system] -requires = ["setuptools"] -build-backend = "setuptools.build_meta" - -[project] -name = "rcs_sb3" -version = "0.7.1" -description = "Stable-Baselines3 integration for RCS environments" -dependencies = ["rcs>=0.7.1", "stable-baselines3>=2.3.0"] -readme = "README.md" -maintainers = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] -authors = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] -requires-python = ">=3.11" - -[tool.black] -line-length = 120 -target-version = ["py310"] - -[tool.isort] -profile = "black" diff --git a/extensions/rcs_sb3/run_ablate.py b/extensions/rcs_sb3/run_ablate.py deleted file mode 100644 index 1c72283c..00000000 --- a/extensions/rcs_sb3/run_ablate.py +++ /dev/null @@ -1,595 +0,0 @@ -"""Grid-search box physics parameters and record grasp slippage. - -The environment setup mirrors ``run_test.py`` but swaps in generated box XML -files with different MuJoCo friction/density values. Each rollout starts with -``StartGraspedWrapper`` so the box is already held, then opens the gripper in -small increments while recording the box z-position over time. Taxim rendering -is intentionally skipped because it does not affect these physics measurements. -""" - -from __future__ import annotations - -import argparse -import concurrent.futures -import csv -import itertools -import os -from pathlib import Path -from typing import Any - -import gymnasium as gym -import mujoco -import numpy as np -import rcs -from rcs._core.common import GripperType, Pose -from rcs._core.sim import SimGripperConfig -from rcs.envs.base import ControlMode, RelativeTo -from rcs.envs.configs import EmptyWorldFR3 - -_TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" -_TAXIM_GRIPPER_XML = Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") -_BOX_XML = "/home/sbien/Documents/Development/V2T/norm2tex/grasp_assets/box/box.xml" -_ROBOT_NAME = "robot" -_SOURCE_FRICTION = 'friction="1 0.3 0.1"' -_SOURCE_DENSITY = 'density="50"' -_BOX_BODY_NAMES = ("_box_body", "box_body") -_BOX_JOINT_NAMES = ("_box_joint", "box_joint") -_GRIPPER_PAD_GEOM_NAME_PART = "digit_pad" -_CONTROL_FREQUENCY_HZ = 30.0 -_GRIPPER_OPEN_STEP = 0.01 - - -def _taxim_gripper_type() -> GripperType: - return GripperType(_TAXIM_GRIPPER_TYPE_ID) - - -def _zero_closed_action(space: gym.Space) -> dict[str, Any]: - return _make_gripper_width_action(space, 0.0) - - -def _taxim_gripper_cfg() -> SimGripperConfig: - return SimGripperConfig( - epsilon_inner=0.005, - epsilon_outer=0.005, - seconds_between_callbacks=0.1, - ignored_collision_geoms=[], - collision_geoms=[], - collision_geoms_fingers=[], - joints=["right_driver_joint", "left_driver_joint"], - max_joint_width=0.005, - min_joint_width=1.0, - actuator="fingers_actuator", - max_actuator_width=0, - min_actuator_width=255, - gripper_type=_taxim_gripper_type(), - ) - - -def _float_list(value: str) -> list[float]: - return [float(item.strip()) for item in value.split(",") if item.strip()] - - -def _format_float(value: float) -> str: - return f"{value:.6g}" - - -def _format_filename_float(value: float) -> str: - return _format_float(value).replace("-", "m").replace(".", "p") - - -def _format_friction(friction: tuple[float, float, float]) -> str: - return " ".join(_format_float(value) for value in friction) - - -def _gripper_opening_schedule() -> list[float]: - step_count = round(1.0 / _GRIPPER_OPEN_STEP) - return [idx / step_count for idx in range(step_count + 1)] - - -def _make_gripper_width_action(space: gym.Space, width: float) -> dict[str, Any]: - action = space.sample() - - def visit(value: Any) -> None: - if isinstance(value, dict): - for key, child in value.items(): - if key == "gripper": - value[key] = np.array([width], dtype=np.float32) - continue - visit(child) - elif isinstance(value, np.ndarray): - value[...] = 0 - - visit(action) - return action - - -def _extract_gripper_width(action: Any) -> float | None: - if isinstance(action, dict): - if "gripper" in action: - return float(np.asarray(action["gripper"]).reshape(-1)[0]) - for value in action.values(): - width = _extract_gripper_width(value) - if width is not None: - return width - return None - - -def _write_box_xml( - *, - source_xml: Path, - friction: tuple[float, float, float], - density: float, -) -> Path: - xml_content = source_xml.read_text() - if _SOURCE_FRICTION not in xml_content: - msg = f"Expected {_SOURCE_FRICTION!r} in {source_xml}." - raise ValueError(msg) - if _SOURCE_DENSITY not in xml_content: - msg = f"Expected {_SOURCE_DENSITY!r} in {source_xml}." - raise ValueError(msg) - - xml_content = xml_content.replace(_SOURCE_FRICTION, f'friction="{_format_friction(friction)}"') - xml_content = xml_content.replace(_SOURCE_DENSITY, f'density="{_format_float(density)}"') - - stem_values = [*friction, density] - stem = "_".join(_format_filename_float(value) for value in stem_values) - xml_path = source_xml.parent / f"box_{stem}.xml" - xml_path.write_text(xml_content) - return xml_path - - -def _make_gripper_pad_friction_neutral(env: gym.Env) -> None: - sim = env.get_wrapper_attr("sim") - changed_geom_names = [] - for geom_id in range(sim.model.ngeom): - geom_name = mujoco.mj_id2name(sim.model, mujoco.mjtObj.mjOBJ_GEOM, geom_id) - if geom_name is None or _GRIPPER_PAD_GEOM_NAME_PART not in geom_name: - continue - - sim.model.geom_friction[geom_id, :] = 0.0 - changed_geom_names.append(geom_name) - - if not changed_geom_names: - msg = f"Could not find gripper pad geoms containing {_GRIPPER_PAD_GEOM_NAME_PART!r}." - raise ValueError(msg) - - -def _box_z_csv_path( - *, - output_dir: Path, - friction: tuple[float, float, float], - density: float, - seed: int, -) -> Path: - stem_values = [*friction, density] - param_stem = "_".join(_format_filename_float(value) for value in stem_values) - return output_dir / f"box_z_records_{param_stem}.csv" - - -def _format_width_schedule(gripper_widths: list[float]) -> str: - if not gripper_widths: - return "none" - return ( - f"{_format_float(gripper_widths[0])}..{_format_float(gripper_widths[-1])} " - f"step={_format_float(_GRIPPER_OPEN_STEP)}" - ) - - -class BoxZRecorderWrapper(gym.Wrapper): - """Append one CSV row per reset/step with the box z-position.""" - - FIELDNAMES = ( - "run_id", - "phase", - "step", - "time_s", - "seed", - "friction_slide", - "friction_spin", - "friction_roll", - "density", - "loaded_friction_slide", - "loaded_friction_spin", - "loaded_friction_roll", - "commanded_gripper_width", - "box_z", - "z_drop_from_reset", - "slipped", - "terminated", - "truncated", - "reward", - ) - - def __init__( - self, - env: gym.Env, - *, - csv_path: Path, - metadata: dict[str, Any], - slip_threshold: float, - ): - super().__init__(env) - self.csv_path = csv_path - self.metadata = metadata - self.slip_threshold = slip_threshold - self.step_idx = 0 - self.reset_z: float | None = None - - self.csv_path.parent.mkdir(parents=True, exist_ok=True) - self.csv_path.unlink(missing_ok=True) - self._needs_header = True - - def _box_z(self) -> float: - sim = self.env.get_wrapper_attr("sim") - for joint_name in _BOX_JOINT_NAMES: - joint_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_JOINT, joint_name) - if joint_id >= 0: - return float(np.asarray(sim.data.joint(joint_name).qpos)[2]) - - for body_name in _BOX_BODY_NAMES: - body_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_BODY, body_name) - if body_id >= 0: - return float(sim.data.xpos[body_id, 2]) - - msg = f"Could not find box joint/body using names {_BOX_JOINT_NAMES} / {_BOX_BODY_NAMES}." - raise ValueError(msg) - - def _box_geom_friction(self) -> tuple[float, float, float]: - sim = self.env.get_wrapper_attr("sim") - for geom_name in ("_box_geom", "box_geom"): - geom_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) - if geom_id >= 0: - friction = sim.model.geom_friction[geom_id] - return float(friction[0]), float(friction[1]), float(friction[2]) - - msg = "Could not find box geom using names ('_box_geom', 'box_geom')." - raise ValueError(msg) - - def _append_row( - self, - *, - phase: str, - step: int, - commanded_gripper_width: float | None, - reward: float | None = None, - terminated: bool = False, - truncated: bool = False, - ) -> None: - box_z = self._box_z() - loaded_friction = self._box_geom_friction() - if self.reset_z is None: - self.reset_z = box_z - z_drop = self.reset_z - box_z - row = { - **self.metadata, - "phase": phase, - "step": step, - "time_s": max(step, 0) / _CONTROL_FREQUENCY_HZ, - "loaded_friction_slide": loaded_friction[0], - "loaded_friction_spin": loaded_friction[1], - "loaded_friction_roll": loaded_friction[2], - "commanded_gripper_width": commanded_gripper_width, - "box_z": box_z, - "z_drop_from_reset": z_drop, - "slipped": z_drop >= self.slip_threshold, - "terminated": terminated, - "truncated": truncated, - "reward": reward, - } - with self.csv_path.open("a", newline="") as f: - writer = csv.DictWriter(f, fieldnames=self.FIELDNAMES) - if self._needs_header: - writer.writeheader() - self._needs_header = False - writer.writerow(row) - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - obs, info = self.env.reset(seed=seed, options=options) - self.step_idx = 0 - self.reset_z = None - self._append_row(phase="reset", step=-1, commanded_gripper_width=None) - return obs, info - - def step(self, action: Any): - obs, reward, terminated, truncated, info = self.env.step(action) - self._append_row( - phase="step", - step=self.step_idx, - commanded_gripper_width=_extract_gripper_width(action), - reward=float(reward), - terminated=bool(terminated), - truncated=bool(truncated), - ) - self.step_idx += 1 - return obs, reward, terminated, truncated, info - - -class StartGraspedWrapper(gym.Wrapper): - """Close the gripper after reset so the episode starts with the object held.""" - - def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10): - super().__init__(env) - self.settle_steps = settle_steps - self.post_gravity_settle_steps = post_gravity_settle_steps - - def _closed_gripper_hold_action(self) -> dict[str, Any]: - return _zero_closed_action(self.env.action_space) - - def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: - cfg = gripper.get_config() - actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) - if actuator_id < 0: - msg = f"Could not find gripper actuator {cfg.actuator!r}." - raise ValueError(msg) - ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width - ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] - sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - sim = self.env.get_wrapper_attr("sim") - gravity = np.array(sim.model.opt.gravity, copy=True) - - sim.model.opt.gravity[:] = 0 - obs, info = self.env.reset(seed=seed, options=options) - - robot = self.env.get_wrapper_attr("robot") - gripper = self.env.get_wrapper_attr("gripper") - if isinstance(robot, dict): - robot = robot[_ROBOT_NAME] - if isinstance(gripper, dict): - gripper = gripper[_ROBOT_NAME] - hold_joints = robot.get_joint_position().copy() - - try: - for step_idx in range(self.settle_steps): - width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) - self._command_gripper_width(sim, gripper, width) - robot.set_joint_position(hold_joints) - sim.step(1) - finally: - sim.model.opt.gravity[:] = gravity - - gripper.grasp() - for _ in range(self.post_gravity_settle_steps): - robot.set_joint_position(hold_joints) - gripper.grasp() - sim.step(1) - - sim.sync_gui() - return obs, info - - -def make_franka_sim_env_without_taxim( - *, - box_xml_path: Path, - render_mode: str, - start_grasped: bool, - grasp_settle_steps: int, - post_gravity_settle_steps: int, -) -> gym.Env: - rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) - - scene = EmptyWorldFR3() - cfg = scene.config() - cfg.control_mode = ControlMode.JOINTS - cfg.headless = render_mode != "human" - cfg.sim_cfg.realtime = render_mode == "human" - cfg.sim_cfg.async_control = render_mode == "human" - cfg.sim_cfg.frequency = int(_CONTROL_FREQUENCY_HZ) - cfg.wrapper_cfg.binary_gripper = False - cfg.wrapper_cfg.home_on_reset = True - cfg.max_relative_movement = np.deg2rad(5) - cfg.relative_to = RelativeTo.LAST_STEP - cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} - cfg.gripper_offsets = None - cfg.root_frame_objects = { - "": ( - str(box_xml_path), - Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), - ) - } - cfg.robot_cfgs[_ROBOT_NAME].tcp_offset = rcs.GRIPPER_OFFSETS[rcs.common.GripperType("Robotiq2F85")] - q_home = cfg.robot_cfgs[_ROBOT_NAME].q_home.copy() - q_home[-1] = -1.571 - cfg.robot_cfgs[_ROBOT_NAME].q_home = q_home - cfg.camera_cfgs = None - cfg.camera_adds = None - - env = scene.create_env(cfg) - _make_gripper_pad_friction_neutral(env) - if start_grasped: - env = StartGraspedWrapper( - env, - settle_steps=grasp_settle_steps, - post_gravity_settle_steps=post_gravity_settle_steps, - ) - if render_mode == "human": - env.get_wrapper_attr("sim").open_gui() - return env - - -def make_ablation_env( - *, - box_xml_path: Path, - args: argparse.Namespace, - metadata: dict[str, Any], - csv_path: Path, -) -> gym.Env: - env = make_franka_sim_env_without_taxim( - box_xml_path=box_xml_path, - render_mode="human" if args.gui else "rgb_array", - start_grasped=True, - grasp_settle_steps=args.grasp_settle_steps, - post_gravity_settle_steps=args.post_gravity_settle_steps, - ) - return BoxZRecorderWrapper( - env, - csv_path=csv_path, - metadata=metadata, - slip_threshold=args.slip_threshold, - ) - - -def _make_ablation_jobs(args: argparse.Namespace) -> list[tuple[int, tuple[float, float, float], float]]: - friction_grid = itertools.product( - args.friction_slide_values, - args.friction_spin_values, - args.friction_roll_values, - ) - jobs = [] - for run_idx, (friction_values, density) in enumerate(itertools.product(friction_grid, args.density_values)): - friction = tuple(float(value) for value in friction_values) - jobs.append((run_idx, friction, float(density))) - return jobs - - -def _num_parallel_envs(args: argparse.Namespace, job_count: int) -> int: - if job_count == 0 or args.gui: - return 1 - if args.num_envs <= 0: - return min(job_count, os.cpu_count() or 1) - return min(job_count, args.num_envs) - - -def _run_ablation_job( - run_idx: int, - friction: tuple[float, float, float], - density: float, - args: argparse.Namespace, - output_dir: Path, - source_xml: Path, - gripper_widths: list[float], -) -> Path: - run_id = f"run_{run_idx:04d}" - seed = args.seed + run_idx - box_xml_path = _write_box_xml( - source_xml=source_xml, - friction=friction, - density=density, - ) - csv_path = _box_z_csv_path( - output_dir=output_dir, - friction=friction, - density=density, - seed=seed, - ) - metadata = { - "run_id": run_id, - "seed": seed, - "friction_slide": friction[0], - "friction_spin": friction[1], - "friction_roll": friction[2], - "density": density, - } - - env = make_ablation_env( - box_xml_path=box_xml_path, - args=args, - metadata=metadata, - csv_path=csv_path, - ) - try: - env.reset(seed=seed) - done = False - for gripper_width in gripper_widths: - action = _make_gripper_width_action(env.action_space, gripper_width) - for _ in range(args.steps): - _, _, terminated, truncated, _ = env.step(action) - if args.stop_on_done and (terminated or truncated): - done = True - break - if done: - break - finally: - env.close() - - return csv_path - - -def _print_job_start(run_idx: int, friction: tuple[float, float, float], density: float, csv_path: Path) -> None: - print( - f"run_{run_idx:04d}: friction={_format_friction(friction)} " - f"density={_format_float(density)} csv={csv_path}" - ) - - -def run_ablation(args: argparse.Namespace) -> None: - output_dir = args.output_dir.expanduser().resolve() - source_xml = Path(_BOX_XML) - gripper_widths = _gripper_opening_schedule() - jobs = _make_ablation_jobs(args) - num_envs = _num_parallel_envs(args, len(jobs)) - - print(f"Running {len(jobs)} ablation rollouts with {num_envs} parallel environment(s).") - print(f"Gripper schedule: {_format_width_schedule(gripper_widths)}") - if args.gui and args.num_envs not in (0, 1): - print("--gui uses one environment even when --num-envs requests more.") - - if num_envs == 1: - for run_idx, friction, density in jobs: - csv_path = _box_z_csv_path( - output_dir=output_dir, - friction=friction, - density=density, - seed=args.seed + run_idx, - ) - _print_job_start(run_idx, friction, density, csv_path) - _run_ablation_job(run_idx, friction, density, args, output_dir, source_xml, gripper_widths) - else: - with concurrent.futures.ProcessPoolExecutor(max_workers=num_envs) as executor: - future_to_job = {} - for run_idx, friction, density in jobs: - csv_path = _box_z_csv_path( - output_dir=output_dir, - friction=friction, - density=density, - seed=args.seed + run_idx, - ) - _print_job_start(run_idx, friction, density, csv_path) - future = executor.submit( - _run_ablation_job, - run_idx, - friction, - density, - args, - output_dir, - source_xml, - gripper_widths, - ) - future_to_job[future] = (run_idx, csv_path) - - for future in concurrent.futures.as_completed(future_to_job): - run_idx, csv_path = future_to_job[future] - future.result() - print(f"run_{run_idx:04d}: wrote {csv_path}") - - print(f"Wrote {len(jobs)} ablation rollouts to {output_dir}") - - -def main() -> None: - parser = argparse.ArgumentParser(description="Ablate box friction/density and record z slippage.") - parser.add_argument("--seed", type=int, default=0) - parser.add_argument("--output-dir", type=Path, default=Path("ablation_runs")) - parser.add_argument("--steps", type=int, default=30, help="Settling steps to run after each gripper width command.") - parser.add_argument("--num-envs", type=int, default=0, help="Parallel environments to run. Use 0 for all CPU cores.") - parser.add_argument("--slip-threshold", type=float, default=0.01, help="Meters of z-drop counted as slipped.") - parser.add_argument("--stop-on-done", action="store_true") - parser.add_argument("--gui", action="store_true") - parser.add_argument("--grasp-settle-steps", type=int, default=30) - parser.add_argument("--post-gravity-settle-steps", type=int, default=10) - - parser.add_argument("--friction-slide-values", type=_float_list, default=[0,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1])#, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]) - parser.add_argument("--friction-spin-values", type=_float_list, default=[0.3]) - parser.add_argument("--friction-roll-values", type=_float_list, default=[0.1]) - parser.add_argument("--density-values", type=_float_list, default=[50.0]) - - args = parser.parse_args() - run_ablation(args) - - -if __name__ == "__main__": - main() diff --git a/extensions/rcs_sb3/run_test.py b/extensions/rcs_sb3/run_test.py deleted file mode 100644 index be31cffb..00000000 --- a/extensions/rcs_sb3/run_test.py +++ /dev/null @@ -1,468 +0,0 @@ -"""Smoke-test the RCS SB3 policy wrapper on a simulated FR3 + Taxim stack. - -This uses a tiny PPO model to verify the runtime pipeline: - - RCS + Taxim observations -> policy wrapper -> generated action dict -> robot wrappers -""" - -from __future__ import annotations - -import argparse -from pathlib import Path -from typing import Any - -import gymnasium as gym -import mujoco -import numpy as np -from gymnasium.spaces import Dict as DictSpace -from rcs._core.common import GripperType, Pose -from rcs._core.sim import SimGripperConfig -from rcs.envs.base import ControlMode, RelativeTo -from rcs.envs.configs import EmptyWorldFR3 -from rcs_sb3 import StableBaselines3PolicyWrapper, StableBaselines3Wrapper -from rcs_taxim.taxim_wrapper import TaximSimWrapper -from stable_baselines3 import PPO -from stable_baselines3.common.vec_env import SubprocVecEnv -import os - -import rcs - -_TAXIM_GRIPPER_TYPE_ID = "Robotiq2F85Digit" -_TAXIM_GRIPPER_XML = Path("/workspaces/robot-control-stack/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") -_BOX_XML = "/workspaces/robot-control-stack/norm2tex/grasp_assets/box/box.xml" -_NORM2TEX_DIR = Path("/workspaces/robot-control-stack/norm2tex") -_ROBOT_NAME = "robot" -_CUBE_GEOM = "_box_geom" -_CUBE_MESH = "_box_mesh" - - -def _taxim_gripper_type() -> GripperType: - return GripperType(_TAXIM_GRIPPER_TYPE_ID) - - -def _zero_closed_action(space: gym.Space) -> dict[str, Any]: - action = space.sample() - - def visit(value: Any) -> None: - if isinstance(value, dict): - if "gripper" in value: - value["gripper"] = np.array([0.0], dtype=np.float32) - for child in value.values(): - visit(child) - elif isinstance(value, np.ndarray): - value[...] = 0 - - visit(action) - return action - - -def _taxim_gripper_cfg() -> SimGripperConfig: - return SimGripperConfig( - epsilon_inner=0.005, - epsilon_outer=0.005, - seconds_between_callbacks=0.1, - ignored_collision_geoms=[], - collision_geoms=[], - collision_geoms_fingers=[], - joints=["right_driver_joint", "left_driver_joint"], - max_joint_width=0.005, - min_joint_width=1.0, - actuator="fingers_actuator", - max_actuator_width=0, - min_actuator_width=255, - gripper_type=_taxim_gripper_type(), - ) - - -class DummySB3Model(PPO): - """PPO subclass used as the starting point for real SB3 training logic.""" - - def __init__(self, *args: Any, **kwargs: Any): - super().__init__(*args, **kwargs) - - -def make_zero_sb3_model(env: gym.Env, args: argparse.Namespace) -> DummySB3Model: - return DummySB3Model( - "MultiInputPolicy", - env, - n_steps=args.n_steps, - batch_size=args.batch_size, - seed=args.seed, - verbose=1, - ) - - -class StartGraspedWrapper(gym.Wrapper): - """Close the gripper after reset so the episode starts with the object held.""" - - def __init__(self, env: gym.Env, settle_steps: int = 30, post_gravity_settle_steps: int = 10, drop_z_threshold: float = 0.1, hold_bonus: float = 1.0, max_steps: int = 100): - super().__init__(env) - self.settle_steps = settle_steps - self.post_gravity_settle_steps = post_gravity_settle_steps - self.drop_z_threshold = drop_z_threshold - self.hold_bonus = hold_bonus - self._step_count = 0 - self._start_obj_z: float | None = None - self.max_step_count = max_steps - - def _closed_gripper_hold_action(self) -> dict[str, Any]: - return _zero_closed_action(self.env.action_space) - - def _command_gripper_width(self, sim: Any, gripper: Any, width: float) -> None: - cfg = gripper.get_config() - actuator_id = mujoco.mj_name2id(sim.model, mujoco.mjtObj.mjOBJ_ACTUATOR, cfg.actuator) - if actuator_id < 0: - msg = f"Could not find gripper actuator {cfg.actuator!r}." - raise ValueError(msg) - ctrl = width * (cfg.max_actuator_width - cfg.min_actuator_width) + cfg.min_actuator_width - ctrl_low, ctrl_high = sim.model.actuator_ctrlrange[actuator_id] - sim.data.ctrl[actuator_id] = np.clip(ctrl, ctrl_low, ctrl_high) - - def _object_z(self) -> float: - return float(np.asarray(self.sim.data.joint("_box_joint").qpos).reshape(-1)[2]) - - def step(self, action: dict[str, Any]) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]: - obs, _, terminated, truncated, info = self.env.step(action) - obj_z = self._object_z() - self._step_count += 1 - gripper_width = info["robot"]["gripper_width"] - dropped = self._start_obj_z is not None and obj_z < self._start_obj_z - self.drop_z_threshold - - if dropped: - reward = 0.0 - terminated = True - else: - reward = (self.hold_bonus + (1 - gripper_width)) / 2 - truncated = truncated or self._step_count >= self.max_step_count - - info["rl_result"] = { - "reward": reward, - "terminated": terminated, - "truncated": truncated, - "gripper_width": gripper_width, - "dropped": dropped, - } - return obs, reward, terminated, truncated, info - - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[dict[str, Any], dict[str, Any]]: - sim = self.env.get_wrapper_attr("sim") - gravity = np.array(sim.model.opt.gravity, copy=True) - - # CoverWrapper steps the simulation during reset. Disable gravity before - # the wrapped reset so the cube does not fall before we can close. - sim.model.opt.gravity[:] = 0 - obs, info = self.env.reset(seed=seed, options=options) - self._step_count = 0 - - robot = self.env.get_wrapper_attr("robot") - gripper = self.env.get_wrapper_attr("gripper") - if isinstance(robot, dict): - robot = robot["robot"] - if isinstance(gripper, dict): - gripper = gripper["robot"] - hold_joints = robot.get_joint_position().copy() - - try: - for step_idx in range(self.settle_steps): - width = 1.0 - (step_idx + 1) / max(self.settle_steps, 1) - self._command_gripper_width(sim, gripper, width) - robot.set_joint_position(hold_joints) - sim.step(1) - finally: - sim.model.opt.gravity[:] = gravity - - gripper.grasp() - for _ in range(self.post_gravity_settle_steps): - robot.set_joint_position(hold_joints) - gripper.grasp() - sim.step(1) - - self._start_obj_z = self._object_z() - - obs, _, terminated, truncated, info = self.env.step(self._closed_gripper_hold_action()) - if terminated or truncated: - obs, info = self.env.reset(seed=seed, options=options) - sim.sync_gui() - return obs, info - -def _make_obj_xml_from_mesh_path(mesh_path: Path) -> str: - material_type = mesh_path.name.split('/')[-1].split('_')[1].lower() - # TODO: Depending on material type, different friction and mass - - mesh_name = mesh_path.name.split('/')[-1] - xml_path = mesh_path.parent.parent / f"{mesh_name.split('.')[0]}.xml" - source_xml_path = mesh_path.parent.parent / "box.xml" - - # Open xml, replace box.obj with mesh name, and write to new xml path - with open(source_xml_path, 'r') as f: - xml_content = f.read() - xml_content = xml_content.replace("box.obj", mesh_name) - if xml_path.exists(): - os.remove(xml_path) - with open(xml_path, 'w') as f: - f.write(xml_content) - return str(xml_path) - -def _get_normal_map_path_from_mesh_path(mesh_path: Path) -> Path: - # assert that the normal map exists - normal_name = mesh_path.stem.split('.')[0][:-3] + "_normal.png" - normal_path = mesh_path.parent / normal_name - assert normal_path.exists(), f"Normal map {normal_path} does not exist." - print(f"Normal map {normal_path} exists. Preparing Taxim texture...") - return normal_path - -def _select_random_texture(): - # Randomly select a box material from the json files - json_dir = Path(__file__).parent - json_files = ["fabric_textures.json",] - with open(json_dir / np.random.choice(json_files), 'r') as f: - import json - texture_dict = json.load(f) - return Path(os.path.join(_NORM2TEX_DIR, np.random.choice(texture_dict)['path'])) - -def make_franka_taxim_sim_env( - *, - render_mode: str, - visualize_taxim: bool, - enable_depth: bool, - start_grasped: bool, - grasp_settle_steps: int, - post_gravity_settle_steps: int, - uv_obj_path: Path | None = None, -) -> gym.Env: - rcs.GRIPPER_PATHS[_taxim_gripper_type()] = str(_TAXIM_GRIPPER_XML) - - scene = EmptyWorldFR3() - cfg = scene.config() - cfg.control_mode = ControlMode.JOINTS - cfg.headless = render_mode != "human" - cfg.sim_cfg.realtime = render_mode == "human" - cfg.sim_cfg.async_control = render_mode == "human" - cfg.sim_cfg.frequency = 30 - cfg.wrapper_cfg.binary_gripper = True - cfg.wrapper_cfg.home_on_reset = True - cfg.max_relative_movement = np.deg2rad(5) - cfg.relative_to = RelativeTo.LAST_STEP - cfg.gripper_cfgs = {_ROBOT_NAME: _taxim_gripper_cfg()} - cfg.gripper_offsets = None - - - # Prepare the box XML and normal map as input if argument is given - box_xml_path = _BOX_XML - target_normal_map_dict = None - if uv_obj_path is not None: - box_xml_path = _make_obj_xml_from_mesh_path(uv_obj_path) - box_normal_map_path = _get_normal_map_path_from_mesh_path(uv_obj_path) - target_normal_map_dict = {_CUBE_GEOM: str(box_normal_map_path)} - - cfg.root_frame_objects = { - "": ( - # rcs.OBJECT_PATHS["green_cube"], - box_xml_path, - Pose(translation=np.array([0.31, 0.0, 0.425]), quaternion=np.array([0.0, 0.0, 0.0, 1.0])), - ) - } - cfg.robot_cfgs[_ROBOT_NAME].tcp_offset = rcs.GRIPPER_OFFSETS[rcs.common.GripperType("Robotiq2F85")] - q_home = cfg.robot_cfgs[_ROBOT_NAME].q_home.copy() - q_home[-1] = -1.571 - cfg.robot_cfgs[_ROBOT_NAME].q_home = q_home - cfg.camera_cfgs = None - cfg.camera_adds = None - - env = scene.create_env(cfg) - env = TaximSimWrapper( - env, - taxim_sites=["gripperleft_digit_pad", "gripperright_digit_pad"], - taxim_pad_geoms=["gripperleft_digit_pad", "gripperright_digit_pad"], - target_geom_mesh_dict={_CUBE_GEOM: _CUBE_MESH}, - target_geom_normal_map_dict=target_normal_map_dict, - taxim_sensor_type="digit", - taxim_fps=60, - enable_depth=enable_depth, - visualize=visualize_taxim, - ) - if start_grasped: - env = StartGraspedWrapper( - env, - settle_steps=grasp_settle_steps, - post_gravity_settle_steps=post_gravity_settle_steps, - ) - if render_mode == "human": - env.get_wrapper_attr("sim").open_gui() - return env - - -def make_inference_env(args: argparse.Namespace) -> gym.Env: - - raw_env = make_franka_taxim_sim_env( - render_mode="human" if args.gui else "rgb_array", - visualize_taxim=args.visualize_taxim, - enable_depth=args.enable_taxim_depth, - start_grasped=not args.no_start_grasped, - grasp_settle_steps=args.grasp_settle_steps, - post_gravity_settle_steps=args.post_gravity_settle_steps, - uv_obj_path=_select_random_texture() if args.with_texture else None, - ) - env = StableBaselines3Wrapper( - raw_env, - flatten_actions=False, - flatten_observations=False, - ) - zero_model = make_zero_sb3_model(env, args) - return StableBaselines3PolicyWrapper( - env, - zero_model, - deterministic=False, - flatten_actions=False, - flatten_observations=False, - ) - - -def run_inference_smoke(args: argparse.Namespace) -> None: - env = make_inference_env(args) - obs, info = env.reset(seed=args.seed) - print(f"reset: obs_keys={list(obs.keys())}, info_keys={list(info.keys())}") - - for step_idx in range(args.infer_steps): - obs, reward, terminated, truncated, info = env.step() - action = info.get(StableBaselines3PolicyWrapper.ACTION_INFO_KEY) - action_keys = list(action.keys()) if isinstance(action, dict) else type(action).__name__ - frame_keys = list(obs.get("frames", {}).keys()) if isinstance(obs, dict) else [] - print( - f"step={step_idx:03d} reward={reward:.3f} " - f"terminated={terminated} truncated={truncated} " - f"action_keys={action_keys} frame_keys={frame_keys}" - ) - if terminated or truncated: - obs, info = env.reset() - print(f"reset: obs_keys={list(obs.keys())}, info_keys={list(info.keys())}") - - env.close() - - -def make_train_env( - rank: int, - seed: int, - start_grasped: bool, - grasp_settle_steps: int, - post_gravity_settle_steps: int, - with_texture: bool = False -): - def _init(): - env = make_franka_taxim_sim_env( - render_mode="rgb_array", - visualize_taxim=False, - enable_depth=False, - start_grasped=start_grasped, - grasp_settle_steps=grasp_settle_steps, - post_gravity_settle_steps=post_gravity_settle_steps, - uv_obj_path=_select_random_texture() if with_texture else None - ) - env.reset(seed=seed + rank) - return env - - return _init - - -def make_sb3_train_env( - rank: int, - seed: int, - start_grasped: bool, - grasp_settle_steps: int, - post_gravity_settle_steps: int, - with_texture: bool = False -): - raw_env_fn = make_train_env( - rank, - seed, - start_grasped, - grasp_settle_steps, - post_gravity_settle_steps, - with_texture=with_texture - ) - - def _init(): - return StableBaselines3Wrapper( - raw_env_fn(), - flatten_actions=False, - flatten_observations=False, - ) - - return _init - - -def run_training_smoke(args: argparse.Namespace) -> None: - if args.num_envs < 0: - msg = "--num-envs must be >= 0. Use 0 for single-process breakpoint debugging." - raise ValueError(msg) - - if args.num_envs == 0: - train_env = make_sb3_train_env( - 0, - args.seed, - not args.no_start_grasped, - args.grasp_settle_steps, - args.post_gravity_settle_steps, - with_texture=args.with_texture - )() - else: - train_env = SubprocVecEnv( - [ - make_sb3_train_env( - rank, - args.seed, - not args.no_start_grasped, - args.grasp_settle_steps, - args.post_gravity_settle_steps, - with_texture=args.with_texture - ) - for rank in range(args.num_envs) - ], - start_method="spawn", - ) - try: - if isinstance(train_env.action_space, DictSpace): - msg = ( - "Raw RCS envs expose Dict action spaces, but SB3 PPO does not support Dict actions. " - "Expected make_sb3_train_env to adapt actions before constructing PPO." - ) - raise TypeError(msg) - model = make_zero_sb3_model(train_env, args) - model.learn(total_timesteps=args.total_timesteps) - finally: - train_env.close() - - -def main() -> None: - parser = argparse.ArgumentParser(description="Smoke-test RCS + Taxim with SB3.") - parser.add_argument("--mode", choices=("infer", "train"), default="infer") - parser.add_argument("--seed", type=int, default=0) - parser.add_argument("--enable-taxim-depth", action="store_true") - parser.add_argument("--no-start-grasped", action="store_true", help="Do not close the gripper after reset.") - parser.add_argument("--grasp-settle-steps", type=int, default=30) - parser.add_argument("--post-gravity-settle-steps", type=int, default=10) - parser.add_argument("--with-texture", action="store_true", help="Use a random texture for the box object.") - - # Inference mode args - parser.add_argument("--infer-steps", type=int, default=20, help="Inference smoke-test steps.") - parser.add_argument("--gui", action="store_true", help="Open the MuJoCo GUI for inference mode.") - parser.add_argument("--visualize-taxim", action="store_true", help="Show nonblocking Taxim tactile windows.") - - # Training mode args - parser.add_argument("--num-envs", type=int, default=2, help="Parallel env count for train mode. Use 0 to disable subprocess vectorization for debugging.",) - parser.add_argument("--total-timesteps", type=int, default=32) - parser.add_argument("--n-steps", type=int, default=8) - parser.add_argument("--batch-size", type=int, default=16) - args = parser.parse_args() - - if args.mode == "infer": - run_inference_smoke(args) - else: - run_training_smoke(args) - - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/extensions/rcs_sb3/src/rcs_sb3/__init__.py b/extensions/rcs_sb3/src/rcs_sb3/__init__.py deleted file mode 100644 index b3211d6b..00000000 --- a/extensions/rcs_sb3/src/rcs_sb3/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -from rcs_sb3.interface import AlgorithmInterface -from rcs_sb3.ppo import SB3PPO, SB3PPOConfig -from rcs_sb3.sb3 import SB3AlgorithmConfig, StableBaselines3Algorithm -from rcs_sb3.wrappers import FlattenActionWrapper, StableBaselines3PolicyWrapper, StableBaselines3Wrapper - -__all__ = [ - "AlgorithmInterface", - "FlattenActionWrapper", - "SB3AlgorithmConfig", - "SB3PPO", - "SB3PPOConfig", - "StableBaselines3Wrapper", - "StableBaselines3PolicyWrapper", - "StableBaselines3Algorithm", -] diff --git a/extensions/rcs_sb3/src/rcs_sb3/interface.py b/extensions/rcs_sb3/src/rcs_sb3/interface.py deleted file mode 100644 index d9f1b62d..00000000 --- a/extensions/rcs_sb3/src/rcs_sb3/interface.py +++ /dev/null @@ -1,50 +0,0 @@ -from __future__ import annotations - -from abc import ABC, abstractmethod -from pathlib import Path -from typing import Any - -import gymnasium as gym - - -class AlgorithmInterface(ABC): - """Framework-neutral interface for trainable RL algorithms.""" - - @abstractmethod - def as_wrapper(self, env: gym.Env) -> gym.Wrapper: - """Return an RCS wrapper that injects policy actions into the stack.""" - - @abstractmethod - def make_training_env(self, env: gym.Env) -> gym.Env: - """Return the environment prepared for training in the underlying RL framework.""" - - @abstractmethod - def build(self, env: gym.Env) -> Any: - """Create and store a model for the wrapped environment.""" - - @abstractmethod - def action(self, observation: Any, deterministic: bool | None = None) -> Any: - """Generate one environment action from an observation.""" - - @abstractmethod - def learn(self, total_timesteps: int | None = None, **kwargs: Any) -> Any: - """Train the model.""" - - @abstractmethod - def predict( - self, - observation: Any, - state: Any = None, - episode_start: Any = None, - deterministic: bool = False, - ) -> tuple[Any, Any]: - """Predict the next action from an observation.""" - - @abstractmethod - def save(self, path: str | Path) -> None: - """Save the current model.""" - - @classmethod - @abstractmethod - def load(cls, path: str | Path, env: gym.Env | None = None, **kwargs: Any) -> "AlgorithmInterface": - """Load a model into an algorithm implementation.""" diff --git a/extensions/rcs_sb3/src/rcs_sb3/ppo.py b/extensions/rcs_sb3/src/rcs_sb3/ppo.py deleted file mode 100644 index 4e605db9..00000000 --- a/extensions/rcs_sb3/src/rcs_sb3/ppo.py +++ /dev/null @@ -1,19 +0,0 @@ -from __future__ import annotations - -from dataclasses import dataclass - -from stable_baselines3 import PPO - -from rcs_sb3.sb3 import SB3AlgorithmConfig, StableBaselines3Algorithm - - -@dataclass -class SB3PPOConfig(SB3AlgorithmConfig): - """Configuration for Stable-Baselines3 PPO.""" - - -class SB3PPO(StableBaselines3Algorithm): - """PPO implementation behind the framework-neutral algorithm interface.""" - - algorithm_cls = PPO - config_cls = SB3PPOConfig diff --git a/extensions/rcs_sb3/src/rcs_sb3/sb3.py b/extensions/rcs_sb3/src/rcs_sb3/sb3.py deleted file mode 100644 index d63eb47f..00000000 --- a/extensions/rcs_sb3/src/rcs_sb3/sb3.py +++ /dev/null @@ -1,121 +0,0 @@ -from __future__ import annotations - -from dataclasses import dataclass, field -from pathlib import Path -from typing import Any, ClassVar, Type - -import gymnasium as gym -from stable_baselines3.common.base_class import BaseAlgorithm - -from rcs_sb3.interface import AlgorithmInterface -from rcs_sb3.wrappers import StableBaselines3PolicyWrapper, StableBaselines3Wrapper - - -@dataclass -class SB3AlgorithmConfig: - """Configuration shared by Stable-Baselines3 algorithms.""" - - policy: str = "MlpPolicy" - total_timesteps: int = 100_000 - flatten_actions: bool = True - flatten_observations: bool = True - deterministic_actions: bool = True - preserve_external_actions: bool = True - model_kwargs: dict[str, Any] = field(default_factory=dict) - learn_kwargs: dict[str, Any] = field(default_factory=dict) - - -class StableBaselines3Algorithm(AlgorithmInterface): - """Base class for Stable-Baselines3-backed algorithms.""" - - algorithm_cls: ClassVar[Type[BaseAlgorithm]] - config_cls: ClassVar[type[SB3AlgorithmConfig]] = SB3AlgorithmConfig - - def __init__(self, config: SB3AlgorithmConfig | None = None, model: BaseAlgorithm | None = None): - self.config = config if config is not None else self.config_cls() - self.model = model - self.env: gym.Env | None = None - - def as_wrapper(self, env: gym.Env) -> gym.Wrapper: - if self.model is None: - msg = "Call build(env) or load(path, env=env) before creating the RCS policy wrapper." - raise RuntimeError(msg) - return StableBaselines3PolicyWrapper( - env, - self.model, - deterministic=self.config.deterministic_actions, - flatten_actions=self.config.flatten_actions, - flatten_observations=self.config.flatten_observations, - preserve_external_actions=self.config.preserve_external_actions, - ) - - def make_training_env(self, env: gym.Env) -> gym.Env: - return StableBaselines3Wrapper( - env, - flatten_actions=self.config.flatten_actions, - flatten_observations=self.config.flatten_observations, - ) - - def wrap_env(self, env: gym.Env) -> gym.Env: - """Backward-compatible alias for ``make_training_env``.""" - return self.make_training_env(env) - - def build(self, env: gym.Env) -> BaseAlgorithm: - self.env = self.make_training_env(env) - self.model = self.algorithm_cls(self.config.policy, self.env, **self.config.model_kwargs) - return self.model - - def action(self, observation: Any, deterministic: bool | None = None) -> Any: - if self.model is None: - msg = "Call build(env) or load(path, env=env) before action()." - raise RuntimeError(msg) - action, _ = self.predict( - observation, - deterministic=self.config.deterministic_actions if deterministic is None else deterministic, - ) - return action - - def learn(self, total_timesteps: int | None = None, **kwargs: Any) -> BaseAlgorithm: - if self.model is None: - msg = "Call build(env) or load(path, env=env) before learn()." - raise RuntimeError(msg) - learn_kwargs = {**self.config.learn_kwargs, **kwargs} - return self.model.learn(total_timesteps=total_timesteps or self.config.total_timesteps, **learn_kwargs) - - def predict( - self, - observation: Any, - state: Any = None, - episode_start: Any = None, - deterministic: bool = False, - ) -> tuple[Any, Any]: - if self.model is None: - msg = "Call build(env) or load(path, env=env) before predict()." - raise RuntimeError(msg) - return self.model.predict( - observation, - state=state, - episode_start=episode_start, - deterministic=deterministic, - ) - - def save(self, path: str | Path) -> None: - if self.model is None: - msg = "Call build(env) or load(path, env=env) before save()." - raise RuntimeError(msg) - self.model.save(path) - - @classmethod - def load(cls, path: str | Path, env: gym.Env | None = None, **kwargs: Any) -> "StableBaselines3Algorithm": - config = kwargs.pop("config", None) or cls.config_cls() - wrapped_env = None - if env is not None: - wrapped_env = StableBaselines3Wrapper( - env, - flatten_actions=config.flatten_actions, - flatten_observations=config.flatten_observations, - ) - model = cls.algorithm_cls.load(path, env=wrapped_env, **kwargs) - instance = cls(config=config, model=model) - instance.env = wrapped_env - return instance diff --git a/extensions/rcs_sb3/src/rcs_sb3/wrappers.py b/extensions/rcs_sb3/src/rcs_sb3/wrappers.py deleted file mode 100644 index 5a6082aa..00000000 --- a/extensions/rcs_sb3/src/rcs_sb3/wrappers.py +++ /dev/null @@ -1,234 +0,0 @@ -from __future__ import annotations - -import copy -from typing import Any - -import gymnasium as gym -import numpy as np -from gymnasium.spaces import Box, Dict as DictSpace -from gymnasium.spaces import utils as space_utils - - -class FlattenActionWrapper(gym.ActionWrapper): - """Expose a flat Box action space while forwarding unflattened actions to RCS.""" - - def __init__(self, env: gym.Env): - super().__init__(env) - if not isinstance(env.action_space, DictSpace): - msg = "FlattenActionWrapper expects a gymnasium.spaces.Dict action space." - raise TypeError(msg) - - flat_space = space_utils.flatten_space(env.action_space) - if not isinstance(flat_space, Box): - msg = "Stable-Baselines3 requires flattenable continuous RCS actions." - raise TypeError(msg) - self.action_space = Box( - low=np.asarray(flat_space.low, dtype=np.float32), - high=np.asarray(flat_space.high, dtype=np.float32), - dtype=np.float32, - ) - - def action(self, action: np.ndarray) -> dict[str, Any]: - return space_utils.unflatten(self.env.action_space, np.asarray(action, dtype=self.action_space.dtype)) - -class TaximSB3ObservationWrapper(gym.ObservationWrapper): - def __init__( - self, - env: gym.Env, - *, - left_frame_key: str = "tactile_gripperleft_digit_pad", - right_frame_key: str = "tactile_gripperright_digit_pad", - ): - super().__init__(env) - self.left_frame_key = left_frame_key - self.right_frame_key = right_frame_key - - left_space = env.observation_space["frames"][left_frame_key]["rgb"]["data"] - h, w, c = left_space.shape - - gripper_space = env.observation_space["robot"]["gripper"] - - state_space = copy.deepcopy(env.observation_space) - del state_space.spaces["frames"] - - self._state_space = state_space - flat_state_space = space_utils.flatten_space(state_space) - - self.observation_space = gym.spaces.Dict( - { - "left_rgb": gym.spaces.Box(0, 255, shape=(c, h, w), dtype=np.uint8), - "right_rgb": gym.spaces.Box(0, 255, shape=(c, h, w), dtype=np.uint8), - "state": gripper_space - } - ) - - def observation(self, obs): - left_rgb = obs["frames"][self.left_frame_key]["rgb"]["data"] - right_rgb = obs["frames"][self.right_frame_key]["rgb"]["data"] - gripper_state = obs['robot']['gripper'] - state_obs = copy.deepcopy(obs) - del state_obs["frames"] - - return { - "left_rgb": np.transpose(left_rgb, (2, 0, 1)), - "right_rgb": np.transpose(right_rgb, (2, 0, 1)), - "state": gripper_state, - } - -class GripperOnlyActionWrapper(gym.ActionWrapper): - def __init__( - self, - env: gym.Env, - *, - robot_key: str = "robot", - gripper_key: str = "gripper", - joints_key: str = "joints", - ): - super().__init__(env) - self.robot_key = robot_key - self.gripper_key = gripper_key - self.joints_key = joints_key - - robot_action_space = env.action_space[robot_key] - self._robot_action_space = robot_action_space - - gripper_space = robot_action_space[gripper_key] - self.action_space = gym.spaces.Box( - low=np.asarray(gripper_space.low, dtype=np.float32), - high=np.asarray(gripper_space.high, dtype=np.float32), - shape=gripper_space.shape, - dtype=np.float32, - ) - - def action(self, action: np.ndarray) -> dict[str, Any]: - robot_action = self._robot_action_space.sample() - - for key, space in self._robot_action_space.spaces.items(): - if isinstance(space, gym.spaces.Box): - robot_action[key] = np.zeros(space.shape, dtype=space.dtype) - - robot_action[self.gripper_key] = np.asarray(action, dtype=np.float32) - - return { - self.robot_key: robot_action, - } - -class StableBaselines3Wrapper(gym.Wrapper): - """Prepare an RCS environment for Stable-Baselines3 training. - - RCS environments commonly expose dict action spaces. Stable-Baselines3 - policies do not accept dict actions, so this wrapper flattens them into a - single continuous Box. Dict observations are flattened by default for - ``MlpPolicy``. Set ``flatten_observations=False`` for ``MultiInputPolicy``. - """ - - def __init__( - self, - env: gym.Env, - *, - flatten_actions: bool = True, - flatten_observations: bool = True, - ): - if flatten_actions and isinstance(env.action_space, DictSpace): - env = FlattenActionWrapper(env) - elif not flatten_actions and isinstance(env.action_space, DictSpace): - env = GripperOnlyActionWrapper(env) - if flatten_observations and isinstance(env.observation_space, DictSpace): - env = gym.wrappers.FlattenObservation(env) - elif not flatten_observations and isinstance(env.observation_space, DictSpace): - env = TaximSB3ObservationWrapper(env) - super().__init__(env) - - -class StableBaselines3PolicyWrapper(gym.Wrapper): - """RCS control wrapper that generates actions with a Stable-Baselines3 model. - - The wrapper keeps the last fully assembled observation returned by lower RCS - wrappers. On each ``step()``, it predicts a policy action from that stored - observation, merges the prediction into the incoming action dict, and passes - the result down toward the robot wrapper. - """ - - ACTION_INFO_KEY = "sb3_action" - - def __init__( - self, - env: gym.Env, - model: Any, - *, - deterministic: bool = True, - flatten_actions: bool = True, - flatten_observations: bool = True, - preserve_external_actions: bool = True, - action_info_key: str | None = ACTION_INFO_KEY, - ): - super().__init__(env) - self.model = model - self.deterministic = deterministic - self.flatten_actions = flatten_actions - self.flatten_observations = flatten_observations - self.preserve_external_actions = preserve_external_actions - self.action_info_key = action_info_key - self._last_observation: Any | None = None - self._policy_state: Any = None - self._episode_start = True - - def _model_observation(self, observation: Any) -> Any: - if self.flatten_observations and isinstance(self.env.observation_space, DictSpace): - return space_utils.flatten(self.env.observation_space, observation).astype(np.float32) - return observation - - def _env_action(self, action: Any) -> Any: - if self.flatten_actions and isinstance(self.env.action_space, DictSpace): - return space_utils.unflatten(self.env.action_space, np.asarray(action, dtype=np.float32)) - return action - - def policy_action(self, observation: Any | None = None, deterministic: bool | None = None) -> Any: - observation = self._last_observation if observation is None else observation - if observation is None: - msg = "Call reset() before requesting a policy action." - raise RuntimeError(msg) - action, self._policy_state = self.model.predict( - self._model_observation(observation), - state=self._policy_state, - episode_start=np.array([self._episode_start]), - deterministic=self.deterministic if deterministic is None else deterministic, - ) - self._episode_start = False - return self._env_action(action) - - def _merge_actions(self, external_action: Any, policy_action: Any) -> Any: - if not isinstance(policy_action, dict): - return policy_action - if external_action is None: - return policy_action - if not isinstance(external_action, dict): - msg = "External action must be a dict when the policy produces dict actions." - raise TypeError(msg) - merged_action = copy.deepcopy(policy_action) - if self.preserve_external_actions: - merged_action.update(external_action) - else: - merged_action = copy.deepcopy(external_action) - merged_action.update(policy_action) - return merged_action - - def step(self, action: dict[str, Any] | None = None): - generated_action = self.policy_action() - env_action = self._merge_actions(action, generated_action) - observation, reward, terminated, truncated, info = self.env.step(env_action) - self._last_observation = observation - self._episode_start = terminated or truncated - if self.action_info_key is not None: - info = dict(info) - info[self.action_info_key] = copy.deepcopy(generated_action) - return observation, reward, terminated, truncated, info - - def reset( - self, *, seed: int | None = None, options: dict[str, Any] | None = None - ) -> tuple[Any, dict[str, Any]]: - observation, info = self.env.reset(seed=seed, options=options) - self._last_observation = observation - self._policy_state = None - self._episode_start = True - return observation, info diff --git a/extensions/rcs_sb3/tests/test_video_recording.py b/extensions/rcs_sb3/tests/test_video_recording.py deleted file mode 100644 index 6fc8f9fd..00000000 --- a/extensions/rcs_sb3/tests/test_video_recording.py +++ /dev/null @@ -1,50 +0,0 @@ -from __future__ import annotations - -from pathlib import Path -import sys - -REPO_ROOT = Path(__file__).resolve().parents[3] -for candidate in (REPO_ROOT / "python", REPO_ROOT / "extensions" / "rcs_sb3", REPO_ROOT / "extensions" / "rcs_sb3" / "src"): - sys.path.insert(0, str(candidate)) - -import cv2 -import numpy as np - -from run_test import _EpisodeVideoWriter, _compose_video_frame - - -def test_compose_video_frame_and_write_mp4(tmp_path: Path): - obs = { - "frames": { - "head": {"rgb": {"data": np.full((240, 320, 3), (0, 0, 255), dtype=np.uint8)}}, - "tactile_gripperleft_digit_pad": { - "rgb": {"data": np.full((240, 320, 3), (255, 0, 0), dtype=np.uint8)} - }, - "tactile_gripperright_digit_pad": { - "rgb": {"data": np.full((240, 320, 3), (0, 255, 0), dtype=np.uint8)} - }, - } - } - composed = _compose_video_frame(obs) - - assert composed.shape == (240, 960, 3) - assert composed.dtype == np.uint8 - - video_path = tmp_path / "taxim_inference.mp4" - writer = _EpisodeVideoWriter(video_path, fps=30.0) - writer.write(composed) - writer.write(composed) - writer.close() - - assert video_path.exists() - assert video_path.stat().st_size > 0 - - cap = cv2.VideoCapture(str(video_path)) - try: - ok, frame = cap.read() - assert ok is True - assert frame is not None - assert frame.shape[0] == 240 - assert frame.shape[1] == 960 - finally: - cap.release() diff --git a/extensions/rcs_sb3/tests/test_wrappers.py b/extensions/rcs_sb3/tests/test_wrappers.py deleted file mode 100644 index 1208b4a0..00000000 --- a/extensions/rcs_sb3/tests/test_wrappers.py +++ /dev/null @@ -1,69 +0,0 @@ -import gymnasium as gym -import numpy as np - -from rcs_sb3 import SB3PPO, SB3PPOConfig, StableBaselines3PolicyWrapper, StableBaselines3Wrapper - - -class DummyRCSEnv(gym.Env): - def __init__(self): - self.action_space = gym.spaces.Dict( - { - "joints": gym.spaces.Box(low=-1.0, high=1.0, shape=(2,), dtype=np.float64), - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ) - self.observation_space = gym.spaces.Dict( - { - "joints": gym.spaces.Box(low=-10.0, high=10.0, shape=(2,), dtype=np.float64), - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ) - self.last_action = None - - def step(self, action): - self.last_action = action - return {"joints": np.zeros(2), "gripper": np.ones(1)}, 0.0, False, False, {} - - def reset(self, *, seed=None, options=None): - super().reset(seed=seed) - return {"joints": np.zeros(2), "gripper": np.ones(1)}, {} - - -class FakeSB3Model: - def predict(self, observation, state=None, episode_start=None, deterministic=False): - assert observation.shape == (3,) - return np.array([0.25, -0.25, 1.0], dtype=np.float32), state - - -def test_stable_baselines3_wrapper_flattens_dict_action_and_observation_spaces(): - env = DummyRCSEnv() - wrapped = StableBaselines3Wrapper(env) - - assert isinstance(wrapped.action_space, gym.spaces.Box) - assert isinstance(wrapped.observation_space, gym.spaces.Box) - - wrapped.step(np.array([0.5, -0.5, 1.0], dtype=np.float32)) - - assert set(env.last_action.keys()) == {"joints", "gripper"} - np.testing.assert_allclose(env.last_action["joints"], np.array([0.5, -0.5])) - np.testing.assert_allclose(env.last_action["gripper"], np.array([1.0])) - - -def test_policy_wrapper_generates_action_from_last_observation(): - env = DummyRCSEnv() - wrapped = StableBaselines3PolicyWrapper(env, FakeSB3Model()) - - wrapped.reset() - _, _, _, _, info = wrapped.step() - - np.testing.assert_allclose(env.last_action["joints"], np.array([0.25, -0.25])) - np.testing.assert_allclose(env.last_action["gripper"], np.array([1.0])) - np.testing.assert_allclose(info["sb3_action"]["joints"], np.array([0.25, -0.25])) - - -def test_ppo_build_uses_wrapped_env_without_training(): - env = DummyRCSEnv() - trainer = SB3PPO(SB3PPOConfig(model_kwargs={"n_steps": 2, "batch_size": 2})) - model = trainer.build(env) - - assert model.env is not None From 1fab445a63581c12662e72c509e7a9854a5b438f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 5 May 2026 10:23:09 +0200 Subject: [PATCH 16/87] fix(docker): link script --- docker/README.md | 3 ++- docker/link-editable-source.sh | 25 ++++++++++--------------- 2 files changed, 12 insertions(+), 16 deletions(-) diff --git a/docker/README.md b/docker/README.md index 78bd0da4..35b4bd13 100644 --- a/docker/README.md +++ b/docker/README.md @@ -23,6 +23,7 @@ Notes: - `~/zed_models` is mounted into `/usr/local/zed/resources` to match the direct `docker run` setup. - `/dev/dri` is masked inside the container so host Mesa/AMD render nodes do not override the NVIDIA runtime devices. - NVIDIA PRIME/GLX environment variables are exported to bias OpenGL/EGL selection toward the NVIDIA stack when using X11 forwarding. -- Python source changes are picked up from the mounted repo, including `extensions/rcs_zed`. +- The simulator still bootstraps EGL for offscreen MuJoCo camera rendering; set `RCS_MUJOCO_DISABLE_EGL=1` only if you intentionally want to disable that path. +- Python source changes are picked up from the mounted repo. - If you change C++ code in `rcs` or `rcs_fr3`, rebuild the image. - For non-GPU hosts, comment out the GPU-related lines in `docker/compose/dev.yml`. diff --git a/docker/link-editable-source.sh b/docker/link-editable-source.sh index 0b1b967a..0a93db47 100644 --- a/docker/link-editable-source.sh +++ b/docker/link-editable-source.sh @@ -10,26 +10,21 @@ fi SITE_PACKAGES="$(python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')" -link_mixed_package() { +link_compiled_package() { src_dir="$1" dst_dir="$2" - keep_dir_name="${3:-}" if [ ! -d "$src_dir" ] || [ ! -d "$dst_dir" ]; then return fi - # Replace only the Python sources from the mounted repo and keep compiled - # artifacts that were installed into site-packages during image build. - for path in "$src_dir"/* "$src_dir"/.[!.]* "$src_dir"/..?*; do - [ -e "$path" ] || continue - name="$(basename "$path")" - if [ -n "$keep_dir_name" ] && [ "$name" = "$keep_dir_name" ]; then - continue - fi - rm -rf "$dst_dir/$name" - cp -as "$path" "$dst_dir/$name" - done + tmp_keep="$(mktemp -d)" + find "$dst_dir" -maxdepth 1 \( -name '_core*.so' -o -name 'lib*.so*' \) -exec mv {} "$tmp_keep/" \; + rm -rf "$dst_dir" + mkdir -p "$dst_dir" + cp -as "$src_dir/." "$dst_dir/" + find "$tmp_keep" -maxdepth 1 -type f -exec mv {} "$dst_dir/" \; + rmdir "$tmp_keep" } link_pure_python_package() { @@ -44,8 +39,8 @@ link_pure_python_package() { ln -s "$src_dir" "$dst_dir" } -link_mixed_package "$REPO_ROOT/python/rcs" "$SITE_PACKAGES/rcs" "_core" -link_mixed_package "$REPO_ROOT/extensions/rcs_fr3/src/rcs_fr3" "$SITE_PACKAGES/rcs_fr3" "_core" +link_compiled_package "$REPO_ROOT/python/rcs" "$SITE_PACKAGES/rcs" +link_compiled_package "$REPO_ROOT/extensions/rcs_fr3/src/rcs_fr3" "$SITE_PACKAGES/rcs_fr3" link_pure_python_package "$REPO_ROOT/extensions/rcs_realsense/src/rcs_realsense" "$SITE_PACKAGES/rcs_realsense" link_pure_python_package "$REPO_ROOT/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85" "$SITE_PACKAGES/rcs_robotiq2f85" link_pure_python_package "$REPO_ROOT/extensions/rcs_zed/src/rcs_zed" "$SITE_PACKAGES/rcs_zed" From 577193977c421e890b6225c3a22ba1bd81ec472b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 5 May 2026 10:29:43 +0200 Subject: [PATCH 17/87] feat: zed cli rgb snapshot --- extensions/rcs_zed/src/rcs_zed/__main__.py | 104 ++++++++++++++++----- 1 file changed, 81 insertions(+), 23 deletions(-) diff --git a/extensions/rcs_zed/src/rcs_zed/__main__.py b/extensions/rcs_zed/src/rcs_zed/__main__.py index cfe51fa5..8e2558f4 100644 --- a/extensions/rcs_zed/src/rcs_zed/__main__.py +++ b/extensions/rcs_zed/src/rcs_zed/__main__.py @@ -1,4 +1,6 @@ import logging +from pathlib import Path +from time import monotonic import cv2 import typer @@ -14,6 +16,36 @@ def _display_frame(window_name: str, frame): cv2.imshow(window_name, frame.camera.color.data[:, :, ::-1]) +def _resolve_serial(serial: str | None) -> str: + if serial is not None: + return serial + + try: + devices = ZEDCameraSet.enumerate_connected_devices() + except RuntimeError as exc: + msg = str(exc) + raise typer.BadParameter(msg) from exc + if len(devices) == 0: + msg = "No ZED devices connected." + raise typer.BadParameter(msg) + return next(iter(devices)) + + +def _create_rgb_camera(serial: str, width: int, height: int, fps: int) -> ZEDCameraSet: + return ZEDCameraSet( + cameras={ + "viewer": common.BaseCameraConfig( + identifier=serial, + resolution_width=width, + resolution_height=height, + frame_rate=fps, + ) + }, + enable_depth=False, + enable_imu=False, + ) + + @zed_app.command() def serials(): """Reads out the serial numbers and models of connected ZED devices via the SDK.""" @@ -39,29 +71,8 @@ def rgb_view( window_name: str = typer.Option("ZED RGB", help="OpenCV window title."), ): """Open a live RGB window using the RCS ZED camera interface.""" - if serial is None: - try: - devices = ZEDCameraSet.enumerate_connected_devices() - except RuntimeError as exc: - msg = str(exc) - raise typer.BadParameter(msg) from exc - if len(devices) == 0: - msg = "No ZED devices connected." - raise typer.BadParameter(msg) - serial = next(iter(devices)) - - camera = ZEDCameraSet( - cameras={ - "viewer": common.BaseCameraConfig( - identifier=serial, - resolution_width=width, - resolution_height=height, - frame_rate=fps, - ) - }, - enable_depth=False, - enable_imu=False, - ) + serial = _resolve_serial(serial) + camera = _create_rgb_camera(serial, width, height, fps) try: camera.open() @@ -81,6 +92,53 @@ def rgb_view( cv2.destroyAllWindows() +@zed_app.command("rgb-snapshot") +def rgb_snapshot( + serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."), + output: Path = typer.Option(Path("zed_latest.png"), "--output", "-o", help="PNG file to write."), + width: int = typer.Option(1280, help="Requested capture width."), + height: int = typer.Option(720, help="Requested capture height."), + fps: int = typer.Option(30, help="Requested capture frame rate."), + duration: float = typer.Option(1.0, "--duration", "-d", help="Seconds to read frames before saving."), +): + """Open a ZED camera briefly and save the latest RGB frame as a PNG.""" + if duration <= 0: + msg = "Duration must be greater than zero." + raise typer.BadParameter(msg) + if output.suffix.lower() != ".png": + msg = "Output path must end in .png." + raise typer.BadParameter(msg) + + serial = _resolve_serial(serial) + camera = _create_rgb_camera(serial, width, height, fps) + + try: + camera.open() + except Exception as exc: + msg = f"Could not start ZED camera {serial}: {exc}" + raise typer.BadParameter(msg) from exc + + latest_frame = None + frames_read = 0 + deadline = monotonic() + duration + try: + while latest_frame is None or monotonic() < deadline: + latest_frame = camera.poll_frame("viewer") + frames_read += 1 + finally: + camera.close() + + assert latest_frame is not None + output.parent.mkdir(parents=True, exist_ok=True) + image_bgr = latest_frame.camera.color.data[:, :, ::-1] + print(latest_frame.camera.color.intrinsics) + if not cv2.imwrite(str(output), image_bgr): + msg = f"Could not write PNG to {output}." + raise typer.BadParameter(msg) + + typer.echo(f"Saved {output} from ZED {serial} after reading {frames_read} frame(s).") + + def main(): zed_app() From 38e000030f68bf23eb5340e58f413d67280d82e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 5 May 2026 18:56:24 +0200 Subject: [PATCH 18/87] fix(teleop): depth in cameras --- examples/teleop/franka.py | 2 +- extensions/rcs_fr3/src/rcs_fr3/creators.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/teleop/franka.py b/examples/teleop/franka.py index 2f0d6ede..3736d55b 100644 --- a/examples/teleop/franka.py +++ b/examples/teleop/franka.py @@ -117,7 +117,7 @@ def get_env(): for name, identifier in ZED_CAMERA_DICT.items() }, kwargs={ - "enable_depth": False, + "enable_depth": INCLUDE_DEPTH, "enable_imu": False, }, ) diff --git a/extensions/rcs_fr3/src/rcs_fr3/creators.py b/extensions/rcs_fr3/src/rcs_fr3/creators.py index 2225a577..e28401e4 100644 --- a/extensions/rcs_fr3/src/rcs_fr3/creators.py +++ b/extensions/rcs_fr3/src/rcs_fr3/creators.py @@ -203,7 +203,7 @@ def create_env(self, cfg: FR3HardwareEnvCreatorConfig) -> gym.Env: camera_set.start() camera_set.wait_for_frames() logger.info("CameraSet started") - env = CameraSetWrapper(env, camera_set) + env = CameraSetWrapper(env, camera_set, cfg.wrapper_cfg.include_depth) if cfg.relative_to != RelativeTo.NONE: env = RelativeActionSpace(env, max_mov=cfg.max_relative_movement, relative_to=cfg.relative_to) @@ -236,7 +236,7 @@ def create_env(self, cfg: FR3MultiHardwareEnvCreatorConfig) -> gym.Env: camera_set.start() camera_set.wait_for_frames() logger.info("CameraSet started") - env = CameraSetWrapper(env, camera_set) + env = CameraSetWrapper(env, camera_set, cfg.wrapper_cfg.include_depth) return CoverWrapper(env) def config(self) -> FR3MultiHardwareEnvCreatorConfig: From 6a27ad972ab9531b94ba88319f2e77ea2e444b64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 5 May 2026 18:56:52 +0200 Subject: [PATCH 19/87] chore(quest): simplify right/left swapping logic --- python/rcs/operator/quest.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/python/rcs/operator/quest.py b/python/rcs/operator/quest.py index 322b870a..158850f0 100644 --- a/python/rcs/operator/quest.py +++ b/python/rcs/operator/quest.py @@ -128,6 +128,14 @@ def _reset_state(self): self._last_controller_pose[controller] = Pose() self._grp_pos[controller] = 1 + def _swap_controller_input(self, input_data: dict[str, Any]) -> dict[str, Any]: + if not self.config.switched_left_right: + return input_data + swapped = copy.copy(input_data) + swapped["left"] = input_data["right"] + swapped["right"] = input_data["left"] + return swapped + @staticmethod def _normalize_axis(value: bool | float | int) -> float: if isinstance(value, bool): @@ -139,13 +147,6 @@ def consume_commands(self) -> TeleopCommands: with self._cmd_lock: cmds = copy.copy(self._commands) self._commands = TeleopCommands() - if self.config.switched_left_right: - swapped_reset_origin_to_current = {} - if "left" in cmds.reset_origin_to_current: - swapped_reset_origin_to_current["right"] = cmds.reset_origin_to_current["left"] - if "right" in cmds.reset_origin_to_current: - swapped_reset_origin_to_current["left"] = cmds.reset_origin_to_current["right"] - cmds.reset_origin_to_current = swapped_reset_origin_to_current return cmds def reset_operator_state(self): @@ -176,11 +177,7 @@ def consume_action(self) -> dict[str, ArmWithGripper]: tquat=np.concatenate([transform.translation(), transform.rotation_q()]), gripper=np.array([self._grp_pos[controller]]), ) - return ( - {"left": transforms["right"], "right": transforms["left"]} - if self.config.switched_left_right - else transforms - ) + return transforms def set_camera(self, observation: dict) -> None: if not self.config.display_cameras: @@ -241,6 +238,8 @@ def run(self): logger.warning("[Quest Reader] packets arriving again") warning_raised = False + input_data = self._swap_controller_input(input_data) + # === Update Semantic Commands === with self._cmd_lock: if input_data[self._start_btn] and (self._prev_data is None or not self._prev_data[self._start_btn]): @@ -293,7 +292,8 @@ def run(self): gripper_axis = self._normalize_axis(input_data[controller][self._grp_btn[controller]]) # convert from IRIS to RCS gripper logic - self._grp_pos[controller] = 1.0 - gripper_axis + with self._resource_lock: + self._grp_pos[controller] = 1.0 - gripper_axis self._prev_data = input_data rate_limiter() From f76c77afef45dafaf9692280ce7426b137b9c8f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 5 May 2026 18:58:28 +0200 Subject: [PATCH 20/87] impr(robotiq): physical reset only in constructor --- extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py index a5ed5736..4bb10d4e 100644 --- a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py +++ b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py @@ -42,7 +42,8 @@ class RobotiQ2F85Gripper(Gripper): def __init__(self, cfg: RobotiQ2F85GripperConfig): super().__init__() self._cfg: RobotiQ2F85GripperConfig = cfg - self.gripper = Robotiq2F85Driver(serial_number=cfg.serial_number) + self.gripper = Robotiq2F85Driver(serial_number=cfg.serial_number, ignore_read_frequency=True) + self.gripper.reset() def get_normalized_width(self) -> float: # value between 0 and 1 (0 is closed) @@ -61,7 +62,7 @@ def open(self) -> None: self.set_normalized_width(1.0) def reset(self) -> None: - self.gripper.reset() + self.open() def set_normalized_width(self, width: float, force: float = 0) -> None: """ From 49f55651891fa8d4a423069e458ddcff9ee8ab12 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 12 May 2026 11:55:05 +0200 Subject: [PATCH 21/87] feat: robotiq in teleop script --- .dockerignore | 2 ++ docker/Dockerfile | 3 +- examples/teleop/franka.py | 35 ++++++++++++++------- extensions/rcs_fr3/src/rcs_fr3/configs.py | 1 + python/tests/test_quest_operator.py | 38 ++++++++++++++++++++++- 5 files changed, 66 insertions(+), 13 deletions(-) diff --git a/.dockerignore b/.dockerignore index bdf319e7..8b767f67 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1 +1,3 @@ **/build/ +real* +test* diff --git a/docker/Dockerfile b/docker/Dockerfile index 2b03ad71..b72bde92 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -53,7 +53,8 @@ RUN chmod +x /usr/local/bin/link-editable-source \ && uv pip install --no-build-isolation /opt/rcs-src/extensions/rcs_fr3 \ && uv pip install /opt/rcs-src/extensions/rcs_realsense \ && uv pip install /opt/rcs-src/extensions/rcs_robotiq2f85 \ - && uv pip install /opt/rcs-src/extensions/rcs_zed + && uv pip install /opt/rcs-src/extensions/rcs_zed \ + && uv pip install /opt/rcs-src/examples/teleop/SimPublisher WORKDIR /workspace/robot-control-stack diff --git a/examples/teleop/franka.py b/examples/teleop/franka.py index 3736d55b..f3951c98 100644 --- a/examples/teleop/franka.py +++ b/examples/teleop/franka.py @@ -26,22 +26,26 @@ "right": "0", } - -ROBOT_INSTANCE = RobotPlatform.SIMULATION -# ROBOT_INSTANCE = RobotPlatform.HARDWARE +# use `udevadm info -a -n /dev/ttyUSB0 | grep serial` +# to find out the serial numbers +ROBOTIQ_SERIAL = { + "left": "DAAQMPDC", + "right": "DAAQMJHX", +} RECORD_FPS = 30 # set camera dict to none disable cameras -# CAMERA_DICT = { -# "left_wrist": "230422272017", -# "right_wrist": "230422271040", -# "side": "243522070385", -# "bird_eye": "243522070364", -# } -CAMERA_DICT = None +CAMERA_DICT = { + "right_wrist": "230422272017", + "left_wrist": "230422271040", + # "side": "243522070385", + # "bird_eye": "243522070364", +} +# CAMERA_DICT = None ZED_CAMERA_DICT = { - "zed": "19928076", + "head": "19928076", } +# ZED_CAMERA_DICT = None MQ3_ADDR = "10.42.0.1" INCLUDE_DEPTH = False @@ -119,6 +123,7 @@ def get_env(): kwargs={ "enable_depth": INCLUDE_DEPTH, "enable_imu": False, + "include_right": True, }, ) if DIGIT_DICT is not None: @@ -137,11 +142,19 @@ def get_env(): hw_cfg.camera_cfgs = camera_cfgs or None hw_cfg.control_mode = config.operator_class.control_mode[0] hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH + hw_cfg.wrapper_cfg.binary_gripper = False + # hw_cfg.wrapper_cfg.binary_gripper = True hw_cfg.max_relative_movement = ( 0.5 if config.operator_class.control_mode[0] == ControlMode.JOINTS else (0.5, np.deg2rad(90)) ) hw_cfg.relative_to = config.operator_class.control_mode[1] hw_cfg.robot_to_shared_base_frame = robot2world + hw_cfg.robot_cfgs["left"].ignore_realtime = True + hw_cfg.robot_cfgs["right"].ignore_realtime = True + hw_cfg.robot_cfgs["left"].speed_factor = 0.3 + hw_cfg.robot_cfgs["right"].speed_factor = 0.3 + hw_cfg.gripper_cfgs["left"].serial_number = ROBOTIQ_SERIAL["left"] + hw_cfg.gripper_cfgs["right"].serial_number = ROBOTIQ_SERIAL["right"] env_rel = env_creator.create_env(hw_cfg) operator = GelloOperator(config) if isinstance(config, GelloConfig) else QuestOperator(config) else: diff --git a/extensions/rcs_fr3/src/rcs_fr3/configs.py b/extensions/rcs_fr3/src/rcs_fr3/configs.py index 3eaa8b0a..baf47eaf 100644 --- a/extensions/rcs_fr3/src/rcs_fr3/configs.py +++ b/extensions/rcs_fr3/src/rcs_fr3/configs.py @@ -152,6 +152,7 @@ def config(self) -> FR3MultiHardwareEnvCreatorConfig: class FrankaDuoEnv(DefaultFR3MultiHardwareEnv): + # use `udevadm info -a -n /dev/ttyUSB0 | grep serial` to find out the serial numbers left_gripper_serial_number = "DAAQMJHX" right_gripper_serial_number = "DAAQMPDC" diff --git a/python/tests/test_quest_operator.py b/python/tests/test_quest_operator.py index d5af2a78..55db719a 100644 --- a/python/tests/test_quest_operator.py +++ b/python/tests/test_quest_operator.py @@ -1,6 +1,9 @@ import threading from typing import Any, cast +import numpy as np + +from rcs._core.common import Pose from rcs.operator.interface import TeleopCommands from rcs.operator.quest import QuestOperator @@ -9,13 +12,46 @@ class _Config: switched_left_right = True +def test_swap_controller_input_swaps_left_and_right_packets(): + operator = QuestOperator.__new__(QuestOperator) + operator.config = cast(Any, _Config()) + + input_data = { + "left": {"hand_trigger": 0.1, "index_trigger": 0.2}, + "right": {"hand_trigger": 0.9, "index_trigger": 0.8}, + "A": True, + } + + swapped = QuestOperator._swap_controller_input(operator, input_data) + + assert swapped["left"] == input_data["right"] + assert swapped["right"] == input_data["left"] + assert swapped["A"] is True + + def test_consume_commands_swaps_both_reset_origin_keys(): operator = QuestOperator.__new__(QuestOperator) operator.config = cast(Any, _Config()) operator._cmd_lock = threading.Lock() - operator._commands = TeleopCommands(reset_origin_to_current={"left": True, "right": False}) + operator._commands = TeleopCommands(reset_origin_to_current={"right": True, "left": False}) cmds = QuestOperator.consume_commands(operator) assert cmds.reset_origin_to_current == {"right": True, "left": False} assert operator._commands.reset_origin_to_current == {} + + +def test_consume_action_swaps_gripper_with_controller(): + operator = QuestOperator.__new__(QuestOperator) + operator.config = cast(Any, _Config()) + operator._resource_lock = threading.Lock() + operator.controller_names = ["left", "right"] + operator._last_controller_pose = {key: Pose() for key in operator.controller_names} + operator._offset_pose = {key: Pose() for key in operator.controller_names} + operator._set_frame = {key: Pose() for key in operator.controller_names} + operator._grp_pos = {"left": 0.75, "right": 0.25} + + actions = QuestOperator.consume_action(operator) + + assert np.allclose(actions["left"]["gripper"], np.array([0.75])) + assert np.allclose(actions["right"]["gripper"], np.array([0.25])) From 0671b3e2db8a4cb254fc51712399ecfc16838b5c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 12 May 2026 11:58:26 +0200 Subject: [PATCH 22/87] impr(gripper): improved change detection --- .../rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py | 8 ++++--- python/rcs/envs/base.py | 21 +++++++++++++------ python/rcs/utils.py | 1 - 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py index 4bb10d4e..db4be1fa 100644 --- a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py +++ b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/hw.py @@ -42,12 +42,13 @@ class RobotiQ2F85Gripper(Gripper): def __init__(self, cfg: RobotiQ2F85GripperConfig): super().__init__() self._cfg: RobotiQ2F85GripperConfig = cfg - self.gripper = Robotiq2F85Driver(serial_number=cfg.serial_number, ignore_read_frequency=True) + self.gripper = Robotiq2F85Driver(serial_number=cfg.serial_number) + self._last_normalized_width = 1.0 self.gripper.reset() def get_normalized_width(self) -> float: - # value between 0 and 1 (0 is closed) - return self.gripper.opening / 85 + # Return the last commanded width to avoid a synchronous Modbus read on every env step. + return self._last_normalized_width def grasp(self) -> None: """ @@ -71,6 +72,7 @@ def set_normalized_width(self, width: float, force: float = 0) -> None: if not (0 <= width <= 1): msg = f"Width must be between 0 and 1, got {width}." raise ValueError(msg) + self._last_normalized_width = width abs_width = width * 85 self.gripper.go_to( opening=float(abs_width), diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index 1cbfbb1f..13bda16b 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -944,6 +944,14 @@ def __init__(self, env, gripper: common.Gripper, binary: bool = True): self.gripper = gripper self._last_gripper_cmd = None + def _command_changed(self, gripper_action: np.ndarray) -> bool: + if self._last_gripper_cmd is None: + return True + last_action = np.asarray(self._last_gripper_cmd, dtype=np.float32) + if self.binary: + return not np.array_equal(gripper_action, last_action) + return not np.allclose(gripper_action, last_action, atol=1e-3, rtol=0.0) + def close(self): self.gripper.close() super().close() @@ -975,13 +983,14 @@ def action(self, action: dict[str, Any]) -> dict[str, Any]: gripper_action = [gripper_action] # type: ignore if self.binary: gripper_action = np.round(gripper_action) - gripper_action = np.clip(gripper_action, 0.0, 1.0) + gripper_action = np.clip(np.asarray(gripper_action, dtype=np.float32), 0.0, 1.0) - if self.binary: - self.gripper.grasp() if gripper_action == self.BINARY_GRIPPER_CLOSED else self.gripper.open() - else: - self.gripper.set_normalized_width(gripper_action[0]) - self._last_gripper_cmd = gripper_action + if self._command_changed(gripper_action): + if self.binary: + self.gripper.grasp() if gripper_action[0] < 0.5 else self.gripper.open() + else: + self.gripper.set_normalized_width(float(gripper_action[0])) + self._last_gripper_cmd = gripper_action.tolist() del action[self.gripper_key] return action diff --git a/python/rcs/utils.py b/python/rcs/utils.py index 9f9b7e7f..25ef2abb 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -27,7 +27,6 @@ def __call__(self): if self.t is None: self.t = perf_counter() self._last_print = self.t - sleep(1 / self.frame_rate) return sleep_time = 1 / self.frame_rate - (perf_counter() - self.t) if sleep_time > 0: From 706a868fa942d3a35eceabdbfb509e2970f27098 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 12 May 2026 11:59:23 +0200 Subject: [PATCH 23/87] feat(zed): add option to record both eyes --- extensions/rcs_zed/src/rcs_zed/camera.py | 156 +++++++++++++----- .../rcs_zed/tests/test_zed_extension.py | 58 ++++++- 2 files changed, 171 insertions(+), 43 deletions(-) diff --git a/extensions/rcs_zed/src/rcs_zed/camera.py b/extensions/rcs_zed/src/rcs_zed/camera.py index e9fd61dd..881a1368 100644 --- a/extensions/rcs_zed/src/rcs_zed/camera.py +++ b/extensions/rcs_zed/src/rcs_zed/camera.py @@ -30,6 +30,8 @@ class ZEDFrameBundle: color: np.ndarray timestamp: float color_intrinsics: np.ndarray[tuple[typing.Literal[3], typing.Literal[4]], np.dtype[np.float64]] + right_color: np.ndarray | None = None + right_color_intrinsics: np.ndarray[tuple[typing.Literal[3], typing.Literal[4]], np.dtype[np.float64]] | None = None depth: np.ndarray | None = None accel: np.ndarray | None = None gyro: np.ndarray | None = None @@ -47,12 +49,20 @@ def _intrinsics_matrix(fx: float, fy: float, cx: float, cy: float) -> np.ndarray class PyZEDCameraHandle: - def __init__(self, camera: typing.Any, device_info: ZEDDeviceInfo, color_intrinsics: np.ndarray): + def __init__( + self, + camera: typing.Any, + device_info: ZEDDeviceInfo, + color_intrinsics: np.ndarray, + right_color_intrinsics: np.ndarray | None = None, + ): self.camera = camera self.device_info = device_info self.color_intrinsics = color_intrinsics + self.right_color_intrinsics = right_color_intrinsics self.runtime_parameters = sl.RuntimeParameters() # type: ignore[union-attr] self.image_mat = sl.Mat() # type: ignore[union-attr] + self.right_image_mat = sl.Mat() # type: ignore[union-attr] self.depth_mat = sl.Mat() # type: ignore[union-attr] self.sensors_data = sl.SensorsData() # type: ignore[union-attr] @@ -69,7 +79,7 @@ def _timestamp_seconds(self) -> float: pass return time() - def grab_frame(self) -> ZEDFrameBundle: + def grab_frame(self, include_right: bool = False) -> ZEDFrameBundle: err = self.camera.grab(self.runtime_parameters) if err != sl.ERROR_CODE.SUCCESS: # type: ignore[union-attr] msg = f"Failed to grab ZED frame: {err}" @@ -82,6 +92,15 @@ def grab_frame(self) -> ZEDFrameBundle: raise RuntimeError(msg) color_rgb = color_raw[:, :, :3][:, :, ::-1] if color_raw.shape[2] == 4 else color_raw[:, :, ::-1] + right_color = None + if include_right: + self.camera.retrieve_image(self.right_image_mat, sl.VIEW.RIGHT) # type: ignore[union-attr] + right_raw = np.array(self.right_image_mat.get_data(), copy=True) + if right_raw.ndim != 3: + msg = f"Unexpected ZED right image shape {right_raw.shape}" + raise RuntimeError(msg) + right_color = right_raw[:, :, :3][:, :, ::-1] if right_raw.shape[2] == 4 else right_raw[:, :, ::-1] + depth = None if self.device_info.has_depth: self.camera.retrieve_measure(self.depth_mat, sl.MEASURE.DEPTH) # type: ignore[union-attr] @@ -105,6 +124,8 @@ def grab_frame(self) -> ZEDFrameBundle: return ZEDFrameBundle( color=color_rgb, + right_color=right_color, + right_color_intrinsics=self.right_color_intrinsics if right_color is not None else None, depth=depth, accel=accel, gyro=gyro, @@ -185,6 +206,7 @@ def open_camera( *, enable_depth: bool, enable_imu: bool, + include_right: bool, ) -> PyZEDCameraHandle: cls._require_sdk() assert sl is not None @@ -206,6 +228,7 @@ def open_camera( information = camera.get_camera_information() calibration = information.camera_configuration.calibration_parameters left_cam = calibration.left_cam + right_cam = calibration.right_cam info = ZEDDeviceInfo( serial=str(config.identifier), model=cls._model_to_string(information.camera_model), @@ -213,7 +236,15 @@ def open_camera( has_imu=enable_imu and cls._device_has_imu(information), ) intrinsics = _intrinsics_matrix(left_cam.fx, left_cam.fy, left_cam.cx, left_cam.cy) - return PyZEDCameraHandle(camera=camera, device_info=info, color_intrinsics=intrinsics) + right_intrinsics = None + if include_right: + right_intrinsics = _intrinsics_matrix(right_cam.fx, right_cam.fy, right_cam.cx, right_cam.cy) + return PyZEDCameraHandle( + camera=camera, + device_info=info, + color_intrinsics=intrinsics, + right_color_intrinsics=right_intrinsics, + ) def __init__( self, @@ -221,6 +252,7 @@ def __init__( calibration_strategy: dict[str, CalibrationStrategy] | None = None, enable_depth: bool = True, enable_imu: bool = True, + include_right: bool = False, ) -> None: self.cameras = cameras if calibration_strategy is None: @@ -228,12 +260,14 @@ def __init__( self.calibration_strategy = calibration_strategy self.enable_depth = enable_depth self.enable_imu = enable_imu + self.include_right = include_right self._logger = logging.getLogger(__name__) - self._camera_names = list(self.cameras.keys()) + self._camera_names = self._logical_camera_names() self._available_devices: dict[str, ZEDDeviceInfo] = {} self._enabled_devices: dict[str, PyZEDCameraHandle] = {} self._frame_buffer_lock: dict[str, threading.Lock] = {} self._frame_buffer: dict[str, list[Frame]] = {} + self._pending_right_bundles: dict[str, ZEDFrameBundle] = {} assert ( len({camera.resolution_width for camera in self.cameras.values()}) == 1 @@ -246,7 +280,63 @@ def camera_names(self) -> list[str]: return self._camera_names def config(self, camera_name) -> common.BaseCameraConfig: - return self.cameras[camera_name] + return self.cameras[self._physical_camera_name(camera_name)] + + @staticmethod + def _right_camera_name(camera_name: str) -> str: + return f"{camera_name}_right" + + def _physical_camera_name(self, camera_name: str) -> str: + if camera_name in self.cameras: + return camera_name + if self.include_right and camera_name.endswith("_right"): + physical_name = camera_name.removesuffix("_right") + if physical_name in self.cameras: + return physical_name + msg = f"Camera {camera_name} not found in the enabled devices" + raise AssertionError(msg) + + def _is_right_camera_name(self, camera_name: str) -> bool: + return camera_name not in self.cameras and self._physical_camera_name(camera_name) != camera_name + + def _logical_camera_names(self) -> list[str]: + names = list(self.cameras.keys()) + if self.include_right: + names.extend(self._right_camera_name(camera_name) for camera_name in self.cameras) + return names + + def _frame_from_bundle(self, camera_name: str, bundle: ZEDFrameBundle) -> Frame: + physical_name = self._physical_camera_name(camera_name) + extrinsics = self.calibration_strategy[physical_name].get_extrinsics() + is_right = self._is_right_camera_name(camera_name) + color_data = bundle.right_color if is_right else bundle.color + color_intrinsics = bundle.right_color_intrinsics if is_right else bundle.color_intrinsics + if color_data is None or color_intrinsics is None: + msg = f"Missing {'right' if is_right else 'left'} image data for {camera_name}" + raise RuntimeError(msg) + + color = DataFrame( + data=color_data, + timestamp=bundle.timestamp, + intrinsics=color_intrinsics, + extrinsics=extrinsics, + ) + depth = None + if not is_right and bundle.depth is not None: + depth = DataFrame( + data=bundle.depth, + timestamp=bundle.timestamp, + intrinsics=bundle.color_intrinsics, + extrinsics=extrinsics, + ) + + accel = DataFrame(data=bundle.accel, timestamp=bundle.timestamp) if bundle.accel is not None else None + gyro = DataFrame(data=bundle.gyro, timestamp=bundle.timestamp) if bundle.gyro is not None else None + return Frame( + camera=CameraFrame(color=color, depth=depth), + imu=IMUFrame(accel=accel, gyro=gyro) if (accel is not None or gyro is not None) else None, + avg_timestamp=bundle.timestamp, + ) def update_available_devices(self): self._available_devices = self.enumerate_connected_devices() @@ -256,6 +346,7 @@ def open(self): self._enabled_devices = {} self._frame_buffer = {} self._frame_buffer_lock = {} + self._pending_right_bundles = {} for camera_name, camera_cfg in self.cameras.items(): if camera_cfg.identifier not in self._available_devices: @@ -267,6 +358,7 @@ def open(self): camera_cfg, enable_depth=self.enable_depth and device_info.has_depth, enable_imu=self.enable_imu and device_info.has_imu, + include_right=self.include_right, ) self._enabled_devices[camera_name] = opened self._frame_buffer[camera_name] = [] @@ -274,44 +366,34 @@ def open(self): def poll_frame(self, camera_name: str) -> Frame: assert camera_name in self.camera_names, f"Camera {camera_name} not found in the enabled devices" - device = self._enabled_devices[camera_name] - bundle = device.grab_frame() - extrinsics = self.calibration_strategy[camera_name].get_extrinsics() - - color = DataFrame( - data=bundle.color, - timestamp=bundle.timestamp, - intrinsics=bundle.color_intrinsics, - extrinsics=extrinsics, - ) - depth = None - if bundle.depth is not None: - depth = DataFrame( - data=bundle.depth, - timestamp=bundle.timestamp, - intrinsics=bundle.color_intrinsics, - extrinsics=extrinsics, - ) - - accel = DataFrame(data=bundle.accel, timestamp=bundle.timestamp) if bundle.accel is not None else None - gyro = DataFrame(data=bundle.gyro, timestamp=bundle.timestamp) if bundle.gyro is not None else None - - frame = Frame( - camera=CameraFrame(color=color, depth=depth), - imu=IMUFrame(accel=accel, gyro=gyro) if (accel is not None or gyro is not None) else None, - avg_timestamp=bundle.timestamp, - ) - - with self._frame_buffer_lock[camera_name]: - if len(self._frame_buffer[camera_name]) >= self.CALIBRATION_FRAME_SIZE: - self._frame_buffer[camera_name].pop(0) - self._frame_buffer[camera_name].append(copy.deepcopy(frame)) + physical_name = self._physical_camera_name(camera_name) + device = self._enabled_devices[physical_name] + + if self._is_right_camera_name(camera_name): + bundle = self._pending_right_bundles.pop(physical_name, None) + if bundle is None: + bundle = device.grab_frame(include_right=True) + else: + bundle = device.grab_frame(include_right=self.include_right) + if self.include_right and bundle.right_color is not None: + self._pending_right_bundles[physical_name] = bundle + else: + self._pending_right_bundles.pop(physical_name, None) + + frame = self._frame_from_bundle(camera_name, bundle) + + if not self._is_right_camera_name(camera_name): + with self._frame_buffer_lock[physical_name]: + if len(self._frame_buffer[physical_name]) >= self.CALIBRATION_FRAME_SIZE: + self._frame_buffer[physical_name].pop(0) + self._frame_buffer[physical_name].append(copy.deepcopy(frame)) return frame def close(self): for device in self._enabled_devices.values(): device.close() self._enabled_devices = {} + self._pending_right_bundles = {} def calibrate(self) -> bool: for camera_name in self.cameras: diff --git a/extensions/rcs_zed/tests/test_zed_extension.py b/extensions/rcs_zed/tests/test_zed_extension.py index 32e8294f..cb17acec 100644 --- a/extensions/rcs_zed/tests/test_zed_extension.py +++ b/extensions/rcs_zed/tests/test_zed_extension.py @@ -20,8 +20,10 @@ def __init__(self, device_info: ZEDDeviceInfo, color_intrinsics: np.ndarray, fra self.color_intrinsics = color_intrinsics self._frame_bundle = frame_bundle self.closed = False + self.grab_calls: list[bool] = [] - def grab_frame(self) -> ZEDFrameBundle: + def grab_frame(self, include_right: bool = False) -> ZEDFrameBundle: + self.grab_calls.append(include_right) return self._frame_bundle def close(self): @@ -31,7 +33,7 @@ def close(self): class PatchZedState(TypedDict): devices: dict[str, ZEDDeviceInfo] opened: dict[str, FakeOpenedZEDCamera] - open_calls: list[tuple[str, bool, bool]] + open_calls: list[tuple[str, bool, bool, bool]] @pytest.fixture() @@ -41,8 +43,8 @@ def patch_zed(monkeypatch) -> PatchZedState: def fake_enumerate(_cls): return state["devices"] - def fake_open(_cls, config: common.BaseCameraConfig, *, enable_depth: bool, enable_imu: bool): - state["open_calls"].append((config.identifier, enable_depth, enable_imu)) + def fake_open(_cls, config: common.BaseCameraConfig, *, enable_depth: bool, enable_imu: bool, include_right: bool): + state["open_calls"].append((config.identifier, enable_depth, enable_imu, include_right)) return state["opened"][config.identifier] monkeypatch.setattr(ZEDCameraSet, "enumerate_connected_devices", classmethod(fake_enumerate)) @@ -78,7 +80,7 @@ def test_zed_frame_mapping_depth_scaling_and_imu_downgrade(patch_zed): frame = camera_set.poll_frame("wrist") assert frame.camera.color.intrinsics is not None - assert patch_zed["open_calls"] == [("123", True, False)] + assert patch_zed["open_calls"] == [("123", True, False, False)] assert np.array_equal(frame.camera.color.data, color) assert np.array_equal(frame.camera.depth.data, depth) # type: ignore[union-attr] assert np.array_equal(frame.camera.color.intrinsics, intrinsics) @@ -113,7 +115,51 @@ def test_zed_enumeration_and_multi_camera_open(patch_zed): }, ) camera_set.open() - assert patch_zed["open_calls"] == [("111", True, False), ("222", True, True)] + assert patch_zed["open_calls"] == [("111", True, False, False), ("222", True, True, False)] camera_set.close() assert opened["111"].closed assert opened["222"].closed + + +def test_zed_include_right_adds_logical_right_camera_without_double_grab(patch_zed): + left_intrinsics = np.array([[100.0, 0.0, 10.0, 0.0], [0.0, 110.0, 20.0, 0.0], [0.0, 0.0, 1.0, 0.0]]) + right_intrinsics = np.array([[120.0, 0.0, 12.0, 0.0], [0.0, 130.0, 22.0, 0.0], [0.0, 0.0, 1.0, 0.0]]) + left_color = np.arange(27, dtype=np.uint8).reshape(3, 3, 3) + right_color = np.arange(27, 54, dtype=np.uint8).reshape(3, 3, 3) + frame_bundle = ZEDFrameBundle( + color=left_color, + right_color=right_color, + timestamp=12.5, + color_intrinsics=left_intrinsics, + right_color_intrinsics=right_intrinsics, + ) + device_info = ZEDDeviceInfo(serial="123", model="ZED Mini", has_depth=True, has_imu=False) + opened = FakeOpenedZEDCamera(device_info=device_info, color_intrinsics=left_intrinsics, frame_bundle=frame_bundle) + patch_zed["devices"] = {"123": device_info} + patch_zed["opened"] = {"123": opened} + + camera_set = ZEDCameraSet( + cameras={ + "wrist": common.BaseCameraConfig( + identifier="123", resolution_width=1280, resolution_height=720, frame_rate=30 + ) + }, + include_right=True, + ) + + assert camera_set.camera_names == ["wrist", "wrist_right"] + assert camera_set.config("wrist_right").identifier == "123" + + camera_set.open() + assert patch_zed["open_calls"] == [("123", True, False, True)] + left_frame = camera_set.poll_frame("wrist") + right_frame = camera_set.poll_frame("wrist_right") + + assert opened.grab_calls == [True] + assert np.array_equal(left_frame.camera.color.data, left_color) + assert np.array_equal(right_frame.camera.color.data, right_color) + assert np.array_equal(left_frame.camera.color.intrinsics, left_intrinsics) + assert np.array_equal(right_frame.camera.color.intrinsics, right_intrinsics) + assert left_frame.avg_timestamp == right_frame.avg_timestamp == 12.5 + assert left_frame.camera.depth is None + assert right_frame.camera.depth is None From 0144e4729436d2062341eb3bbed71c5150baee71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 8 May 2026 16:57:31 +0200 Subject: [PATCH 24/87] feat(inference): add initial inference loop script --- examples/inference/README.md | 0 examples/inference/franka.py | 236 ++++++++++++++++++++++++++++ examples/inference/requirements.txt | 1 + 3 files changed, 237 insertions(+) create mode 100644 examples/inference/README.md create mode 100644 examples/inference/franka.py create mode 100644 examples/inference/requirements.txt diff --git a/examples/inference/README.md b/examples/inference/README.md new file mode 100644 index 00000000..e69de29b diff --git a/examples/inference/franka.py b/examples/inference/franka.py new file mode 100644 index 00000000..8ac52572 --- /dev/null +++ b/examples/inference/franka.py @@ -0,0 +1,236 @@ +from dataclasses import dataclass +import datetime +import logging +from typing import Any + +import numpy as np +from rcs._core.common import BaseCameraConfig, RobotPlatform +from rcs._core.sim import SimConfig +from rcs.envs.base import ControlMode, RelativeTo +from rcs.envs.configs import EmptyWorldFR3Duo +import gymnasium as gym + +import rcs +from rcs.envs.tasks import PickTaskConfig +from vlagents.client import RemoteAgent +from vlagents.policies import Act, Obs + +logger = logging.getLogger(__name__) + + +ROBOT2IP = { + "right": "192.168.102.1", + "left": "192.168.101.1", +} +ROBOT2ID = { + "left": "1", + "right": "0", +} + + +ROBOT_INSTANCE = RobotPlatform.SIMULATION +# ROBOT_INSTANCE = RobotPlatform.HARDWARE + +# set camera dict to none disable cameras +# CAMERA_DICT = { +# "left_wrist": "230422272017", +# "right_wrist": "230422271040", +# "side": "243522070385", +# "bird_eye": "243522070364", +# } +CAMERA_DICT = None +ZED_CAMERA_DICT = { + "zed": "19928076", +} +INCLUDE_DEPTH = False + + +# DIGIT_DICT = { +# "digit_right_left": "D21182", +# "digit_right_right": "D21193" +# } +DIGIT_DICT = None + + +DATASET_PATH = "test_iris" +INSTRUCTION = "pick up cube" +RECORD_FPS = 30 +CONTROL_MODE = ControlMode.JOINTS +RELATIVETO = RelativeTo.NONE +DEBUG = True +VIDEO_PATH = "videos" +MODEL = "pi05" +IP = "" +PORT = 20997 + + +robot2world = { + "right": rcs.common.Pose( + translation=np.array([0, 0, 0]), rpy_vector=np.array([0.89360858, -0.17453293, 0.46425758]) + ), + "left": rcs.common.Pose( + translation=np.array([0, 0, 0]), rpy_vector=np.array([-0.89360858, -0.17453293, -0.46425758]) + ), +} + +@dataclass +class InferenceConfig: + vlagents_host: str + vlagents_port: int + vlagents_model: str + instruction: str + robot_keys: list[str] + jpeg_encoding: bool = True + on_same_machine: bool = False + +class ModelInference: + def __init__(self, env: gym.Env, cfg: InferenceConfig): + self.env = env + self.gripper_state = 1 + self._cfg = cfg + self.remote_agent = RemoteAgent(cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding) + + + def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: + cameras = {} + for frame in obs["frames"]: + cameras[frame] = obs["frames"][frame]["rgb"]["data"] + state = [] + for robot in self._cfg.robot_keys: + # TODO: currently hardcoded for joints + state.append(obs[robot]["joints"]) + state.append(obs[robot]["gripper"]) + + return Obs(cameras=None, gripper=None, info=info, state=np.concatenate(state)) + + def action_agents2rcs(self, action: Act) -> dict[str, Any]: + act = {} + for idx, robot in enumerate(self._cfg.robot_keys): + # TODO: this is currently hard coded for franka joints + act[robot] = {} + act[robot]["joints"] = action.action[idx*8:idx*8+7] + act[robot]["gripper"] = action.action[idx*8+7] + return act + + + def loop(self): + obs, _ = self.env.reset() + + obs_dict = self.obs_rcs2agents(obs) + + self.remote_agent.reset(obs_dict, instruction=self._cfg.instruction) + + while True: + action = self.remote_agent.act(obs_dict) + if action.done: + logger.info("done issued by agent, shutting down") + break + obs, _, _, _, info = self.env.step(self.action_agents2rcs(action)) + + obs_dict = self.obs_rcs2agents(obs) + + +def get_env(): + if ROBOT_INSTANCE == RobotPlatform.HARDWARE: + from rcs_fr3.configs import FrankaDuoEnv + from rcs_fr3.creators import HardwareCameraCreatorConfig + + env_creator = FrankaDuoEnv() + env_creator.left_ip = ROBOT2IP["left"] + env_creator.right_ip = ROBOT2IP["right"] + hw_cfg = env_creator.config() + camera_cfgs: dict[str, HardwareCameraCreatorConfig] = {} + if CAMERA_DICT is not None: + camera_cfgs["realsense"] = HardwareCameraCreatorConfig( + camera_type_id="realsense", + camera_cfgs={ + name: BaseCameraConfig( + identifier=identifier, + resolution_width=1280, + resolution_height=720, + frame_rate=30, + ) + for name, identifier in CAMERA_DICT.items() + }, + ) + if ZED_CAMERA_DICT is not None: + camera_cfgs["zed"] = HardwareCameraCreatorConfig( + camera_type_id="zed", + camera_cfgs={ + name: BaseCameraConfig( + identifier=identifier, + resolution_width=1280, + resolution_height=720, + frame_rate=30, + ) + for name, identifier in ZED_CAMERA_DICT.items() + }, + kwargs={ + "enable_depth": False, + "enable_imu": False, + }, + ) + if DIGIT_DICT is not None: + camera_cfgs["digit"] = HardwareCameraCreatorConfig( + camera_type_id="digit", + camera_cfgs={ + name: BaseCameraConfig( + identifier=identifier, + resolution_width=320, + resolution_height=240, + frame_rate=30, + ) + for name, identifier in DIGIT_DICT.items() + }, + ) + hw_cfg.camera_cfgs = camera_cfgs or None + hw_cfg.control_mode = CONTROL_MODE + hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH + hw_cfg.max_relative_movement = ( + 0.5 if CONTROL_MODE == ControlMode.JOINTS else (0.5, np.deg2rad(90)) + ) + hw_cfg.relative_to = RELATIVETO + hw_cfg.robot_to_shared_base_frame = robot2world + env_rel = env_creator.create_env(hw_cfg) + else: + # FR3 + + scene = EmptyWorldFR3Duo() + sim_cfg_data = scene.config() + sim_cfg_data.sim_cfg = SimConfig( + async_control=True, realtime=True, frequency=RECORD_FPS, max_convergence_steps=500 + ) + sim_cfg_data.relative_to = RelativeTo.CONFIGURED_ORIGIN + sim_cfg_data.wrapper_cfg.include_depth = INCLUDE_DEPTH + if sim_cfg_data.root_frame_objects is None: + sim_cfg_data.root_frame_objects = {} + sim_cfg_data.task_cfg = PickTaskConfig(robot_name="right") + + env_rel = scene.create_env(sim_cfg_data) + + return env_rel + + +def main(): + env_rel = get_env() + env_rel.reset() + + VIDEO_PATH.mkdir(parents=True, exist_ok=True) + timestamp = str(datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) + + + camera_set = env_rel.get_wrapper_attr("camera_set") + camera_set.record_video(VIDEO_PATH, timestamp) + + # env = RHCWrapper(env, exec_horizon=1) + + cfg = InferenceConfig(IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=True, robot_keys=["left", "right"]) + controller = ModelInference(env_rel, cfg) + input("robot is about to be controlled by AI, press enter to start") + with env_rel: + controller.loop() + + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/examples/inference/requirements.txt b/examples/inference/requirements.txt new file mode 100644 index 00000000..cb843744 --- /dev/null +++ b/examples/inference/requirements.txt @@ -0,0 +1 @@ +vlagents @ git+https://github.com/RobotControlStack/vlagents.git@lerobot \ No newline at end of file From 0931f929b883f8a919520a48cd965bbf639b97e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Thu, 14 May 2026 14:42:39 +0200 Subject: [PATCH 25/87] style: format inference franka script --- examples/inference/franka.py | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 8ac52572..bbd0c053 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -1,17 +1,17 @@ -from dataclasses import dataclass import datetime import logging +from dataclasses import dataclass from typing import Any +import gymnasium as gym import numpy as np from rcs._core.common import BaseCameraConfig, RobotPlatform from rcs._core.sim import SimConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3Duo -import gymnasium as gym +from rcs.envs.tasks import PickTaskConfig import rcs -from rcs.envs.tasks import PickTaskConfig from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs @@ -73,6 +73,7 @@ ), } + @dataclass class InferenceConfig: vlagents_host: str @@ -83,13 +84,15 @@ class InferenceConfig: jpeg_encoding: bool = True on_same_machine: bool = False + class ModelInference: def __init__(self, env: gym.Env, cfg: InferenceConfig): self.env = env self.gripper_state = 1 self._cfg = cfg - self.remote_agent = RemoteAgent(cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding) - + self.remote_agent = RemoteAgent( + cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding + ) def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} @@ -108,11 +111,10 @@ def action_agents2rcs(self, action: Act) -> dict[str, Any]: for idx, robot in enumerate(self._cfg.robot_keys): # TODO: this is currently hard coded for franka joints act[robot] = {} - act[robot]["joints"] = action.action[idx*8:idx*8+7] - act[robot]["gripper"] = action.action[idx*8+7] + act[robot]["joints"] = action.action[idx * 8 : idx * 8 + 7] + act[robot]["gripper"] = action.action[idx * 8 + 7] return act - def loop(self): obs, _ = self.env.reset() @@ -186,9 +188,7 @@ def get_env(): hw_cfg.camera_cfgs = camera_cfgs or None hw_cfg.control_mode = CONTROL_MODE hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH - hw_cfg.max_relative_movement = ( - 0.5 if CONTROL_MODE == ControlMode.JOINTS else (0.5, np.deg2rad(90)) - ) + hw_cfg.max_relative_movement = 0.5 if CONTROL_MODE == ControlMode.JOINTS else (0.5, np.deg2rad(90)) hw_cfg.relative_to = RELATIVETO hw_cfg.robot_to_shared_base_frame = robot2world env_rel = env_creator.create_env(hw_cfg) @@ -212,25 +212,25 @@ def get_env(): def main(): - env_rel = get_env() + env_rel = get_env() env_rel.reset() VIDEO_PATH.mkdir(parents=True, exist_ok=True) - timestamp = str(datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) - + timestamp = str(datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) camera_set = env_rel.get_wrapper_attr("camera_set") camera_set.record_video(VIDEO_PATH, timestamp) # env = RHCWrapper(env, exec_horizon=1) - cfg = InferenceConfig(IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=True, robot_keys=["left", "right"]) + cfg = InferenceConfig( + IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=True, robot_keys=["left", "right"] + ) controller = ModelInference(env_rel, cfg) input("robot is about to be controlled by AI, press enter to start") with env_rel: controller.loop() - if __name__ == "__main__": - main() \ No newline at end of file + main() From c736087dcd68b10faad030b5480c04803292b016 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Thu, 14 May 2026 19:22:37 +0200 Subject: [PATCH 26/87] fix(franka): inference script after testing Co-authored-by: Copilot --- docker/Dockerfile | 4 +- docker/link-editable-source.sh | 1 + examples/inference/franka.py | 67 +++++++++++++++++++++------------- 3 files changed, 46 insertions(+), 26 deletions(-) diff --git a/docker/Dockerfile b/docker/Dockerfile index b72bde92..9c88e253 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -54,7 +54,9 @@ RUN chmod +x /usr/local/bin/link-editable-source \ && uv pip install /opt/rcs-src/extensions/rcs_realsense \ && uv pip install /opt/rcs-src/extensions/rcs_robotiq2f85 \ && uv pip install /opt/rcs-src/extensions/rcs_zed \ - && uv pip install /opt/rcs-src/examples/teleop/SimPublisher + && uv pip install /opt/rcs-src/examples/teleop/SimPublisher \ + && uv pip install /opt/rcs-src/2f85-python-driver \ + && uv pip install /opt/rcs-src/vlagents WORKDIR /workspace/robot-control-stack diff --git a/docker/link-editable-source.sh b/docker/link-editable-source.sh index 0a93db47..02bf007e 100644 --- a/docker/link-editable-source.sh +++ b/docker/link-editable-source.sh @@ -44,3 +44,4 @@ link_compiled_package "$REPO_ROOT/extensions/rcs_fr3/src/rcs_fr3" "$SITE_PACKAGE link_pure_python_package "$REPO_ROOT/extensions/rcs_realsense/src/rcs_realsense" "$SITE_PACKAGES/rcs_realsense" link_pure_python_package "$REPO_ROOT/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85" "$SITE_PACKAGES/rcs_robotiq2f85" link_pure_python_package "$REPO_ROOT/extensions/rcs_zed/src/rcs_zed" "$SITE_PACKAGES/rcs_zed" +link_pure_python_package "$REPO_ROOT/vlagents" "$SITE_PACKAGES/vlagents" diff --git a/examples/inference/franka.py b/examples/inference/franka.py index bbd0c053..37bb8bae 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -1,8 +1,13 @@ +import copy import datetime import logging from dataclasses import dataclass +from pathlib import Path +from time import sleep from typing import Any +from rcs.utils import SimpleFrameRate + import gymnasium as gym import numpy as np from rcs._core.common import BaseCameraConfig, RobotPlatform @@ -28,22 +33,26 @@ } -ROBOT_INSTANCE = RobotPlatform.SIMULATION -# ROBOT_INSTANCE = RobotPlatform.HARDWARE +# ROBOT_INSTANCE = RobotPlatform.SIMULATION +ROBOT_INSTANCE = RobotPlatform.HARDWARE # set camera dict to none disable cameras -# CAMERA_DICT = { -# "left_wrist": "230422272017", -# "right_wrist": "230422271040", -# "side": "243522070385", -# "bird_eye": "243522070364", -# } -CAMERA_DICT = None +CAMERA_DICT = { + "left_wrist": "230422272017", + "right_wrist": "230422271040", + # "side": "243522070385", + # "bird_eye": "243522070364", +} +# CAMERA_DICT = None ZED_CAMERA_DICT = { - "zed": "19928076", + "head": "19928076", } INCLUDE_DEPTH = False +ROBOTIQ_SERIAL = { + "left": "DAAQMPDC", + "right": "DAAQMJHX", +} # DIGIT_DICT = { # "digit_right_left": "D21182", @@ -52,16 +61,15 @@ DIGIT_DICT = None -DATASET_PATH = "test_iris" -INSTRUCTION = "pick up cube" +INSTRUCTION = "pick up the black cube with the right arm and place it into the black bowl; pick up the white cube with the left arm and place it into the white bowl" RECORD_FPS = 30 CONTROL_MODE = ControlMode.JOINTS RELATIVETO = RelativeTo.NONE DEBUG = True VIDEO_PATH = "videos" -MODEL = "pi05" -IP = "" -PORT = 20997 +MODEL = "lerobot" +IP = "172.29.5.16" +PORT = 20000 robot2world = { @@ -93,6 +101,7 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self.remote_agent = RemoteAgent( cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding ) + self.frame_rate = SimpleFrameRate(RECORD_FPS) def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} @@ -104,7 +113,7 @@ def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: state.append(obs[robot]["joints"]) state.append(obs[robot]["gripper"]) - return Obs(cameras=None, gripper=None, info=info, state=np.concatenate(state)) + return Obs(cameras=cameras, gripper=None, info=info, state=np.concatenate(state)) def action_agents2rcs(self, action: Act) -> dict[str, Any]: act = {} @@ -112,7 +121,7 @@ def action_agents2rcs(self, action: Act) -> dict[str, Any]: # TODO: this is currently hard coded for franka joints act[robot] = {} act[robot]["joints"] = action.action[idx * 8 : idx * 8 + 7] - act[robot]["gripper"] = action.action[idx * 8 + 7] + act[robot]["gripper"] = action.action[idx * 8 + 7 : idx * 8 + 8] return act def loop(self): @@ -120,16 +129,18 @@ def loop(self): obs_dict = self.obs_rcs2agents(obs) - self.remote_agent.reset(obs_dict, instruction=self._cfg.instruction) + self.remote_agent.reset(copy.deepcopy(obs_dict), instruction=self._cfg.instruction) while True: - action = self.remote_agent.act(obs_dict) + action = self.remote_agent.act(copy.deepcopy(obs_dict)) if action.done: logger.info("done issued by agent, shutting down") break - obs, _, _, _, info = self.env.step(self.action_agents2rcs(action)) + a = self.action_agents2rcs(action) + obs, _, _, _, info = self.env.step(a) obs_dict = self.obs_rcs2agents(obs) + self.frame_rate() def get_env(): @@ -191,6 +202,12 @@ def get_env(): hw_cfg.max_relative_movement = 0.5 if CONTROL_MODE == ControlMode.JOINTS else (0.5, np.deg2rad(90)) hw_cfg.relative_to = RELATIVETO hw_cfg.robot_to_shared_base_frame = robot2world + hw_cfg.robot_cfgs["left"].ignore_realtime = True + hw_cfg.robot_cfgs["right"].ignore_realtime = True + hw_cfg.robot_cfgs["left"].speed_factor = 0.3 + hw_cfg.robot_cfgs["right"].speed_factor = 0.3 + hw_cfg.gripper_cfgs["left"].serial_number = ROBOTIQ_SERIAL["left"] + hw_cfg.gripper_cfgs["right"].serial_number = ROBOTIQ_SERIAL["right"] env_rel = env_creator.create_env(hw_cfg) else: # FR3 @@ -215,16 +232,16 @@ def main(): env_rel = get_env() env_rel.reset() - VIDEO_PATH.mkdir(parents=True, exist_ok=True) - timestamp = str(datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) + # Path(VIDEO_PATH).mkdir(parents=True, exist_ok=True) + # timestamp = str(datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")) - camera_set = env_rel.get_wrapper_attr("camera_set") - camera_set.record_video(VIDEO_PATH, timestamp) + # camera_set = env_rel.get_wrapper_attr("camera_set") + # camera_set.record_video(Path(VIDEO_PATH), timestamp) # env = RHCWrapper(env, exec_horizon=1) cfg = InferenceConfig( - IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=True, robot_keys=["left", "right"] + IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=False, robot_keys=["left", "right"] ) controller = ModelInference(env_rel, cfg) input("robot is about to be controlled by AI, press enter to start") From 3f34995e5f28c833ea606cc7bdc475a45d3b5d73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Mon, 18 May 2026 14:17:53 +0200 Subject: [PATCH 27/87] feat: sim inference --- examples/inference/franka.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 37bb8bae..93ff6f18 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -5,6 +5,7 @@ from pathlib import Path from time import sleep from typing import Any +from PIL import Image from rcs.utils import SimpleFrameRate @@ -17,6 +18,7 @@ from rcs.envs.tasks import PickTaskConfig import rcs +from rcs_duobench.tasks.bin_sort import BinSortEnvConfig from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs @@ -107,6 +109,8 @@ def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} for frame in obs["frames"]: cameras[frame] = obs["frames"][frame]["rgb"]["data"] + cameras[frame] = np.array(Image.fromarray(cameras[frame]).resize((224, 224), Image.Resampling.LANCZOS)) + state = [] for robot in self._cfg.robot_keys: # TODO: currently hardcoded for joints @@ -212,16 +216,21 @@ def get_env(): else: # FR3 - scene = EmptyWorldFR3Duo() + scene = BinSortEnvConfig() sim_cfg_data = scene.config() sim_cfg_data.sim_cfg = SimConfig( - async_control=True, realtime=True, frequency=RECORD_FPS, max_convergence_steps=500 + async_control=True, realtime=False, frequency=RECORD_FPS, max_convergence_steps=500 ) sim_cfg_data.relative_to = RelativeTo.CONFIGURED_ORIGIN sim_cfg_data.wrapper_cfg.include_depth = INCLUDE_DEPTH - if sim_cfg_data.root_frame_objects is None: - sim_cfg_data.root_frame_objects = {} - sim_cfg_data.task_cfg = PickTaskConfig(robot_name="right") + sim_cfg_data.control_mode = ControlMode.JOINTS + sim_cfg_data.relative_to = RELATIVETO + sim_cfg_data.wrapper_cfg.binary_gripper = True + + + # if sim_cfg_data.root_frame_objects is None: + # sim_cfg_data.root_frame_objects = {} + # sim_cfg_data.task_cfg = PickTaskConfig(robot_name="right") env_rel = scene.create_env(sim_cfg_data) From f3a6b7322764455ee2a4911a16b3b8302adff109 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Mon, 18 May 2026 15:06:25 +0200 Subject: [PATCH 28/87] fix: patch always open gripper observation --- examples/inference/franka.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 93ff6f18..fd1acdb7 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -142,6 +142,8 @@ def loop(self): break a = self.action_agents2rcs(action) obs, _, _, _, info = self.env.step(a) + # print(obs["left"]["joints"], obs["left"]["gripper"], obs["right"]["joints"], obs["right"]["gripper"]) + obs["left"]["gripper"] = obs["right"]["gripper"] = 1.0 obs_dict = self.obs_rcs2agents(obs) self.frame_rate() From cc9cce791cc3d8aa27029df72cf5a817e12d6361 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 10:31:20 +0200 Subject: [PATCH 29/87] feat: reconnect and keyboard control --- examples/inference/franka.py | 143 ++++++++++++++++++++++++++++------- 1 file changed, 115 insertions(+), 28 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index fd1acdb7..1d29ca13 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -1,11 +1,13 @@ import copy import datetime +import json import logging -from dataclasses import dataclass +from dataclasses import asdict, dataclass, field from pathlib import Path from time import sleep from typing import Any from PIL import Image +import threading from rcs.utils import SimpleFrameRate @@ -22,6 +24,8 @@ from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs +from pynput import keyboard + logger = logging.getLogger(__name__) @@ -35,8 +39,8 @@ } -# ROBOT_INSTANCE = RobotPlatform.SIMULATION -ROBOT_INSTANCE = RobotPlatform.HARDWARE +ROBOT_INSTANCE = RobotPlatform.SIMULATION +# ROBOT_INSTANCE = RobotPlatform.HARDWARE # set camera dict to none disable cameras CAMERA_DICT = { @@ -64,14 +68,14 @@ INSTRUCTION = "pick up the black cube with the right arm and place it into the black bowl; pick up the white cube with the left arm and place it into the white bowl" -RECORD_FPS = 30 +FPS = 30 CONTROL_MODE = ControlMode.JOINTS RELATIVETO = RelativeTo.NONE -DEBUG = True -VIDEO_PATH = "videos" +RECORD_PATH = "inference_recordings" MODEL = "lerobot" -IP = "172.29.5.16" +IP = "localhost" PORT = 20000 +CONFIG_PATH = Path(__file__).with_suffix(".json") robot2world = { @@ -86,13 +90,23 @@ @dataclass class InferenceConfig: - vlagents_host: str - vlagents_port: int - vlagents_model: str - instruction: str - robot_keys: list[str] + vlagents_host: str = IP + vlagents_port: int = PORT + vlagents_model: str = MODEL + instruction: str = INSTRUCTION + robot_keys: list[str] = field(default_factory=lambda: ["left", "right"]) jpeg_encoding: bool = True on_same_machine: bool = False + fps: int = FPS + record_path: str = RECORD_PATH + + +def load_inference_config() -> InferenceConfig: + if not CONFIG_PATH.exists(): + CONFIG_PATH.write_text(json.dumps(asdict(InferenceConfig()), indent=2) + "\n") + return InferenceConfig() + return InferenceConfig(**json.loads(CONFIG_PATH.read_text())) + class ModelInference: @@ -100,10 +114,33 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self.env = env self.gripper_state = 1 self._cfg = cfg + self._episode_running = False + self._start_requested = False + self._stop_requested = False + self._reload_requested = False + self._cmd_lock = threading.Lock() self.remote_agent = RemoteAgent( cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding ) - self.frame_rate = SimpleFrameRate(RECORD_FPS) + self.frame_rate = SimpleFrameRate(self._cfg.fps) + self._listener = keyboard.Listener(on_press=self._on_press) + self._listener.start() + + def _on_press(self, key): + try: + if not hasattr(key, "char"): + return + if key.char == "e": + with self._cmd_lock: + self._start_requested = True + elif key.char == "q": + with self._cmd_lock: + self._stop_requested = True + elif key.char == "o": + with self._cmd_lock: + self._reload_requested = True + except AttributeError: + pass def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} @@ -130,26 +167,78 @@ def action_agents2rcs(self, action: Act) -> dict[str, Any]: def loop(self): obs, _ = self.env.reset() - obs_dict = self.obs_rcs2agents(obs) - - self.remote_agent.reset(copy.deepcopy(obs_dict), instruction=self._cfg.instruction) + logger.info("waiting for 'e' to start an episode, 'q' to stop and reset, and 'o' to reload config") while True: + with self._cmd_lock: + start_requested = self._start_requested + stop_requested = self._stop_requested + reload_requested = self._reload_requested + self._start_requested = False + self._stop_requested = False + self._reload_requested = False + + if reload_requested: + self._cfg = load_inference_config() + try: + self.remote_agent.reconnect( + host=self._cfg.vlagents_host, + port=self._cfg.vlagents_port, + model=self._cfg.vlagents_model, + on_same_machine=self._cfg.on_same_machine, + jpeg_encoding=self._cfg.jpeg_encoding, + ) + logger.info( + "reloaded config from %s with host=%s port=%s model=%s", + CONFIG_PATH, + self._cfg.vlagents_host, + self._cfg.vlagents_port, + self._cfg.vlagents_model, + ) + except Exception: + logger.exception("failed to reconnect after reloading %s", CONFIG_PATH) + obs, _ = self.env.reset() + obs_dict = self.obs_rcs2agents(obs) + self._episode_running = False + + if stop_requested: + if self._episode_running: + logger.info("stopping episode and resetting environment") + obs, _ = self.env.reset() + obs_dict = self.obs_rcs2agents(obs) + self._episode_running = False + + if not self._episode_running: + try: + self.remote_agent.ensure_connected() + except Exception: + sleep(0.5) + continue + if start_requested: + logger.info("starting episode") + self.remote_agent.reset(copy.deepcopy(obs_dict), instruction=self._cfg.instruction) + self._episode_running = True + else: + sleep(0.05) + continue + action = self.remote_agent.act(copy.deepcopy(obs_dict)) if action.done: - logger.info("done issued by agent, shutting down") - break + logger.info("done issued by agent, resetting environment") + obs, _ = self.env.reset() + obs_dict = self.obs_rcs2agents(obs) + self._episode_running = False + continue a = self.action_agents2rcs(action) obs, _, _, _, info = self.env.step(a) # print(obs["left"]["joints"], obs["left"]["gripper"], obs["right"]["joints"], obs["right"]["gripper"]) - obs["left"]["gripper"] = obs["right"]["gripper"] = 1.0 obs_dict = self.obs_rcs2agents(obs) self.frame_rate() -def get_env(): +def get_env(cfg: InferenceConfig) -> gym.Env: if ROBOT_INSTANCE == RobotPlatform.HARDWARE: from rcs_fr3.configs import FrankaDuoEnv from rcs_fr3.creators import HardwareCameraCreatorConfig @@ -210,8 +299,8 @@ def get_env(): hw_cfg.robot_to_shared_base_frame = robot2world hw_cfg.robot_cfgs["left"].ignore_realtime = True hw_cfg.robot_cfgs["right"].ignore_realtime = True - hw_cfg.robot_cfgs["left"].speed_factor = 0.3 - hw_cfg.robot_cfgs["right"].speed_factor = 0.3 + hw_cfg.robot_cfgs["left"].speed_factor = 0.1 + hw_cfg.robot_cfgs["right"].speed_factor = 0.1 hw_cfg.gripper_cfgs["left"].serial_number = ROBOTIQ_SERIAL["left"] hw_cfg.gripper_cfgs["right"].serial_number = ROBOTIQ_SERIAL["right"] env_rel = env_creator.create_env(hw_cfg) @@ -221,7 +310,7 @@ def get_env(): scene = BinSortEnvConfig() sim_cfg_data = scene.config() sim_cfg_data.sim_cfg = SimConfig( - async_control=True, realtime=False, frequency=RECORD_FPS, max_convergence_steps=500 + async_control=True, realtime=False, frequency=cfg.fps, max_convergence_steps=500 ) sim_cfg_data.relative_to = RelativeTo.CONFIGURED_ORIGIN sim_cfg_data.wrapper_cfg.include_depth = INCLUDE_DEPTH @@ -240,7 +329,7 @@ def get_env(): def main(): - env_rel = get_env() + env_rel = get_env(cfg) env_rel.reset() # Path(VIDEO_PATH).mkdir(parents=True, exist_ok=True) @@ -251,11 +340,9 @@ def main(): # env = RHCWrapper(env, exec_horizon=1) - cfg = InferenceConfig( - IP, PORT, MODEL, INSTRUCTION, jpeg_encoding=True, on_same_machine=False, robot_keys=["left", "right"] - ) + cfg = load_inference_config() controller = ModelInference(env_rel, cfg) - input("robot is about to be controlled by AI, press enter to start") + input("robot is about to be controlled by AI, press enter to enable keyboard control") with env_rel: controller.loop() From 22fa5bee9eb953e4d5fc1bcde50b62a1c2e4e733 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 10:31:44 +0200 Subject: [PATCH 30/87] feat: optionally record --- examples/inference/franka.py | 31 ++++++++++++++++++++++++++----- 1 file changed, 26 insertions(+), 5 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 1d29ca13..e00a1ab5 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -17,6 +17,7 @@ from rcs._core.sim import SimConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3Duo +from rcs.envs.storage_wrapper import StorageWrapper from rcs.envs.tasks import PickTaskConfig import rcs @@ -116,6 +117,7 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self._cfg = cfg self._episode_running = False self._start_requested = False + self._record_requested = False self._stop_requested = False self._reload_requested = False self._cmd_lock = threading.Lock() @@ -133,6 +135,9 @@ def _on_press(self, key): if key.char == "e": with self._cmd_lock: self._start_requested = True + elif key.char == "r": + with self._cmd_lock: + self._record_requested = True elif key.char == "q": with self._cmd_lock: self._stop_requested = True @@ -168,14 +173,16 @@ def action_agents2rcs(self, action: Act) -> dict[str, Any]: def loop(self): obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) - logger.info("waiting for 'e' to start an episode, 'q' to stop and reset, and 'o' to reload config") + logger.info("waiting for 'e' to start, 'r' to start and record, 'q' to stop and reset, and 'o' to reload config") while True: with self._cmd_lock: start_requested = self._start_requested + record_requested = self._record_requested stop_requested = self._stop_requested reload_requested = self._reload_requested self._start_requested = False + self._record_requested = False self._stop_requested = False self._reload_requested = False @@ -198,6 +205,9 @@ def loop(self): ) except Exception: logger.exception("failed to reconnect after reloading %s", CONFIG_PATH) + if isinstance(self.env, StorageWrapper): + self.env.base_dir = self._cfg.record_path + self.env.set_instruction(self._cfg.instruction) obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) self._episode_running = False @@ -215,8 +225,12 @@ def loop(self): except Exception: sleep(0.5) continue - if start_requested: - logger.info("starting episode") + if start_requested or record_requested: + if isinstance(self.env, StorageWrapper): + self.env.set_instruction(self._cfg.instruction) + if record_requested: + self.env.start_record() + logger.info("starting episode%s", " with recording" if record_requested else "") self.remote_agent.reset(copy.deepcopy(obs_dict), instruction=self._cfg.instruction) self._episode_running = True else: @@ -325,10 +339,18 @@ def get_env(cfg: InferenceConfig) -> gym.Env: env_rel = scene.create_env(sim_cfg_data) - return env_rel + return StorageWrapper( + env_rel, + cfg.record_path, + cfg.instruction, + batch_size=32, + max_rows_per_group=2, + max_rows_per_file=10, + ) def main(): + cfg = load_inference_config() env_rel = get_env(cfg) env_rel.reset() @@ -340,7 +362,6 @@ def main(): # env = RHCWrapper(env, exec_horizon=1) - cfg = load_inference_config() controller = ModelInference(env_rel, cfg) input("robot is about to be controlled by AI, press enter to enable keyboard control") with env_rel: From 72d3ec814d55d78f33f4090aea137c93a7426fd0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 11:06:17 +0200 Subject: [PATCH 31/87] feat: added mp4 video converter from recording --- python/rcs/__main__.py | 23 +++++++++ python/rcs/utils.py | 108 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 131 insertions(+) diff --git a/python/rcs/__main__.py b/python/rcs/__main__.py index 32dd98a4..4f97eae0 100644 --- a/python/rcs/__main__.py +++ b/python/rcs/__main__.py @@ -21,6 +21,7 @@ run_conversion, ) from rcs.sim.replayer import replay as replay_dataset +from rcs.utils import export_episode_videos app = typer.Typer() @@ -195,5 +196,27 @@ def lerobot_convert( ) +@app.command("episode-videos") +def episode_videos( + dataset: Annotated[ + Path, + typer.Argument( + exists=True, + help="Parquet dataset file or directory with parquet parts.", + ), + ], + output: Annotated[ + Path, + typer.Argument( + exists=False, + help="Output directory for episode mp4 files.", + ), + ], + fps: Annotated[int, typer.Option(help="Video frames per second.")] = DEFAULT_FPS, + n: Annotated[int, typer.Option(help="Maximum number of episodes to export. -1 means all.")] = -1, +): + export_episode_videos(dataset=dataset, output=output, fps=fps, n=n) + + if __name__ == "__main__": app() diff --git a/python/rcs/utils.py b/python/rcs/utils.py index 25ef2abb..b2f97cd3 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -1,6 +1,15 @@ +import datetime import logging +import math +import subprocess +from pathlib import Path from time import perf_counter, sleep +import duckdb +import numpy as np +import torch +from torchvision.io import decode_jpeg + logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) @@ -44,3 +53,102 @@ def __enter__(self): def __exit__(self, *args): pass + + +def _write_mp4(frames: list[np.ndarray], output_path: Path, fps: int) -> None: + if not frames: + return + + height, width = frames[0].shape[:2] + process = subprocess.Popen( + [ + "ffmpeg", + "-y", + "-f", + "rawvideo", + "-pix_fmt", + "rgb24", + "-s", + f"{width}x{height}", + "-r", + str(fps), + "-i", + "-", + "-an", + "-vf", + "pad=ceil(iw/2)*2:ceil(ih/2)*2", + "-c:v", + "libx264", + "-pix_fmt", + "yuv420p", + "-movflags", + "+faststart", + str(output_path), + ], + stdin=subprocess.PIPE, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + assert process.stdin is not None + for frame in frames: + process.stdin.write(np.ascontiguousarray(frame).astype(np.uint8).tobytes()) + process.stdin.close() + process.wait() + + +def export_episode_videos( + dataset: str | Path, + output: str | Path, + fps: int = 30, + n: int = -1, +) -> None: + dataset = Path(dataset) + output = Path(output) + output.mkdir(parents=True, exist_ok=True) + + source = str(dataset / "*.parquet") if dataset.is_dir() else str(dataset) + source_escaped = source.replace("'", "''") + conn = duckdb.connect() + relation = conn.sql(f"SELECT * FROM read_parquet('{source_escaped}')") + frame_struct = relation.select("obs.frames").types[0] + camera_names = [name for name, _ in frame_struct.children] + + uuids = conn.execute(f"SELECT DISTINCT uuid FROM read_parquet('{source_escaped}') ORDER BY uuid").fetchall() + for index, (episode_id,) in enumerate(uuids): + if n != -1 and index >= n: + break + + image_selects = ", ".join(f"obs.frames.{camera}.rgb.data AS {camera}" for camera in camera_names) + not_null_checks = " ".join(f"AND obs.frames.{camera}.rgb.data IS NOT NULL" for camera in camera_names) + rows = conn.execute( + f""" + SELECT timestamp, {image_selects} + FROM read_parquet('{source_escaped}') + WHERE uuid = ? + {not_null_checks} + ORDER BY step + """, + [episode_id], + ).fetchall() + if not rows: + continue + + timestamp = datetime.datetime.fromtimestamp(float(rows[0][0])).strftime("%Y-%m-%d-%H-%M-%S") + frames = [] + cols = math.ceil(math.sqrt(len(camera_names))) + rows_per_frame = math.ceil(len(camera_names) / cols) + + for row in rows: + decoded = [ + decode_jpeg(torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8)).permute(1, 2, 0).cpu().numpy() + for image_bytes in row[1:] + ] + height, width = decoded[0].shape[:2] + tiled = np.zeros((rows_per_frame * height, cols * width, 3), dtype=np.uint8) + for camera_index, image in enumerate(decoded): + top = (camera_index // cols) * height + left = (camera_index % cols) * width + tiled[top : top + height, left : left + width] = image + frames.append(tiled) + + _write_mp4(frames, output / f"{timestamp}.mp4", fps=fps) From 9d178a87ae65424452a33fb6846a56989918e294 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 11:32:12 +0200 Subject: [PATCH 32/87] feat(mp4): added joint display --- python/rcs/utils.py | 73 +++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 67 insertions(+), 6 deletions(-) diff --git a/python/rcs/utils.py b/python/rcs/utils.py index b2f97cd3..d061ba81 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -1,13 +1,18 @@ import datetime import logging import math +import os import subprocess from pathlib import Path from time import perf_counter, sleep import duckdb +os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib") +import matplotlib +matplotlib.use("Agg") import numpy as np import torch +from matplotlib import pyplot as plt from torchvision.io import decode_jpeg logger = logging.getLogger(__name__) @@ -96,6 +101,43 @@ def _write_mp4(frames: list[np.ndarray], output_path: Path, fps: int) -> None: process.wait() +def _render_action_panel( + joint_history: dict[str, np.ndarray], + gripper_history: dict[str, np.ndarray], + step: int, + height: int, + width: int, +) -> np.ndarray: + fig, axes = plt.subplots( + len(joint_history), + 1, + figsize=(width / 100, height / 100), + dpi=100, + squeeze=False, + ) + x = np.arange(len(next(iter(joint_history.values())))) + for axis, robot_key in zip(axes[:, 0], joint_history, strict=True): + joints = joint_history[robot_key] + for joint_idx in range(joints.shape[1]): + axis.plot(x, joints[:, joint_idx], linewidth=1) + axis.axvline(step, color="tab:red", linewidth=2) + axis.set_xlim(0, max(len(x) - 1, 1)) + axis.set_title(robot_key) + axis.set_xlabel("step") + axis.set_ylabel("joint") + + gripper_axis = axis.twinx() + gripper_axis.plot(x, gripper_history[robot_key], color="black", linestyle="--", linewidth=2) + gripper_axis.set_ylabel("gripper") + gripper_axis.set_ylim(-0.1, 1.1) + + fig.tight_layout() + fig.canvas.draw() + image = np.asarray(fig.canvas.buffer_rgba())[..., :3].copy() + plt.close(fig) + return image + + def export_episode_videos( dataset: str | Path, output: str | Path, @@ -112,6 +154,7 @@ def export_episode_videos( relation = conn.sql(f"SELECT * FROM read_parquet('{source_escaped}')") frame_struct = relation.select("obs.frames").types[0] camera_names = [name for name, _ in frame_struct.children] + robot_names = [name for name, _ in relation.select("obs").types[0].children if name != "frames"] uuids = conn.execute(f"SELECT DISTINCT uuid FROM read_parquet('{source_escaped}') ORDER BY uuid").fetchall() for index, (episode_id,) in enumerate(uuids): @@ -119,10 +162,19 @@ def export_episode_videos( break image_selects = ", ".join(f"obs.frames.{camera}.rgb.data AS {camera}" for camera in camera_names) + state_selects = ", ".join( + [ + *(f"obs.{robot}.joints AS joints_{robot}" for robot in robot_names), + *( + f"COALESCE(CAST(action.{robot}.gripper[1] AS DOUBLE), obs.{robot}.gripper[1]) AS gripper_{robot}" + for robot in robot_names + ), + ] + ) not_null_checks = " ".join(f"AND obs.frames.{camera}.rgb.data IS NOT NULL" for camera in camera_names) rows = conn.execute( f""" - SELECT timestamp, {image_selects} + SELECT timestamp, {image_selects}, {state_selects} FROM read_parquet('{source_escaped}') WHERE uuid = ? {not_null_checks} @@ -135,15 +187,24 @@ def export_episode_videos( timestamp = datetime.datetime.fromtimestamp(float(rows[0][0])).strftime("%Y-%m-%d-%H-%M-%S") frames = [] - cols = math.ceil(math.sqrt(len(camera_names))) - rows_per_frame = math.ceil(len(camera_names) / cols) - - for row in rows: + joint_history = { + robot: np.asarray([row[1 + len(camera_names) + robot_idx] for row in rows], dtype=np.float32) + for robot_idx, robot in enumerate(robot_names) + } + gripper_history = { + robot: np.asarray([row[1 + len(camera_names) + len(robot_names) + robot_idx] for row in rows], dtype=np.float32) + for robot_idx, robot in enumerate(robot_names) + } + cols = math.ceil(math.sqrt(len(camera_names) + 1)) + rows_per_frame = math.ceil((len(camera_names) + 1) / cols) + + for step_idx, row in enumerate(rows): decoded = [ decode_jpeg(torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8)).permute(1, 2, 0).cpu().numpy() - for image_bytes in row[1:] + for image_bytes in row[1 : 1 + len(camera_names)] ] height, width = decoded[0].shape[:2] + decoded.append(_render_action_panel(joint_history, gripper_history, step_idx, height, width)) tiled = np.zeros((rows_per_frame * height, cols * width, 3), dtype=np.uint8) for camera_index, image in enumerate(decoded): top = (camera_index // cols) * height From 015fbbe4c7ae1b2f27e3c63a167a195f9d3ae4a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 13:45:45 +0200 Subject: [PATCH 33/87] fix: printing and sim sleep --- examples/inference/franka.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index e00a1ab5..2bd7d41e 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -78,6 +78,11 @@ PORT = 20000 CONFIG_PATH = Path(__file__).with_suffix(".json") +logging.basicConfig( + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + level=logging.INFO, +) + robot2world = { "right": rcs.common.Pose( @@ -249,7 +254,9 @@ def loop(self): # print(obs["left"]["joints"], obs["left"]["gripper"], obs["right"]["joints"], obs["right"]["gripper"]) obs_dict = self.obs_rcs2agents(obs) - self.frame_rate() + + if ROBOT_INSTANCE == RobotPlatform.HARDWARE: + self.frame_rate() def get_env(cfg: InferenceConfig) -> gym.Env: From 02ef0793e99461fe66b9c504e22fba9e8694ec67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 14:26:06 +0200 Subject: [PATCH 34/87] feat: action chunking optionally in inference script --- examples/inference/franka.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 2bd7d41e..1cfe009c 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -105,6 +105,7 @@ class InferenceConfig: on_same_machine: bool = False fps: int = FPS record_path: str = RECORD_PATH + n_action_steps: int | None = None def load_inference_config() -> InferenceConfig: @@ -132,6 +133,7 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self.frame_rate = SimpleFrameRate(self._cfg.fps) self._listener = keyboard.Listener(on_press=self._on_press) self._listener.start() + self._action_buffer = [] def _on_press(self, key): try: @@ -166,6 +168,18 @@ def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: return Obs(cameras=cameras, gripper=None, info=info, state=np.concatenate(state)) + def act(self, obs_dict) -> None: + done = False + if self._cfg.n_action_steps is None: + return self.remote_agent.act(obs_dict) + if len(self._action_buffer) == 0: + action = self.remote_agent.act(obs_dict) + selected_action = action.action[:self._cfg.n_action_steps] + self._action_buffer = selected_action.tolist() + done = action.done + act = self._action_buffer.pop(0) + return Act(action=act, done=done) + def action_agents2rcs(self, action: Act) -> dict[str, Any]: act = {} for idx, robot in enumerate(self._cfg.robot_keys): @@ -242,7 +256,7 @@ def loop(self): sleep(0.05) continue - action = self.remote_agent.act(copy.deepcopy(obs_dict)) + action = self.act(copy.deepcopy(obs_dict)) if action.done: logger.info("done issued by agent, resetting environment") obs, _ = self.env.reset() @@ -370,7 +384,6 @@ def main(): # env = RHCWrapper(env, exec_horizon=1) controller = ModelInference(env_rel, cfg) - input("robot is about to be controlled by AI, press enter to enable keyboard control") with env_rel: controller.loop() From e06bf34bb6262c162e5e24ecdb335fa0fdca7af2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 14:31:03 +0200 Subject: [PATCH 35/87] feat: support for relative actions --- examples/inference/franka.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 1cfe009c..319578db 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -177,6 +177,9 @@ def act(self, obs_dict) -> None: selected_action = action.action[:self._cfg.n_action_steps] self._action_buffer = selected_action.tolist() done = action.done + if RELATIVETO == RelativeTo.CONFIGURED_ORIGIN: + for robot in self.env.get_wrapper_attr("envs"): + self.env.get_wrapper_attr("envs")[robot].get_wrapper_attr("set_origin_to_current")() act = self._action_buffer.pop(0) return Act(action=act, done=done) From e5aafd86abdb67eba385d6f912eca117dcbb9e70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 16:12:10 +0200 Subject: [PATCH 36/87] feat: inference add success button --- examples/inference/franka.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 319578db..2d014905 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -124,6 +124,7 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self._episode_running = False self._start_requested = False self._record_requested = False + self._success_requested = False self._stop_requested = False self._reload_requested = False self._cmd_lock = threading.Lock() @@ -145,6 +146,9 @@ def _on_press(self, key): elif key.char == "r": with self._cmd_lock: self._record_requested = True + elif key.char == "s": + with self._cmd_lock: + self._success_requested = True elif key.char == "q": with self._cmd_lock: self._stop_requested = True @@ -195,16 +199,20 @@ def action_agents2rcs(self, action: Act) -> dict[str, Any]: def loop(self): obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) - logger.info("waiting for 'e' to start, 'r' to start and record, 'q' to stop and reset, and 'o' to reload config") + logger.info( + "waiting for 'e' to start, 'r' to start and record, 's' for success and reset, 'q' to stop and reset, and 'o' to reload config" + ) while True: with self._cmd_lock: start_requested = self._start_requested record_requested = self._record_requested + success_requested = self._success_requested stop_requested = self._stop_requested reload_requested = self._reload_requested self._start_requested = False self._record_requested = False + self._success_requested = False self._stop_requested = False self._reload_requested = False @@ -232,6 +240,16 @@ def loop(self): self.env.set_instruction(self._cfg.instruction) obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) + self._action_buffer = [] + self._episode_running = False + + if success_requested: + if self._episode_running: + logger.info("marking episode successful and resetting environment") + self.env.get_wrapper_attr("success")() + obs, _ = self.env.reset() + obs_dict = self.obs_rcs2agents(obs) + self._action_buffer = [] self._episode_running = False if stop_requested: @@ -239,6 +257,7 @@ def loop(self): logger.info("stopping episode and resetting environment") obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) + self._action_buffer = [] self._episode_running = False if not self._episode_running: @@ -264,6 +283,7 @@ def loop(self): logger.info("done issued by agent, resetting environment") obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) + self._action_buffer = [] self._episode_running = False continue a = self.action_agents2rcs(action) @@ -370,6 +390,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: batch_size=32, max_rows_per_group=2, max_rows_per_file=10, + allow_wrapper_instruction=False ) From 549f288c63ab92a7afd7a0e555e91190e473c897 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 16:12:47 +0200 Subject: [PATCH 37/87] fix(storage wrapper): flush keeps last to avoid success problems --- python/rcs/envs/storage_wrapper.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/python/rcs/envs/storage_wrapper.py b/python/rcs/envs/storage_wrapper.py index 497a1f03..58929bf3 100644 --- a/python/rcs/envs/storage_wrapper.py +++ b/python/rcs/envs/storage_wrapper.py @@ -182,15 +182,18 @@ def _writer_worker(self): ), ) - def _flush(self): + def _flush(self, keep_last: bool = False): + rows = self.buffer[:-1] if keep_last else self.buffer + if len(rows) == 0: + return if self.schema is None: - temp_batch = pa.RecordBatch.from_pylist(self.buffer) + temp_batch = pa.RecordBatch.from_pylist(rows) self.schema = temp_batch.schema - self.buffer[-1]["success"] = self._success - batch = pa.RecordBatch.from_pylist(self.buffer, schema=self.schema) + rows[-1]["success"] = self._success + batch = pa.RecordBatch.from_pylist(rows, schema=self.schema) self.queue.put(batch) - self.buffer.clear() + self.buffer = self.buffer[-1:] if keep_last else [] def _flatten_arrays(self, d: dict[str, Any]): # NOTE: list / tuples of arrays not supported @@ -284,7 +287,9 @@ def step(self, action): self.step_cnt += 1 if len(self.buffer) == self.batch_size: - self._flush() + # Keep the most recent row in memory so a success() right before reset() + # can still mark the episode as successful even if the batch boundary was hit. + self._flush(keep_last=True) return obs_original, reward, terminated, truncated, info From 8ff357869aca35bf2cdad7928a95c48caa996ec5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 16:13:08 +0200 Subject: [PATCH 38/87] fix(mp4): shows joint actions if available --- python/rcs/utils.py | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/python/rcs/utils.py b/python/rcs/utils.py index d061ba81..1571233c 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -153,8 +153,13 @@ def export_episode_videos( conn = duckdb.connect() relation = conn.sql(f"SELECT * FROM read_parquet('{source_escaped}')") frame_struct = relation.select("obs.frames").types[0] + action_struct = relation.select("action").types[0] camera_names = [name for name, _ in frame_struct.children] robot_names = [name for name, _ in relation.select("obs").types[0].children if name != "frames"] + action_fields_by_robot = { + robot: {field_name for field_name, _ in robot_struct.children} + for robot, robot_struct in action_struct.children + } uuids = conn.execute(f"SELECT DISTINCT uuid FROM read_parquet('{source_escaped}') ORDER BY uuid").fetchall() for index, (episode_id,) in enumerate(uuids): @@ -162,13 +167,26 @@ def export_episode_videos( break image_selects = ", ".join(f"obs.frames.{camera}.rgb.data AS {camera}" for camera in camera_names) + joint_selects = ", ".join( + ( + f"COALESCE(action.{robot}.joints, obs.{robot}.joints) AS joints_{robot}" + if "joints" in action_fields_by_robot.get(robot, set()) + else f"obs.{robot}.joints AS joints_{robot}" + ) + for robot in robot_names + ) + gripper_selects = ", ".join( + ( + f"COALESCE(CAST(action.{robot}.gripper[1] AS DOUBLE), obs.{robot}.gripper[1]) AS gripper_{robot}" + if "gripper" in action_fields_by_robot.get(robot, set()) + else f"obs.{robot}.gripper[1] AS gripper_{robot}" + ) + for robot in robot_names + ) state_selects = ", ".join( [ - *(f"obs.{robot}.joints AS joints_{robot}" for robot in robot_names), - *( - f"COALESCE(CAST(action.{robot}.gripper[1] AS DOUBLE), obs.{robot}.gripper[1]) AS gripper_{robot}" - for robot in robot_names - ), + joint_selects, + gripper_selects, ] ) not_null_checks = " ".join(f"AND obs.frames.{camera}.rgb.data IS NOT NULL" for camera in camera_names) From 10cad997913667d890d644d2f1cb5c02c44f7c31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 20:54:23 +0200 Subject: [PATCH 39/87] fix(fr3): torque discontinuity while reset --- extensions/rcs_fr3/src/hw/Franka.cpp | 13 ++++++++----- extensions/rcs_fr3/src/hw/Franka.h | 1 + 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/extensions/rcs_fr3/src/hw/Franka.cpp b/extensions/rcs_fr3/src/hw/Franka.cpp index 1fbb140d..4d0eb285 100644 --- a/extensions/rcs_fr3/src/hw/Franka.cpp +++ b/extensions/rcs_fr3/src/hw/Franka.cpp @@ -220,6 +220,11 @@ void Franka::check_for_background_errors() { } } +void Franka::clear_background_error() { + std::lock_guard lock(this->exception_mutex); + this->background_exception = nullptr; +} + void Franka::osc_set_cartesian_position( const common::Pose& desired_pose_EE_in_base_frame) { this->check_for_background_errors(); @@ -335,8 +340,7 @@ void Franka::osc() { // torques handler if (this->running_controller.load() == Controller::none) { - franka::Torques zero_torques{{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}}; - return franka::MotionFinished(zero_torques); + return franka::MotionFinished(franka::Torques(robot_state.tau_J_d)); } // TO BE replaced // if (!this->control_thread_running && dq.maxCoeff() < 0.0001) { @@ -541,9 +545,7 @@ void Franka::joint_controller() { // torques handler if (this->running_controller.load() == Controller::none) { - // TODO: test if this also works when the robot is moving - franka::Torques zero_torques{{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}}; - return franka::MotionFinished(zero_torques); + return franka::MotionFinished(franka::Torques(robot_state.tau_J_d)); } common::Vector7d desired_q; @@ -667,6 +669,7 @@ void Franka::automatic_error_recovery() { void Franka::reset() { this->stop_control_thread(); this->automatic_error_recovery(); + this->clear_background_error(); } void Franka::wait_milliseconds(int milliseconds) { diff --git a/extensions/rcs_fr3/src/hw/Franka.h b/extensions/rcs_fr3/src/hw/Franka.h index 6054b924..9601d343 100644 --- a/extensions/rcs_fr3/src/hw/Franka.h +++ b/extensions/rcs_fr3/src/hw/Franka.h @@ -93,6 +93,7 @@ class Franka : public common::Robot { void joint_controller(); void zero_torque_controller(); void check_for_background_errors(); + void clear_background_error(); public: Franka(const FrankaConfig& cfg, From 52654fe55f160a567fb1fb3eeb9f902dc52fabc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 21:17:20 +0200 Subject: [PATCH 40/87] fix(hw camera): stop camera before stop polling thread --- python/rcs/camera/hw.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/python/rcs/camera/hw.py b/python/rcs/camera/hw.py index 460f26f7..da8dc8d9 100644 --- a/python/rcs/camera/hw.py +++ b/python/rcs/camera/hw.py @@ -179,15 +179,19 @@ def get_timestamp_frames(self, ts: datetime) -> FrameSet | None: def stop(self): """Stops the polling of the cameras.""" self.running = False - assert self._thread is not None - self._thread.join() - self._thread = None + if self._thread is not None: + self._thread.join() + self._thread = None def close(self): - if self.running and self._thread is not None: + if self.running: + self.running = False + for camera in self.cameras: + camera.close() self.stop() - for camera in self.cameras: - camera.close() + else: + for camera in self.cameras: + camera.close() self.stop_video() def start(self, warm_up: bool = True): From 086e4d0bde46f5a45f7d919ac17964d72b6ec65f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Tue, 19 May 2026 21:39:57 +0200 Subject: [PATCH 41/87] feat: using input instead of pynput --- examples/inference/franka.py | 114 ++++++++++++++++++++--------------- 1 file changed, 67 insertions(+), 47 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 2d014905..9ad6b1af 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -1,13 +1,14 @@ import copy -import datetime import json import logging +import threading from dataclasses import asdict, dataclass, field from pathlib import Path +from queue import Empty, Queue from time import sleep from typing import Any + from PIL import Image -import threading from rcs.utils import SimpleFrameRate @@ -25,8 +26,6 @@ from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs -from pynput import keyboard - logger = logging.getLogger(__name__) @@ -122,41 +121,45 @@ def __init__(self, env: gym.Env, cfg: InferenceConfig): self.gripper_state = 1 self._cfg = cfg self._episode_running = False - self._start_requested = False - self._record_requested = False - self._success_requested = False - self._stop_requested = False - self._reload_requested = False - self._cmd_lock = threading.Lock() + self._command_queue: Queue[str] = Queue() + self._shutdown_requested = threading.Event() self.remote_agent = RemoteAgent( cfg.vlagents_host, cfg.vlagents_port, cfg.vlagents_model, cfg.on_same_machine, cfg.jpeg_encoding ) self.frame_rate = SimpleFrameRate(self._cfg.fps) - self._listener = keyboard.Listener(on_press=self._on_press) - self._listener.start() self._action_buffer = [] - def _on_press(self, key): - try: - if not hasattr(key, "char"): - return - if key.char == "e": - with self._cmd_lock: - self._start_requested = True - elif key.char == "r": - with self._cmd_lock: - self._record_requested = True - elif key.char == "s": - with self._cmd_lock: - self._success_requested = True - elif key.char == "q": - with self._cmd_lock: - self._stop_requested = True - elif key.char == "o": - with self._cmd_lock: - self._reload_requested = True - except AttributeError: - pass + def submit_command(self, command: str) -> None: + self._command_queue.put(command) + + def request_shutdown(self) -> None: + self._shutdown_requested.set() + + def _drain_commands(self) -> tuple[bool, bool, bool, bool, bool]: + start_requested = False + record_requested = False + success_requested = False + stop_requested = False + reload_requested = False + + while True: + try: + command = self._command_queue.get_nowait() + except Empty: + break + + if command == "e": + start_requested = True + elif command == "r": + record_requested = True + elif command == "s": + success_requested = True + elif command == "q": + stop_requested = True + elif command == "o": + reload_requested = True + + return start_requested, record_requested, success_requested, stop_requested, reload_requested def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} @@ -200,21 +203,13 @@ def loop(self): obs, _ = self.env.reset() obs_dict = self.obs_rcs2agents(obs) logger.info( - "waiting for 'e' to start, 'r' to start and record, 's' for success and reset, 'q' to stop and reset, and 'o' to reload config" + "waiting for input: 'e' to start, 'r' to start and record, 's' for success and reset, 'q' to stop and reset, and 'o' to reload config" ) - while True: - with self._cmd_lock: - start_requested = self._start_requested - record_requested = self._record_requested - success_requested = self._success_requested - stop_requested = self._stop_requested - reload_requested = self._reload_requested - self._start_requested = False - self._record_requested = False - self._success_requested = False - self._stop_requested = False - self._reload_requested = False + while not self._shutdown_requested.is_set(): + start_requested, record_requested, success_requested, stop_requested, reload_requested = ( + self._drain_commands() + ) if reload_requested: self._cfg = load_inference_config() @@ -296,6 +291,28 @@ def loop(self): self.frame_rate() +def command_loop(controller: ModelInference) -> None: + prompt = "Command [e=start, r=record, s=success/reset, q=stop/reset, o=reload, x=exit]: " + while True: + try: + command = input(prompt).strip().lower() + except EOFError: + command = "x" + except KeyboardInterrupt: + print() + command = "x" + + if not command: + continue + if command == "x": + controller.request_shutdown() + return + if command in {"e", "r", "s", "q", "o"}: + controller.submit_command(command) + continue + logger.info("unknown command %r", command) + + def get_env(cfg: InferenceConfig) -> gym.Env: if ROBOT_INSTANCE == RobotPlatform.HARDWARE: from rcs_fr3.configs import FrankaDuoEnv @@ -409,7 +426,10 @@ def main(): controller = ModelInference(env_rel, cfg) with env_rel: - controller.loop() + worker = threading.Thread(target=controller.loop, name="model-inference", daemon=True) + worker.start() + command_loop(controller) + worker.join() if __name__ == "__main__": From 804a823069a5c4748c808b41977e9d7f30cd2b7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Wed, 20 May 2026 08:38:17 +0200 Subject: [PATCH 42/87] feat: add limited absolute action wrapper --- python/rcs/envs/base.py | 88 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index 13bda16b..c0ef156e 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -596,6 +596,94 @@ class RelativeTo(Enum): CONFIGURED_ORIGIN = auto() NONE = auto() +class LimitedAbsoluteAction(ActObsInfoWrapper): + ABSOLUTE_ACTION_KEY = "limited_absolute_action" + + def __init__( + self, + env, + max_mov: float | tuple[float, float] | None = None, + ): + super().__init__(env) + self.joints_key = get_space_keys(LimitedJointsRelDictType)[0] + self.trpy_key = get_space_keys(LimitedTRPYRelDictType)[0] + self.tquat_key = get_space_keys(LimitedTQuatRelDictType)[0] + self._absolute_action: common.Pose | VecType | None = None + self.max_mov = max_mov + + def _get_current(self) -> np.ndarray: + if self.get_wrapper_attr("get_control_mode")() == ControlMode.JOINTS: + return self._robot.get_joint_position() + else: + return self._robot.get_cartesian_position() + + def action(self, action: dict[str, Any]) -> dict[str, Any]: + if self.max_mov is None: + return action + if self.get_wrapper_attr("get_control_mode")() == ControlMode.JOINTS: + assert isinstance(self.max_mov, float) + low, high = self._robot.get_config().joint_limits + curr = self._get_current() + delta = action[self.joints_key] - curr + limited_delta = np.clip(delta, -self.max_mov, self.max_mov) + clipped_joints = np.clip(curr + limited_delta, low, high) + action.update(JointsDictType(joints=clipped_joints)) + self._absolute_action = clipped_joints + + elif self.get_wrapper_attr("get_control_mode")() == ControlMode.CARTESIAN_TRPY: + assert isinstance(self.max_mov, tuple) + curr = cast(common.Pose, self._get_current()) + pose_space = cast(gym.spaces.Box, get_space(TRPYDictType).spaces[self.trpy_key]) + target_pose = common.Pose( + translation=action[self.trpy_key][:3], + rpy_vector=action[self.trpy_key][3:], + ) + pose_delta = common.Pose( + translation=target_pose.translation() - curr.translation(), # type: ignore + rpy_vector=(target_pose * curr.inverse()).rotation_rpy().as_vector(), + ) + limited_delta = pose_delta.limit_translation_length(self.max_mov[0]).limit_rotation_angle(self.max_mov[1]) + clipped_pose = np.concatenate( + [ + np.clip(curr.translation() + limited_delta.translation(), pose_space.low[:3], pose_space.high[:3]), + (limited_delta * curr).rotation_rpy().as_vector(), + ] + ) + action.update(TRPYDictType(xyzrpy=clipped_pose)) + self._absolute_action = clipped_pose + + elif self.get_wrapper_attr("get_control_mode")() == ControlMode.CARTESIAN_TQuat: + assert isinstance(self.max_mov, tuple) + curr = cast(common.Pose, self._get_current()) + pose_space = cast(gym.spaces.Box, get_space(TQuatDictType).spaces[self.tquat_key]) + target_pose = common.Pose( + translation=action[self.tquat_key][:3], + quaternion=action[self.tquat_key][3:], + ) + pose_delta = target_pose * curr.inverse() + limited_delta = pose_delta.limit_translation_length(self.max_mov[0]).limit_rotation_angle(self.max_mov[1]) + clipped_pose = np.concatenate( + [ + np.clip(curr.translation() + limited_delta.translation(), pose_space.low[:3], pose_space.high[:3]), + (limited_delta * curr).rotation_q(), + ] + ) + action.update(TQuatDictType(tquat=clipped_pose)) # type: ignore + self._absolute_action = clipped_pose + else: + msg = "Control mode not recognized!" + raise ValueError(msg) + return action + + def observation(self, observation: dict, info: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: + if self._absolute_action is not None: + info[self.ABSOLUTE_ACTION_KEY] = ( + list(self._absolute_action.translation()) + list(self._absolute_action.rotation_q()) + if isinstance(self._absolute_action, common.Pose) + else self._absolute_action + ) + return observation, info + class RelativeActionSpace(ActObsInfoWrapper): DEFAULT_MAX_CART_MOV = 0.5 From 9ebe4e6e2108a0d94dad6ce215bd71aab58fd51b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Wed, 20 May 2026 07:56:43 +0200 Subject: [PATCH 43/87] feat: add limited absolute actions to inference script --- examples/inference/franka.py | 7 ++++++- extensions/rcs_fr3/src/rcs_fr3/creators.py | 3 +++ python/rcs/envs/scenes.py | 3 +++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 9ad6b1af..2c2ed6ad 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -76,6 +76,8 @@ IP = "localhost" PORT = 20000 CONFIG_PATH = Path(__file__).with_suffix(".json") +MAX_REL_MOV_JOINTS = np.deg2rad(0.5) +MAX_REL_MOV_CART = (0.5, np.deg2rad(90)) logging.basicConfig( format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", @@ -105,6 +107,8 @@ class InferenceConfig: fps: int = FPS record_path: str = RECORD_PATH n_action_steps: int | None = None + max_rel_mov_joints: float = MAX_REL_MOV_JOINTS + max_rel_mov_cart: tuple[float, float] = MAX_REL_MOV_CART def load_inference_config() -> InferenceConfig: @@ -369,7 +373,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: hw_cfg.camera_cfgs = camera_cfgs or None hw_cfg.control_mode = CONTROL_MODE hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH - hw_cfg.max_relative_movement = 0.5 if CONTROL_MODE == ControlMode.JOINTS else (0.5, np.deg2rad(90)) + hw_cfg.max_relative_movement = cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart hw_cfg.relative_to = RELATIVETO hw_cfg.robot_to_shared_base_frame = robot2world hw_cfg.robot_cfgs["left"].ignore_realtime = True @@ -392,6 +396,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: sim_cfg_data.control_mode = ControlMode.JOINTS sim_cfg_data.relative_to = RELATIVETO sim_cfg_data.wrapper_cfg.binary_gripper = True + sim_cfg_data.max_relative_movement = cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart # if sim_cfg_data.root_frame_objects is None: diff --git a/extensions/rcs_fr3/src/rcs_fr3/creators.py b/extensions/rcs_fr3/src/rcs_fr3/creators.py index e28401e4..01386503 100644 --- a/extensions/rcs_fr3/src/rcs_fr3/creators.py +++ b/extensions/rcs_fr3/src/rcs_fr3/creators.py @@ -15,6 +15,7 @@ GripperWrapper, HandWrapper, HardwareEnv, + LimitedAbsoluteAction, MultiRobotWrapper, RelativeActionSpace, RelativeTo, @@ -207,6 +208,8 @@ def create_env(self, cfg: FR3HardwareEnvCreatorConfig) -> gym.Env: if cfg.relative_to != RelativeTo.NONE: env = RelativeActionSpace(env, max_mov=cfg.max_relative_movement, relative_to=cfg.relative_to) + else: + env = LimitedAbsoluteAction(env, max_mov=cfg.max_relative_movement) return CoverWrapper(env) def config(self) -> FR3HardwareEnvCreatorConfig: diff --git a/python/rcs/envs/scenes.py b/python/rcs/envs/scenes.py index ef281673..6cedeae3 100644 --- a/python/rcs/envs/scenes.py +++ b/python/rcs/envs/scenes.py @@ -14,6 +14,7 @@ ControlMode, CoverWrapper, GripperWrapper, + LimitedAbsoluteAction, MultiRobotWrapper, RelativeActionSpace, RelativeTo, @@ -363,6 +364,8 @@ def create_env_from_model(self, cfg: SimEnvCreatorConfig, mjmodel: MjModel) -> g env = RelativeActionSpace( env, max_mov=prefixed_cfg.max_relative_movement, relative_to=prefixed_cfg.relative_to ) + else: + env = LimitedAbsoluteAction(env, max_mov=cfg.max_relative_movement) envs[robot_name] = env env = MultiRobotWrapper(envs, prefixed_cfg.robot_to_shared_base_frame) From b59f134fecaac7c6b7a97f00d6173707c683c72d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Thu, 21 May 2026 13:36:18 +0200 Subject: [PATCH 44/87] stash: latest version Co-authored-by: Copilot --- .dockerignore | 7 + docker/Dockerfile | 3 +- examples/inference/franka.json | 20 + examples/inference/franka.py | 11 +- examples/teleop/inspect_parquet_duckdb.ipynb | 506 ++++++++++++++----- extensions/rcs_fr3/src/hw/Franka.cpp | 10 +- python/rcs/envs/base.py | 14 +- python/rcs/envs/storage_wrapper.py | 2 +- python/rcs/lerobot_joint_converter.py | 8 +- python/rcs/utils.py | 142 +++++- 10 files changed, 579 insertions(+), 144 deletions(-) create mode 100644 examples/inference/franka.json diff --git a/.dockerignore b/.dockerignore index 8b767f67..fb730c5f 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,3 +1,10 @@ **/build/ real* test* +sim* +transfer_cube +single_pick* +ball_maze +candy +*.parquet +*venv* diff --git a/docker/Dockerfile b/docker/Dockerfile index 9c88e253..7770f522 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -56,7 +56,8 @@ RUN chmod +x /usr/local/bin/link-editable-source \ && uv pip install /opt/rcs-src/extensions/rcs_zed \ && uv pip install /opt/rcs-src/examples/teleop/SimPublisher \ && uv pip install /opt/rcs-src/2f85-python-driver \ - && uv pip install /opt/rcs-src/vlagents + && uv pip install /opt/rcs-src/vlagents \ + && uv pip install /opt/rcs-src/rcs_duobench WORKDIR /workspace/robot-control-stack diff --git a/examples/inference/franka.json b/examples/inference/franka.json new file mode 100644 index 00000000..7dac17c1 --- /dev/null +++ b/examples/inference/franka.json @@ -0,0 +1,20 @@ +{ + "vlagents_host": "localhost", + "vlagents_port": 20000, + "vlagents_model": "lerobot", + "instruction": "open the box with the right arm and place the cube inside the box with the left arm", + "robot_keys": [ + "left", + "right" + ], + "jpeg_encoding": true, + "on_same_machine": false, + "fps": 30, + "record_path": "inference_recordings_hinge_chest_duobench_act_hinge_chest_real_2026-05-18_21-55-00", + "n_action_steps": 100, + "max_rel_mov_joints": 0.08726646259971647, + "max_rel_mov_cart": [ + 0.5, + 1.5707963267948966 + ] +} diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 2c2ed6ad..20c04173 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -22,7 +22,7 @@ from rcs.envs.tasks import PickTaskConfig import rcs -from rcs_duobench.tasks.bin_sort import BinSortEnvConfig +# from rcs_duobench.tasks.bin_sort import BinSortEnvConfig from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs @@ -39,8 +39,8 @@ } -ROBOT_INSTANCE = RobotPlatform.SIMULATION -# ROBOT_INSTANCE = RobotPlatform.HARDWARE +# ROBOT_INSTANCE = RobotPlatform.SIMULATION +ROBOT_INSTANCE = RobotPlatform.HARDWARE # set camera dict to none disable cameras CAMERA_DICT = { @@ -71,6 +71,7 @@ FPS = 30 CONTROL_MODE = ControlMode.JOINTS RELATIVETO = RelativeTo.NONE +# RELATIVETO = RelativeTo.CONFIGURED_ORIGIN RECORD_PATH = "inference_recordings" MODEL = "lerobot" IP = "localhost" @@ -373,6 +374,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: hw_cfg.camera_cfgs = camera_cfgs or None hw_cfg.control_mode = CONTROL_MODE hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH + hw_cfg.wrapper_cfg.binary_gripper = True hw_cfg.max_relative_movement = cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart hw_cfg.relative_to = RELATIVETO hw_cfg.robot_to_shared_base_frame = robot2world @@ -386,12 +388,11 @@ def get_env(cfg: InferenceConfig) -> gym.Env: else: # FR3 - scene = BinSortEnvConfig() + # scene = BinSortEnvConfig() sim_cfg_data = scene.config() sim_cfg_data.sim_cfg = SimConfig( async_control=True, realtime=False, frequency=cfg.fps, max_convergence_steps=500 ) - sim_cfg_data.relative_to = RelativeTo.CONFIGURED_ORIGIN sim_cfg_data.wrapper_cfg.include_depth = INCLUDE_DEPTH sim_cfg_data.control_mode = ControlMode.JOINTS sim_cfg_data.relative_to = RELATIVETO diff --git a/examples/teleop/inspect_parquet_duckdb.ipynb b/examples/teleop/inspect_parquet_duckdb.ipynb index 87c24370..31a5bf5d 100644 --- a/examples/teleop/inspect_parquet_duckdb.ipynb +++ b/examples/teleop/inspect_parquet_duckdb.ipynb @@ -2,68 +2,169 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "85351314", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting duckdb\n", + " Downloading duckdb-1.5.3-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl.metadata (4.2 kB)\n", + "Downloading duckdb-1.5.3-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl (21.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.5/21.5 MB\u001b[0m \u001b[31m103.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hInstalling collected packages: duckdb\n", + "Successfully installed duckdb-1.5.3\n" + ] + }, { "data": { "text/plain": [ - "(┌─────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────┬─────────┬─────────┬─────────┐\n", - " │ column_name │ column_type │ null │ key │ default │ extra │\n", - " │ varchar │ varchar │ varchar │ varchar │ varchar │ varchar │\n", - " ├─────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────┼─────────┼─────────┼─────────┤\n", - " │ obs │ STRUCT(\"left\" STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], gripper DOUBLE[]), \"right\" STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], gripper DOUBLE[]), frames STRUCT(head STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), left_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), right_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])))) │ YES │ NULL │ NULL │ NULL │\n", - " │ info │ STRUCT(\"left\" STRUCT(collision BOOLEAN, ik_success BOOLEAN, is_sim_converged BOOLEAN, gripper_width DOUBLE, is_grasped BOOLEAN, terminated BOOLEAN, truncated BOOLEAN), \"right\" STRUCT(collision BOOLEAN, ik_success BOOLEAN, is_sim_converged BOOLEAN, gripper_width DOUBLE, is_grasped BOOLEAN, terminated BOOLEAN, truncated BOOLEAN), camera_available BOOLEAN, frame_timestamp DOUBLE, is_grasped BOOLEAN, success BOOLEAN) │ YES │ NULL │ NULL │ NULL │\n", - " │ reward │ DOUBLE │ YES │ NULL │ NULL │ NULL │\n", - " │ step │ BIGINT │ YES │ NULL │ NULL │ NULL │\n", - " │ uuid │ VARCHAR │ YES │ NULL │ NULL │ NULL │\n", - " │ success │ BOOLEAN │ YES │ NULL │ NULL │ NULL │\n", - " │ action │ STRUCT(\"left\" STRUCT(tquat DOUBLE[], gripper BIGINT[]), \"right\" STRUCT(tquat DOUBLE[], gripper BIGINT[])) │ YES │ NULL │ NULL │ NULL │\n", - " │ instruction │ VARCHAR │ YES │ NULL │ NULL │ NULL │\n", - " │ timestamp │ DOUBLE │ YES │ NULL │ NULL │ NULL │\n", - " │ head │ STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])) │ YES │ NULL │ NULL │ NULL │\n", - " │ left_wrist │ STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])) │ YES │ NULL │ NULL │ NULL │\n", - " │ right_wrist │ STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]), depth STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])) │ YES │ NULL │ NULL │ NULL │\n", - " └─────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────┴─────────┴─────────┴─────────┘\n", - " 12 rows 6 columns,\n", + "(┌─────────────┬───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────┬─────────┬─────────┬─────────┐\n", + " │ column_name │ column_type │ null │ key │ default │ extra │\n", + " │ varchar │ varchar │ varchar │ varchar │ varchar │ varchar │\n", + " ├─────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────┼─────────┼─────────┼─────────┤\n", + " │ obs │ STRUCT(\"left\" STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], robot_state STRUCT(EE_T_K DOUBLE[], F_T_EE DOUBLE[], F_T_NE DOUBLE[], F_x_Cee DOUBLE[], F_x_Cload DOUBLE[], F_x_Ctotal DOUBLE[], I_ee DOUBLE[], I_load DOUBLE[], I_total DOUBLE[], K_F_ext_hat_K DOUBLE[], NE_T_EE DOUBLE[], O_F_ext_hat_K DOUBLE[], O_T_EE DOUBLE[], O_T_EE_c DOUBLE[], O_T_EE_d DOUBLE[], O_dP_EE_c DOUBLE[], O_dP_EE_d DOUBLE[], O_ddP_EE_c DOUBLE[], O_ddP_O DOUBLE[], cartesian_collision DOUBLE[], cartesian_contact DOUBLE[], control_command_success_rate DOUBLE, ddelbow_c DOUBLE[], ddq_d DOUBLE[], delbow_c DOUBLE[], dq DOUBLE[], dq_d DOUBLE[], dtau_J DOUBLE[], dtheta DOUBLE[], elbow DOUBLE[], elbow_c DOUBLE[], elbow_d DOUBLE[], joint_collision DOUBLE[], joint_contact DOUBLE[], m_ee DOUBLE, m_load DOUBLE, m_total DOUBLE, q DOUBLE[], q_d DOUBLE[], tau_J DOUBLE[], tau_J_d DOUBLE[], tau_ext_hat_filtered DOUBLE[], theta DOUBLE[]), gripper DOUBLE[]), \"right\" STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], robot_state STRUCT(EE_T_K DOUBLE[], F_T_EE DOUBLE[], F_T_NE DOUBLE[], F_x_Cee DOUBLE[], F_x_Cload DOUBLE[], F_x_Ctotal DOUBLE[], I_ee DOUBLE[], I_load DOUBLE[], I_total DOUBLE[], K_F_ext_hat_K DOUBLE[], NE_T_EE DOUBLE[], O_F_ext_hat_K DOUBLE[], O_T_EE DOUBLE[], O_T_EE_c DOUBLE[], O_T_EE_d DOUBLE[], O_dP_EE_c DOUBLE[], O_dP_EE_d DOUBLE[], O_ddP_EE_c DOUBLE[], O_ddP_O DOUBLE[], cartesian_collision DOUBLE[], cartesian_contact DOUBLE[], control_command_success_rate DOUBLE, ddelbow_c DOUBLE[], ddq_d DOUBLE[], delbow_c DOUBLE[], dq DOUBLE[], dq_d DOUBLE[], dtau_J DOUBLE[], dtheta DOUBLE[], elbow DOUBLE[], elbow_c DOUBLE[], elbow_d DOUBLE[], joint_collision DOUBLE[], joint_contact DOUBLE[], m_ee DOUBLE, m_load DOUBLE, m_total DOUBLE, q DOUBLE[], q_d DOUBLE[], tau_J DOUBLE[], tau_J_d DOUBLE[], tau_ext_hat_filtered DOUBLE[], theta DOUBLE[]), gripper DOUBLE[]), frames STRUCT(right_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), left_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), head STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), head_right STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])))) │ YES │ NULL │ NULL │ NULL │\n", + " │ info │ STRUCT(\"left\" STRUCT(platform VARCHAR, robot_type VARCHAR, gripper_type VARCHAR, absolute_action DOUBLE[], terminated BOOLEAN, truncated BOOLEAN), \"right\" STRUCT(platform VARCHAR, robot_type VARCHAR, gripper_type VARCHAR, absolute_action DOUBLE[], terminated BOOLEAN, truncated BOOLEAN), camera_available BOOLEAN, frame_timestamp DOUBLE) │ YES │ NULL │ NULL │ NULL │\n", + " │ reward │ DOUBLE │ YES │ NULL │ NULL │ NULL │\n", + " │ step │ BIGINT │ YES │ NULL │ NULL │ NULL │\n", + " │ uuid │ VARCHAR │ YES │ NULL │ NULL │ NULL │\n", + " │ success │ BOOLEAN │ YES │ NULL │ NULL │ NULL │\n", + " │ action │ STRUCT(\"left\" STRUCT(tquat DOUBLE[], gripper DOUBLE[]), \"right\" STRUCT(tquat DOUBLE[], gripper DOUBLE[])) │ YES │ NULL │ NULL │ NULL │\n", + " │ env_action │ STRUCT(\"left\" STRUCT(tquat DOUBLE[], gripper DOUBLE[]), \"right\" STRUCT(tquat DOUBLE[], gripper DOUBLE[])) │ YES │ NULL │ NULL │ NULL │\n", + " │ instruction │ VARCHAR │ YES │ NULL │ NULL │ NULL │\n", + " │ timestamp │ DOUBLE │ YES │ NULL │ NULL │ NULL │\n", + " │ left │ STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], robot_state STRUCT(EE_T_K DOUBLE[], F_T_EE DOUBLE[], F_T_NE DOUBLE[], F_x_Cee DOUBLE[], F_x_Cload DOUBLE[], F_x_Ctotal DOUBLE[], I_ee DOUBLE[], I_load DOUBLE[], I_total DOUBLE[], K_F_ext_hat_K DOUBLE[], NE_T_EE DOUBLE[], O_F_ext_hat_K DOUBLE[], O_T_EE DOUBLE[], O_T_EE_c DOUBLE[], O_T_EE_d DOUBLE[], O_dP_EE_c DOUBLE[], O_dP_EE_d DOUBLE[], O_ddP_EE_c DOUBLE[], O_ddP_O DOUBLE[], cartesian_collision DOUBLE[], cartesian_contact DOUBLE[], control_command_success_rate DOUBLE, ddelbow_c DOUBLE[], ddq_d DOUBLE[], delbow_c DOUBLE[], dq DOUBLE[], dq_d DOUBLE[], dtau_J DOUBLE[], dtheta DOUBLE[], elbow DOUBLE[], elbow_c DOUBLE[], elbow_d DOUBLE[], joint_collision DOUBLE[], joint_contact DOUBLE[], m_ee DOUBLE, m_load DOUBLE, m_total DOUBLE, q DOUBLE[], q_d DOUBLE[], tau_J DOUBLE[], tau_J_d DOUBLE[], tau_ext_hat_filtered DOUBLE[], theta DOUBLE[]), gripper DOUBLE[]) │ YES │ NULL │ NULL │ NULL │\n", + " │ right │ STRUCT(tquat DOUBLE[], joints DOUBLE[], xyzrpy DOUBLE[], robot_state STRUCT(EE_T_K DOUBLE[], F_T_EE DOUBLE[], F_T_NE DOUBLE[], F_x_Cee DOUBLE[], F_x_Cload DOUBLE[], F_x_Ctotal DOUBLE[], I_ee DOUBLE[], I_load DOUBLE[], I_total DOUBLE[], K_F_ext_hat_K DOUBLE[], NE_T_EE DOUBLE[], O_F_ext_hat_K DOUBLE[], O_T_EE DOUBLE[], O_T_EE_c DOUBLE[], O_T_EE_d DOUBLE[], O_dP_EE_c DOUBLE[], O_dP_EE_d DOUBLE[], O_ddP_EE_c DOUBLE[], O_ddP_O DOUBLE[], cartesian_collision DOUBLE[], cartesian_contact DOUBLE[], control_command_success_rate DOUBLE, ddelbow_c DOUBLE[], ddq_d DOUBLE[], delbow_c DOUBLE[], dq DOUBLE[], dq_d DOUBLE[], dtau_J DOUBLE[], dtheta DOUBLE[], elbow DOUBLE[], elbow_c DOUBLE[], elbow_d DOUBLE[], joint_collision DOUBLE[], joint_contact DOUBLE[], m_ee DOUBLE, m_load DOUBLE, m_total DOUBLE, q DOUBLE[], q_d DOUBLE[], tau_J DOUBLE[], tau_J_d DOUBLE[], tau_ext_hat_filtered DOUBLE[], theta DOUBLE[]), gripper DOUBLE[]) │ YES │ NULL │ NULL │ NULL │\n", + " │ frames │ STRUCT(right_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), left_wrist STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), head STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[])), head_right STRUCT(rgb STRUCT(\"data\" BLOB, intrinsics DOUBLE[], extrinsics DOUBLE[], intrinsics_shape BIGINT[], extrinsics_shape BIGINT[]))) │ YES │ NULL │ NULL │ NULL │\n", + " └─────────────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────┴─────────┴─────────┴─────────┘\n", + " 13 rows 6 columns,\n", " ┌──────────┐\n", " │ n_frames │\n", " │ int64 │\n", " ├──────────┤\n", - " │ 5321 │\n", + " │ 67528 │\n", " └──────────┘)" ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import duckdb\n", - "path = \"/home/tobi/coding/rcs_clones/robot-control-stack/data_grasp\"\n", - "duckdb.sql(f\"describe select *, unnest(obs.frames) from read_parquet('{path}')\"), duckdb.sql(f\"select count(*) as n_frames from read_parquet('{path}')\")" + "path = \"/home/juelg/code/duobench/robot-control-stack/bin_sortv2\"\n", + "duckdb.sql(f\"describe select *, unnest(obs) from read_parquet('{path}')\"), duckdb.sql(f\"select count(*) as n_frames from read_parquet('{path}')\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6c50d53e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Latest Episode UUID and Timestamp: ('5f3c0399f9544621ba6caca3363635e8', 1779292467.945553)\n" + ] + } + ], + "source": [ + "import duckdb\n", + "\n", + "path = \"/home/juelg/code/duobench/robot-control-stack/bin_sortv2\"\n", + "\n", + "# Pull only the single latest record\n", + "query = f\"\"\"\n", + " SELECT uuid, timestamp \n", + " FROM read_parquet('{path}') \n", + " ORDER BY timestamp DESC \n", + " LIMIT 1\n", + "\"\"\"\n", + "\n", + "# Fetch as a standard Python tuple: (uuid, timestamp)\n", + "latest_record = duckdb.sql(query).fetchone()\n", + "\n", + "print(\"Latest Episode UUID and Timestamp:\", latest_record)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4c70a2ea", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7ce86cc47a58401f86e5c2825e37bf77", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successfully set 'success' to False for UUID: 5f3c0399f9544621ba6caca3363635e8\n" + ] + } + ], + "source": [ + "import duckdb\n", + "\n", + "path = \"/home/juelg/code/duobench/robot-control-stack/bin_sortv2\"\n", + "path2 = \"/home/juelg/code/duobench/robot-control-stack/bin_sortv3\"\n", + "target_uuid = \"5f3c0399f9544621ba6caca3363635e8\"\n", + "\n", + "# SQL to select all data, but override 'success' for the specific UUID\n", + "query = f\"\"\"\n", + " SELECT \n", + " * EXCLUDE (success), \n", + " CASE \n", + " WHEN uuid = '{target_uuid}' THEN false \n", + " ELSE success \n", + " END AS success\n", + " FROM read_parquet('{path}')\n", + "\"\"\"\n", + "\n", + "# Execute and load into a Pandas DataFrame\n", + "df = duckdb.sql(query).df()\n", + "\n", + "# Overwrite the original Parquet file with the updated data\n", + "df.to_parquet(path2)\n", + "\n", + "print(f\"Successfully set 'success' to False for UUID: {target_uuid}\")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "8085186f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n", - "│ info │\n", - "│ struct(\"left\" struct(collision boolean, ik_success boolean, is_sim_converged boolean, gripper_width double, is_grasped boolean, terminated boolean, truncated boolean), \"right\" struct(collision boolean, ik_success boolean, is_sim_converged boolean, gripper_width double, is_grasped boolean, terminated boolean, truncated boolean), camera_available boolean, frame_timestamp double, is_grasped boolean, success boolean) │\n", - "├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n", - "│ {'left': {'collision': false, 'ik_success': true, 'is_sim_converged': true, 'gripper_width': 1.0, 'is_grasped': false, 'terminated': false, 'truncated': false}, 'right': {'collision': false, 'ik_success': true, 'is_sim_converged': true, 'gripper_width': 0.4277359972585904, 'is_grasped': true, 'terminated': false, 'truncated': false}, 'camera_available': true, 'frame_timestamp': 5.5799999999996075, 'is_grasped': false, 'success': true} │\n", - "└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘" + "┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n", + "│ info │\n", + "│ struct(\"left\" struct(platform varchar, robot_type varchar, gripper_type varchar, absolute_action double[], terminated boolean, truncated boolean), \"right\" struct(platform varchar, robot_type varchar, gripper_type varchar, absolute_action double[], terminated boolean, truncated boolean), camera_available boolean, frame_timestamp double) │\n", + "├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n", + "│ {'left': {'platform': hardware, 'robot_type': FR3, 'gripper_type': Robotiq2F85, 'absolute_action': [0.43102648854255676, 0.15267090499401093, 0.4907831847667694, -0.8132432068150006, -0.25469918399466873, -0.08214187685901374, 0.5167364166649981], 'terminated': false, 'truncated': false}, 'right': {'platform': hardware, 'robot_type': FR3, 'gripper_type': Robotiq2F85, 'absolute_action': [0.4207998514175415, -0.10432350635528564, 0.4641386866569519, 0.8890941201964603, -0.14876354495806932, -0.04081969258450916, 0.43094640713306454], 'terminated': false, 'truncated': false}, 'camera_available': true, 'frame_timestamp': 1779290162.1749835} │\n", + "└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘" ] }, - "execution_count": 2, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -79,6 +180,95 @@ ")" ] }, + { + "cell_type": "code", + "execution_count": 19, + "id": "69753776", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "┌──────────────────────────────────┐\n", + "│ successful │\n", + "│ varchar │\n", + "├──────────────────────────────────┤\n", + "│ 0e61faf0c4d147938802da6f285cc053 │\n", + "│ 56626f8b6c5d4e73bd6efd911aea68c0 │\n", + "│ 7c5e7de2d7aa4db8b361ec5b22499c6b │\n", + "│ 87901475844a441395b3c7d51d82c1de │\n", + "└──────────────────────────────────┘" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "duckdb.sql(\n", + " \"SELECT DISTINCT uuid as successful \"\n", + " f\"FROM read_parquet('{path}') \"\n", + " \"WHERE success ORDER BY uuid\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "3856373f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading data from /home/juelg/code/duobench/robot-control-stack/ball_maze/2026-05-12_part-0.parquet...\n", + "Updating 'success' to false for UUID: 7c5e7de2d7aa4db8b361ec5b22499c6b...\n", + "Writing to temporary file...\n", + "Overwriting the original file...\n", + "Done! Directory structure is preserved.\n" + ] + } + ], + "source": [ + "import duckdb\n", + "import os\n", + "\n", + "# --- Configuration Variables ---\n", + "directory_path = \"/home/juelg/code/duobench/robot-control-stack/ball_maze\"\n", + "file_name = \"2026-05-12_part-0.parquet\"\n", + "target_uuid = \"7c5e7de2d7aa4db8b361ec5b22499c6b\"\n", + "\n", + "# Construct the full paths\n", + "file_path = os.path.join(directory_path, file_name)\n", + "temp_path = file_path + \".tmp\"\n", + "\n", + "# --- Database Operations ---\n", + "con = duckdb.connect()\n", + "\n", + "print(f\"Reading data from {file_path}...\")\n", + "# 1. Load the Parquet data from the specific file\n", + "con.execute(f\"CREATE TABLE dataset AS SELECT * FROM read_parquet('{file_path}')\")\n", + "\n", + "print(f\"Updating 'success' to false for UUID: {target_uuid}...\")\n", + "# 2. Execute the update\n", + "con.execute(\"UPDATE dataset SET success = false WHERE uuid = ?\", (target_uuid,))\n", + "\n", + "print(\"Writing to temporary file...\")\n", + "# 3. Write the modified table back to a temporary file inside the directory\n", + "con.execute(f\"COPY dataset TO '{temp_path}' (FORMAT PARQUET)\")\n", + "\n", + "# Close the database connection before manipulating files\n", + "con.close()\n", + "\n", + "print(\"Overwriting the original file...\")\n", + "# 4. Safely replace the exact file, leaving the directory intact\n", + "os.replace(temp_path, file_path)\n", + "\n", + "print(\"Done! Directory structure is preserved.\")" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -92,13 +282,13 @@ " │ successful │\n", " │ int64 │\n", " ├────────────┤\n", - " │ 27 │\n", + " │ 113 │\n", " └────────────┘,\n", " ┌────────────┐\n", " │ n_episodes │\n", " │ int64 │\n", " ├────────────┤\n", - " │ 30 │\n", + " │ 115 │\n", " └────────────┘)" ] }, @@ -120,22 +310,22 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 84, "id": "f1ee638e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "┌────────────────────┬────────────────────┬───────────────────┐\n", - "│ (max(step) / 30) │ (min(step) / 30) │ (avg(step) / 30) │\n", - "│ double │ double │ double │\n", - "├────────────────────┼────────────────────┼───────────────────┤\n", - "│ 17.533333333333335 │ 1.0666666666666667 │ 5.346779661016949 │\n", - "└────────────────────┴────────────────────┴───────────────────┘" + "┌────────────────────┬───────────────────┬───────────────────┐\n", + "│ (max(step) / 30) │ (min(step) / 30) │ (avg(step) / 30) │\n", + "│ double │ double │ double │\n", + "├────────────────────┼───────────────────┼───────────────────┤\n", + "│ 19.533333333333335 │ 8.533333333333333 │ 11.66923076923077 │\n", + "└────────────────────┴───────────────────┴───────────────────┘" ] }, - "execution_count": 4, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" } @@ -152,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "97808e66", "metadata": {}, "outputs": [ @@ -160,14 +350,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "episode uuid: bda71d1e8bf44a6e9a0467ca9e1e7bfd, success: False, n_steps: 150, info: {'left': {'collision': False, 'ik_success': True, 'is_sim_converged': True, 'gripper_width': 1.0, 'is_grasped': False, 'terminated': False, 'truncated': False}, 'right': {'collision': False, 'ik_success': True, 'is_sim_converged': True, 'gripper_width': 1.0, 'is_grasped': False, 'terminated': False, 'truncated': False}, 'camera_available': True, 'frame_timestamp': 4.899999999999682, 'is_grasped': False, 'success': False}\n" + "episode uuid: 7c5e7de2d7aa4db8b361ec5b22499c6b, success: False, n_steps: 844, info: {'left': {'platform': 'hardware', 'absolute_action': [0.5092409253120422, 0.2895634174346924, 0.16640011966228485, 0.8264918230390301, 0.3795456871273817, 0.1573973020068592, -0.3848147959130286], 'terminated': False, 'truncated': False}, 'right': {'platform': 'hardware', 'absolute_action': [0.46342507004737854, -0.32870620489120483, 0.1969984769821167, 0.8623926086992065, -0.3068727980040084, 0.05247313104626525, 0.3991924909418636], 'terminated': False, 'truncated': False}, 'camera_available': True, 'frame_timestamp': 1778597070.9116964}\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -179,11 +369,11 @@ "from matplotlib import pyplot as plt\n", "from PIL import Image\n", "import duckdb\n", - "episode = 0\n", - "step = 100\n", + "episode = 2\n", + "step = 800\n", "\n", "\n", - "uuids = duckdb.sql(f\"SELECT DISTINCT uuid FROM read_parquet('{path}') WHERE success\").fetchnumpy()\n", + "uuids = duckdb.sql(f\"SELECT DISTINCT uuid FROM read_parquet('{path}') WHERE success ORDER BY uuid\").fetchnumpy()\n", "# uuids\n", "uuid1 = uuids[\"uuid\"][episode]\n", "rel = duckdb.read_parquet(path)\n", @@ -195,7 +385,7 @@ "\n", "\n", "# Create a figure with 1 row and 2 columns\n", - "fig, ax = plt.subplots(1, 3, figsize=(20, 5))\n", + "fig, ax = plt.subplots(1, 4, figsize=(20, 5))\n", "\n", "\n", "img1_data = rel.filter(f\"uuid='{uuid1}' and step={step}\").select(\"obs.frames.head.rgb.data\").fetchone()[0]\n", @@ -203,6 +393,7 @@ "ax[0].imshow(image1)\n", "ax[0].set_title(\"Head Camera\")\n", "\n", + "\n", "img2_data = rel.filter(f\"uuid='{uuid1}' and step={step}\").select(\"obs.frames.left_wrist.rgb.data\").fetchone()[0]\n", "image2 = Image.open(io.BytesIO(img2_data))\n", "ax[1].imshow(image2)\n", @@ -213,6 +404,11 @@ "ax[2].imshow(image3)\n", "ax[2].set_title(\"Right Wrist Camera\") # Optional title\n", "\n", + "img1_data = rel.filter(f\"uuid='{uuid1}' and step={step}\").select(\"obs.frames.head_right.rgb.data\").fetchone()[0]\n", + "image1 = Image.open(io.BytesIO(img1_data))\n", + "ax[3].imshow(image1)\n", + "ax[3].set_title(\"Head right Camera\")\n", + "\n", "\n", "\n", "plt.show()" @@ -220,7 +416,82 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 96, + "id": "9a4574f4", + "metadata": {}, + "outputs": [ + { + "ename": "BinderException", + "evalue": "Binder Error: Could not find key \"depth\" in struct\n\nCandidate Entries: \"rgb\"", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mBinderException\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[96]\u001b[39m\u001b[32m, line 28\u001b[39m\n\u001b[32m 24\u001b[39m LIMIT \u001b[32m1\u001b[39m;\n\u001b[32m 25\u001b[39m \"\"\"\n\u001b[32m 26\u001b[39m \n\u001b[32m 27\u001b[39m \u001b[38;5;66;03m# Execute the query and fetch the single row\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m28\u001b[39m row = duckdb.sql(query).fetchone()\n\u001b[32m 29\u001b[39m \n\u001b[32m 30\u001b[39m \u001b[38;5;66;03m# Extract the BLOBs (returned as Python bytes)\u001b[39;00m\n\u001b[32m 31\u001b[39m left_wrist_blob, right_wrist_blob, head_blob = row\n", + "\u001b[31mBinderException\u001b[39m: Binder Error: Could not find key \"depth\" in struct\n\nCandidate Entries: \"rgb\"" + ] + } + ], + "source": [ + "import duckdb\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "\n", + "# Define the path to your parquet file(s)\n", + "\n", + "# SQL query to get the first step of the first episode\n", + "query = f\"\"\"\n", + "WITH first_episode AS (\n", + " -- Identify the first episode (uuid) by taking the earliest timestamp\n", + " SELECT uuid\n", + " FROM read_parquet('{path}')\n", + " ORDER BY \"timestamp\" ASC\n", + " LIMIT 1\n", + ")\n", + "SELECT \n", + " obs.frames.left_wrist.depth.data AS left_wrist_blob,\n", + " obs.frames.right_wrist.depth.data AS right_wrist_blob,\n", + " obs.frames.head.depth.data AS head_blob\n", + "FROM read_parquet('{path}')\n", + "WHERE uuid = (SELECT uuid FROM first_episode)\n", + "ORDER BY step ASC\n", + "LIMIT 1;\n", + "\"\"\"\n", + "\n", + "# Execute the query and fetch the single row\n", + "row = duckdb.sql(query).fetchone()\n", + "\n", + "# Extract the BLOBs (returned as Python bytes)\n", + "left_wrist_blob, right_wrist_blob, head_blob = row\n", + "\n", + "# Convert bytes to PIL Images\n", + "img_left = Image.open(io.BytesIO(left_wrist_blob))\n", + "img_right = Image.open(io.BytesIO(right_wrist_blob))\n", + "img_head = Image.open(io.BytesIO(head_blob))\n", + "\n", + "# Plot the frames side-by-side\n", + "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + "\n", + "axes[0].imshow(img_left)\n", + "axes[0].set_title(\"Left Wrist Frame\")\n", + "axes[0].axis(\"off\")\n", + "\n", + "axes[1].imshow(img_right)\n", + "axes[1].set_title(\"Right Wrist Frame\")\n", + "axes[1].axis(\"off\")\n", + "\n", + "axes[2].imshow(img_head)\n", + "axes[2].set_title(\"Head Frame\")\n", + "axes[2].axis(\"off\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, "id": "758f3147", "metadata": {}, "outputs": [ @@ -231,35 +502,35 @@ "│ timestamp │\n", "│ double │\n", "├───────────────────┤\n", - "│ 1777204228.532817 │\n", - "│ 1777204228.583433 │\n", - "│ 1777204228.635595 │\n", - "│ 1777204228.686985 │\n", - "│ 1777204228.735731 │\n", - "│ 1777204228.7872 │\n", - "│ 1777204228.83733 │\n", - "│ 1777204228.884319 │\n", - "│ 1777204228.934861 │\n", - "│ 1777204076.763415 │\n", + "│ 1777976566.764664 │\n", + "│ 1777976566.796761 │\n", + "│ 1777976566.828648 │\n", + "│ 1777976566.861564 │\n", + "│ 1777976566.892437 │\n", + "│ 1777976566.925095 │\n", + "│ 1777976566.973188 │\n", + "│ 1777976567.004589 │\n", + "│ 1777976567.037067 │\n", + "│ 1777976567.070343 │\n", "│ · │\n", "│ · │\n", "│ · │\n", - "│ 1777204207.432611 │\n", - "│ 1777204207.474623 │\n", - "│ 1777204207.51622 │\n", - "│ 1777204207.553477 │\n", - "│ 1777204207.595021 │\n", - "│ 1777204207.629543 │\n", - "│ 1777204207.667513 │\n", - "│ 1777204207.704982 │\n", - "│ 1777204207.745933 │\n", - "│ 1777204207.783519 │\n", + "│ 1777976516.320072 │\n", + "│ 1777976516.370078 │\n", + "│ 1777976516.400288 │\n", + "│ 1777976516.433601 │\n", + "│ 1777976516.464637 │\n", + "│ 1777976516.496684 │\n", + "│ 1777976516.530015 │\n", + "│ 1777976516.560782 │\n", + "│ 1777976516.593983 │\n", + "│ 1777976516.624152 │\n", "└───────────────────┘\n", - " 5321 rows \n", + " 1108 rows \n", " (20 shown) " ] }, - "execution_count": 7, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -273,6 +544,18 @@ ")" ] }, + { + "cell_type": "code", + "execution_count": 199, + "id": "e6cd3e1d", + "metadata": {}, + "outputs": [], + "source": [ + "path = \"/home/juelg/code/duobench/robot-control-stack/real_bin_sort_test2_new2_without_nogrp\"\n", + "# path = \"/home/juelg/code/duobench/robot-control-stack/real_bin_sort_test2_new_without_nogrp\"\n", + "# path = \"/home/juelg/code/duobench/robot-control-stack/real_bin_sort_test2_old_without_nogrp\"" + ] + }, { "cell_type": "code", "execution_count": 8, @@ -286,7 +569,7 @@ "│ average_frequency_hz │\n", "│ double │\n", "├──────────────────────┤\n", - "│ 20.90057259306587 │\n", + "│ 22.238600508286407 │\n", "└──────────────────────┘" ] }, @@ -315,22 +598,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "b67b4bf2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "┌────────────────────┐\n", - "│ std_frequency_hz │\n", - "│ double │\n", - "├────────────────────┤\n", - "│ 1.9147779001859897 │\n", - "└────────────────────┘" + "┌──────────────────┐\n", + "│ std_frequency_hz │\n", + "│ double │\n", + "├──────────────────┤\n", + "│ NULL │\n", + "└──────────────────┘" ] }, - "execution_count": 9, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -355,22 +638,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "0eac2e74", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "┌───────────────────┬───────────────────┐\n", - "│ mean_frequency_hz │ std_frequency_hz │\n", - "│ double │ double │\n", - "├───────────────────┼───────────────────┤\n", - "│ 21.94798549029336 │ 4.965794976134775 │\n", - "└───────────────────┴───────────────────┘" + "┌────────────────────┬───────────────────┐\n", + "│ mean_frequency_hz │ std_frequency_hz │\n", + "│ double │ double │\n", + "├────────────────────┼───────────────────┤\n", + "│ 28.036486568649778 │ 17.32944834547649 │\n", + "└────────────────────┴───────────────────┘" ] }, - "execution_count": 10, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -403,45 +686,24 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 65, "id": "a7b09572", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "┌──────────────────────────────────┬────────────────────┬─────────────┬────────────────────┬─────────────┐\n", - "│ uuid │ min_freq_hz │ step_at_min │ max_freq_hz │ step_at_max │\n", - "│ varchar │ double │ int64 │ double │ int64 │\n", - "├──────────────────────────────────┼────────────────────┼─────────────┼────────────────────┼─────────────┤\n", - "│ bda71d1e8bf44a6e9a0467ca9e1e7bfd │ 5.9396196596507576 │ 31 │ 28.946996466431095 │ 77 │\n", - "│ 66cbb1ca310f435e99f780de83895bd9 │ 5.826619916316131 │ 63 │ 28.967788275595336 │ 89 │\n", - "│ 1c6853006d9e4b02b2a31dac40fcd2bd │ 6.0373760477197385 │ 95 │ 30.792018441569883 │ 2 │\n", - "│ 3aa324d79982427182cc5df4f465d1bb │ 4.8488334857395206 │ 31 │ 29.719435981010417 │ 108 │\n", - "│ 4497782de6c34767b0aaa425b2e26eb3 │ 6.3683313114258775 │ 95 │ 33.85697795500593 │ 21 │\n", - "│ a7757dcc23904a8b82c1274c42d9715c │ 5.752982583195486 │ 31 │ 29.731865514528145 │ 6 │\n", - "│ 14da252f8ffe4293bcd2ade05d7f0519 │ 4.957952658175478 │ 447 │ 24.100486111909166 │ 241 │\n", - "│ 27c6b0e231094c76bbe8e3e93460cd2f │ 6.442051846004037 │ 31 │ 21.560997676474823 │ 17 │\n", - "│ 6d3bac5e8e7641419677573d1c09d817 │ 6.4079591044785245 │ 159 │ 30.754087782845243 │ 48 │\n", - "│ c8a8d90fb7484ebf8852760ce2046007 │ 6.316199712373222 │ 127 │ 30.063462710102858 │ 91 │\n", - "│ · │ · │ · │ · │ · │\n", - "│ · │ · │ · │ · │ · │\n", - "│ · │ · │ · │ · │ · │\n", - "│ 73ce9d02be9c4d9fb8a3ab1356062aca │ 6.078736688328628 │ 31 │ 28.515221972941735 │ 119 │\n", - "│ a70da27eb26046d58cb03b18e82947db │ 5.946263510678114 │ 31 │ 30.023650680028634 │ 88 │\n", - "│ 08e6a2023e794cdb93e27709cd73bcee │ 6.197898718839124 │ 31 │ 31.30965497678446 │ 5 │\n", - "│ 36cfab4f02cf48b88dfd58b5c0c71596 │ 6.028672207162015 │ 31 │ 29.214144917845527 │ 74 │\n", - "│ 0686f634cc844c09be7dce44e519346c │ 6.107388472520928 │ 159 │ 29.564001353332582 │ 148 │\n", - "│ 11b8aef48c4641fe8b2fa12f6aa269e8 │ 6.009797810895659 │ 31 │ 29.010866182034487 │ 139 │\n", - "│ 730e310a0095461794f2eedb0faf15a0 │ 6.5395399890235995 │ 31 │ 30.061523465496975 │ 15 │\n", - "│ 8174017865424b349f766454a8e63a6d │ 6.308438315946528 │ 31 │ 30.07337831346034 │ 52 │\n", - "│ 84399ec490944ff4ac15b13ff9c1c3e8 │ 6.1951340557019465 │ 31 │ 30.397912740976953 │ 14 │\n", - "│ af89603bb83742828785b22507b4406d │ 3.75373892373768 │ 31 │ 28.77699105329601 │ 94 │\n", - "└──────────────────────────────────┴────────────────────┴─────────────┴────────────────────┴─────────────┘\n", - " 30 rows (20 shown) 5 columns" + "┌──────────────────────────────────┬────────────────────┬─────────────┬───────────────────┬─────────────┐\n", + "│ uuid │ min_freq_hz │ step_at_min │ max_freq_hz │ step_at_max │\n", + "│ varchar │ double │ int64 │ double │ int64 │\n", + "├──────────────────────────────────┼────────────────────┼─────────────┼───────────────────┼─────────────┤\n", + "│ db2c428740ef4693aecaa6ed4db5f761 │ 15.220687602969887 │ 364 │ 76.42960749298445 │ 365 │\n", + "│ c9fd93d28de541059df9b87b575ae526 │ 13.4226318484383 │ 600 │ 79.47219432707429 │ 1 │\n", + "│ 21198747942f4118b7f969a4a250fea4 │ 14.582137654580663 │ 936 │ 80.05160797786048 │ 937 │\n", + "└──────────────────────────────────┴────────────────────┴─────────────┴───────────────────┴─────────────┘" ] }, - "execution_count": 11, + "execution_count": 65, "metadata": {}, "output_type": "execute_result" } @@ -483,7 +745,7 @@ ], "metadata": { "kernelspec": { - "display_name": "rcs", + "display_name": "base", "language": "python", "name": "python3" }, @@ -497,7 +759,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.14" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/extensions/rcs_fr3/src/hw/Franka.cpp b/extensions/rcs_fr3/src/hw/Franka.cpp index 4d0eb285..f5ad2b9d 100644 --- a/extensions/rcs_fr3/src/hw/Franka.cpp +++ b/extensions/rcs_fr3/src/hw/Franka.cpp @@ -518,11 +518,11 @@ void Franka::joint_controller() { this->set_default_robot_behavior(); // high collision threshold values for high impedance - // this->robot.setCollisionBehavior( - // {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, - // {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, - // {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, - // {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}); + this->robot.setCollisionBehavior( + {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, + {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, + {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}, + {{100.0, 100.0, 100.0, 100.0, 100.0, 100.0}}); // deoxys/config/joint-impedance-controller.yml common::Vector7d Kp; diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index c0ef156e..0eb9b9d6 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -3,6 +3,7 @@ import copy import logging from enum import Enum, auto +from time import sleep from typing import Annotated, Any, ClassVar, Literal, TypeAlias, cast import gymnasium as gym @@ -397,7 +398,17 @@ def reset( self.prev_action = None self.robot.reset() if self.home_on_reset: - self.robot.move_home() + exception = True + # sleep(1) + while exception: + try: + self.robot.move_home() + exception = False + except Exception: + # sleep(0.1) + self.robot.automatic_error_recovery() + sleep(0.1) + # sleep(4) return super().reset(seed=seed, options=options) def close(self): @@ -609,6 +620,7 @@ def __init__( self.trpy_key = get_space_keys(LimitedTRPYRelDictType)[0] self.tquat_key = get_space_keys(LimitedTQuatRelDictType)[0] self._absolute_action: common.Pose | VecType | None = None + self._robot = cast(common.Robot, self.get_wrapper_attr("robot")) self.max_mov = max_mov def _get_current(self) -> np.ndarray: diff --git a/python/rcs/envs/storage_wrapper.py b/python/rcs/envs/storage_wrapper.py index 58929bf3..23b33252 100644 --- a/python/rcs/envs/storage_wrapper.py +++ b/python/rcs/envs/storage_wrapper.py @@ -326,4 +326,4 @@ def close(self): self.queue.put(self.QueueSentinel) wait([self._writer_future]) - StorageWrapper.consolidate(self.base_dir, self.schema) + # StorageWrapper.consolidate(self.base_dir, self.schema) diff --git a/python/rcs/lerobot_joint_converter.py b/python/rcs/lerobot_joint_converter.py index 6092c2ba..047b0f97 100644 --- a/python/rcs/lerobot_joint_converter.py +++ b/python/rcs/lerobot_joint_converter.py @@ -9,11 +9,7 @@ import numpy as np import pandas as pd import pyarrow as pa -import torch -from lerobot.datasets.lerobot_dataset import LeRobotDataset from rcs._core.common import GripperType, RobotType -from torchvision.io import decode_jpeg -from torchvision.transforms import v2 import rcs @@ -435,6 +431,10 @@ def run_conversion( video_encoding: bool = False, video_backend: str | None = None, ) -> None: + import torch + from lerobot.datasets.lerobot_dataset import LeRobotDataset + from torchvision.io import decode_jpeg + from torchvision.transforms import v2 robot_type_converted = RobotType(robot_type) gripper_type_converted = GripperType(gripper_type) converter = JointDatasetConverter( diff --git a/python/rcs/utils.py b/python/rcs/utils.py index 1571233c..a9cc71f6 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -8,12 +8,7 @@ import duckdb os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib") -import matplotlib -matplotlib.use("Agg") import numpy as np -import torch -from matplotlib import pyplot as plt -from torchvision.io import decode_jpeg logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) @@ -52,6 +47,138 @@ def __call__(self): self.t = perf_counter() +class SimpleFrameRateN: + def __init__(self, frame_rate: float | None, loop_name: str = "HybridFrameRate", spin_buffer: float = 0.002): + """ + Utility class to manage frame rates with high precision using a hybrid sleep/spin technique. + + Args: + frame_rate (float | None): The desired frame rate in frames per second. + loop_name (str): Identifier for logging. + spin_buffer (float): Seconds to wake up early for the precision spin-wait (default 2ms). + """ + self.frame_rate = frame_rate + self.loop_name = loop_name + self.frame_interval = 1.0 / frame_rate if frame_rate else 0.0 + self.spin_buffer = spin_buffer + + # Timing state + self.next_target_time: float | None = None + + # Logging state + self.frames_since_print = 0 + self.last_print_time: float | None = None + + def reset(self): + """Resets the internal timers.""" + self.next_target_time = None + self.frames_since_print = 0 + self.last_print_time = None + + def __call__(self): + """Limits the loop to the target frame rate.""" + if self.frame_rate is None: + return + + now = perf_counter() + + # 1. Initialize on the very first frame + if self.next_target_time is None: + self.next_target_time = now + self.frame_interval + self.last_print_time = now + self.frames_since_print = 0 + return + + # 2. Hybrid Wait Strategy + wait_time = self.next_target_time - now + + if wait_time > 0: + # Step A: Sleep and yield CPU for the bulk of the waiting time + sleep_time = wait_time - self.spin_buffer + if sleep_time > 0: + sleep(sleep_time) + + # Step B: "Spin" for the remaining sub-millisecond precision + # This loops infinitely and hogs the CPU until the exact microsecond is reached + while perf_counter() < self.next_target_time: + pass + + # 3. Advance target time strictly by interval to prevent long-term drift + self.next_target_time += self.frame_interval + + # Anti-Spam: If the system lagged massively (e.g., loading a large file), + # fast-forward the target time so we don't try to rapidly catch up without sleeping. + now_after_wait = perf_counter() + if now_after_wait > self.next_target_time + self.frame_interval * 2: + self.next_target_time = now_after_wait + + # 4. Accurate FPS Logging + self.frames_since_print += 1 + elapsed_since_print = now_after_wait - self.last_print_time + + if elapsed_since_print > 10.0: + actual_fps = self.frames_since_print / elapsed_since_print + logger.debug(f"FPS {self.loop_name}: {actual_fps:.2f}") + self.last_print_time = now_after_wait + self.frames_since_print = 0 + + + +class SimpleFrameRateNN: + def __init__(self, frame_rate: float | None, loop_name: str = "PrecisionInterval", spin_buffer: float = 0.0015): + self.frame_rate = frame_rate + self.loop_name = loop_name + self.frame_interval = 1.0 / frame_rate if frame_rate else 0.0 + self.spin_buffer = spin_buffer + + self.t = None + self._last_print = None + self._frame_count = 0 + + def reset(self): + self.t = None + self._frame_count = 0 + + def __call__(self): + if self.frame_rate is None: + return + + now = perf_counter() + + # Initial call setup + if self.t is None: + self.t = now + self._last_print = now + return + + # 1. Calculate how much time is left for THIS frame + elapsed = now - self.t + remaining = self.frame_interval - elapsed + + if remaining > 0: + # 2. Hybrid Sleep: yield the majority of the time to the OS + if remaining > self.spin_buffer: + sleep(remaining - self.spin_buffer) + + # 3. Precision Spin: busy-wait for the last tiny fraction + target = self.t + self.frame_interval + while perf_counter() < target: + pass + + # 4. Logging logic (Average over time) + self._frame_count += 1 + curr_time = perf_counter() + if curr_time - self._last_print > 10: + fps = self._frame_count / (curr_time - self._last_print) + logger.debug(f"FPS {self.loop_name}: {fps:.2f}") + self._last_print = curr_time + self._frame_count = 0 + + # 5. Reset the stopwatch AFTER the wait + # This prevents the 'oscillating jitter' by not forcing a catch-up + self.t = perf_counter() + + class ContextManager: def __enter__(self): pass @@ -144,6 +271,11 @@ def export_episode_videos( fps: int = 30, n: int = -1, ) -> None: + import matplotlib + matplotlib.use("Agg") + import torch + from matplotlib import pyplot as plt + from torchvision.io import decode_jpeg dataset = Path(dataset) output = Path(output) output.mkdir(parents=True, exist_ok=True) From 79ce2d2fe87625a9106cbc06cb9d4b50ba4e89fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Thu, 21 May 2026 13:41:21 +0200 Subject: [PATCH 45/87] stash: add notes --- notes.md | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 notes.md diff --git a/notes.md b/notes.md new file mode 100644 index 00000000..79fa4b87 --- /dev/null +++ b/notes.md @@ -0,0 +1,45 @@ +```shell +# build, only if changes in cpp +docker build -f docker/Dockerfile -t rcs-dev . + + +# run docker + +docker compose -f docker/compose/dev.yml run --rm rcs +bash +export PYTHONPATH="/workspace/robot-control-stack/vlagents/src" +python examples/inference/franka.py + +``` + + +# act +```shell +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/bin_sort/real/duobench_act_bin_sort_real_2026-05-18_21-54-59/150000/pretrained_model", "n_action_steps": 1}' + +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/transfer_cube/duobench_act_transfer_cube_real_2026-05-18_21-55-01/150000/pretrained_model/", "n_action_steps": 1}' +``` + +# pi0 +```shell +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_merged_real_v1_2026-05-19_07-14-26/040000/pretrained_model", "n_action_steps": 1}' + +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_bin_sort_real_2026-05-19_22-52-01/030000/pretrained_model", "n_action_steps": 1}' +``` + + + +# xvla +```shell +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "xvla", "checkpoint_path": "/hdd_data/juelg/duobench/weights/xvla/duobench_xvla_merged_real_v1_2026-05-19_17-00-27/040000/pretrained_model", "n_action_steps": 1, "rename_map": {"head": "image", "left_wrist": "image2", "right_wrist": "image3"}}' +``` + + +# tasks +## bin sort +``` +0: "pick up a box", +1: "pick up the other box with the other arm", +2: "place the box in the correct bin", +3: "task completed; both boxes are in the correct bins", +``` \ No newline at end of file From bd27bf983a6aa8b5ef0897755ae18e9ddc18f7bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Thu, 21 May 2026 22:56:16 +0200 Subject: [PATCH 46/87] fix: left/right wrist camera bug --- examples/inference/franka.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 20c04173..8171fe61 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -44,8 +44,8 @@ # set camera dict to none disable cameras CAMERA_DICT = { - "left_wrist": "230422272017", - "right_wrist": "230422271040", + "right_wrist": "230422272017", + "left_wrist": "230422271040", # "side": "243522070385", # "bird_eye": "243522070364", } From 15d269345f0b63d246d70bfea55b32cdf688c644 Mon Sep 17 00:00:00 2001 From: Tobias Juelg Date: Fri, 22 May 2026 10:01:25 +0200 Subject: [PATCH 47/87] fix: docker dependency --- docker/Dockerfile | 1 + examples/inference/franka.json | 6 +-- notes.md | 71 ++++++++++++++++++++++------------ 3 files changed, 50 insertions(+), 28 deletions(-) diff --git a/docker/Dockerfile b/docker/Dockerfile index 7770f522..d40dace2 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -20,6 +20,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ libglfw3-dev \ libpoco-dev \ ninja-build \ + liburdfdom-dev \ && rm -rf /var/lib/apt/lists/* RUN curl -LsSf https://astral.sh/uv/install.sh | sh diff --git a/examples/inference/franka.json b/examples/inference/franka.json index 7dac17c1..f14d956b 100644 --- a/examples/inference/franka.json +++ b/examples/inference/franka.json @@ -2,7 +2,7 @@ "vlagents_host": "localhost", "vlagents_port": 20000, "vlagents_model": "lerobot", - "instruction": "open the box with the right arm and place the cube inside the box with the left arm", + "instruction": "use the left arm to place the white cube in the white bowl; use the right arm to place the black cube in the black bowl", "robot_keys": [ "left", "right" @@ -10,8 +10,8 @@ "jpeg_encoding": true, "on_same_machine": false, "fps": 30, - "record_path": "inference_recordings_hinge_chest_duobench_act_hinge_chest_real_2026-05-18_21-55-00", - "n_action_steps": 100, + "record_path": "inference_recordings_bin_sort_duobench_xvla_bin_sort_real_2026-05-20_23-25-47_040000", + "n_action_steps": 30, "max_rel_mov_joints": 0.08726646259971647, "max_rel_mov_cart": [ 0.5, diff --git a/notes.md b/notes.md index 79fa4b87..33a306de 100644 --- a/notes.md +++ b/notes.md @@ -1,45 +1,66 @@ + +## robot setup +- switich on the power (socket button and foot button) +- create an ssh connection to transformer from multihead (the machine with the screen) ```shell -# build, only if changes in cpp -docker build -f docker/Dockerfile -t rcs-dev . +ssh -D 10000 transformer +``` +- go to setttings in your browser and type proxy, set manual proxy configuration and fill socks host "localhost" and port 10000 +- then open "https://192.168.101.1/" for the left, and "https://192.168.102.1/desk/" for right (our left) +- wait for the robot s to stop blinking and unlock the joints in desk +## shutdown +- press shutdown in both franka desk interfaces +- wait 2 minutes +- switch of socket and foot button +- lock the pc, dont shut it down -# run docker -docker compose -f docker/compose/dev.yml run --rm rcs -bash -export PYTHONPATH="/workspace/robot-control-stack/vlagents/src" -python examples/inference/franka.py -``` -# act +## policy server setup +- run the models outside the docker with the following commands; replace the path to match the checkpoint (make sure you run it in the following path: /code/duobench/robot-control-stack) +### act ```shell -python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/bin_sort/real/duobench_act_bin_sort_real_2026-05-18_21-54-59/150000/pretrained_model", "n_action_steps": 1}' - -python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/transfer_cube/duobench_act_transfer_cube_real_2026-05-18_21-55-01/150000/pretrained_model/", "n_action_steps": 1}' +uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/transfer_cube/duobench_act_transfer_cube_real_2026-05-18_21-55-01/150000/pretrained_model/", "n_action_steps": 1}' ``` -# pi0 +### pi05 ```shell -python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_merged_real_v1_2026-05-19_07-14-26/040000/pretrained_model", "n_action_steps": 1}' - -python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_bin_sort_real_2026-05-19_22-52-01/030000/pretrained_model", "n_action_steps": 1}' +uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_merged_real_v1_2026-05-19_07-14-26/040000/pretrained_model", "n_action_steps": 1}' ``` +### xvla +```shell +uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "xvla", "checkpoint_path": "/hdd_data/juelg/duobench/weights/xvla/duobench_xvla_merged_real_v1_2026-05-20_23-32-13/040000/pretrained_model", "n_action_steps": 1, "rename_map": {"head": "image", "left_wrist": "image2", "right_wrist": "image3"}}' +``` +## docker setup -# xvla ```shell -python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "xvla", "checkpoint_path": "/hdd_data/juelg/duobench/weights/xvla/duobench_xvla_merged_real_v1_2026-05-19_17-00-27/040000/pretrained_model", "n_action_steps": 1, "rename_map": {"head": "image", "left_wrist": "image2", "right_wrist": "image3"}}' +exec su -l $USER +cd /code/duobench/robot-control-stack + + +# build, only once or if changes in c++ +# docker build -f docker/Dockerfile -t rcs-dev . + + +# run docker +docker compose -f docker/compose/dev.yml run --rm rcs +bash +export PYTHONPATH="/workspace/robot-control-stack/vlagents/src" + +# run the following command in the docker to start eval +python examples/inference/franka.py ``` # tasks -## bin sort -``` -0: "pick up a box", -1: "pick up the other box with the other arm", -2: "place the box in the correct bin", -3: "task completed; both boxes are in the correct bins", -``` \ No newline at end of file +- for each new model and task you need to go to the [franka.json](examples/inference/franka.json) file and adapt + - instruction: can be found in the task in [rcs_duobench/src/rcs_duobench/tasks](rcs_duobench/src/rcs_duobench/tasks) + - record_path: "inference_recordings___" + - for example: task=transfer_cube, modelpoath=duobench_xvla_merged_real_v1_2026-05-19_17-00-27, checkpoint=150000 +- run the new policy server +- start examples/inference/franka.py or press "o" if its already running \ No newline at end of file From ba1fd2d8fb4be1f456f6066a440a7ac46672590d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 22 May 2026 22:07:32 +0200 Subject: [PATCH 48/87] fix(inference): image resize method to match conversion --- examples/inference/franka.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 8171fe61..7ba61123 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -170,7 +170,7 @@ def obs_rcs2agents(self, obs: dict, info: dict | None = None) -> Obs: cameras = {} for frame in obs["frames"]: cameras[frame] = obs["frames"][frame]["rgb"]["data"] - cameras[frame] = np.array(Image.fromarray(cameras[frame]).resize((224, 224), Image.Resampling.LANCZOS)) + cameras[frame] = np.array(Image.fromarray(cameras[frame]).resize((224, 224), Image.Resampling.BILINEAR)) state = [] for robot in self._cfg.robot_keys: From 4790f5630e90e4d183f15e64a6cbd2ebda88d4b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sun, 21 Jun 2026 13:12:24 -0700 Subject: [PATCH 49/87] docs: added documentation for assets path --- README.md | 10 ++++++++++ docs/getting_started/index.md | 10 ++++++++++ 2 files changed, 20 insertions(+) diff --git a/README.md b/README.md index d88d7365..8579cb4d 100644 --- a/README.md +++ b/README.md @@ -152,6 +152,16 @@ pip install -ve . ``` +### RCS Asset Cache + +RCS resolves its asset directory from the `RCS_PREFIX` environment variable. When it is unset, RCS defaults to `~/.rcs`. + +On import, RCS checks whether that path exists. If it does not, it downloads the matching asset archive from GitHub into that location automatically. + +```shell +export RCS_PREFIX=/path/to/rcs-assets +``` + ### Via PyPI/pip *Coming soon...* diff --git a/docs/getting_started/index.md b/docs/getting_started/index.md index cdfac035..72ef4747 100644 --- a/docs/getting_started/index.md +++ b/docs/getting_started/index.md @@ -36,6 +36,16 @@ pip install -ve . For a docker deployment, see the `docker` folder in the repository. +## RCS Asset Cache + +RCS resolves its asset directory from the `RCS_PREFIX` environment variable. If `RCS_PREFIX` is not set, it defaults to `~/.rcs`. + +On import, RCS checks whether that path exists. If it does not, it downloads the matching asset archive from GitHub into that location automatically. + +```shell +export RCS_PREFIX=/path/to/rcs-assets +``` + ## Basic Usage The python package is called `rcs`. From c02ace9145ba48f095a2d77d5a49c6c922d9f7a8 Mon Sep 17 00:00:00 2001 From: Tobias Juelg Date: Mon, 22 Jun 2026 01:11:30 +0200 Subject: [PATCH 50/87] fix(pypi): pin compatible pinocchio runtime deps --- pyproject.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index f2355a90..de2dc377 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,6 +39,9 @@ dependencies = [ "simplejpeg", "mujoco>=3.3.5", "pin==3.7.0", + # pin 3.7.0 currently resolves against older urdfdom/tinyxml SONAMEs at runtime + "cmeel-urdfdom<5", + "cmeel-tinyxml2<11", "greenlet", "duckdb", "pandas", @@ -74,6 +77,8 @@ dev = [ build_deps = [ "mujoco>=3.3.5", "pin==3.7.0", + "cmeel-urdfdom<5", + "cmeel-tinyxml2<11", ] [tool.cibuildwheel] From 79626e59d29eadae312d200086390768ffe7f8fd Mon Sep 17 00:00:00 2001 From: Tobias Juelg Date: Mon, 22 Jun 2026 01:11:30 +0200 Subject: [PATCH 51/87] fix(egl): fail fast when rendering is requested without egl --- python/rcs/camera/sim.py | 2 ++ python/rcs/sim/egl_bootstrap.py | 29 ++++++++++++++++++++++++++--- src/rcs/utils.cpp | 8 ++++++++ 3 files changed, 36 insertions(+), 3 deletions(-) diff --git a/python/rcs/camera/sim.py b/python/rcs/camera/sim.py index a374bc97..d508165a 100644 --- a/python/rcs/camera/sim.py +++ b/python/rcs/camera/sim.py @@ -11,6 +11,7 @@ from rcs._core.sim import SimCameraConfig from rcs._core.sim import SimCameraSet as _SimCameraSet from rcs.camera.interface import BaseCameraSet, CameraFrame, DataFrame, Frame, FrameSet +from rcs.sim import egl_bootstrap from rcs import sim @@ -31,6 +32,7 @@ def __init__( self.cameras = cameras self.physical_units = physical_units + egl_bootstrap.require("simulation camera rendering") super().__init__(simulation, cameras, render_on_demand=render_on_demand) self._sim: sim.Sim diff --git a/python/rcs/sim/egl_bootstrap.py b/python/rcs/sim/egl_bootstrap.py index 57884bde..9aa2d95a 100644 --- a/python/rcs/sim/egl_bootstrap.py +++ b/python/rcs/sim/egl_bootstrap.py @@ -10,12 +10,15 @@ import os _egl_available = False +_egl_error = None _addr_make_current = None _egl_display = None _egl_context = None name = ctypes.util.find_library("EGL") -if name is not None: +if name is None: + _egl_error = "Could not find libEGL via ctypes.util.find_library('EGL')." +else: try: import mujoco.egl from mujoco.egl import GLContext @@ -26,8 +29,28 @@ _egl_display = int(mujoco.egl.EGL_DISPLAY.address) _egl_context = int(_ctx._context.address) _egl_available = True - except Exception: - pass + except Exception as exc: + _egl_error = f"Failed to initialize MuJoCo EGL context: {exc!r}" + + +def is_available() -> bool: + return _egl_available + + +def failure_reason() -> str | None: + return _egl_error + + +def require(feature: str = "offscreen rendering"): + if _egl_available: + return + reason = _egl_error or "unknown EGL initialization failure" + message = ( + f"EGL is required for {feature}, but it is not available. {reason} " + "If you do not need rendering, run RCS without simulation cameras/viewers. " + "If you do need headless rendering, install the system EGL/OpenGL runtime libraries." + ) + raise RuntimeError(message) def bootstrap(): diff --git a/src/rcs/utils.cpp b/src/rcs/utils.cpp index d348375b..18a4e58b 100644 --- a/src/rcs/utils.cpp +++ b/src/rcs/utils.cpp @@ -18,6 +18,14 @@ void bootstrap_egl(uintptr_t fn_addr, uintptr_t dpy, uintptr_t ctx) { } void ensure_current() { + if (g_makeCurrent == nullptr || g_display == EGL_NO_DISPLAY || + g_context == EGL_NO_CONTEXT) { + throw std::runtime_error( + "EGL rendering was requested, but EGL was not bootstrapped. " + "This usually means libEGL or the MuJoCo EGL context is unavailable. " + "Run without cameras/viewers if you do not need rendering, or install " + "the required system EGL/OpenGL runtime libraries."); + } if (!g_makeCurrent(g_display, g_surface, g_surface, g_context)) throw std::runtime_error("eglMakeCurrent failed"); } From 6cf3e0f6f5b97ae044913026575a0e1ef147ffdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Wed, 24 Jun 2026 21:30:24 -0700 Subject: [PATCH 52/87] chore: rename python package to rcs_core --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index de2dc377..f455b6d0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,9 +13,9 @@ requires = [ build-backend = "scikit_build_core.build" [project] -name = "rcs" +name = "rcs_core" version = "0.7.1" -description = "A Lean Ecosystem for Robot Learning at Scale" +description = "A lean, ROS-free sim-to-real framework for training and deploying Vision-Language-Action (VLA) models and RL agents. Native MuJoCo Gymnasium wrappers with synchronous execution for Franka, UR5e, xArm, and SO101." dependencies = [ "websockets>=11.0", "requests~=2.31", From 8a2bf7e756037f013fbf7df585a75ded3daf1b6e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Wed, 24 Jun 2026 22:04:38 -0700 Subject: [PATCH 53/87] chore: remove global pynput dependency --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index f455b6d0..c2165257 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,7 +26,6 @@ dependencies = [ "etils[epath]>=1.7.0", "glfw~=2.7", "pyopengl~=3.1.9", - "pynput>=1.7.7", "pillow>=10.3", "python-dotenv>=1.0.1", "opencv-python~=4.10.0.84", From 8150dedd8597996e3f2f4ade5714d5f651858a07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Wed, 24 Jun 2026 22:04:48 -0700 Subject: [PATCH 54/87] =?UTF-8?q?bump:=20version=200.7.1=20=E2=86=92=200.7?= =?UTF-8?q?.2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 8 ++++++++ CMakeLists.txt | 2 +- extensions/rcs_fr3/CMakeLists.txt | 2 +- extensions/rcs_fr3/pyproject.toml | 4 ++-- extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi | 2 +- extensions/rcs_panda/CMakeLists.txt | 2 +- extensions/rcs_panda/pyproject.toml | 4 ++-- extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi | 2 +- extensions/rcs_realsense/pyproject.toml | 4 ++-- extensions/rcs_realsense/src/rcs_realsense/__init__.py | 2 +- extensions/rcs_robotics_library/CMakeLists.txt | 2 +- extensions/rcs_robotics_library/pyproject.toml | 4 ++-- .../src/rcs_robotics_library/_core/__init__.pyi | 2 +- extensions/rcs_robotiq2f85/pyproject.toml | 4 ++-- .../rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py | 2 +- extensions/rcs_so101/CMakeLists.txt | 2 +- extensions/rcs_so101/pyproject.toml | 4 ++-- extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi | 2 +- extensions/rcs_tacto/pyproject.toml | 4 ++-- extensions/rcs_tacto/src/rcs_tacto/__init__.py | 2 +- extensions/rcs_ur5e/pyproject.toml | 4 ++-- extensions/rcs_ur5e/src/rcs_ur5e/__init__.py | 2 +- extensions/rcs_xarm7/pyproject.toml | 4 ++-- extensions/rcs_xarm7/src/rcs_xarm7/__init__.py | 2 +- pyproject.toml | 2 +- python/rcs/_core/__init__.pyi | 2 +- 26 files changed, 42 insertions(+), 34 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c3525275..9c21dfa5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +## v0.7.2 (2026-06-24) + +### Fix + +- **egl**: fail fast when rendering is requested without egl +- **pypi**: pin compatible pinocchio runtime deps +- sim reset (#314) + ## v0.7.1 (2026-06-02) ### Feat diff --git a/CMakeLists.txt b/CMakeLists.txt index 972a0a5f..a9d48a8b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.5) project( rcs LANGUAGES C CXX - VERSION 0.7.1 + VERSION 0.7.2 DESCRIPTION "Robot Control Stack Library" ) diff --git a/extensions/rcs_fr3/CMakeLists.txt b/extensions/rcs_fr3/CMakeLists.txt index a6213135..46689427 100644 --- a/extensions/rcs_fr3/CMakeLists.txt +++ b/extensions/rcs_fr3/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.24) project( rcs_fr3 LANGUAGES C CXX - VERSION 0.7.1 + VERSION 0.7.2 DESCRIPTION "RCS Libfranka integration" ) diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index aeb0d289..d62c3370 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -13,9 +13,9 @@ build-backend = "scikit_build_core.build" [project] name = "rcs_fr3" -version = "0.7.1" +version = "0.7.2" description = "RCS libfranka integration" -dependencies = ["rcs>=0.7.1", "frankik"] +dependencies = ["rcs>=0.7.2", "frankik"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi b/extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi index 7a5f99cc..78b6b4cc 100644 --- a/extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi +++ b/extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import hw __all__: list[str] = ["hw"] -__version__: str = "0.7.1" +__version__: str = "0.7.2" diff --git a/extensions/rcs_panda/CMakeLists.txt b/extensions/rcs_panda/CMakeLists.txt index 775e2235..01a83198 100644 --- a/extensions/rcs_panda/CMakeLists.txt +++ b/extensions/rcs_panda/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.24) project( rcs_panda LANGUAGES C CXX - VERSION 0.7.1 + VERSION 0.7.2 DESCRIPTION "RCS Libfranka integration" ) diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index f3552688..7194a38b 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -12,9 +12,9 @@ build-backend = "scikit_build_core.build" [project] name = "rcs_panda" -version = "0.7.1" +version = "0.7.2" description = "RCS libfranka integration" -dependencies = ["rcs>=0.7.1"] +dependencies = ["rcs>=0.7.2"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi b/extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi index 7a5f99cc..78b6b4cc 100644 --- a/extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi +++ b/extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import hw __all__: list[str] = ["hw"] -__version__: str = "0.7.1" +__version__: str = "0.7.2" diff --git a/extensions/rcs_realsense/pyproject.toml b/extensions/rcs_realsense/pyproject.toml index 8dc82aa6..addfbd8f 100644 --- a/extensions/rcs_realsense/pyproject.toml +++ b/extensions/rcs_realsense/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_realsense" -version = "0.7.1" +version = "0.7.2" description = "RCS realsense module" dependencies = [ - "rcs>=0.7.1", + "rcs>=0.7.2", "pyrealsense2~=2.55.1", "pupil_apriltags", "diskcache", diff --git a/extensions/rcs_realsense/src/rcs_realsense/__init__.py b/extensions/rcs_realsense/src/rcs_realsense/__init__.py index a5f830a2..bc8c296f 100644 --- a/extensions/rcs_realsense/src/rcs_realsense/__init__.py +++ b/extensions/rcs_realsense/src/rcs_realsense/__init__.py @@ -1 +1 @@ -__version__ = "0.7.1" +__version__ = "0.7.2" diff --git a/extensions/rcs_robotics_library/CMakeLists.txt b/extensions/rcs_robotics_library/CMakeLists.txt index a9849ae4..e27f0940 100644 --- a/extensions/rcs_robotics_library/CMakeLists.txt +++ b/extensions/rcs_robotics_library/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.19) project( rcs_fr3 LANGUAGES C CXX - VERSION 0.7.1 + VERSION 0.7.2 DESCRIPTION "RCS robotics library integration" ) diff --git a/extensions/rcs_robotics_library/pyproject.toml b/extensions/rcs_robotics_library/pyproject.toml index c0b6e00f..a3a1079a 100644 --- a/extensions/rcs_robotics_library/pyproject.toml +++ b/extensions/rcs_robotics_library/pyproject.toml @@ -12,10 +12,10 @@ build-backend = "scikit_build_core.build" [project] name = "rcs_robotics_library" -version = "0.7.1" +version = "0.7.2" description = "RCS robotics library integration" readme = "README.md" -dependencies = ["rcs>=0.7.1"] +dependencies = ["rcs>=0.7.2"] maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, diff --git a/extensions/rcs_robotics_library/src/rcs_robotics_library/_core/__init__.pyi b/extensions/rcs_robotics_library/src/rcs_robotics_library/_core/__init__.pyi index 7e130934..d574dd50 100644 --- a/extensions/rcs_robotics_library/src/rcs_robotics_library/_core/__init__.pyi +++ b/extensions/rcs_robotics_library/src/rcs_robotics_library/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import rl __all__: list[str] = ["rl"] -__version__: str = "0.7.1" +__version__: str = "0.7.2" diff --git a/extensions/rcs_robotiq2f85/pyproject.toml b/extensions/rcs_robotiq2f85/pyproject.toml index 17625268..6168b7bf 100644 --- a/extensions/rcs_robotiq2f85/pyproject.toml +++ b/extensions/rcs_robotiq2f85/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_robotiq2f85" -version = "0.7.1" +version = "0.7.2" description="RCS RobotiQ module" dependencies = [ - "rcs>=0.7.1", + "rcs>=0.7.2", "2f85-python-driver @ git+https://github.com/RobotControlStack/2f85-python-driver.git", ] readme = "README.md" diff --git a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py index a5f830a2..bc8c296f 100644 --- a/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py +++ b/extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py @@ -1 +1 @@ -__version__ = "0.7.1" +__version__ = "0.7.2" diff --git a/extensions/rcs_so101/CMakeLists.txt b/extensions/rcs_so101/CMakeLists.txt index 3633b530..472128ef 100644 --- a/extensions/rcs_so101/CMakeLists.txt +++ b/extensions/rcs_so101/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.19) project( rcs_so101 LANGUAGES C CXX - VERSION 0.7.1 + VERSION 0.7.2 DESCRIPTION "RCS so101 ik" ) diff --git a/extensions/rcs_so101/pyproject.toml b/extensions/rcs_so101/pyproject.toml index a4d45705..41fe4559 100644 --- a/extensions/rcs_so101/pyproject.toml +++ b/extensions/rcs_so101/pyproject.toml @@ -12,9 +12,9 @@ build-backend = "scikit_build_core.build" [project] name = "rcs_so101" -version = "0.7.1" +version = "0.7.2" description = "RCS SO101 module" -dependencies = ["rcs>=0.7.1", "lerobot==0.3.3"] +dependencies = ["rcs>=0.7.2", "lerobot==0.3.3"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi b/extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi index 45ef0245..1baf0df9 100644 --- a/extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi +++ b/extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import so101_ik __all__: list[str] = ["so101_ik"] -__version__: str = "0.7.1" +__version__: str = "0.7.2" diff --git a/extensions/rcs_tacto/pyproject.toml b/extensions/rcs_tacto/pyproject.toml index 01e0121c..387f7bf3 100644 --- a/extensions/rcs_tacto/pyproject.toml +++ b/extensions/rcs_tacto/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_tacto" -version = "0.7.1" +version = "0.7.2" description = "RCS integration of tacto" dependencies = [ - "rcs>=0.7.1", + "rcs>=0.7.2", "omegaconf", "mujoco-tacto@git+https://github.com/utn-air/mujoco-tacto.git@main", ] diff --git a/extensions/rcs_tacto/src/rcs_tacto/__init__.py b/extensions/rcs_tacto/src/rcs_tacto/__init__.py index a5f830a2..bc8c296f 100644 --- a/extensions/rcs_tacto/src/rcs_tacto/__init__.py +++ b/extensions/rcs_tacto/src/rcs_tacto/__init__.py @@ -1 +1 @@ -__version__ = "0.7.1" +__version__ = "0.7.2" diff --git a/extensions/rcs_ur5e/pyproject.toml b/extensions/rcs_ur5e/pyproject.toml index 59cb36b3..bedef490 100644 --- a/extensions/rcs_ur5e/pyproject.toml +++ b/extensions/rcs_ur5e/pyproject.toml @@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_ur5e" -version = "0.7.1" +version = "0.7.2" description = "RCS UR5e module" -dependencies = ["rcs>=0.7.1", "ur_rtde==1.6.1"] +dependencies = ["rcs>=0.7.2", "ur_rtde==1.6.1"] readme = "README.md" maintainers = [ { name = "Johannes Hechtl", email = "johannes.hechtl@siemens.com" }, diff --git a/extensions/rcs_ur5e/src/rcs_ur5e/__init__.py b/extensions/rcs_ur5e/src/rcs_ur5e/__init__.py index 08d80bee..deee221c 100644 --- a/extensions/rcs_ur5e/src/rcs_ur5e/__init__.py +++ b/extensions/rcs_ur5e/src/rcs_ur5e/__init__.py @@ -1,6 +1,6 @@ from rcs_ur5e import configs, creators, hw -__version__ = "0.7.1" +__version__ = "0.7.2" __all__ = [ "configs", diff --git a/extensions/rcs_xarm7/pyproject.toml b/extensions/rcs_xarm7/pyproject.toml index 488b8c07..ec6902b4 100644 --- a/extensions/rcs_xarm7/pyproject.toml +++ b/extensions/rcs_xarm7/pyproject.toml @@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_xarm7" -version = "0.7.1" +version = "0.7.2" description = "RCS xArm7 module" -dependencies = ["rcs>=0.7.1", "xarm-python-sdk==1.17.0"] +dependencies = ["rcs>=0.7.2", "xarm-python-sdk==1.17.0"] readme = "README.md" maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, diff --git a/extensions/rcs_xarm7/src/rcs_xarm7/__init__.py b/extensions/rcs_xarm7/src/rcs_xarm7/__init__.py index 7c0cb857..aea67f74 100644 --- a/extensions/rcs_xarm7/src/rcs_xarm7/__init__.py +++ b/extensions/rcs_xarm7/src/rcs_xarm7/__init__.py @@ -1,6 +1,6 @@ from rcs_xarm7 import configs, creators, hw -__version__ = "0.7.1" +__version__ = "0.7.2" __all__ = [ "configs", diff --git a/pyproject.toml b/pyproject.toml index c2165257..dd1d797e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,7 +14,7 @@ build-backend = "scikit_build_core.build" [project] name = "rcs_core" -version = "0.7.1" +version = "0.7.2" description = "A lean, ROS-free sim-to-real framework for training and deploying Vision-Language-Action (VLA) models and RL agents. Native MuJoCo Gymnasium wrappers with synchronous execution for Franka, UR5e, xArm, and SO101." dependencies = [ "websockets>=11.0", diff --git a/python/rcs/_core/__init__.pyi b/python/rcs/_core/__init__.pyi index 7d6df81b..d1d5add8 100644 --- a/python/rcs/_core/__init__.pyi +++ b/python/rcs/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import common, sim __all__: list[str] = ["common", "sim"] -__version__: str = "0.7.1" +__version__: str = "0.8.0" From c57c151aeca977c861e3bc485203abf79cd04ab3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 12:05:55 -0700 Subject: [PATCH 55/87] build: rename rcs to rcs-core - fix rcs package name in extensions - added rcs as dependency in build process - improved robustness of downloading assets --- README.md | 10 ++++--- extensions/rcs_fr3/cmake/Findrcs.cmake | 29 ++++++++++++++----- extensions/rcs_fr3/pyproject.toml | 3 +- extensions/rcs_panda/cmake/Findrcs.cmake | 29 ++++++++++++++----- extensions/rcs_panda/pyproject.toml | 3 +- extensions/rcs_realsense/pyproject.toml | 2 +- .../rcs_robotics_library/cmake/Findrcs.cmake | 29 ++++++++++++++----- .../rcs_robotics_library/pyproject.toml | 3 +- extensions/rcs_robotiq2f85/pyproject.toml | 2 +- extensions/rcs_so101/cmake/Findrcs.cmake | 29 ++++++++++++++----- extensions/rcs_so101/pyproject.toml | 3 +- extensions/rcs_tacto/pyproject.toml | 2 +- extensions/rcs_ur5e/pyproject.toml | 2 +- extensions/rcs_xarm7/pyproject.toml | 2 +- pyproject.toml | 19 ++++++------ python/rcs/__init__.py | 6 +++- 16 files changed, 122 insertions(+), 51 deletions(-) diff --git a/README.md b/README.md index 8579cb4d..d6e9f722 100644 --- a/README.md +++ b/README.md @@ -148,8 +148,13 @@ pip install 'pip>=25.1' pip install --group build_deps # install rcs -pip install -ve . +pip install -ve . --no-build-isolation +``` + +### Via PyPI/pip +```shell +pip install rcs-core ``` ### RCS Asset Cache @@ -162,9 +167,6 @@ On import, RCS checks whether that path exists. If it does not, it downloads the export RCS_PREFIX=/path/to/rcs-assets ``` -### Via PyPI/pip - -*Coming soon...* ## 🦾 Hardware Extensions diff --git a/extensions/rcs_fr3/cmake/Findrcs.cmake b/extensions/rcs_fr3/cmake/Findrcs.cmake index 08456ccc..595d53bb 100644 --- a/extensions/rcs_fr3/cmake/Findrcs.cmake +++ b/extensions/rcs_fr3/cmake/Findrcs.cmake @@ -2,28 +2,43 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") + endif() + return() + endif() + + execute_process( + COMMAND + ${Python3_EXECUTABLE} + -c + "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" + OUTPUT_VARIABLE rcs_package_dir + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if (NOT rcs_package_dir) + set(rcs_FOUND FALSE) + if (rcs_FIND_REQUIRED) + message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) - file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") + set(rcs_library_path "${rcs_package_dir}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") endif() return() endif() @@ -43,4 +58,4 @@ if (NOT rcs_FOUND) IMPORTED_LOCATION "${rcs_library_path}" ) set(rcs_FOUND TRUE) -endif() \ No newline at end of file +endif() diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index d62c3370..f8ff1cde 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -8,6 +8,7 @@ requires = [ "cmake", "ninja", "pin==3.7.0", + "rcs-core>=0.7.2", ] build-backend = "scikit_build_core.build" @@ -15,7 +16,7 @@ build-backend = "scikit_build_core.build" name = "rcs_fr3" version = "0.7.2" description = "RCS libfranka integration" -dependencies = ["rcs>=0.7.2", "frankik"] +dependencies = ["rcs-core>=0.7.2", "frankik"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_panda/cmake/Findrcs.cmake b/extensions/rcs_panda/cmake/Findrcs.cmake index 08456ccc..595d53bb 100644 --- a/extensions/rcs_panda/cmake/Findrcs.cmake +++ b/extensions/rcs_panda/cmake/Findrcs.cmake @@ -2,28 +2,43 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") + endif() + return() + endif() + + execute_process( + COMMAND + ${Python3_EXECUTABLE} + -c + "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" + OUTPUT_VARIABLE rcs_package_dir + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if (NOT rcs_package_dir) + set(rcs_FOUND FALSE) + if (rcs_FIND_REQUIRED) + message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) - file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") + set(rcs_library_path "${rcs_package_dir}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") endif() return() endif() @@ -43,4 +58,4 @@ if (NOT rcs_FOUND) IMPORTED_LOCATION "${rcs_library_path}" ) set(rcs_FOUND TRUE) -endif() \ No newline at end of file +endif() diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index 7194a38b..1d89f057 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -7,6 +7,7 @@ requires = [ "pybind11", "cmake", "ninja", + "rcs-core>=0.7.2", ] build-backend = "scikit_build_core.build" @@ -14,7 +15,7 @@ build-backend = "scikit_build_core.build" name = "rcs_panda" version = "0.7.2" description = "RCS libfranka integration" -dependencies = ["rcs>=0.7.2"] +dependencies = ["rcs-core>=0.7.2"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_realsense/pyproject.toml b/extensions/rcs_realsense/pyproject.toml index addfbd8f..07817b81 100644 --- a/extensions/rcs_realsense/pyproject.toml +++ b/extensions/rcs_realsense/pyproject.toml @@ -7,7 +7,7 @@ name = "rcs_realsense" version = "0.7.2" description = "RCS realsense module" dependencies = [ - "rcs>=0.7.2", + "rcs-core>=0.7.2", "pyrealsense2~=2.55.1", "pupil_apriltags", "diskcache", diff --git a/extensions/rcs_robotics_library/cmake/Findrcs.cmake b/extensions/rcs_robotics_library/cmake/Findrcs.cmake index 08456ccc..595d53bb 100644 --- a/extensions/rcs_robotics_library/cmake/Findrcs.cmake +++ b/extensions/rcs_robotics_library/cmake/Findrcs.cmake @@ -2,28 +2,43 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") + endif() + return() + endif() + + execute_process( + COMMAND + ${Python3_EXECUTABLE} + -c + "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" + OUTPUT_VARIABLE rcs_package_dir + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if (NOT rcs_package_dir) + set(rcs_FOUND FALSE) + if (rcs_FIND_REQUIRED) + message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) - file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") + set(rcs_library_path "${rcs_package_dir}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") endif() return() endif() @@ -43,4 +58,4 @@ if (NOT rcs_FOUND) IMPORTED_LOCATION "${rcs_library_path}" ) set(rcs_FOUND TRUE) -endif() \ No newline at end of file +endif() diff --git a/extensions/rcs_robotics_library/pyproject.toml b/extensions/rcs_robotics_library/pyproject.toml index a3a1079a..3be07bbf 100644 --- a/extensions/rcs_robotics_library/pyproject.toml +++ b/extensions/rcs_robotics_library/pyproject.toml @@ -7,6 +7,7 @@ requires = [ "pybind11", "cmake", "ninja", + "rcs-core>=0.7.2", ] build-backend = "scikit_build_core.build" @@ -15,7 +16,7 @@ name = "rcs_robotics_library" version = "0.7.2" description = "RCS robotics library integration" readme = "README.md" -dependencies = ["rcs>=0.7.2"] +dependencies = ["rcs-core>=0.7.2"] maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, diff --git a/extensions/rcs_robotiq2f85/pyproject.toml b/extensions/rcs_robotiq2f85/pyproject.toml index 6168b7bf..144fcae1 100644 --- a/extensions/rcs_robotiq2f85/pyproject.toml +++ b/extensions/rcs_robotiq2f85/pyproject.toml @@ -7,7 +7,7 @@ name = "rcs_robotiq2f85" version = "0.7.2" description="RCS RobotiQ module" dependencies = [ - "rcs>=0.7.2", + "rcs-core>=0.7.2", "2f85-python-driver @ git+https://github.com/RobotControlStack/2f85-python-driver.git", ] readme = "README.md" diff --git a/extensions/rcs_so101/cmake/Findrcs.cmake b/extensions/rcs_so101/cmake/Findrcs.cmake index 08456ccc..595d53bb 100644 --- a/extensions/rcs_so101/cmake/Findrcs.cmake +++ b/extensions/rcs_so101/cmake/Findrcs.cmake @@ -2,28 +2,43 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") + endif() + return() + endif() + + execute_process( + COMMAND + ${Python3_EXECUTABLE} + -c + "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" + OUTPUT_VARIABLE rcs_package_dir + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if (NOT rcs_package_dir) + set(rcs_FOUND FALSE) + if (rcs_FIND_REQUIRED) + message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) - file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") + set(rcs_library_path "${rcs_package_dir}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs. Please install rcs using pip.") + message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") endif() return() endif() @@ -43,4 +58,4 @@ if (NOT rcs_FOUND) IMPORTED_LOCATION "${rcs_library_path}" ) set(rcs_FOUND TRUE) -endif() \ No newline at end of file +endif() diff --git a/extensions/rcs_so101/pyproject.toml b/extensions/rcs_so101/pyproject.toml index 41fe4559..7ea34566 100644 --- a/extensions/rcs_so101/pyproject.toml +++ b/extensions/rcs_so101/pyproject.toml @@ -7,6 +7,7 @@ requires = [ "pybind11", "cmake", "ninja", + "rcs-core>=0.7.2", ] build-backend = "scikit_build_core.build" @@ -14,7 +15,7 @@ build-backend = "scikit_build_core.build" name = "rcs_so101" version = "0.7.2" description = "RCS SO101 module" -dependencies = ["rcs>=0.7.2", "lerobot==0.3.3"] +dependencies = ["rcs-core>=0.7.2", "lerobot==0.3.3"] readme = "README.md" maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] diff --git a/extensions/rcs_tacto/pyproject.toml b/extensions/rcs_tacto/pyproject.toml index 387f7bf3..fd7381a9 100644 --- a/extensions/rcs_tacto/pyproject.toml +++ b/extensions/rcs_tacto/pyproject.toml @@ -7,7 +7,7 @@ name = "rcs_tacto" version = "0.7.2" description = "RCS integration of tacto" dependencies = [ - "rcs>=0.7.2", + "rcs-core>=0.7.2", "omegaconf", "mujoco-tacto@git+https://github.com/utn-air/mujoco-tacto.git@main", ] diff --git a/extensions/rcs_ur5e/pyproject.toml b/extensions/rcs_ur5e/pyproject.toml index bedef490..5f3da01d 100644 --- a/extensions/rcs_ur5e/pyproject.toml +++ b/extensions/rcs_ur5e/pyproject.toml @@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta" name = "rcs_ur5e" version = "0.7.2" description = "RCS UR5e module" -dependencies = ["rcs>=0.7.2", "ur_rtde==1.6.1"] +dependencies = ["rcs-core>=0.7.2", "ur_rtde==1.6.1"] readme = "README.md" maintainers = [ { name = "Johannes Hechtl", email = "johannes.hechtl@siemens.com" }, diff --git a/extensions/rcs_xarm7/pyproject.toml b/extensions/rcs_xarm7/pyproject.toml index ec6902b4..b8897e93 100644 --- a/extensions/rcs_xarm7/pyproject.toml +++ b/extensions/rcs_xarm7/pyproject.toml @@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta" name = "rcs_xarm7" version = "0.7.2" description = "RCS xArm7 module" -dependencies = ["rcs>=0.7.2", "xarm-python-sdk==1.17.0"] +dependencies = ["rcs-core>=0.7.2", "xarm-python-sdk==1.17.0"] readme = "README.md" maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, diff --git a/pyproject.toml b/pyproject.toml index dd1d797e..8bedd090 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -78,6 +78,7 @@ build_deps = [ "pin==3.7.0", "cmeel-urdfdom<5", "cmeel-tinyxml2<11", + "scikit-build-core>=0.3.3", ] [tool.cibuildwheel] @@ -187,44 +188,44 @@ version_files = [ "extensions/rcs_fr3/src/rcs_fr3/_core/__init__.pyi:__version__", "extensions/rcs_fr3/pyproject.toml:version", # The line below updates the dependency string "rcs>=x.y.z" - "extensions/rcs_fr3/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_fr3/pyproject.toml:\"rcs-core>=(.*)\"", # --- Panda Extension --- "extensions/rcs_panda/CMakeLists.txt:VERSION", "extensions/rcs_panda/src/rcs_panda/_core/__init__.pyi:__version__", "extensions/rcs_panda/pyproject.toml:version", - "extensions/rcs_panda/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_panda/pyproject.toml:\"rcs-core>=(.*)\"", # --- Robotics Library --- "extensions/rcs_robotics_library/CMakeLists.txt:VERSION", "extensions/rcs_robotics_library/src/rcs_robotics_library/_core/__init__.pyi:__version__", "extensions/rcs_robotics_library/pyproject.toml:version", - "extensions/rcs_robotics_library/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_robotics_library/pyproject.toml:\"rcs-core>=(.*)\"", # --- SO101 --- "extensions/rcs_so101/CMakeLists.txt:VERSION", "extensions/rcs_so101/src/rcs_so101/_core/__init__.pyi:__version__", "extensions/rcs_so101/pyproject.toml:version", - "extensions/rcs_so101/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_so101/pyproject.toml:\"rcs-core>=(.*)\"", # --- Other Extensions --- "extensions/rcs_realsense/pyproject.toml:version", "extensions/rcs_realsense/src/rcs_realsense/__init__.py:__version__", - "extensions/rcs_realsense/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_realsense/pyproject.toml:\"rcs-core>=(.*)\"", "extensions/rcs_xarm7/pyproject.toml:version", "extensions/rcs_xarm7/src/rcs_xarm7/__init__.py:__version__", - "extensions/rcs_xarm7/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_xarm7/pyproject.toml:\"rcs-core>=(.*)\"", "extensions/rcs_ur5e/pyproject.toml:version", "extensions/rcs_ur5e/src/rcs_ur5e/__init__.py:__version__", - "extensions/rcs_ur5e/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_ur5e/pyproject.toml:\"rcs-core>=(.*)\"", "extensions/rcs_tacto/pyproject.toml:version", "extensions/rcs_tacto/src/rcs_tacto/__init__.py:__version__", - "extensions/rcs_tacto/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_tacto/pyproject.toml:\"rcs-core>=(.*)\"", "extensions/rcs_robotiq2f85/pyproject.toml:version", "extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py:__version__", - "extensions/rcs_robotiq2f85/pyproject.toml:\"rcs>=(.*)\"", + "extensions/rcs_robotiq2f85/pyproject.toml:\"rcs-core>=(.*)\"", ] diff --git a/python/rcs/__init__.py b/python/rcs/__init__.py index 459ebf0f..106ed229 100644 --- a/python/rcs/__init__.py +++ b/python/rcs/__init__.py @@ -15,6 +15,7 @@ from rcs import camera, envs, hand, sim GITHUB_ASSET_ARCHIVE_URL = "https://github.com/RobotControlStack/robot-control-stack/archive/refs/tags/{tag}.zip" +REQUIRED_ASSET = Path("assets/scenes/empty_world/scene.xml") def download_assets( @@ -56,6 +57,9 @@ def get_prefix( assets_dirname: str = "assets", download_fn: Callable[[str, Path, str, str], None] = download_assets, ) -> str: + def has_required_assets(prefix: Path) -> bool: + return (prefix / REQUIRED_ASSET).is_file() + if env_prefix: prefix = Path(env_prefix).expanduser().resolve() else: @@ -65,7 +69,7 @@ def get_prefix( prefix = default_prefix.resolve() assets_dir = prefix / assets_dirname - if not assets_dir.is_dir(): + if not assets_dir.is_dir() or not has_required_assets(prefix): prefix.mkdir(parents=True, exist_ok=True) print(f"Assets not found at {assets_dir}, downloading them now.") download_fn(version, prefix, github_asset_archive_url, assets_dirname) From c183ca812b069d9393fb636b9ba41428728a7643 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 13:01:31 -0700 Subject: [PATCH 56/87] ci: python wheel building --- .github/workflows/build_wheels.yaml | 100 ++++++++++++++++++++++++++ .github/workflows/ci.yaml | 2 +- extensions/rcs_usb_cam/pyproject.toml | 4 +- extensions/rcs_zed/pyproject.toml | 4 +- pyproject.toml | 8 +++ python/rcs/_core/__init__.pyi | 2 +- 6 files changed, 114 insertions(+), 6 deletions(-) create mode 100644 .github/workflows/build_wheels.yaml diff --git a/.github/workflows/build_wheels.yaml b/.github/workflows/build_wheels.yaml new file mode 100644 index 00000000..fc272ef1 --- /dev/null +++ b/.github/workflows/build_wheels.yaml @@ -0,0 +1,100 @@ +name: Build and Publish Wheels + +on: + workflow_dispatch: + release: + types: [published] + +jobs: + build_core_wheels: + name: Build core wheels + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Build core wheels + uses: pypa/cibuildwheel@v2.22.0 + env: + CIBW_ARCHS_LINUX: x86_64 + CIBW_BUILD: cp311-* cp312-* cp313-* + + - uses: actions/upload-artifact@v4 + with: + name: core-wheels + path: ./wheelhouse/*.whl + + build_extension_wheels: + name: Build ${{ matrix.extension }} wheels on Python ${{ matrix.python-version }} + needs: [build_core_wheels] + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.11", "3.12", "3.13"] + extension: + - rcs_fr3 + - rcs_panda + - rcs_robotics_library + - rcs_so101 + - rcs_realsense + - rcs_robotiq2f85 + - rcs_tacto + - rcs_ur5e + - rcs_usb_cam + - rcs_xarm7 + - rcs_zed + + steps: + - uses: actions/checkout@v4 + + - uses: actions/download-artifact@v4 + with: + name: core-wheels + path: dist/core + + - name: Install root Debian dependencies + run: | + sudo apt-get update + sudo xargs -a debian_deps.txt apt-get install -y + + - name: Install extension Debian dependencies + run: | + deps_file="extensions/${{ matrix.extension }}/debian_deps.txt" + if [ -f "${deps_file}" ]; then + sudo xargs -a "${deps_file}" apt-get install -y + fi + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: pip + + - name: Build extension wheel + env: + PIP_FIND_LINKS: ${{ github.workspace }}/dist/core + run: | + python -m pip install --upgrade pip + python -m pip install build + python -m build --wheel "extensions/${{ matrix.extension }}" + + - uses: actions/upload-artifact@v4 + with: + name: wheels-${{ matrix.extension }}-py${{ matrix.python-version }} + path: extensions/${{ matrix.extension }}/dist/*.whl + + upload_pypi: + needs: [build_core_wheels, build_extension_wheels] + runs-on: ubuntu-latest + if: github.event_name == 'release' && github.event.action == 'published' + environment: pypi + permissions: + id-token: write + steps: + - uses: actions/download-artifact@v4 + with: + pattern: "*wheels*" + merge-multiple: true + path: dist + + - uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index a439df47..b81d0fbb 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -141,7 +141,7 @@ jobs: - name: Install RCS run: pip install -ve . --group dev - name: Install extension - run: pip install -ve extensions/${{ matrix.extension }} + run: pip install -ve extensions/${{ matrix.extension }} --no-build-isolation - name: Check that stub files are up-to-date run: make -C extensions/${{ matrix.extension }} stubgen && git diff --exit-code - name: Check clang format diff --git a/extensions/rcs_usb_cam/pyproject.toml b/extensions/rcs_usb_cam/pyproject.toml index 4a39396b..fa365498 100644 --- a/extensions/rcs_usb_cam/pyproject.toml +++ b/extensions/rcs_usb_cam/pyproject.toml @@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_usb_cam" -version = "0.5.0" +version = "0.7.2" description = "RCS USB Camera module" -dependencies = ["rcs>=0.5.2", "opencv-python~=4.10.0"] +dependencies = ["rcs-core>=0.7.2", "opencv-python~=4.10.0"] maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, diff --git a/extensions/rcs_zed/pyproject.toml b/extensions/rcs_zed/pyproject.toml index 51694e69..89d3b851 100644 --- a/extensions/rcs_zed/pyproject.toml +++ b/extensions/rcs_zed/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_zed" -version = "0.6.3" +version = "0.7.2" description = "RCS ZED camera module" dependencies = [ - "rcs>=0.6.3", + "rcs-core>=0.7.2", "opencv-python~=4.10.0", "pupil_apriltags", "diskcache", diff --git a/pyproject.toml b/pyproject.toml index 8bedd090..ab0adf23 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -228,4 +228,12 @@ version_files = [ "extensions/rcs_robotiq2f85/pyproject.toml:version", "extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py:__version__", "extensions/rcs_robotiq2f85/pyproject.toml:\"rcs-core>=(.*)\"", + + "extensions/rcs_usb_cam/pyproject.toml:version", + "extensions/rcs_usb_cam/src/rcs_usb_cam/__init__.py:__version__", + "extensions/rcs_usb_cam/pyproject.toml:\"rcs-core>=(.*)\"", + + "extensions/rcs_zed/pyproject.toml:version", + "extensions/rcs_zed/src/rcs_zed/__init__.py:__version__", + "extensions/rcs_zed/pyproject.toml:\"rcs-core>=(.*)\"", ] diff --git a/python/rcs/_core/__init__.pyi b/python/rcs/_core/__init__.pyi index d1d5add8..5a27ade9 100644 --- a/python/rcs/_core/__init__.pyi +++ b/python/rcs/_core/__init__.pyi @@ -16,4 +16,4 @@ from __future__ import annotations from . import common, sim __all__: list[str] = ["common", "sim"] -__version__: str = "0.8.0" +__version__: str = "0.7.2" From 2ccd738c5a705cb8b802c49bc1fb7b67c9c1ee5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 16:04:43 -0700 Subject: [PATCH 57/87] docs: updated install instructions - updated install instructions - updated licenses and readmes --- README.md | 3 + docs/extensions/index.md | 2 + docs/extensions/overview.md | 11 ++- docs/extensions/rcs_fr3.md | 60 ++++++--------- docs/extensions/rcs_panda.md | 32 +++++++- docs/extensions/rcs_realsense.md | 10 ++- docs/extensions/rcs_robotics_library.md | 10 ++- docs/extensions/rcs_robotiq2f85.md | 11 ++- docs/extensions/rcs_so101.md | 9 ++- docs/extensions/rcs_tacto.md | 7 ++ docs/extensions/rcs_ur5e.md | 37 +++++++++ docs/extensions/rcs_usb_cam.md | 7 ++ docs/extensions/rcs_xarm7.md | 25 +++++- docs/extensions/rcs_zed.md | 27 +++++++ extensions/README.md | 10 ++- extensions/rcs_fr3/README.md | 77 ++++++++++++------- extensions/rcs_fr3/pyproject.toml | 1 + extensions/rcs_panda/README.md | 77 ++++++++++++------- extensions/rcs_panda/pyproject.toml | 1 + extensions/rcs_realsense/README.md | 34 +++++++- extensions/rcs_realsense/pyproject.toml | 2 + extensions/rcs_robotics_library/README.md | 37 ++++++++- .../rcs_robotics_library/pyproject.toml | 1 + extensions/rcs_robotiq2f85/README.md | 38 +++++++-- extensions/rcs_so101/README.md | 45 +++++++++-- extensions/rcs_so101/pyproject.toml | 1 + extensions/rcs_tacto/README.md | 35 +++++++-- extensions/rcs_tacto/pyproject.toml | 1 + extensions/rcs_ur5e/README.md | 56 ++++++++++++++ extensions/rcs_ur5e/pyproject.toml | 1 + extensions/rcs_usb_cam/README.md | 34 +++++++- extensions/rcs_usb_cam/pyproject.toml | 2 + extensions/rcs_xarm7/README.md | 49 ++++++++++++ extensions/rcs_xarm7/pyproject.toml | 1 + extensions/rcs_zed/README.md | 52 +++++++------ extensions/rcs_zed/pyproject.toml | 2 + 36 files changed, 649 insertions(+), 159 deletions(-) create mode 100644 docs/extensions/rcs_ur5e.md create mode 100644 docs/extensions/rcs_zed.md create mode 100644 extensions/rcs_ur5e/README.md create mode 100644 extensions/rcs_xarm7/README.md diff --git a/README.md b/README.md index d6e9f722..40cc1659 100644 --- a/README.md +++ b/README.md @@ -176,6 +176,9 @@ To install a specific robot extension (example for Franka FR3): ```shell sudo apt install $(cat extensions/rcs_fr3/debian_deps.txt) +pip install rcs-fr3 + +# or install it locally pip install -ve extensions/rcs_fr3 ``` diff --git a/docs/extensions/index.md b/docs/extensions/index.md index 58c0391e..6a6e19d0 100644 --- a/docs/extensions/index.md +++ b/docs/extensions/index.md @@ -7,10 +7,12 @@ overview rcs_fr3 rcs_panda rcs_xarm7 +rcs_ur5e rcs_so101 rcs_realsense rcs_usb_cam rcs_tacto rcs_robotics_library rcs_robotiq2f85 +rcs_zed ``` diff --git a/docs/extensions/overview.md b/docs/extensions/overview.md index 84334d4e..8494cba0 100644 --- a/docs/extensions/overview.md +++ b/docs/extensions/overview.md @@ -11,10 +11,17 @@ An extension is a separate Python package that integrates with RCS. Extensions c ## Installing Extensions -Extensions are typically installed via `pip`. +Extensions are typically installed from PyPI. ```shell -pip install -ve extensions/rcs_fr3 +pip install rcs-fr3 +``` + +For local development from a checkout of this repository, first install RCS itself from the repository root and then install the extension via its path: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_fr3 --no-build-isolation ``` ## Available Extensions diff --git a/docs/extensions/rcs_fr3.md b/docs/extensions/rcs_fr3.md index 4204c06d..865661f1 100644 --- a/docs/extensions/rcs_fr3.md +++ b/docs/extensions/rcs_fr3.md @@ -5,9 +5,15 @@ This extension provides support for the Franka Research 3 (FR3) robot in RCS. ## Installation ```shell -# from root directory sudo apt install $(cat extensions/rcs_fr3/debian_deps.txt) -pip install -ve extensions/rcs_fr3 +pip install rcs-fr3 +``` + +For local development from this repository: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_fr3 --no-build-isolation ``` ### Configuration @@ -22,41 +28,25 @@ DESK_PASSWORD=... ## Usage ```python -import rcs_fr3 -from rcs_fr3._core import hw -from rcs_fr3.desk import FCI, ContextManager, Desk, load_creds_franka_desk -import rcs -import numpy as np - -ROBOT_IP = "172.16.0.2" # Replace with your robot IP - -user, pw = load_creds_franka_desk() -with FCI(Desk(ROBOT_IP, user, pw), unlock=False, lock_when_done=False): - robot_meta = rcs.ROBOTS[rcs.common.RobotType.FR3] - ik = rcs.common.Pin(robot_meta.mjcf_model_path, robot_meta.attachment_site) - - # Configure Robot - robot = hw.Franka(ROBOT_IP, ik) - robot_cfg = hw.FR3Config() - robot_cfg.tcp_offset = rcs.common.Pose(rcs.common.FrankaHandTCPOffset()) - robot.set_config(robot_cfg) - - # Configure Gripper - gripper_cfg_hw = hw.FHConfig() - gripper_cfg_hw.epsilon_inner = gripper_cfg_hw.epsilon_outer = 0.1 - gripper_cfg_hw.speed = 0.1 - gripper_cfg_hw.force = 30 - gripper = hw.FrankaHand(ROBOT_IP, gripper_cfg_hw) - - # Move Robot - robot.set_cartesian_position( - robot.get_cartesian_position() * rcs.common.Pose(translation=np.array([0.05, 0, 0])) - ) - - # Grasp - gripper.grasp() +from rcs.envs.base import ControlMode, RelativeTo +from rcs_fr3.configs import DefaultFR3HardwareEnv + +env_creator = DefaultFR3HardwareEnv() +env_creator.ip = "192.168.101.1" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.5 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +print(env.get_wrapper_attr("robot").get_cartesian_position()) ``` +For a maintained example, see `examples/fr3/fr3_env_cartesian_control.py`. + ## CLI The extension defines useful commands to handle the FR3 robot without the need to use the Desk Website. diff --git a/docs/extensions/rcs_panda.md b/docs/extensions/rcs_panda.md index 21737704..7458d025 100644 --- a/docs/extensions/rcs_panda.md +++ b/docs/extensions/rcs_panda.md @@ -5,11 +5,35 @@ This extension provides support for the Franka Emika Panda robot in RCS. ## Installation ```shell -# from root directory -sudo apt install $(cat extensions/rcs_fr3/debian_deps.txt) -pip install -ve extensions/rcs_panda +sudo apt install $(cat extensions/rcs_panda/debian_deps.txt) +pip install rcs-panda +``` + +For local development from this repository: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_panda --no-build-isolation ``` ## Usage -Please refer to the `rcs_fr3` documentation for similar usage patterns, or check the examples in the repository. +```python +from rcs.envs.base import ControlMode, RelativeTo +from rcs_panda.configs import DefaultPandaHardwareEnv + +env_creator = DefaultPandaHardwareEnv() +env_creator.ip = "192.168.4.100" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.2 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +print(env.get_wrapper_attr("robot").get_cartesian_position()) +``` + +For a maintained example, see `extensions/rcs_panda/src/rcs_panda/panda_env_cartesian_control.py`. diff --git a/docs/extensions/rcs_realsense.md b/docs/extensions/rcs_realsense.md index 578b3373..e9db6cf0 100644 --- a/docs/extensions/rcs_realsense.md +++ b/docs/extensions/rcs_realsense.md @@ -5,11 +5,19 @@ This extension provides support for Intel RealSense cameras in RCS. ## Installation ```shell +pip install rcs-realsense +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation pip install -ve extensions/rcs_realsense ``` ## CLI ```shell -python -m rcs_realsense --help +python -m rcs_realsense serials +python -m rcs_realsense rgb-view ``` diff --git a/docs/extensions/rcs_robotics_library.md b/docs/extensions/rcs_robotics_library.md index 2c6893e8..92dd54dd 100644 --- a/docs/extensions/rcs_robotics_library.md +++ b/docs/extensions/rcs_robotics_library.md @@ -5,7 +5,13 @@ This extension provides integration with the [Robotics Library (RL)](https://www ## Installation ```shell -# from root directory sudo apt install $(cat extensions/rcs_robotics_library/debian_deps.txt) -pip install -ve extensions/rcs_robotics_library +pip install rcs-robotics-library +``` + +For local development from this repository: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_robotics_library --no-build-isolation ``` diff --git a/docs/extensions/rcs_robotiq2f85.md b/docs/extensions/rcs_robotiq2f85.md index de0334e8..3a620b17 100644 --- a/docs/extensions/rcs_robotiq2f85.md +++ b/docs/extensions/rcs_robotiq2f85.md @@ -5,6 +5,13 @@ This extension provides support for Robotiq 2F-85 Gripper in RCS. ## Installation ```shell +pip install rcs-robotiq2f85 +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation pip install -ve extensions/rcs_robotiq2f85 ``` @@ -20,9 +27,9 @@ chmod 777 /dev/ttyUSB0 ## Usage ```python -from rcs_robotiq2f85 import RobotiQGripper +from rcs_robotiq2f85 import RobotiQ2F85GripperConfig, RobotiQGripper -gripper = RobotiQGripper('') +gripper = RobotiQGripper(RobotiQ2F85GripperConfig(serial_number="")) gripper.reset() gripper.shut() print(gripper.get_normalized_width()) diff --git a/docs/extensions/rcs_so101.md b/docs/extensions/rcs_so101.md index 48576d05..bd058eb7 100644 --- a/docs/extensions/rcs_so101.md +++ b/docs/extensions/rcs_so101.md @@ -5,5 +5,12 @@ This extension provides support for the SO101 robot in RCS. ## Installation ```shell -pip install -ve extensions/rcs_so101 +pip install rcs-so101 +``` + +For local development from this repository: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_so101 --no-build-isolation ``` diff --git a/docs/extensions/rcs_tacto.md b/docs/extensions/rcs_tacto.md index a1b94112..104c5244 100644 --- a/docs/extensions/rcs_tacto.md +++ b/docs/extensions/rcs_tacto.md @@ -5,5 +5,12 @@ This extension provides integration with the [Tacto](https://github.com/facebook ## Installation ```shell +pip install rcs-tacto +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation pip install -ve extensions/rcs_tacto ``` diff --git a/docs/extensions/rcs_ur5e.md b/docs/extensions/rcs_ur5e.md new file mode 100644 index 00000000..3070ddc2 --- /dev/null +++ b/docs/extensions/rcs_ur5e.md @@ -0,0 +1,37 @@ +# RCS UR5e Extension + +This extension provides support for the UR5e robot in RCS. + +## Installation + +```shell +pip install rcs-ur5e +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_ur5e +``` + +## Usage + +```python +from rcs.envs.base import ControlMode, RelativeTo +from rcs_ur5e.configs import DefaultUR5eHardwareEnv + +env_creator = DefaultUR5eHardwareEnv() +env_creator.ip = "192.168.1.15" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.2 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +``` + +For a maintained example, see `examples/ur5e/ur5e_env_cartesian_control.py`. diff --git a/docs/extensions/rcs_usb_cam.md b/docs/extensions/rcs_usb_cam.md index aaa27574..3f8f3dbc 100644 --- a/docs/extensions/rcs_usb_cam.md +++ b/docs/extensions/rcs_usb_cam.md @@ -5,5 +5,12 @@ This extension provides support for generic USB webcams in RCS. ## Installation ```shell +pip install rcs-usb-cam +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation pip install -ve extensions/rcs_usb_cam ``` diff --git a/docs/extensions/rcs_xarm7.md b/docs/extensions/rcs_xarm7.md index 43449254..2dcbe801 100644 --- a/docs/extensions/rcs_xarm7.md +++ b/docs/extensions/rcs_xarm7.md @@ -5,9 +5,32 @@ This extension provides support for the xArm7 robot in RCS. ## Installation ```shell +pip install rcs-xarm7 +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation pip install -ve extensions/rcs_xarm7 ``` ## Usage -Please refer to the examples in the repository for usage details. +```python +from rcs.envs.base import ControlMode, RelativeTo +from rcs_xarm7.configs import DefaultXArm7HardwareEnv + +env_creator = DefaultXArm7HardwareEnv() +env_creator.ip = "192.168.1.245" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.max_relative_movement = 0.5 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +``` + +For a maintained example, see `examples/xarm7/xarm7_env_cartesian_control.py`. diff --git a/docs/extensions/rcs_zed.md b/docs/extensions/rcs_zed.md new file mode 100644 index 00000000..fcf7a5ee --- /dev/null +++ b/docs/extensions/rcs_zed.md @@ -0,0 +1,27 @@ +# RCS ZED Extension + +This extension provides support for Stereolabs ZED cameras in RCS. + +## Installation + +- You need a PC with an Nvidia GPU and CUDA 12.8 installed. +- Install the ZED SDK from Stereolabs. +- Install the Python bindings from `zed-python-api`. + +```shell +pip install rcs-zed +``` + +For local development: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_zed +``` + +## CLI + +```shell +python -m rcs_zed serials +python -m rcs_zed rgb-view +``` diff --git a/extensions/README.md b/extensions/README.md index 8cdb1ed6..f7021c0c 100644 --- a/extensions/README.md +++ b/extensions/README.md @@ -2,6 +2,14 @@ RCS supports various hardware extensions for robots and sensors. +All extensions depend on [`rcs-core`](https://pypi.org/project/rcs-core/). If you install an extension directly from PyPI, pip will pull the published `rcs-core` package automatically. + +For local development against this repository, install the main package first from the repository root: + +```shell +pip install -ve . --no-build-isolation +``` + For detailed documentation on available extensions and how to create your own, please visit: -**[robotcontrolstack.org/extensions](https://robotcontrolstack.org/extensions)** \ No newline at end of file +**[robotcontrolstack.org/extensions](https://robotcontrolstack.org/extensions)** diff --git a/extensions/rcs_fr3/README.md b/extensions/rcs_fr3/README.md index 27bb68ec..75d32926 100644 --- a/extensions/rcs_fr3/README.md +++ b/extensions/rcs_fr3/README.md @@ -1,49 +1,70 @@ -# RCS FR3 Hardware Extension -Extension to control the fr3 with rcs. +# RCS FR3 Extension + +Support for the Franka Research 3 (FR3) robot in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: ## Installation + +Install the Debian dependency first: + ```shell -# go to this directory sudo apt install $(cat debian_deps.txt) -pip install -ve . ``` -Add your FR3 credentials to a `.env` file like this: +Install from PyPI: + +```shell +pip install rcs-fr3 +``` + +Warning: plain `pip install rcs-fr3` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout for development: + +```shell +pip install -ve . --no-build-isolation +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_fr3 --no-build-isolation +``` + +Add your FR3 Desk credentials to a `.env` file: + ```env DESK_USERNAME=... DESK_PASSWORD=... ``` ## Usage + ```python -import rcs_fr3 -from rcs_fr3._core import hw +from rcs.envs.base import ControlMode, RelativeTo from rcs_fr3.configs import DefaultFR3HardwareEnv -from rcs_fr3.desk import FCI, ContextManager, Desk, load_creds_franka_desk -user, pw = load_creds_franka_desk() -with FCI(Desk(ROBOT_IP, user, pw), unlock=False, lock_when_done=False): - creator = DefaultFR3HardwareEnv() - creator.ip = ROBOT_IP - cfg = creator.config() - ik = rcs.common.Pin(cfg.robot_cfg.kinematic_model_path, cfg.robot_cfg.attachment_site) - robot = hw.Franka(cfg.robot_cfg, ik) - gripper = hw.FrankaHand(cfg.gripper_cfg) - robot.set_cartesian_position( - robot.get_cartesian_position() * rcs.common.Pose(translation=np.array([0.05, 0, 0])) - ) - gripper.grasp() -``` -For more examples see the [examples](../../examples/) folder. -You can switch to hardware by setting the following flag: -```python -ROBOT_INSTANCE = RobotPlatform.HARDWARE -# ROBOT_INSTANCE = RobotPlatform.SIMULATION + +env_creator = DefaultFR3HardwareEnv() +env_creator.ip = "192.168.101.1" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.5 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +print(env.get_wrapper_attr("robot").get_cartesian_position()) ``` +For a maintained end-to-end example, see [examples/fr3/fr3_env_cartesian_control.py](../../examples/fr3/fr3_env_cartesian_control.py). ## CLI -Defines useful commands to handle the FR3 robot without the need to use the Desk Website. -You can see the available subcommands as follows: + ```shell python -m rcs_fr3 --help ``` diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index f8ff1cde..262aa987 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -18,6 +18,7 @@ version = "0.7.2" description = "RCS libfranka integration" dependencies = ["rcs-core>=0.7.2", "frankik"] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" diff --git a/extensions/rcs_panda/README.md b/extensions/rcs_panda/README.md index 125f49ea..eda281a1 100644 --- a/extensions/rcs_panda/README.md +++ b/extensions/rcs_panda/README.md @@ -1,49 +1,70 @@ -# RCS Panda Hardware Extension -Extension to control the panda with rcs. +# RCS Panda Extension + +Support for the Franka Emika Panda robot in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: ## Installation + +Install the Debian dependency first: + ```shell -# go to this directory sudo apt install $(cat debian_deps.txt) -pip install -ve . ``` -Add your Panda credentials to a `.env` file like this: +Install from PyPI: + +```shell +pip install rcs-panda +``` + +Warning: plain `pip install rcs-panda` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout for development: + +```shell +pip install -ve . --no-build-isolation +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_panda --no-build-isolation +``` + +Add your Panda Desk credentials to a `.env` file: + ```env DESK_USERNAME=... DESK_PASSWORD=... ``` ## Usage + ```python -import rcs_panda -from rcs_panda._core import hw +from rcs.envs.base import ControlMode, RelativeTo from rcs_panda.configs import DefaultPandaHardwareEnv -from rcs_panda.desk import FCI, ContextManager, Desk, load_creds_franka_desk -user, pw = load_creds_franka_desk() -with FCI(Desk(ROBOT_IP, user, pw), unlock=False, lock_when_done=False): - creator = DefaultPandaHardwareEnv() - creator.ip = ROBOT_IP - cfg = creator.config() - ik = rcs.common.Pin(cfg.robot_cfg.kinematic_model_path, cfg.robot_cfg.attachment_site) - robot = hw.Franka(cfg.robot_cfg, ik) - gripper = hw.FrankaHand(cfg.gripper_cfg) - robot.set_cartesian_position( - robot.get_cartesian_position() * rcs.common.Pose(translation=np.array([0.05, 0, 0])) - ) - gripper.grasp() -``` -For more examples see the [examples](../../examples/) folder. -You can switch to hardware by setting the following flag: -```python -ROBOT_INSTANCE = RobotPlatform.HARDWARE -# ROBOT_INSTANCE = RobotPlatform.SIMULATION + +env_creator = DefaultPandaHardwareEnv() +env_creator.ip = "192.168.4.100" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.2 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +print(env.get_wrapper_attr("robot").get_cartesian_position()) ``` +For a maintained example, see [src/rcs_panda/panda_env_cartesian_control.py](src/rcs_panda/panda_env_cartesian_control.py). ## CLI -Defines useful commands to handle the FR3 robot without the need to use the Desk Website. -You can see the available subcommands as follows: + ```shell python -m rcs_panda --help ``` diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index 1d89f057..75069022 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -17,6 +17,7 @@ version = "0.7.2" description = "RCS libfranka integration" dependencies = ["rcs-core>=0.7.2"] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" diff --git a/extensions/rcs_realsense/README.md b/extensions/rcs_realsense/README.md index f0ad1dd4..662d58d8 100644 --- a/extensions/rcs_realsense/README.md +++ b/extensions/rcs_realsense/README.md @@ -1,10 +1,36 @@ -# RCS Realsense Cameras -Package installation: +# RCS RealSense Extension + +Support for Intel RealSense cameras in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: + +## Installation + +Install from PyPI: + +```shell +pip install rcs-realsense +``` + +Warning: plain `pip install rcs-realsense` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + ```shell pip install -ve . ``` -Usage: + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_realsense +``` + +## CLI + ```shell python -m rcs_realsense serials python -m rcs_realsense rgb-view -``` \ No newline at end of file +``` diff --git a/extensions/rcs_realsense/pyproject.toml b/extensions/rcs_realsense/pyproject.toml index 07817b81..7c8b5f33 100644 --- a/extensions/rcs_realsense/pyproject.toml +++ b/extensions/rcs_realsense/pyproject.toml @@ -6,6 +6,8 @@ build-backend = "setuptools.build_meta" name = "rcs_realsense" version = "0.7.2" description = "RCS realsense module" +readme = "README.md" +license = { text = "AGPL-3.0-or-later" } dependencies = [ "rcs-core>=0.7.2", "pyrealsense2~=2.55.1", diff --git a/extensions/rcs_robotics_library/README.md b/extensions/rcs_robotics_library/README.md index 96069664..600e55a6 100644 --- a/extensions/rcs_robotics_library/README.md +++ b/extensions/rcs_robotics_library/README.md @@ -1,12 +1,41 @@ -# RCS Extension for the Robotics Library -Implements access to the C++ library "Robotics Library". +# RCS Robotics Library Extension + +Integration with the [Robotics Library (RL)](https://www.roboticslibrary.org/) for kinematics and path planning. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: ## Installation + +Install the Debian dependencies first: + ```shell -# go to this directory sudo apt install $(cat debian_deps.txt) -pip install -ve . +``` + +Install from PyPI: + +```shell +pip install rcs-robotics-library +``` + +Warning: plain `pip install rcs-robotics-library` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout for development: + +```shell +pip install -ve . --no-build-isolation +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_robotics_library --no-build-isolation ``` ## Usage +```python +from rcs_robotics_library import rl +``` diff --git a/extensions/rcs_robotics_library/pyproject.toml b/extensions/rcs_robotics_library/pyproject.toml index 3be07bbf..5e88dabb 100644 --- a/extensions/rcs_robotics_library/pyproject.toml +++ b/extensions/rcs_robotics_library/pyproject.toml @@ -16,6 +16,7 @@ name = "rcs_robotics_library" version = "0.7.2" description = "RCS robotics library integration" readme = "README.md" +license = { text = "AGPL-3.0-or-later" } dependencies = ["rcs-core>=0.7.2"] maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [ diff --git a/extensions/rcs_robotiq2f85/README.md b/extensions/rcs_robotiq2f85/README.md index 3522d8ca..21afb65e 100644 --- a/extensions/rcs_robotiq2f85/README.md +++ b/extensions/rcs_robotiq2f85/README.md @@ -1,28 +1,52 @@ -# RCS Robotiq 2F-85 Gripper Hardware Extension -Extension to use the Robotiq 2F-85 Gripper with rcs. +# RCS Robotiq 2F-85 Extension + +Support for the Robotiq 2F-85 gripper in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: ## Installation + +Install from PyPI: + +```shell +pip install rcs-robotiq2f85 +``` + +Warning: plain `pip install rcs-robotiq2f85` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + ```shell pip install -ve . ``` -Get the serial number of the gripper with this command: +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_robotiq2f85 +``` + +Get the serial number of the gripper: + ```shell udevadm info -a -n /dev/ttyUSB0 | grep serial ``` -Provide the necessary permission: +Provide device permissions if needed: + ```shell chmod 777 /dev/ttyUSB0 ``` ## Usage + ```python -from rcs_robotiq2f85 import RobotiQGripper, RobotiQ2F85GripperConfig +from rcs_robotiq2f85 import RobotiQ2F85GripperConfig, RobotiQGripper -gripper = RobotiQGripper(RobotiQ2F85GripperConfig(serial_number='')) +gripper = RobotiQGripper(RobotiQ2F85GripperConfig(serial_number="")) gripper.reset() gripper.shut() print(gripper.get_normalized_width()) ``` - diff --git a/extensions/rcs_so101/README.md b/extensions/rcs_so101/README.md index c0333f8b..aec667dd 100644 --- a/extensions/rcs_so101/README.md +++ b/extensions/rcs_so101/README.md @@ -1,13 +1,42 @@ # RCS SO101 Extension -## Package Dependency Issue Workaround -The extension for SO101 depends on the `lerobot` package, which depends on `opencv-python-headless`, which uninstalls RCS' own `opencv-python` dependency install. -Since the extension doesn't care about the OpenCV-dependent parts of `lerobot`, this package works fine even with the full `opencv-python`, but it needs to be re-installed manually. -You can do it by the following: +Support for the SO101 robot in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: + +## Installation + +Install from PyPI: + +```shell +pip install rcs-so101 +``` + +Warning: plain `pip install rcs-so101` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout for development: + +```shell +pip install -ve . --no-build-isolation ``` -pip uninstall opencv-python-headless -pip uninstall opencv-python + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_so101 --no-build-isolation +``` + +## OpenCV Workaround + +This extension depends on `lerobot`, which can pull in `opencv-python-headless` and replace the `opencv-python` variant expected by RCS. + +If that happens, reinstall OpenCV like this: + +```shell +pip uninstall -y opencv-python-headless opencv-python pip install opencv-python~=4.10.0.84 ``` -which will reinstall the correct version of OpenCV to the environment. -Unfortunately, there's no easy automated solution for it, so it needs to be done manually each time this extension is installed with `pip install -e .`. \ No newline at end of file + +For current examples, see [examples/so101](../../examples/so101). diff --git a/extensions/rcs_so101/pyproject.toml b/extensions/rcs_so101/pyproject.toml index 7ea34566..2a3c45aa 100644 --- a/extensions/rcs_so101/pyproject.toml +++ b/extensions/rcs_so101/pyproject.toml @@ -17,6 +17,7 @@ version = "0.7.2" description = "RCS SO101 module" dependencies = ["rcs-core>=0.7.2", "lerobot==0.3.3"] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" diff --git a/extensions/rcs_tacto/README.md b/extensions/rcs_tacto/README.md index 3951f76e..b48e0414 100644 --- a/extensions/rcs_tacto/README.md +++ b/extensions/rcs_tacto/README.md @@ -1,8 +1,33 @@ -# TACTO integration for RCS -This package can be installed by running `pip install -e extensions/rcs_tacto` from the RCS repository root. +# RCS Tacto Extension -An example on how to create the environment is found in `{REPO_ROOT}/examples/grasp_digit_demo.py`. +Integration with the Tacto tactile sensor simulator. -Particularly, take a look at `FR3TactoSimplePickUpSimEnvCreator` to understand how Tacto is inserted into the RCS stack. +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: -Note that it is rather tricky to get the correct contact simulation settings to allow for a robust grasping of objects, so when using it, you will need to play around with the simulation settings. We recommend taking a look at the corresponding [MuJoCo documentation](https://mujoco.readthedocs.io/en/stable/computation/index.html) for more tips. \ No newline at end of file +## Installation + +Install from PyPI: + +```shell +pip install rcs-tacto +``` + +Warning: plain `pip install rcs-tacto` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + +```shell +pip install -ve . +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_tacto +``` + +An example environment is available in [examples/fr3/grasp_digit_demo.py](../../examples/fr3/grasp_digit_demo.py). + +In particular, `FR3TactoSimplePickUpSimEnvCreator` shows how Tacto is integrated into the RCS stack. diff --git a/extensions/rcs_tacto/pyproject.toml b/extensions/rcs_tacto/pyproject.toml index fd7381a9..c31bc919 100644 --- a/extensions/rcs_tacto/pyproject.toml +++ b/extensions/rcs_tacto/pyproject.toml @@ -12,6 +12,7 @@ dependencies = [ "mujoco-tacto@git+https://github.com/utn-air/mujoco-tacto.git@main", ] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, diff --git a/extensions/rcs_ur5e/README.md b/extensions/rcs_ur5e/README.md new file mode 100644 index 00000000..c9babe22 --- /dev/null +++ b/extensions/rcs_ur5e/README.md @@ -0,0 +1,56 @@ +# RCS UR5e Extension + +Support for the UR5e robot in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: + +## Installation + +Install from PyPI: + +```shell +pip install rcs-ur5e +``` + +Warning: plain `pip install rcs-ur5e` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + +```shell +pip install -ve . +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_ur5e +``` + +## Safety Notes + +- This controller does not implement compliant force control. +- Verify the configured home pose before moving real hardware. +- Start at low speed and only increase after confirming motion is safe. + +## Usage + +```python +from rcs.envs.base import ControlMode, RelativeTo +from rcs_ur5e.configs import DefaultUR5eHardwareEnv + +env_creator = DefaultUR5eHardwareEnv() +env_creator.ip = "192.168.1.15" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.camera_cfgs = None +cfg.max_relative_movement = 0.2 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +``` + +For a maintained example, see [examples/ur5e/ur5e_env_cartesian_control.py](../../examples/ur5e/ur5e_env_cartesian_control.py). diff --git a/extensions/rcs_ur5e/pyproject.toml b/extensions/rcs_ur5e/pyproject.toml index 5f3da01d..efad4cc9 100644 --- a/extensions/rcs_ur5e/pyproject.toml +++ b/extensions/rcs_ur5e/pyproject.toml @@ -8,6 +8,7 @@ version = "0.7.2" description = "RCS UR5e module" dependencies = ["rcs-core>=0.7.2", "ur_rtde==1.6.1"] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [ { name = "Johannes Hechtl", email = "johannes.hechtl@siemens.com" }, ] diff --git a/extensions/rcs_usb_cam/README.md b/extensions/rcs_usb_cam/README.md index efa94a5b..5ed35c55 100644 --- a/extensions/rcs_usb_cam/README.md +++ b/extensions/rcs_usb_cam/README.md @@ -1,9 +1,35 @@ -# RCS USC Cameras -Package installation: +# RCS USB Camera Extension + +Support for generic USB webcams in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: + +## Installation + +Install from PyPI: + +```shell +pip install rcs-usb-cam +``` + +Warning: plain `pip install rcs-usb-cam` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + ```shell pip install -ve . ``` -Usage: + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_usb_cam +``` + +## CLI + ```shell python -m rcs_usb_cam rgb-view -``` \ No newline at end of file +``` diff --git a/extensions/rcs_usb_cam/pyproject.toml b/extensions/rcs_usb_cam/pyproject.toml index fa365498..b2426094 100644 --- a/extensions/rcs_usb_cam/pyproject.toml +++ b/extensions/rcs_usb_cam/pyproject.toml @@ -6,6 +6,8 @@ build-backend = "setuptools.build_meta" name = "rcs_usb_cam" version = "0.7.2" description = "RCS USB Camera module" +readme = "README.md" +license = { text = "AGPL-3.0-or-later" } dependencies = ["rcs-core>=0.7.2", "opencv-python~=4.10.0"] maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, diff --git a/extensions/rcs_xarm7/README.md b/extensions/rcs_xarm7/README.md new file mode 100644 index 00000000..4d4e325b --- /dev/null +++ b/extensions/rcs_xarm7/README.md @@ -0,0 +1,49 @@ +# RCS xArm7 Extension + +Support for the xArm7 robot in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: + +## Installation + +Install from PyPI: + +```shell +pip install rcs-xarm7 +``` + +Warning: plain `pip install rcs-xarm7` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: + +```shell +pip install -ve . +``` + +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: + +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_xarm7 +``` + +## Usage + +```python +from rcs.envs.base import ControlMode, RelativeTo +from rcs_xarm7.configs import DefaultXArm7HardwareEnv + +env_creator = DefaultXArm7HardwareEnv() +env_creator.ip = "192.168.1.245" + +cfg = env_creator.config() +cfg.control_mode = ControlMode.CARTESIAN_TQuat +cfg.max_relative_movement = 0.5 +cfg.relative_to = RelativeTo.LAST_STEP + +env = env_creator.create_env(cfg) +obs, info = env.reset() +``` + +For a maintained example, see [examples/xarm7/xarm7_env_cartesian_control.py](../../examples/xarm7/xarm7_env_cartesian_control.py). diff --git a/extensions/rcs_xarm7/pyproject.toml b/extensions/rcs_xarm7/pyproject.toml index b8897e93..af0fce1d 100644 --- a/extensions/rcs_xarm7/pyproject.toml +++ b/extensions/rcs_xarm7/pyproject.toml @@ -8,6 +8,7 @@ version = "0.7.2" description = "RCS xArm7 module" dependencies = ["rcs-core>=0.7.2", "xarm-python-sdk==1.17.0"] readme = "README.md" +license = { text = "AGPL-3.0-or-later" } maintainers = [ { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, { name = "Ken Nakahara", email = "knakahara@lasr.org" }, diff --git a/extensions/rcs_zed/README.md b/extensions/rcs_zed/README.md index 6352d1e6..495c02c8 100644 --- a/extensions/rcs_zed/README.md +++ b/extensions/rcs_zed/README.md @@ -1,43 +1,51 @@ -# Zed Camera Extension +# RCS ZED Extension + +Support for Stereolabs ZED cameras in RCS. + +This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/). +Documentation: ## Installation -- You need a PC with an Nvidia GPU and CUDA 12.8 installed (12.x is probably fine) -- Download and install the Zed SDK from [here](https://www.stereolabs.com/en-fr/developers/release) -- Install the python bindings with the manual [here](https://github.com/stereolabs/zed-python-api) -Or just use the docker shipped with RCS. Checkout [this readme](../../docker/README.md) to build and start the docker. The tools shown below are available inside the docer container. +- You need a PC with an Nvidia GPU and CUDA 12.8 installed. +- Install the ZED SDK from [Stereolabs](https://www.stereolabs.com/en-fr/developers/release). +- Install the Python bindings from the [zed-python-api](https://github.com/stereolabs/zed-python-api). + +Install from PyPI: + +```shell +pip install rcs-zed +``` + +Warning: plain `pip install rcs-zed` will install the published `rcs-core` dependency from PyPI. + +Install from a local checkout: -Package installation: ```shell pip install -ve . ``` +If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root: -## Usage +```shell +pip install -ve . --no-build-isolation +pip install -ve extensions/rcs_zed +``` +## CLI ```shell python -m rcs_zed serials python -m rcs_zed rgb-view ``` -### Permissions +## Permissions + ```shell -# if in docker, run this on your host system sudo usermod -a -G video,plugdev $USER ``` -### Tools to check your Zed -Most relevant is the `ZED_Diagnostic`, use this to check what exactly is not working. - -| Command / Tool | What it does | When to use it | -| :--- | :--- | :--- | -| **`ZED_Explorer`** | Live video feed & recording | To check image quality, adjust exposure, and record **.SVO** files. | -| **`ZED_Depth_Viewer`** | 3D Depth & Point Cloud | To see the "Neural" depth in action and check 3D accuracy. | -| **`ZED_Diagnostic`** | Hardware/Software Health | Use this first if something feels "broken." | -| **`ZED_Sensor_Viewer`** | IMU & Magnetometer | To see real-time data from the accelerometer and gyroscope. | -| **`ZED_Studio`** | Multi-Camera Management | If you have more than one ZED connected at once. | -| **`ZEDfu`** | Spatial Mapping | To "scan" a room and create a 3D mesh in real-time. | +## Connection Diagnostics -### Issues with the connection -- see [this article](https://support.stereolabs.com/hc/en-us/articles/207635225-How-to-fix-USB-3-0-bandwidth-and-connection-issues) \ No newline at end of file +- Use `ZED_Diagnostic` first if something appears broken. +- See the Stereolabs USB troubleshooting guide: diff --git a/extensions/rcs_zed/pyproject.toml b/extensions/rcs_zed/pyproject.toml index 89d3b851..c6bc05c8 100644 --- a/extensions/rcs_zed/pyproject.toml +++ b/extensions/rcs_zed/pyproject.toml @@ -6,6 +6,8 @@ build-backend = "setuptools.build_meta" name = "rcs_zed" version = "0.7.2" description = "RCS ZED camera module" +readme = "README.md" +license = { text = "AGPL-3.0-or-later" } dependencies = [ "rcs-core>=0.7.2", "opencv-python~=4.10.0", From a1ee01ff571c5fff1351f11301761b365c976326 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 16:44:26 -0700 Subject: [PATCH 58/87] docs: added libfranka version documentation --- README.md | 17 ++++++++--------- docs/extensions/index.md | 1 + docs/extensions/libfranka_versions.md | 18 ++++++++++++++++++ extensions/rcs_fr3/README.md | 2 ++ extensions/rcs_fr3/pyproject.toml | 3 +++ extensions/rcs_panda/README.md | 2 ++ extensions/rcs_panda/pyproject.toml | 3 +++ 7 files changed, 37 insertions(+), 9 deletions(-) create mode 100644 docs/extensions/libfranka_versions.md diff --git a/README.md b/README.md index 40cc1659..3d8c35f2 100644 --- a/README.md +++ b/README.md @@ -122,6 +122,13 @@ if __name__ == "__main__": > **Note:** This and other examples can be found in the [`examples/`]() folder. ## 🛠️ Installation +* *For Python >3.11: The `rcs_realsense` extension won't work due to the `pyrealsense2` version RCS utilizes.* +* *For Python >3.12: The `ompl` python module is currently not available on PyPI. If OMPL is not used, it is safe to remove this dependency in `pyproject.toml`.* +### Via PyPI/pip + +```shell +pip install rcs-core +``` ### From Source @@ -129,11 +136,7 @@ Make sure that common build tools (i.e., `build-essential`) and a C++ compiler l *RCS works best in Python 3.11, and all extensions have been tested to work in 3.11.* -* *For Python >3.11: The `rcs_realsense` extension won't work due to the `pyrealsense2` version RCS utilizes.* -* *For Python >3.12: The `ompl` python module is currently not available on PyPI. If OMPL is not used, it is safe to remove this dependency in `pyproject.toml`.* - ```shell - # clone repository git clone https://github.com/RobotControlStack/robot-control-stack.git cd robot-control-stack @@ -151,11 +154,6 @@ pip install --group build_deps pip install -ve . --no-build-isolation ``` -### Via PyPI/pip - -```shell -pip install rcs-core -``` ### RCS Asset Cache @@ -198,6 +196,7 @@ For full documentation, including advanced installation, modular usage, and API Useful quick-reference pages: - **[RCS Conventions](https://robotcontrolstack.org/user_guide/conventions)** for quaternion order, frames, Euler angles, and gripper semantics - **[Sim Scene Configuration](https://robotcontrolstack.org/user_guide/scene_configuration)** for `SimEnvCreatorConfig`, scene frames, and example setup patterns +- **[libfranka Version Info](https://robotcontrolstack.org/extensions/libfranka_versions)** for the currently pinned `rcs_fr3` and `rcs_panda` `libfranka` versions and local-install guidance ## 🤝 Contribution diff --git a/docs/extensions/index.md b/docs/extensions/index.md index 6a6e19d0..67ce5944 100644 --- a/docs/extensions/index.md +++ b/docs/extensions/index.md @@ -4,6 +4,7 @@ :maxdepth: 2 overview +libfranka_versions rcs_fr3 rcs_panda rcs_xarm7 diff --git a/docs/extensions/libfranka_versions.md b/docs/extensions/libfranka_versions.md new file mode 100644 index 00000000..9a465221 --- /dev/null +++ b/docs/extensions/libfranka_versions.md @@ -0,0 +1,18 @@ +# libfranka Versions + +This page documents the `libfranka` version currently pinned by the RCS Franka extensions in their CMake configuration. + +## `rcs_fr3` + +- Current `libfranka` version: `0.20.3` +- CMake source: [extensions/rcs_fr3/CMakeLists.txt](https://github.com/RobotControlStack/robot-control-stack/blob/main/extensions/rcs_fr3/CMakeLists.txt) +- Note: this information reflects the current CMake pin and may become outdated if the version is bumped in a future change. + +When installing `rcs-fr3` from PyPI, this `libfranka` version is fixed by the published package. If you need to change the `libfranka` version, use a local source install and update the CMake configuration there. + +## `rcs_panda` + +- Current `libfranka` version: `0.9.2` +- CMake source: [extensions/rcs_panda/CMakeLists.txt](https://github.com/RobotControlStack/robot-control-stack/blob/main/extensions/rcs_panda/CMakeLists.txt) + +When installing `rcs-panda` from PyPI, this `libfranka` version is fixed by the published package. If you need to change the `libfranka` version, use a local source install and update the CMake configuration there. diff --git a/extensions/rcs_fr3/README.md b/extensions/rcs_fr3/README.md index 75d32926..2a4eb2ba 100644 --- a/extensions/rcs_fr3/README.md +++ b/extensions/rcs_fr3/README.md @@ -34,6 +34,8 @@ pip install -ve . --no-build-isolation pip install -ve extensions/rcs_fr3 --no-build-isolation ``` +For `libfranka` version details, see . + Add your FR3 Desk credentials to a `.env` file: ```env diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index 262aa987..2b71c80f 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -32,6 +32,9 @@ build-dir = "build" wheel.packages = ["src/rcs_fr3"] install.components = ["python_package"] +[tool.cibuildwheel] +skip = ["cp314*", "*-musllinux*"] + [tool.black] line-length = 120 target-version = ["py310"] diff --git a/extensions/rcs_panda/README.md b/extensions/rcs_panda/README.md index eda281a1..b1581269 100644 --- a/extensions/rcs_panda/README.md +++ b/extensions/rcs_panda/README.md @@ -34,6 +34,8 @@ pip install -ve . --no-build-isolation pip install -ve extensions/rcs_panda --no-build-isolation ``` +For `libfranka` version details, see . + Add your Panda Desk credentials to a `.env` file: ```env diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index 75069022..6fee796e 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -31,6 +31,9 @@ build-dir = "build" wheel.packages = ["src/rcs_panda"] install.components = ["python_package"] +[tool.cibuildwheel] +skip = ["cp314*", "*-musllinux*"] + [tool.black] line-length = 120 target-version = ["py310"] From 9680c1ba8750f98eded9e4dadc4b95bb640247c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 17:01:55 -0700 Subject: [PATCH 59/87] build: auditwheel repair and readded libpoco --- extensions/rcs_fr3/CMakeLists.txt | 18 +++++++++++++++++- extensions/rcs_fr3/pyproject.toml | 1 + extensions/rcs_panda/CMakeLists.txt | 18 +++++++++++++++++- extensions/rcs_panda/pyproject.toml | 1 + extensions/rcs_robotics_library/pyproject.toml | 4 ++++ extensions/rcs_so101/pyproject.toml | 4 ++++ 6 files changed, 44 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_fr3/CMakeLists.txt b/extensions/rcs_fr3/CMakeLists.txt index 46689427..c64a92eb 100644 --- a/extensions/rcs_fr3/CMakeLists.txt +++ b/extensions/rcs_fr3/CMakeLists.txt @@ -88,7 +88,23 @@ FetchContent_Declare( OVERRIDE_FIND_PACKAGE ) -FetchContent_MakeAvailable(pybind11 Eigen3 tinyxml2 console_bridge) +# --- POCO C++ Libraries --- +set(ENABLE_TESTS OFF CACHE BOOL "Disable POCO tests" FORCE) +set(ENABLE_DATA_MYSQL OFF CACHE BOOL "Disable POCO MySQL" FORCE) +set(ENABLE_DATA_ODBC OFF CACHE BOOL "Disable POCO ODBC" FORCE) +set(ENABLE_PAGECOMPILER OFF CACHE BOOL "Disable POCO PageCompiler" FORCE) +set(ENABLE_PAGECOMPILER_FILE2PAGE OFF CACHE BOOL "" FORCE) + +FetchContent_Declare( + Poco + GIT_REPOSITORY https://github.com/pocoproject/poco.git + GIT_TAG poco-1.13.3-release + GIT_PROGRESS TRUE + EXCLUDE_FROM_ALL + OVERRIDE_FIND_PACKAGE +) + +FetchContent_MakeAvailable(pybind11 Eigen3 tinyxml2 console_bridge Poco) if(NOT TARGET Eigen3::Eigen3) add_library(Eigen3::Eigen3 ALIAS eigen) endif() diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index 2b71c80f..b2b0a262 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -34,6 +34,7 @@ install.components = ["python_package"] [tool.cibuildwheel] skip = ["cp314*", "*-musllinux*"] +repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude librcs.so --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" [tool.black] line-length = 120 diff --git a/extensions/rcs_panda/CMakeLists.txt b/extensions/rcs_panda/CMakeLists.txt index 01a83198..ac50970b 100644 --- a/extensions/rcs_panda/CMakeLists.txt +++ b/extensions/rcs_panda/CMakeLists.txt @@ -75,7 +75,23 @@ FetchContent_Declare( OVERRIDE_FIND_PACKAGE ) -FetchContent_MakeAvailable(pybind11 Eigen3 console_bridge) +# --- POCO C++ Libraries --- +set(ENABLE_TESTS OFF CACHE BOOL "Disable POCO tests" FORCE) +set(ENABLE_DATA_MYSQL OFF CACHE BOOL "Disable POCO MySQL" FORCE) +set(ENABLE_DATA_ODBC OFF CACHE BOOL "Disable POCO ODBC" FORCE) +set(ENABLE_PAGECOMPILER OFF CACHE BOOL "Disable POCO PageCompiler" FORCE) +set(ENABLE_PAGECOMPILER_FILE2PAGE OFF CACHE BOOL "" FORCE) + +FetchContent_Declare( + Poco + GIT_REPOSITORY https://github.com/pocoproject/poco.git + GIT_TAG poco-1.13.3-release + GIT_PROGRESS TRUE + EXCLUDE_FROM_ALL + OVERRIDE_FIND_PACKAGE +) + +FetchContent_MakeAvailable(pybind11 Eigen3 console_bridge Poco) if(NOT TARGET Eigen3::Eigen3) add_library(Eigen3::Eigen3 ALIAS eigen) endif() diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index 6fee796e..2eb3d4f8 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -33,6 +33,7 @@ install.components = ["python_package"] [tool.cibuildwheel] skip = ["cp314*", "*-musllinux*"] +repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude librcs.so --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" [tool.black] line-length = 120 diff --git a/extensions/rcs_robotics_library/pyproject.toml b/extensions/rcs_robotics_library/pyproject.toml index 5e88dabb..1a9bf297 100644 --- a/extensions/rcs_robotics_library/pyproject.toml +++ b/extensions/rcs_robotics_library/pyproject.toml @@ -34,6 +34,10 @@ build-dir = "build" wheel.packages = ["src/rcs_robotics_library"] install.components = ["python_package"] +[tool.cibuildwheel] +skip = ["cp314*", "*-musllinux*"] +repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude librcs.so --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" + [tool.black] line-length = 120 target-version = ["py310"] diff --git a/extensions/rcs_so101/pyproject.toml b/extensions/rcs_so101/pyproject.toml index 2a3c45aa..88c3cd20 100644 --- a/extensions/rcs_so101/pyproject.toml +++ b/extensions/rcs_so101/pyproject.toml @@ -30,6 +30,10 @@ build-dir = "build" wheel.packages = ["src/rcs_so101"] install.components = ["python_package"] +[tool.cibuildwheel] +skip = ["cp314*", "*-musllinux*"] +repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude librcs.so --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" + [tool.black] line-length = 120 target-version = ["py310"] From 9d886b1f17b4e07d0037bd55f1933770e8e96f23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 17:58:17 -0700 Subject: [PATCH 60/87] build(panda): fr3 copy over --- extensions/rcs_panda/CMakeLists.txt | 12 ++- .../scripts/materialize_fr3_sources.py | 86 +++++++++++++++++++ 2 files changed, 97 insertions(+), 1 deletion(-) create mode 100644 extensions/rcs_panda/scripts/materialize_fr3_sources.py diff --git a/extensions/rcs_panda/CMakeLists.txt b/extensions/rcs_panda/CMakeLists.txt index ac50970b..0f7c061f 100644 --- a/extensions/rcs_panda/CMakeLists.txt +++ b/extensions/rcs_panda/CMakeLists.txt @@ -44,6 +44,16 @@ find_package(Python3 COMPONENTS Interpreter Development.Module REQUIRED) find_package(pinocchio REQUIRED) find_package(rcs REQUIRED) +set(RCS_PANDA_MATERIALIZED_SRC_DIR "${CMAKE_CURRENT_BINARY_DIR}/materialized_src_fr3") +execute_process( + COMMAND + ${Python3_EXECUTABLE} + "${CMAKE_CURRENT_SOURCE_DIR}/scripts/materialize_fr3_sources.py" + --project-root "${CMAKE_CURRENT_SOURCE_DIR}" + --output-dir "${RCS_PANDA_MATERIALIZED_SRC_DIR}" + COMMAND_ERROR_IS_FATAL ANY +) + FetchContent_Declare( libfranka GIT_REPOSITORY https://github.com/frankaemika/libfranka.git @@ -101,4 +111,4 @@ endif() FetchContent_MakeAvailable(libfranka) set_target_properties(franka PROPERTIES CXX_STANDARD 17) -add_subdirectory(src_fr3) +add_subdirectory("${RCS_PANDA_MATERIALIZED_SRC_DIR}" src_fr3) diff --git a/extensions/rcs_panda/scripts/materialize_fr3_sources.py b/extensions/rcs_panda/scripts/materialize_fr3_sources.py new file mode 100644 index 00000000..b575134b --- /dev/null +++ b/extensions/rcs_panda/scripts/materialize_fr3_sources.py @@ -0,0 +1,86 @@ +from __future__ import annotations + +import argparse +import os +import shutil +import subprocess +import tempfile +from pathlib import Path + +try: + import tomllib +except ModuleNotFoundError: # pragma: no cover + import tomli as tomllib # type: ignore + + +REPO_URL = "https://github.com/RobotControlStack/robot-control-stack.git" + + +def load_version(project_root: Path) -> str: + data = tomllib.loads((project_root / "pyproject.toml").read_text()) + return data["project"]["version"] + + +def find_shared_source(project_root: Path) -> Path: + env_override = os.environ.get("RCS_FR3_SOURCE_DIR") + if env_override: + candidate = Path(env_override).resolve() + if (candidate / "CMakeLists.txt").is_file(): + return candidate + msg = f"RCS_FR3_SOURCE_DIR does not point to a valid FR3 source tree: {candidate}" + raise FileNotFoundError(msg) + + sibling = (project_root.parent / "rcs_fr3" / "src").resolve() + if (sibling / "CMakeLists.txt").is_file(): + return sibling + + version = load_version(project_root) + tmpdir = Path(tempfile.mkdtemp(prefix="rcs_panda_fr3_")) + try: + subprocess.run( + ["git", "clone", "--depth", "1", "--branch", f"v{version}", REPO_URL, str(tmpdir)], + check=True, + ) + except subprocess.CalledProcessError: + shutil.rmtree(tmpdir, ignore_errors=True) + tmpdir = Path(tempfile.mkdtemp(prefix="rcs_panda_fr3_")) + subprocess.run( + ["git", "clone", "--depth", "1", REPO_URL, str(tmpdir)], + check=True, + ) + cloned = tmpdir / "extensions" / "rcs_fr3" / "src" + if not (cloned / "CMakeLists.txt").is_file(): + msg = f"Could not locate FR3 shared sources in cloned repo at {cloned}" + raise FileNotFoundError(msg) + return cloned + + +def copy_file(src: Path, dest: Path) -> None: + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(src, dest) + + +def materialize(project_root: Path, output_dir: Path) -> None: + shared_src = find_shared_source(project_root) + panda_src = project_root / "src_fr3" + + if output_dir.exists(): + shutil.rmtree(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + copy_file(shared_src / "CMakeLists.txt", output_dir / "CMakeLists.txt") + shutil.copytree(shared_src / "hw", output_dir / "hw") + copy_file(panda_src / "pybind" / "CMakeLists.txt", output_dir / "pybind" / "CMakeLists.txt") + copy_file(shared_src / "pybind" / "rcs.cpp", output_dir / "pybind" / "rcs.cpp") + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--project-root", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, required=True) + args = parser.parse_args() + materialize(args.project_root.resolve(), args.output_dir.resolve()) + + +if __name__ == "__main__": + main() From a477ac241396abacf48a76b375fe34fff4a9a684 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 21:53:19 -0700 Subject: [PATCH 61/87] build: fix rcs find path --- extensions/rcs_fr3/cmake/Findrcs.cmake | 27 +++++-------------- extensions/rcs_panda/cmake/Findrcs.cmake | 27 +++++-------------- .../rcs_robotics_library/cmake/Findrcs.cmake | 27 +++++-------------- extensions/rcs_so101/cmake/Findrcs.cmake | 27 +++++-------------- 4 files changed, 24 insertions(+), 84 deletions(-) diff --git a/extensions/rcs_fr3/cmake/Findrcs.cmake b/extensions/rcs_fr3/cmake/Findrcs.cmake index 595d53bb..bd89b83e 100644 --- a/extensions/rcs_fr3/cmake/Findrcs.cmake +++ b/extensions/rcs_fr3/cmake/Findrcs.cmake @@ -2,43 +2,28 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") - endif() - return() - endif() - - execute_process( - COMMAND - ${Python3_EXECUTABLE} - -c - "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" - OUTPUT_VARIABLE rcs_package_dir - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - if (NOT rcs_package_dir) - set(rcs_FOUND FALSE) - if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - set(rcs_library_path "${rcs_package_dir}/librcs.so") + cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) + file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() diff --git a/extensions/rcs_panda/cmake/Findrcs.cmake b/extensions/rcs_panda/cmake/Findrcs.cmake index 595d53bb..bd89b83e 100644 --- a/extensions/rcs_panda/cmake/Findrcs.cmake +++ b/extensions/rcs_panda/cmake/Findrcs.cmake @@ -2,43 +2,28 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") - endif() - return() - endif() - - execute_process( - COMMAND - ${Python3_EXECUTABLE} - -c - "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" - OUTPUT_VARIABLE rcs_package_dir - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - if (NOT rcs_package_dir) - set(rcs_FOUND FALSE) - if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - set(rcs_library_path "${rcs_package_dir}/librcs.so") + cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) + file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() diff --git a/extensions/rcs_robotics_library/cmake/Findrcs.cmake b/extensions/rcs_robotics_library/cmake/Findrcs.cmake index 595d53bb..bd89b83e 100644 --- a/extensions/rcs_robotics_library/cmake/Findrcs.cmake +++ b/extensions/rcs_robotics_library/cmake/Findrcs.cmake @@ -2,43 +2,28 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") - endif() - return() - endif() - - execute_process( - COMMAND - ${Python3_EXECUTABLE} - -c - "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" - OUTPUT_VARIABLE rcs_package_dir - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - if (NOT rcs_package_dir) - set(rcs_FOUND FALSE) - if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - set(rcs_library_path "${rcs_package_dir}/librcs.so") + cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) + file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() diff --git a/extensions/rcs_so101/cmake/Findrcs.cmake b/extensions/rcs_so101/cmake/Findrcs.cmake index 595d53bb..bd89b83e 100644 --- a/extensions/rcs_so101/cmake/Findrcs.cmake +++ b/extensions/rcs_so101/cmake/Findrcs.cmake @@ -2,43 +2,28 @@ if (NOT rcs_FOUND) if (NOT Python3_FOUND) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 1. Please install rcs-core using pip.") - endif() - return() - endif() - - execute_process( - COMMAND - ${Python3_EXECUTABLE} - -c - "import importlib.util; import pathlib; spec = importlib.util.find_spec('rcs'); print(pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() if spec and spec.submodule_search_locations else '')" - OUTPUT_VARIABLE rcs_package_dir - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - if (NOT rcs_package_dir) - set(rcs_FOUND FALSE) - if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 2. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the include directory exists - cmake_path(APPEND rcs_package_dir include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) + cmake_path(APPEND Python3_SITELIB rcs include OUTPUT_VARIABLE rcs_INCLUDE_DIRS) if (NOT EXISTS ${rcs_INCLUDE_DIRS}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 3. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() # Check if the library file exists - set(rcs_library_path "${rcs_package_dir}/librcs.so") + cmake_path(APPEND Python3_SITELIB rcs OUTPUT_VARIABLE rcs_library_path) + file(GLOB rcs_library_path "${rcs_library_path}/librcs.so") if (NOT EXISTS ${rcs_library_path}) set(rcs_FOUND FALSE) if (rcs_FIND_REQUIRED) - message(FATAL_ERROR "Could not find rcs 4. Please install rcs-core using pip.") + message(FATAL_ERROR "Could not find rcs. Please install rcs-core using pip.") endif() return() endif() From 70464df6db9caacfc2d27c0c34a1a9e883c73c8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 22:30:07 -0700 Subject: [PATCH 62/87] build: fix license and author name --- extensions/rcs_fr3/pyproject.toml | 6 +++--- extensions/rcs_panda/pyproject.toml | 6 +++--- extensions/rcs_realsense/pyproject.toml | 6 +++--- extensions/rcs_robotics_library/pyproject.toml | 6 +++--- extensions/rcs_robotiq2f85/pyproject.toml | 6 +++--- extensions/rcs_so101/pyproject.toml | 6 +++--- extensions/rcs_tacto/pyproject.toml | 4 ++-- extensions/rcs_ur5e/pyproject.toml | 4 ++-- extensions/rcs_usb_cam/pyproject.toml | 4 ++-- extensions/rcs_xarm7/pyproject.toml | 6 +++--- extensions/rcs_zed/pyproject.toml | 6 +++--- pyproject.toml | 4 ++-- 12 files changed, 32 insertions(+), 32 deletions(-) diff --git a/extensions/rcs_fr3/pyproject.toml b/extensions/rcs_fr3/pyproject.toml index b2b0a262..dd29b836 100644 --- a/extensions/rcs_fr3/pyproject.toml +++ b/extensions/rcs_fr3/pyproject.toml @@ -18,9 +18,9 @@ version = "0.7.2" description = "RCS libfranka integration" dependencies = ["rcs-core>=0.7.2", "frankik"] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] -authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +license = "AGPL-3.0-or-later" +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] +authors = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" diff --git a/extensions/rcs_panda/pyproject.toml b/extensions/rcs_panda/pyproject.toml index 2eb3d4f8..6622a6f1 100644 --- a/extensions/rcs_panda/pyproject.toml +++ b/extensions/rcs_panda/pyproject.toml @@ -17,9 +17,9 @@ version = "0.7.2" description = "RCS libfranka integration" dependencies = ["rcs-core>=0.7.2"] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] -authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +license = "AGPL-3.0-or-later" +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] +authors = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" diff --git a/extensions/rcs_realsense/pyproject.toml b/extensions/rcs_realsense/pyproject.toml index 7c8b5f33..e093495c 100644 --- a/extensions/rcs_realsense/pyproject.toml +++ b/extensions/rcs_realsense/pyproject.toml @@ -7,15 +7,15 @@ name = "rcs_realsense" version = "0.7.2" description = "RCS realsense module" readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" dependencies = [ "rcs-core>=0.7.2", "pyrealsense2~=2.55.1", "pupil_apriltags", "diskcache", ] -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] -authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] +authors = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" [tool.black] diff --git a/extensions/rcs_robotics_library/pyproject.toml b/extensions/rcs_robotics_library/pyproject.toml index 1a9bf297..fd214b2d 100644 --- a/extensions/rcs_robotics_library/pyproject.toml +++ b/extensions/rcs_robotics_library/pyproject.toml @@ -16,11 +16,11 @@ name = "rcs_robotics_library" version = "0.7.2" description = "RCS robotics library integration" readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" dependencies = ["rcs-core>=0.7.2"] -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] authors = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Pierre Krack", email = "pierre.krack@utn.de" }, ] requires-python = ">=3.11" diff --git a/extensions/rcs_robotiq2f85/pyproject.toml b/extensions/rcs_robotiq2f85/pyproject.toml index 144fcae1..4584132e 100644 --- a/extensions/rcs_robotiq2f85/pyproject.toml +++ b/extensions/rcs_robotiq2f85/pyproject.toml @@ -12,10 +12,10 @@ dependencies = [ ] readme = "README.md" maintainers = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, ] authors = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, ] requires-python = ">=3.11" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" diff --git a/extensions/rcs_so101/pyproject.toml b/extensions/rcs_so101/pyproject.toml index 88c3cd20..33b71daf 100644 --- a/extensions/rcs_so101/pyproject.toml +++ b/extensions/rcs_so101/pyproject.toml @@ -17,9 +17,9 @@ version = "0.7.2" description = "RCS SO101 module" dependencies = ["rcs-core>=0.7.2", "lerobot==0.3.3"] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] -authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +license = "AGPL-3.0-or-later" +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] +authors = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" [tool.scikit-build] diff --git a/extensions/rcs_tacto/pyproject.toml b/extensions/rcs_tacto/pyproject.toml index c31bc919..576b67ea 100644 --- a/extensions/rcs_tacto/pyproject.toml +++ b/extensions/rcs_tacto/pyproject.toml @@ -12,9 +12,9 @@ dependencies = [ "mujoco-tacto@git+https://github.com/utn-air/mujoco-tacto.git@main", ] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" maintainers = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, ] authors = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] diff --git a/extensions/rcs_ur5e/pyproject.toml b/extensions/rcs_ur5e/pyproject.toml index efad4cc9..497530cd 100644 --- a/extensions/rcs_ur5e/pyproject.toml +++ b/extensions/rcs_ur5e/pyproject.toml @@ -8,12 +8,12 @@ version = "0.7.2" description = "RCS UR5e module" dependencies = ["rcs-core>=0.7.2", "ur_rtde==1.6.1"] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" maintainers = [ { name = "Johannes Hechtl", email = "johannes.hechtl@siemens.com" }, ] authors = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Johannes Hechtl", email = "johannes.hechtl@siemens.com" }, ] requires-python = ">=3.11" diff --git a/extensions/rcs_usb_cam/pyproject.toml b/extensions/rcs_usb_cam/pyproject.toml index b2426094..a78c3852 100644 --- a/extensions/rcs_usb_cam/pyproject.toml +++ b/extensions/rcs_usb_cam/pyproject.toml @@ -7,10 +7,10 @@ name = "rcs_usb_cam" version = "0.7.2" description = "RCS USB Camera module" readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" dependencies = ["rcs-core>=0.7.2", "opencv-python~=4.10.0"] maintainers = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, ] authors = [{ name = "Seongjin Bien", email = "seongjin.bien@utn.de" }] diff --git a/extensions/rcs_xarm7/pyproject.toml b/extensions/rcs_xarm7/pyproject.toml index af0fce1d..3671b0ba 100644 --- a/extensions/rcs_xarm7/pyproject.toml +++ b/extensions/rcs_xarm7/pyproject.toml @@ -8,13 +8,13 @@ version = "0.7.2" description = "RCS xArm7 module" dependencies = ["rcs-core>=0.7.2", "xarm-python-sdk==1.17.0"] readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" maintainers = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Ken Nakahara", email = "knakahara@lasr.org" }, ] authors = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Ken Nakahara", email = "knakahara@lasr.org" }, ] requires-python = ">=3.11" diff --git a/extensions/rcs_zed/pyproject.toml b/extensions/rcs_zed/pyproject.toml index c6bc05c8..5289ec2e 100644 --- a/extensions/rcs_zed/pyproject.toml +++ b/extensions/rcs_zed/pyproject.toml @@ -7,7 +7,7 @@ name = "rcs_zed" version = "0.7.2" description = "RCS ZED camera module" readme = "README.md" -license = { text = "AGPL-3.0-or-later" } +license = "AGPL-3.0-or-later" dependencies = [ "rcs-core>=0.7.2", "opencv-python~=4.10.0", @@ -15,8 +15,8 @@ dependencies = [ "diskcache", "typer~=0.9", ] -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] -authors = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] +authors = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] requires-python = ">=3.11" [tool.black] diff --git a/pyproject.toml b/pyproject.toml index ab0adf23..60d97325 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,9 +46,9 @@ dependencies = [ "pandas", ] readme = "README.md" -maintainers = [{ name = "Tobias Jülg", email = "tobias.juelg@utn.de" }] +maintainers = [{ name = "Tobias Juelg", email = "tobias.juelg@utn.de" }] authors = [ - { name = "Tobias Jülg", email = "tobias.juelg@utn.de" }, + { name = "Tobias Juelg", email = "tobias.juelg@utn.de" }, { name = "Pierre Krack", email = "pierre.krack@utn.de" }, { name = "Seongjin Bien", email = "seongjin.bien@utn.de" }, ] From e78bed57206ee60bb7bed1d26c87a6305bed4342 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 23:12:45 -0700 Subject: [PATCH 63/87] ci: fix wheel and cibuildwheel for pipy uploading --- .github/workflows/build_wheels.yaml | 57 +++++++++++++++++++++++++---- 1 file changed, 50 insertions(+), 7 deletions(-) diff --git a/.github/workflows/build_wheels.yaml b/.github/workflows/build_wheels.yaml index fc272ef1..59b98f57 100644 --- a/.github/workflows/build_wheels.yaml +++ b/.github/workflows/build_wheels.yaml @@ -23,19 +23,62 @@ jobs: name: core-wheels path: ./wheelhouse/*.whl - build_extension_wheels: - name: Build ${{ matrix.extension }} wheels on Python ${{ matrix.python-version }} + build_cpp_extension_wheels: + name: Build C++ extension wheels for ${{ matrix.extension }} needs: [build_core_wheels] runs-on: ubuntu-latest strategy: fail-fast: false matrix: - python-version: ["3.11", "3.12", "3.13"] extension: - rcs_fr3 - rcs_panda - rcs_robotics_library - rcs_so101 + + steps: + - uses: actions/checkout@v4 + + - uses: actions/download-artifact@v4 + with: + name: core-wheels + path: dist/core + + - name: Install root Debian dependencies + run: | + sudo apt-get update + sudo xargs -a debian_deps.txt apt-get install -y + + - name: Install extension Debian dependencies + run: | + deps_file="extensions/${{ matrix.extension }}/debian_deps.txt" + if [ -f "${deps_file}" ]; then + sudo xargs -a "${deps_file}" apt-get install -y + fi + + - name: Build C++ extension wheels + uses: pypa/cibuildwheel@v2.22.0 + env: + CIBW_ARCHS_LINUX: x86_64 + CIBW_BUILD: cp311-* cp312-* cp313-* + PIP_FIND_LINKS: /project/dist/core + with: + package-dir: extensions/${{ matrix.extension }} + output-dir: extensions/${{ matrix.extension }}/wheelhouse + + - uses: actions/upload-artifact@v4 + with: + name: wheels-${{ matrix.extension }} + path: extensions/${{ matrix.extension }}/wheelhouse/*.whl + + build_python_extension_wheels: + name: Build pure Python wheel for ${{ matrix.extension }} + needs: [build_core_wheels] + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + extension: - rcs_realsense - rcs_robotiq2f85 - rcs_tacto @@ -67,10 +110,10 @@ jobs: - name: Set up Python uses: actions/setup-python@v5 with: - python-version: ${{ matrix.python-version }} + python-version: "3.11" cache: pip - - name: Build extension wheel + - name: Build pure Python wheel env: PIP_FIND_LINKS: ${{ github.workspace }}/dist/core run: | @@ -80,11 +123,11 @@ jobs: - uses: actions/upload-artifact@v4 with: - name: wheels-${{ matrix.extension }}-py${{ matrix.python-version }} + name: wheels-${{ matrix.extension }} path: extensions/${{ matrix.extension }}/dist/*.whl upload_pypi: - needs: [build_core_wheels, build_extension_wheels] + needs: [build_core_wheels, build_cpp_extension_wheels, build_python_extension_wheels] runs-on: ubuntu-latest if: github.event_name == 'release' && github.event.action == 'published' environment: pypi From 61d6784594875c94b038f0218ec2bf04e67ecb49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 23:44:59 -0700 Subject: [PATCH 64/87] chore: cleanup unused codes and comments --- notes.md | 66 ------------------- python/rcs/envs/base.py | 5 +- python/rcs/utils.py | 136 +--------------------------------------- 3 files changed, 3 insertions(+), 204 deletions(-) delete mode 100644 notes.md diff --git a/notes.md b/notes.md deleted file mode 100644 index 33a306de..00000000 --- a/notes.md +++ /dev/null @@ -1,66 +0,0 @@ - -## robot setup -- switich on the power (socket button and foot button) -- create an ssh connection to transformer from multihead (the machine with the screen) -```shell -ssh -D 10000 transformer -``` -- go to setttings in your browser and type proxy, set manual proxy configuration and fill socks host "localhost" and port 10000 -- then open "https://192.168.101.1/" for the left, and "https://192.168.102.1/desk/" for right (our left) -- wait for the robot s to stop blinking and unlock the joints in desk - -## shutdown -- press shutdown in both franka desk interfaces -- wait 2 minutes -- switch of socket and foot button -- lock the pc, dont shut it down - - - - - -## policy server setup -- run the models outside the docker with the following commands; replace the path to match the checkpoint (make sure you run it in the following path: /code/duobench/robot-control-stack) -### act -```shell -uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "/hdd_data/juelg/duobench/weights/act/transfer_cube/duobench_act_transfer_cube_real_2026-05-18_21-55-01/150000/pretrained_model/", "n_action_steps": 1}' -``` - -### pi05 -```shell -uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "pi05", "checkpoint_path": "/hdd_data/juelg/duobench/weights/pi05/duobench_pi05_merged_real_v1_2026-05-19_07-14-26/040000/pretrained_model", "n_action_steps": 1}' -``` - - -### xvla -```shell -uv run python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "xvla", "checkpoint_path": "/hdd_data/juelg/duobench/weights/xvla/duobench_xvla_merged_real_v1_2026-05-20_23-32-13/040000/pretrained_model", "n_action_steps": 1, "rename_map": {"head": "image", "left_wrist": "image2", "right_wrist": "image3"}}' -``` -## docker setup - -```shell -exec su -l $USER -cd /code/duobench/robot-control-stack - - -# build, only once or if changes in c++ -# docker build -f docker/Dockerfile -t rcs-dev . - - -# run docker -docker compose -f docker/compose/dev.yml run --rm rcs -bash -export PYTHONPATH="/workspace/robot-control-stack/vlagents/src" - -# run the following command in the docker to start eval -python examples/inference/franka.py -``` - - -# tasks -- for each new model and task you need to go to the [franka.json](examples/inference/franka.json) file and adapt - - instruction: can be found in the task in [rcs_duobench/src/rcs_duobench/tasks](rcs_duobench/src/rcs_duobench/tasks) - - record_path: "inference_recordings___" - - for example: task=transfer_cube, modelpoath=duobench_xvla_merged_real_v1_2026-05-19_17-00-27, checkpoint=150000 -- run the new policy server -- start examples/inference/franka.py or press "o" if its already running \ No newline at end of file diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index 0eb9b9d6..536746ad 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -399,16 +399,13 @@ def reset( self.robot.reset() if self.home_on_reset: exception = True - # sleep(1) - while exception: + while exception: try: self.robot.move_home() exception = False except Exception: - # sleep(0.1) self.robot.automatic_error_recovery() sleep(0.1) - # sleep(4) return super().reset(seed=seed, options=options) def close(self): diff --git a/python/rcs/utils.py b/python/rcs/utils.py index a9cc71f6..f4689463 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -1,13 +1,11 @@ import datetime import logging import math -import os import subprocess from pathlib import Path from time import perf_counter, sleep import duckdb -os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib") import numpy as np logger = logging.getLogger(__name__) @@ -47,138 +45,6 @@ def __call__(self): self.t = perf_counter() -class SimpleFrameRateN: - def __init__(self, frame_rate: float | None, loop_name: str = "HybridFrameRate", spin_buffer: float = 0.002): - """ - Utility class to manage frame rates with high precision using a hybrid sleep/spin technique. - - Args: - frame_rate (float | None): The desired frame rate in frames per second. - loop_name (str): Identifier for logging. - spin_buffer (float): Seconds to wake up early for the precision spin-wait (default 2ms). - """ - self.frame_rate = frame_rate - self.loop_name = loop_name - self.frame_interval = 1.0 / frame_rate if frame_rate else 0.0 - self.spin_buffer = spin_buffer - - # Timing state - self.next_target_time: float | None = None - - # Logging state - self.frames_since_print = 0 - self.last_print_time: float | None = None - - def reset(self): - """Resets the internal timers.""" - self.next_target_time = None - self.frames_since_print = 0 - self.last_print_time = None - - def __call__(self): - """Limits the loop to the target frame rate.""" - if self.frame_rate is None: - return - - now = perf_counter() - - # 1. Initialize on the very first frame - if self.next_target_time is None: - self.next_target_time = now + self.frame_interval - self.last_print_time = now - self.frames_since_print = 0 - return - - # 2. Hybrid Wait Strategy - wait_time = self.next_target_time - now - - if wait_time > 0: - # Step A: Sleep and yield CPU for the bulk of the waiting time - sleep_time = wait_time - self.spin_buffer - if sleep_time > 0: - sleep(sleep_time) - - # Step B: "Spin" for the remaining sub-millisecond precision - # This loops infinitely and hogs the CPU until the exact microsecond is reached - while perf_counter() < self.next_target_time: - pass - - # 3. Advance target time strictly by interval to prevent long-term drift - self.next_target_time += self.frame_interval - - # Anti-Spam: If the system lagged massively (e.g., loading a large file), - # fast-forward the target time so we don't try to rapidly catch up without sleeping. - now_after_wait = perf_counter() - if now_after_wait > self.next_target_time + self.frame_interval * 2: - self.next_target_time = now_after_wait - - # 4. Accurate FPS Logging - self.frames_since_print += 1 - elapsed_since_print = now_after_wait - self.last_print_time - - if elapsed_since_print > 10.0: - actual_fps = self.frames_since_print / elapsed_since_print - logger.debug(f"FPS {self.loop_name}: {actual_fps:.2f}") - self.last_print_time = now_after_wait - self.frames_since_print = 0 - - - -class SimpleFrameRateNN: - def __init__(self, frame_rate: float | None, loop_name: str = "PrecisionInterval", spin_buffer: float = 0.0015): - self.frame_rate = frame_rate - self.loop_name = loop_name - self.frame_interval = 1.0 / frame_rate if frame_rate else 0.0 - self.spin_buffer = spin_buffer - - self.t = None - self._last_print = None - self._frame_count = 0 - - def reset(self): - self.t = None - self._frame_count = 0 - - def __call__(self): - if self.frame_rate is None: - return - - now = perf_counter() - - # Initial call setup - if self.t is None: - self.t = now - self._last_print = now - return - - # 1. Calculate how much time is left for THIS frame - elapsed = now - self.t - remaining = self.frame_interval - elapsed - - if remaining > 0: - # 2. Hybrid Sleep: yield the majority of the time to the OS - if remaining > self.spin_buffer: - sleep(remaining - self.spin_buffer) - - # 3. Precision Spin: busy-wait for the last tiny fraction - target = self.t + self.frame_interval - while perf_counter() < target: - pass - - # 4. Logging logic (Average over time) - self._frame_count += 1 - curr_time = perf_counter() - if curr_time - self._last_print > 10: - fps = self._frame_count / (curr_time - self._last_print) - logger.debug(f"FPS {self.loop_name}: {fps:.2f}") - self._last_print = curr_time - self._frame_count = 0 - - # 5. Reset the stopwatch AFTER the wait - # This prevents the 'oscillating jitter' by not forcing a catch-up - self.t = perf_counter() - - class ContextManager: def __enter__(self): pass @@ -235,6 +101,8 @@ def _render_action_panel( height: int, width: int, ) -> np.ndarray: + from matplotlib import pyplot as plt + fig, axes = plt.subplots( len(joint_history), 1, From 3d6eb27b694733370ea6a96f23d8ee7b10ffe326 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 23:46:52 -0700 Subject: [PATCH 65/87] docs: added inference --- README.md | 3 +- docs/apps/index.md | 22 ++++++++++ docs/index.md | 7 ++++ examples/inference/README.md | 79 ++++++++++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 1 deletion(-) create mode 100644 docs/apps/index.md diff --git a/README.md b/README.md index 3d8c35f2..12138197 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ Traditional robotics middleware (like ROS/ROS2) and complex motion planning pipe * **Zero ROS Overhead:** No complex message-passing, middleware, or network configuration required. Run natively in Python with a lightweight C++ backend. * **Frictionless Sim-to-Real:** Train your Reinforcement Learning or VLA policies in our MuJoCo Gymnasium wrapper, and deploy the *exact same code* directly to physical hardware. * **Synchronous Execution:** Optimized specifically for the highly parallelized, synchronous data collection required by modern ML workflows. -* **Ready-to-Use Apps:** Ships with pre-built applications for data collection via teleoperation and remote model inference via [vlagents](https://github.com/RobotControlStack/vlagents). +* **Ready-to-Use Apps:** Ships with pre-built applications for data collection via teleoperation and remote model inference via [vlagents](https://github.com/RobotControlStack/vlagents). See [examples/teleop/README.md](examples/teleop/README.md) and [examples/inference/README.md](examples/inference/README.md). ## 🧩 Wrapper-Based Architecture @@ -196,6 +196,7 @@ For full documentation, including advanced installation, modular usage, and API Useful quick-reference pages: - **[RCS Conventions](https://robotcontrolstack.org/user_guide/conventions)** for quaternion order, frames, Euler angles, and gripper semantics - **[Sim Scene Configuration](https://robotcontrolstack.org/user_guide/scene_configuration)** for `SimEnvCreatorConfig`, scene frames, and example setup patterns +- **[Apps](https://robotcontrolstack.org/apps/index)** for the teleoperation and inference example entry points - **[libfranka Version Info](https://robotcontrolstack.org/extensions/libfranka_versions)** for the currently pinned `rcs_fr3` and `rcs_panda` `libfranka` versions and local-install guidance ## 🤝 Contribution diff --git a/docs/apps/index.md b/docs/apps/index.md new file mode 100644 index 00000000..799132db --- /dev/null +++ b/docs/apps/index.md @@ -0,0 +1,22 @@ +# Apps + +RCS ships with ready-to-use applications for common operator workflows such as robot teleoperation and remote policy inference. + +## Teleoperation + +Use the Franka teleoperation app when you want to collect demonstrations or directly control a robot from an operator interface. + +- Example guide: [examples/teleop/README.md](../../examples/teleop/README.md) +- Main script: [examples/teleop/franka.py](../../examples/teleop/franka.py) + +The current example focuses on Franka teleoperation with Meta Quest 3 and GELLO-based setups. + +## Inference + +Use the Franka inference app when you want to run a remote policy server, for example through `vlagents`, against an RCS hardware environment. + +- Example guide: [examples/inference/README.md](../../examples/inference/README.md) +- Main script: [examples/inference/franka.py](../../examples/inference/franka.py) +- Example config: [examples/inference/franka.json](../../examples/inference/franka.json) + +The inference example expects a compatible policy server to already be running and explains the runtime keyboard commands and config fields in its README. diff --git a/docs/index.md b/docs/index.md index 64950871..af8390ca 100644 --- a/docs/index.md +++ b/docs/index.md @@ -31,6 +31,13 @@ getting_started/index user_guide/index ``` +```{toctree} +:maxdepth: 2 +:caption: Apps + +apps/index +``` + ```{toctree} :maxdepth: 2 :caption: API diff --git a/examples/inference/README.md b/examples/inference/README.md index e69de29b..a23a50ca 100644 --- a/examples/inference/README.md +++ b/examples/inference/README.md @@ -0,0 +1,79 @@ +# Franka Inference Example + +This folder contains a hardware-oriented inference example for running a `vlagents` policy server against the Franka duo setup in [franka.py](franka.py) with configuration from [franka.json](franka.json). + +## Policy Server + +Before starting `franka.py`, make sure a `vlagents` policy server is already running. The example connects to a remote agent with: + +- `vlagents_host` +- `vlagents_port` +- `vlagents_model` + +The policy server setup and supported launch commands are documented in: + +- [RobotControlStack/vlagents](https://github.com/RobotControlStack/vlagents) +- [vlagents/README.md](../../vlagents/README.md) + +Typical server startup looks like: + +```shell +python -m vlagents start-server lerobot --port 20000 --host 0.0.0.0 --kwargs '{"policy_name": "act", "checkpoint_path": "", "n_action_steps": 1}' +``` + +For other policies such as `pi05` or `xvla`, use the matching startup command from the `vlagents` README and make sure the values in `franka.json` point at that server. + +## Config File + +[franka.json](franka.json) is an example config, not a universal default. You should review and usually change these values before running inference: + +- `vlagents_host`: Hostname or IP address where the policy server is running. +- `vlagents_port`: Port exposed by the policy server. +- `vlagents_model`: Agent id passed to `vlagents`, for example `lerobot`. +- `instruction`: Natural-language task instruction sent to the policy on reset. +- `robot_keys`: Robot ordering used to pack observations and unpack actions. The script assumes one 8-value action block per robot in this order: `7` joint values plus `1` gripper value. +- `jpeg_encoding`: Whether observations are sent to the policy server using JPEG-compressed images. +- `on_same_machine`: Set this according to whether the policy server runs on the same machine as the control process. +- `fps`: Control loop target frequency used by the local rate limiter. +- `record_path`: Output directory used when recording episodes. +- `n_action_steps`: If `null`, the script requests one action per control step. If set to an integer greater than `0`, the script buffers that many actions from each policy response chunk. +- `max_rel_mov_joints`: Maximum allowed relative joint movement per step when running in joint control mode. +- `max_rel_mov_cart`: Maximum allowed relative Cartesian translation and rotation per step when running in Cartesian modes. + +The current `franka.py` example also contains hardware-specific constants for robot IPs, camera serials, gripper serials, and frame mappings. Those live in the script itself, so update [franka.py](franka.py) if your hardware setup differs. + +## Runtime Keys + +When [franka.py](franka.py) is running, it waits for keyboard input on stdin. The active commands are: + +- `e`: Start an episode without recording. +- `r`: Start an episode and begin recording to `record_path`. +- `s`: Mark the current episode as successful and reset the environment. +- `q`: Stop the current episode and reset the environment. +- `o`: Reload `franka.json`, reconnect the `vlagents` client, reset the environment, and clear any buffered actions. +- `x`: Exit the program. + +## Observation And Action Mapping + +The script translates RCS observations to the `vlagents` `Obs` format as follows: + +- Every camera frame in `obs["frames"]` is converted to RGB and resized to `224x224`. +- State is built by iterating through `robot_keys` in order and concatenating each robot's `joints` and `gripper` values. + +Action decoding is also order-dependent: + +- For each robot in `robot_keys`, the script reads `8` values from the policy action vector. +- Values `0:7` become the robot joint command. +- Value `7:8` becomes the robot gripper command. + +That means `robot_keys` must match the policy's expected robot ordering exactly. + +## Running + +After the policy server is up and `franka.json` is configured, run: + +```shell +python examples/inference/franka.py +``` + +If the policy server is unreachable, the script will keep retrying connection until it becomes available or you exit. From 39497beb5eb5c5e82f38a988c2c35f2173366f48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Fri, 26 Jun 2026 23:53:35 -0700 Subject: [PATCH 66/87] style: fix format --- examples/inference/franka.py | 23 ++++++++++++----------- python/rcs/envs/base.py | 1 + python/rcs/lerobot_joint_converter.py | 1 + python/rcs/utils.py | 9 ++++++--- python/tests/test_quest_operator.py | 1 - 5 files changed, 20 insertions(+), 15 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index 7ba61123..c30e04b0 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -8,24 +8,23 @@ from time import sleep from typing import Any -from PIL import Image - -from rcs.utils import SimpleFrameRate - import gymnasium as gym import numpy as np +from PIL import Image from rcs._core.common import BaseCameraConfig, RobotPlatform from rcs._core.sim import SimConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3Duo from rcs.envs.storage_wrapper import StorageWrapper from rcs.envs.tasks import PickTaskConfig +from rcs.utils import SimpleFrameRate -import rcs # from rcs_duobench.tasks.bin_sort import BinSortEnvConfig from vlagents.client import RemoteAgent from vlagents.policies import Act, Obs +import rcs + logger = logging.getLogger(__name__) @@ -119,7 +118,6 @@ def load_inference_config() -> InferenceConfig: return InferenceConfig(**json.loads(CONFIG_PATH.read_text())) - class ModelInference: def __init__(self, env: gym.Env, cfg: InferenceConfig): self.env = env @@ -186,7 +184,7 @@ def act(self, obs_dict) -> None: return self.remote_agent.act(obs_dict) if len(self._action_buffer) == 0: action = self.remote_agent.act(obs_dict) - selected_action = action.action[:self._cfg.n_action_steps] + selected_action = action.action[: self._cfg.n_action_steps] self._action_buffer = selected_action.tolist() done = action.done if RELATIVETO == RelativeTo.CONFIGURED_ORIGIN: @@ -375,7 +373,9 @@ def get_env(cfg: InferenceConfig) -> gym.Env: hw_cfg.control_mode = CONTROL_MODE hw_cfg.wrapper_cfg.include_depth = INCLUDE_DEPTH hw_cfg.wrapper_cfg.binary_gripper = True - hw_cfg.max_relative_movement = cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart + hw_cfg.max_relative_movement = ( + cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart + ) hw_cfg.relative_to = RELATIVETO hw_cfg.robot_to_shared_base_frame = robot2world hw_cfg.robot_cfgs["left"].ignore_realtime = True @@ -397,8 +397,9 @@ def get_env(cfg: InferenceConfig) -> gym.Env: sim_cfg_data.control_mode = ControlMode.JOINTS sim_cfg_data.relative_to = RELATIVETO sim_cfg_data.wrapper_cfg.binary_gripper = True - sim_cfg_data.max_relative_movement = cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart - + sim_cfg_data.max_relative_movement = ( + cfg.max_rel_mov_joints if CONTROL_MODE == ControlMode.JOINTS else cfg.max_rel_mov_cart + ) # if sim_cfg_data.root_frame_objects is None: # sim_cfg_data.root_frame_objects = {} @@ -413,7 +414,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: batch_size=32, max_rows_per_group=2, max_rows_per_file=10, - allow_wrapper_instruction=False + allow_wrapper_instruction=False, ) diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index 536746ad..a58d39f9 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -604,6 +604,7 @@ class RelativeTo(Enum): CONFIGURED_ORIGIN = auto() NONE = auto() + class LimitedAbsoluteAction(ActObsInfoWrapper): ABSOLUTE_ACTION_KEY = "limited_absolute_action" diff --git a/python/rcs/lerobot_joint_converter.py b/python/rcs/lerobot_joint_converter.py index 047b0f97..24f2c890 100644 --- a/python/rcs/lerobot_joint_converter.py +++ b/python/rcs/lerobot_joint_converter.py @@ -435,6 +435,7 @@ def run_conversion( from lerobot.datasets.lerobot_dataset import LeRobotDataset from torchvision.io import decode_jpeg from torchvision.transforms import v2 + robot_type_converted = RobotType(robot_type) gripper_type_converted = GripperType(gripper_type) converter = JointDatasetConverter( diff --git a/python/rcs/utils.py b/python/rcs/utils.py index f4689463..0cf495c6 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -140,10 +140,12 @@ def export_episode_videos( n: int = -1, ) -> None: import matplotlib + matplotlib.use("Agg") import torch from matplotlib import pyplot as plt from torchvision.io import decode_jpeg + dataset = Path(dataset) output = Path(output) output.mkdir(parents=True, exist_ok=True) @@ -157,8 +159,7 @@ def export_episode_videos( camera_names = [name for name, _ in frame_struct.children] robot_names = [name for name, _ in relation.select("obs").types[0].children if name != "frames"] action_fields_by_robot = { - robot: {field_name for field_name, _ in robot_struct.children} - for robot, robot_struct in action_struct.children + robot: {field_name for field_name, _ in robot_struct.children} for robot, robot_struct in action_struct.children } uuids = conn.execute(f"SELECT DISTINCT uuid FROM read_parquet('{source_escaped}') ORDER BY uuid").fetchall() @@ -210,7 +211,9 @@ def export_episode_videos( for robot_idx, robot in enumerate(robot_names) } gripper_history = { - robot: np.asarray([row[1 + len(camera_names) + len(robot_names) + robot_idx] for row in rows], dtype=np.float32) + robot: np.asarray( + [row[1 + len(camera_names) + len(robot_names) + robot_idx] for row in rows], dtype=np.float32 + ) for robot_idx, robot in enumerate(robot_names) } cols = math.ceil(math.sqrt(len(camera_names) + 1)) diff --git a/python/tests/test_quest_operator.py b/python/tests/test_quest_operator.py index 55db719a..9669fdfb 100644 --- a/python/tests/test_quest_operator.py +++ b/python/tests/test_quest_operator.py @@ -2,7 +2,6 @@ from typing import Any, cast import numpy as np - from rcs._core.common import Pose from rcs.operator.interface import TeleopCommands from rcs.operator.quest import QuestOperator From 5b61a2ea7fcadb5bffd2b311be06d68a3c242027 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 27 Jun 2026 00:37:03 -0700 Subject: [PATCH 67/87] fix: resolve ruff lint errors Wire up the previously-undefined `scene`/`ROBOT_INSTANCE` names in the example scripts, drop unused imports, move the typer.Option default and the unnecessary else-after-return into ruff-compliant form, and add rule-specific noqa comments for the function-scoped torch/torchvision imports in the LeRobot joint converter. --- examples/inference/franka.py | 3 +-- examples/teleop/franka.py | 2 ++ extensions/rcs_zed/src/rcs_zed/__main__.py | 6 +++++- python/rcs/envs/base.py | 3 +-- python/rcs/lerobot_joint_converter.py | 19 ++++++++++--------- python/rcs/utils.py | 1 - 6 files changed, 19 insertions(+), 15 deletions(-) diff --git a/examples/inference/franka.py b/examples/inference/franka.py index c30e04b0..beccd8b3 100644 --- a/examples/inference/franka.py +++ b/examples/inference/franka.py @@ -16,7 +16,6 @@ from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3Duo from rcs.envs.storage_wrapper import StorageWrapper -from rcs.envs.tasks import PickTaskConfig from rcs.utils import SimpleFrameRate # from rcs_duobench.tasks.bin_sort import BinSortEnvConfig @@ -388,7 +387,7 @@ def get_env(cfg: InferenceConfig) -> gym.Env: else: # FR3 - # scene = BinSortEnvConfig() + scene = EmptyWorldFR3Duo() sim_cfg_data = scene.config() sim_cfg_data.sim_cfg = SimConfig( async_control=True, realtime=False, frequency=cfg.fps, max_convergence_steps=500 diff --git a/examples/teleop/franka.py b/examples/teleop/franka.py index f3951c98..efc82fb5 100644 --- a/examples/teleop/franka.py +++ b/examples/teleop/franka.py @@ -26,6 +26,8 @@ "right": "0", } +ROBOT_INSTANCE = RobotPlatform.SIMULATION + # use `udevadm info -a -n /dev/ttyUSB0 | grep serial` # to find out the serial numbers ROBOTIQ_SERIAL = { diff --git a/extensions/rcs_zed/src/rcs_zed/__main__.py b/extensions/rcs_zed/src/rcs_zed/__main__.py index 8e2558f4..0ba4da10 100644 --- a/extensions/rcs_zed/src/rcs_zed/__main__.py +++ b/extensions/rcs_zed/src/rcs_zed/__main__.py @@ -11,6 +11,10 @@ logger = logging.getLogger(__name__) zed_app = typer.Typer(help="CLI tools for the ZED camera module of rcs.") +DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION = typer.Option( + Path("zed_latest.png"), "--output", "-o", help="PNG file to write." +) + def _display_frame(window_name: str, frame): cv2.imshow(window_name, frame.camera.color.data[:, :, ::-1]) @@ -95,7 +99,7 @@ def rgb_view( @zed_app.command("rgb-snapshot") def rgb_snapshot( serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."), - output: Path = typer.Option(Path("zed_latest.png"), "--output", "-o", help="PNG file to write."), + output: Path = DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION, width: int = typer.Option(1280, help="Requested capture width."), height: int = typer.Option(720, help="Requested capture height."), fps: int = typer.Option(30, help="Requested capture frame rate."), diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index a58d39f9..ed6f0899 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -624,8 +624,7 @@ def __init__( def _get_current(self) -> np.ndarray: if self.get_wrapper_attr("get_control_mode")() == ControlMode.JOINTS: return self._robot.get_joint_position() - else: - return self._robot.get_cartesian_position() + return self._robot.get_cartesian_position() def action(self, action: dict[str, Any]) -> dict[str, Any]: if self.max_mov is None: diff --git a/python/rcs/lerobot_joint_converter.py b/python/rcs/lerobot_joint_converter.py index 24f2c890..0c86fd28 100644 --- a/python/rcs/lerobot_joint_converter.py +++ b/python/rcs/lerobot_joint_converter.py @@ -125,9 +125,9 @@ def __init__( rcs.ROBOTS[robot_type].mjcf_model_path, rcs.ROBOTS[robot_type].attachment_site, ) - self.camera_resizers = {camera.name: v2.Resize(camera.resolution) for camera in self.cameras} + self.camera_resizers = {camera.name: v2.Resize(camera.resolution) for camera in self.cameras} # noqa: F821 - self.lrds = LeRobotDataset.create( + self.lrds = LeRobotDataset.create( # noqa: F821 repo_id=self.repo_id, robot_type=self.robot_type.id, root=self.root, @@ -394,10 +394,11 @@ def parse_episode(self, episode_id: str, table: pd.DataFrame, success: bool): def _decode_and_resize_batch(self, image_bytes_list: list[bytes], camera: CamConversionConfig) -> np.ndarray: image_tensors = [ - torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8) for image_bytes in image_bytes_list + torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8) # noqa: F821 + for image_bytes in image_bytes_list ] - decoded = decode_jpeg(image_tensors) - batch = torch.stack(decoded) + decoded = decode_jpeg(image_tensors) # noqa: F821 + batch = torch.stack(decoded) # noqa: F821 resized = self.camera_resizers[camera.name](batch) return resized.permute(0, 2, 3, 1).cpu().numpy() @@ -431,10 +432,10 @@ def run_conversion( video_encoding: bool = False, video_backend: str | None = None, ) -> None: - import torch - from lerobot.datasets.lerobot_dataset import LeRobotDataset - from torchvision.io import decode_jpeg - from torchvision.transforms import v2 + import torch # noqa: F401 + from lerobot.datasets.lerobot_dataset import LeRobotDataset # noqa: F401 + from torchvision.io import decode_jpeg # noqa: F401 + from torchvision.transforms import v2 # noqa: F401 robot_type_converted = RobotType(robot_type) gripper_type_converted = GripperType(gripper_type) diff --git a/python/rcs/utils.py b/python/rcs/utils.py index 0cf495c6..0848a37b 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -143,7 +143,6 @@ def export_episode_videos( matplotlib.use("Agg") import torch - from matplotlib import pyplot as plt from torchvision.io import decode_jpeg dataset = Path(dataset) From 5c44b8ce2e12a86de5355dfe1c24be3aa1189a62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 27 Jun 2026 00:45:51 -0700 Subject: [PATCH 68/87] fix: resolve mypy type errors Exclude examples/inference/franka.py from mypy to resolve a duplicate "franka" module clash with examples/teleop/franka.py (whose franka.py is the one example/teleop/quest_align_frame.py actually imports from). Make LimitedAbsoluteAction._get_current()'s return annotation honest (np.ndarray | common.Pose) since it returns a Pose in cartesian control modes, and add a cast at the one call site that lacked one. Add rule-specific type: ignore / noqa comments for the remaining cases where the underlying stubs don't match runtime behavior (FR3-only robot methods, duckdb's loosely-typed schema introspection, Optional fields that are known to be set, and the lerobot torch imports). --- Makefile | 2 +- examples/teleop/franka.py | 4 ++-- extensions/rcs_zed/src/rcs_zed/__main__.py | 4 +--- extensions/rcs_zed/tests/test_zed_extension.py | 4 ++-- python/rcs/envs/base.py | 6 +++--- python/rcs/lerobot_joint_converter.py | 13 ++++++++----- python/rcs/utils.py | 3 ++- 7 files changed, 19 insertions(+), 17 deletions(-) diff --git a/Makefile b/Makefile index 9d5908b6..a8f89c3f 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ PYSRC = python CPPSRC = src COMPILE_MODE = Release LINT_EXCLUDE_RUFF = --exclude examples/teleop/SimPublisher -LINT_EXCLUDE_MYPY = 'build|examples/teleop/SimPublisher' +LINT_EXCLUDE_MYPY = 'build|examples/teleop/SimPublisher|examples/inference/franka.py' # CPP cppcheckformat: diff --git a/examples/teleop/franka.py b/examples/teleop/franka.py index efc82fb5..b543c96d 100644 --- a/examples/teleop/franka.py +++ b/examples/teleop/franka.py @@ -155,8 +155,8 @@ def get_env(): hw_cfg.robot_cfgs["right"].ignore_realtime = True hw_cfg.robot_cfgs["left"].speed_factor = 0.3 hw_cfg.robot_cfgs["right"].speed_factor = 0.3 - hw_cfg.gripper_cfgs["left"].serial_number = ROBOTIQ_SERIAL["left"] - hw_cfg.gripper_cfgs["right"].serial_number = ROBOTIQ_SERIAL["right"] + hw_cfg.gripper_cfgs["left"].serial_number = ROBOTIQ_SERIAL["left"] # type: ignore + hw_cfg.gripper_cfgs["right"].serial_number = ROBOTIQ_SERIAL["right"] # type: ignore env_rel = env_creator.create_env(hw_cfg) operator = GelloOperator(config) if isinstance(config, GelloConfig) else QuestOperator(config) else: diff --git a/extensions/rcs_zed/src/rcs_zed/__main__.py b/extensions/rcs_zed/src/rcs_zed/__main__.py index 0ba4da10..c7052a5e 100644 --- a/extensions/rcs_zed/src/rcs_zed/__main__.py +++ b/extensions/rcs_zed/src/rcs_zed/__main__.py @@ -11,9 +11,7 @@ logger = logging.getLogger(__name__) zed_app = typer.Typer(help="CLI tools for the ZED camera module of rcs.") -DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION = typer.Option( - Path("zed_latest.png"), "--output", "-o", help="PNG file to write." -) +DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION = typer.Option(Path("zed_latest.png"), "--output", "-o", help="PNG file to write.") def _display_frame(window_name: str, frame): diff --git a/extensions/rcs_zed/tests/test_zed_extension.py b/extensions/rcs_zed/tests/test_zed_extension.py index cb17acec..5ab7c457 100644 --- a/extensions/rcs_zed/tests/test_zed_extension.py +++ b/extensions/rcs_zed/tests/test_zed_extension.py @@ -158,8 +158,8 @@ def test_zed_include_right_adds_logical_right_camera_without_double_grab(patch_z assert opened.grab_calls == [True] assert np.array_equal(left_frame.camera.color.data, left_color) assert np.array_equal(right_frame.camera.color.data, right_color) - assert np.array_equal(left_frame.camera.color.intrinsics, left_intrinsics) - assert np.array_equal(right_frame.camera.color.intrinsics, right_intrinsics) + assert np.array_equal(left_frame.camera.color.intrinsics, left_intrinsics) # type: ignore[arg-type] + assert np.array_equal(right_frame.camera.color.intrinsics, right_intrinsics) # type: ignore[arg-type] assert left_frame.avg_timestamp == right_frame.avg_timestamp == 12.5 assert left_frame.camera.depth is None assert right_frame.camera.depth is None diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index ed6f0899..94fc6019 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -404,7 +404,7 @@ def reset( self.robot.move_home() exception = False except Exception: - self.robot.automatic_error_recovery() + self.robot.automatic_error_recovery() # type: ignore[attr-defined] sleep(0.1) return super().reset(seed=seed, options=options) @@ -621,7 +621,7 @@ def __init__( self._robot = cast(common.Robot, self.get_wrapper_attr("robot")) self.max_mov = max_mov - def _get_current(self) -> np.ndarray: + def _get_current(self) -> np.ndarray | common.Pose: if self.get_wrapper_attr("get_control_mode")() == ControlMode.JOINTS: return self._robot.get_joint_position() return self._robot.get_cartesian_position() @@ -632,7 +632,7 @@ def action(self, action: dict[str, Any]) -> dict[str, Any]: if self.get_wrapper_attr("get_control_mode")() == ControlMode.JOINTS: assert isinstance(self.max_mov, float) low, high = self._robot.get_config().joint_limits - curr = self._get_current() + curr: np.ndarray | common.Pose = cast(np.ndarray, self._get_current()) delta = action[self.joints_key] - curr limited_delta = np.clip(delta, -self.max_mov, self.max_mov) clipped_joints = np.clip(curr + limited_delta, low, high) diff --git a/python/rcs/lerobot_joint_converter.py b/python/rcs/lerobot_joint_converter.py index 0c86fd28..f9efaeae 100644 --- a/python/rcs/lerobot_joint_converter.py +++ b/python/rcs/lerobot_joint_converter.py @@ -125,9 +125,12 @@ def __init__( rcs.ROBOTS[robot_type].mjcf_model_path, rcs.ROBOTS[robot_type].attachment_site, ) - self.camera_resizers = {camera.name: v2.Resize(camera.resolution) for camera in self.cameras} # noqa: F821 + self.camera_resizers = { + camera.name: v2.Resize(camera.resolution) # type: ignore[name-defined] # noqa: F821 + for camera in self.cameras + } - self.lrds = LeRobotDataset.create( # noqa: F821 + self.lrds = LeRobotDataset.create( # type: ignore[name-defined] # noqa: F821 repo_id=self.repo_id, robot_type=self.robot_type.id, root=self.root, @@ -394,11 +397,11 @@ def parse_episode(self, episode_id: str, table: pd.DataFrame, success: bool): def _decode_and_resize_batch(self, image_bytes_list: list[bytes], camera: CamConversionConfig) -> np.ndarray: image_tensors = [ - torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8) # noqa: F821 + torch.frombuffer(bytearray(image_bytes), dtype=torch.uint8) # type: ignore[name-defined] # noqa: F821 for image_bytes in image_bytes_list ] - decoded = decode_jpeg(image_tensors) # noqa: F821 - batch = torch.stack(decoded) # noqa: F821 + decoded = decode_jpeg(image_tensors) # type: ignore[name-defined] # noqa: F821 + batch = torch.stack(decoded) # type: ignore[name-defined] # noqa: F821 resized = self.camera_resizers[camera.name](batch) return resized.permute(0, 2, 3, 1).cpu().numpy() diff --git a/python/rcs/utils.py b/python/rcs/utils.py index 0848a37b..5f5aa372 100644 --- a/python/rcs/utils.py +++ b/python/rcs/utils.py @@ -158,7 +158,8 @@ def export_episode_videos( camera_names = [name for name, _ in frame_struct.children] robot_names = [name for name, _ in relation.select("obs").types[0].children if name != "frames"] action_fields_by_robot = { - robot: {field_name for field_name, _ in robot_struct.children} for robot, robot_struct in action_struct.children + robot: {field_name for field_name, _ in robot_struct.children} # type: ignore[union-attr] + for robot, robot_struct in action_struct.children } uuids = conn.execute(f"SELECT DISTINCT uuid FROM read_parquet('{source_escaped}') ORDER BY uuid").fetchall() From d171c2706c213cd6d2ca1152b2ffed3f645ecf8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 27 Jun 2026 01:12:31 -0700 Subject: [PATCH 69/87] docs: added python headers to readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 12138197..47156100 100644 --- a/README.md +++ b/README.md @@ -132,7 +132,7 @@ pip install rcs-core ### From Source -Make sure that common build tools (i.e., `build-essential`) and a C++ compiler like `gcc` or `clang` are installed on your system/conda/docker. +Make sure that common build tools (i.e., `build-essential`), python headers and a C++ compiler like `gcc` or `clang` are installed on your system/conda/docker. *RCS works best in Python 3.11, and all extensions have been tested to work in 3.11.* From 307d7bda5275ecca099cf1543e73f057ab8f2b5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 27 Jun 2026 11:21:02 -0700 Subject: [PATCH 70/87] fix: resolve pytest failures and StorageWrapper hang StorageWrapper._flush() inferred and permanently cached its pyarrow schema from whatever rows happened to be in the first flush. Since "action" is logged one step behind (frame 0 has no prior action), an unlucky first batch consisting only of that null action got pyarrow's null type pinned for the field forever, so every later batch with a real action value failed with "Invalid null value". Defer flushing until the buffered rows yield a schema with no null-typed fields instead of caching a too-eager guess. Separately, close() called _flush() and only sent the writer thread's stop sentinel afterwards, so any exception during that flush (such as the one above) left the background ThreadPoolExecutor thread blocked on an empty queue forever, hanging the whole process at interpreter exit. Wrap the flush in try/finally so the sentinel is always sent. Also add the include_rotation field quest.py now reads to the QuestOperator test config double, which test_consume_action_swaps_ gripper_with_controller was missing. --- python/rcs/envs/storage_wrapper.py | 26 +++++++++++++++++++++----- python/tests/test_quest_operator.py | 1 + 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/python/rcs/envs/storage_wrapper.py b/python/rcs/envs/storage_wrapper.py index 23b33252..59285f4b 100644 --- a/python/rcs/envs/storage_wrapper.py +++ b/python/rcs/envs/storage_wrapper.py @@ -182,12 +182,27 @@ def _writer_worker(self): ), ) + @staticmethod + def _has_null_typed_field(fields: pa.Schema | pa.StructType) -> bool: + return any( + pa.types.is_null(field.type) + or (pa.types.is_struct(field.type) and StorageWrapper._has_null_typed_field(field.type)) + for field in fields + ) + def _flush(self, keep_last: bool = False): rows = self.buffer[:-1] if keep_last else self.buffer if len(rows) == 0: return if self.schema is None: temp_batch = pa.RecordBatch.from_pylist(rows) + # All-None columns (e.g. the very first frame's "action") infer as pyarrow's + # null type. Writing a fragment with that schema poisons every later read of + # the dataset once a real value for that field shows up, so hold these rows + # back in the buffer until enough data has accumulated to resolve a concrete + # schema instead. + if self._has_null_typed_field(temp_batch.schema): + return self.schema = temp_batch.schema rows[-1]["success"] = self._success @@ -320,10 +335,11 @@ def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = Non return obs, info def close(self): - if len(self.buffer) > 0: - self._flush() - - self.queue.put(self.QueueSentinel) - wait([self._writer_future]) + try: + if len(self.buffer) > 0: + self._flush() + finally: + self.queue.put(self.QueueSentinel) + wait([self._writer_future]) # StorageWrapper.consolidate(self.base_dir, self.schema) diff --git a/python/tests/test_quest_operator.py b/python/tests/test_quest_operator.py index 9669fdfb..be3961c8 100644 --- a/python/tests/test_quest_operator.py +++ b/python/tests/test_quest_operator.py @@ -9,6 +9,7 @@ class _Config: switched_left_right = True + include_rotation = True def test_swap_controller_input_swaps_left_and_right_packets(): From 5d0cbd734451996f9253d1224ab16cac472f5785 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 27 Jun 2026 23:13:40 -0700 Subject: [PATCH 71/87] style: fix gym warning and path obj in cli --- extensions/rcs_zed/src/rcs_zed/__main__.py | 13 ++++++------- python/rcs/envs/base.py | 3 ++- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/extensions/rcs_zed/src/rcs_zed/__main__.py b/extensions/rcs_zed/src/rcs_zed/__main__.py index c7052a5e..ba6c3771 100644 --- a/extensions/rcs_zed/src/rcs_zed/__main__.py +++ b/extensions/rcs_zed/src/rcs_zed/__main__.py @@ -11,8 +11,6 @@ logger = logging.getLogger(__name__) zed_app = typer.Typer(help="CLI tools for the ZED camera module of rcs.") -DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION = typer.Option(Path("zed_latest.png"), "--output", "-o", help="PNG file to write.") - def _display_frame(window_name: str, frame): cv2.imshow(window_name, frame.camera.color.data[:, :, ::-1]) @@ -97,17 +95,18 @@ def rgb_view( @zed_app.command("rgb-snapshot") def rgb_snapshot( serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."), - output: Path = DEFAULT_RGB_SNAPSHOT_OUTPUT_OPTION, + output: str = typer.Option("zed_latest.png", "--output", "-o", help="PNG file to write."), width: int = typer.Option(1280, help="Requested capture width."), height: int = typer.Option(720, help="Requested capture height."), fps: int = typer.Option(30, help="Requested capture frame rate."), duration: float = typer.Option(1.0, "--duration", "-d", help="Seconds to read frames before saving."), ): """Open a ZED camera briefly and save the latest RGB frame as a PNG.""" + output_path = Path(output) if duration <= 0: msg = "Duration must be greater than zero." raise typer.BadParameter(msg) - if output.suffix.lower() != ".png": + if output_path.suffix.lower() != ".png": msg = "Output path must end in .png." raise typer.BadParameter(msg) @@ -131,11 +130,11 @@ def rgb_snapshot( camera.close() assert latest_frame is not None - output.parent.mkdir(parents=True, exist_ok=True) + output_path.parent.mkdir(parents=True, exist_ok=True) image_bgr = latest_frame.camera.color.data[:, :, ::-1] print(latest_frame.camera.color.intrinsics) - if not cv2.imwrite(str(output), image_bgr): - msg = f"Could not write PNG to {output}." + if not cv2.imwrite(str(output_path), image_bgr): + msg = f"Could not write PNG to {output_path}." raise typer.BadParameter(msg) typer.echo(f"Saved {output} from ZED {serial} after reading {frames_read} frame(s).") diff --git a/python/rcs/envs/base.py b/python/rcs/envs/base.py index 94fc6019..c5d8da0e 100644 --- a/python/rcs/envs/base.py +++ b/python/rcs/envs/base.py @@ -283,7 +283,8 @@ def reset( self.np_random, _ = seeding.np_random(seed) re = super().reset(seed=None, options=options) if self.env.get_wrapper_attr("PLATFORM") == RobotPlatform.SIMULATION: - self.sim.step(30) # apply reset state + sim = cast(simulation.Sim, self.get_wrapper_attr("sim")) + sim.step(30) # apply reset state return re From fb1143e24c4566ac84810e0d059058c51010d0e9 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Wed, 8 Jul 2026 10:39:47 +0200 Subject: [PATCH 72/87] format: pyformat --- .../rcs_taxim/examples/grasp_digit_demo.py | 2 +- .../rcs_taxim/src/rcs_taxim/creators.py | 28 +++++++++---------- .../rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 4 ++- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/extensions/rcs_taxim/examples/grasp_digit_demo.py b/extensions/rcs_taxim/examples/grasp_digit_demo.py index 5db4c679..d98791cb 100644 --- a/extensions/rcs_taxim/examples/grasp_digit_demo.py +++ b/extensions/rcs_taxim/examples/grasp_digit_demo.py @@ -102,4 +102,4 @@ def main(): if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/extensions/rcs_taxim/src/rcs_taxim/creators.py b/extensions/rcs_taxim/src/rcs_taxim/creators.py index e56f4f22..f81eb984 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/creators.py +++ b/extensions/rcs_taxim/src/rcs_taxim/creators.py @@ -49,20 +49,20 @@ def _make_camera_cfgs( def _taxim_gripper_cfg() -> SimGripperConfig: return SimGripperConfig( - epsilon_inner=0.005, - epsilon_outer=0.005, - seconds_between_callbacks=0.1, - ignored_collision_geoms=[], - collision_geoms=[], - collision_geoms_fingers=[], - joints=["right_driver_joint", "left_driver_joint"], - max_joint_width=0.005, - min_joint_width=1.0, - actuator="fingers_actuator", - max_actuator_width=0, - min_actuator_width=255, - gripper_type=_TAXIM_GRIPPER_TYPE, - ) + epsilon_inner=0.005, + epsilon_outer=0.005, + seconds_between_callbacks=0.1, + ignored_collision_geoms=[], + collision_geoms=[], + collision_geoms_fingers=[], + joints=["right_driver_joint", "left_driver_joint"], + max_joint_width=0.005, + min_joint_width=1.0, + actuator="fingers_actuator", + max_actuator_width=0, + min_actuator_width=255, + gripper_type=_TAXIM_GRIPPER_TYPE, + ) class FR3TaximSimplePickUpSimEnvCreator: diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index 2ca3851e..461997cd 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -92,7 +92,9 @@ def _ensure_initialized(self) -> None: def _render_tactile_frames(self, visualize: bool) -> dict[str, dict[str, dict[str, Any]]]: frames: dict[str, dict[str, dict[str, Any]]] = {} for site, sensor in zip(self.taxim_sites, self.taxim_sensors, strict=True): - rgb, depth, _ = sensor.render_taxim(self.model, self.data, visualize=self.visualize, cycle_bg=self.taxim_bg_randomize) + rgb, depth, _ = sensor.render_taxim( + self.model, self.data, visualize=self.visualize, cycle_bg=self.taxim_bg_randomize + ) tactile_obs: dict[str, dict[str, Any]] = {"rgb": {"data": rgb}} if self.enable_depth: tactile_obs["depth"] = {"data": depth} From a1e33a05235cd191d78d12503195790b7011dbab Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Wed, 8 Jul 2026 10:40:41 +0200 Subject: [PATCH 73/87] misc: bump taxim version --- extensions/rcs_taxim/pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_taxim/pyproject.toml b/extensions/rcs_taxim/pyproject.toml index cc6df942..1eeda051 100644 --- a/extensions/rcs_taxim/pyproject.toml +++ b/extensions/rcs_taxim/pyproject.toml @@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta" [project] name = "rcs_taxim" -version = "0.6.3" +version = "0.7.2" description = "RCS integration of mujoco-taxim" dependencies = [ - "rcs>=0.6.3", + "rcs>=0.7.2", "omegaconf", #"mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@956b7d05e1f28d6d186eb1d386f4c13d7b014308", ] From 6c7ccafd54253cdd9bf24020584a0df24a9ebfa1 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Wed, 8 Jul 2026 11:10:23 +0200 Subject: [PATCH 74/87] misc: update mujoco-taxim dependency --- extensions/rcs_taxim/pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/rcs_taxim/pyproject.toml b/extensions/rcs_taxim/pyproject.toml index 1eeda051..15e7a6e6 100644 --- a/extensions/rcs_taxim/pyproject.toml +++ b/extensions/rcs_taxim/pyproject.toml @@ -9,7 +9,7 @@ description = "RCS integration of mujoco-taxim" dependencies = [ "rcs>=0.7.2", "omegaconf", - #"mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@956b7d05e1f28d6d186eb1d386f4c13d7b014308", + "mujoco-taxim@git+https://github.com/utn-air/mujoco-taxim.git@norm2tex", ] readme = "README.md" maintainers = [ From bc7511bd88af4c397855910a95b082db138f005a Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sun, 12 Jul 2026 15:21:32 +0200 Subject: [PATCH 75/87] fix: correct EE orientation and trajectory for Robotiq --- extensions/rcs_taxim/examples/grasp_digit_demo.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_taxim/examples/grasp_digit_demo.py b/extensions/rcs_taxim/examples/grasp_digit_demo.py index d98791cb..fc60b850 100644 --- a/extensions/rcs_taxim/examples/grasp_digit_demo.py +++ b/extensions/rcs_taxim/examples/grasp_digit_demo.py @@ -36,7 +36,7 @@ def get_object_pose(self, geom_name: str) -> Pose: geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) obj_pose_world_coordinates = Pose( translation=data.geom_xpos[geom_id], rotation=data.geom_xmat[geom_id].reshape(3, 3) - ) * Pose(rpy_vector=np.array([0, 0, np.pi]), translation=np.array([0.0, 0.0, 0.0])) + ) * Pose(rpy_vector=np.array([0, 0, -np.pi/4]), translation=np.array([0.0, 0.0, 0.0])) return self._robot.to_pose_in_robot_coordinates(obj_pose_world_coordinates) def generate_waypoints(self, start_pose: Pose, end_pose: Pose, num_waypoints: int) -> list[Pose]: @@ -64,7 +64,7 @@ def approach(self, geom_name: str): self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) def grasp(self, geom_name: str): - waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=-0.005, num_waypoints=60) + waypoints = self.plan_linear_motion(geom_name=geom_name, delta_up=0.09, num_waypoints=60) self.execute_motion(waypoints=waypoints, gripper=GripperWrapper.BINARY_GRIPPER_OPEN) for _ in range(4): From 062360dc1a49390febeff7b1b148789dd296ad75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20J=C3=BClg?= Date: Sat, 11 Jul 2026 18:01:00 -0700 Subject: [PATCH 76/87] Merge pull request #317 from RobotControlStack/upgrade-mjspec Upgrades composer to use mujoco==3.10.0 --- pyproject.toml | 8 ++--- python/rcs/sim/composer.py | 62 ++++++++++---------------------------- 2 files changed, 20 insertions(+), 50 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 60d97325..ed4da7fc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ requires = [ "pybind11", "cmake", "ninja", - "mujoco>=3.3.5", + "mujoco==3.10.0", "pin==3.7.0", ] build-backend = "scikit_build_core.build" @@ -36,7 +36,7 @@ dependencies = [ "rpyc~=6.0.2", "pyarrow", "simplejpeg", - "mujoco>=3.3.5", + "mujoco==3.10.0", "pin==3.7.0", # pin 3.7.0 currently resolves against older urdfdom/tinyxml SONAMEs at runtime "cmeel-urdfdom<5", @@ -74,7 +74,7 @@ dev = [ "cmake", ] build_deps = [ - "mujoco>=3.3.5", + "mujoco==3.10.0", "pin==3.7.0", "cmeel-urdfdom<5", "cmeel-tinyxml2<11", @@ -86,7 +86,7 @@ skip = ["cp314*", "*-musllinux*"] # Install X11 headers needed to compile GLFW before-all = "yum install -y libXi-devel libXcursor-devel libXinerama-devel libXrandr-devel glfw-devel" # Exclude MuJoCo AND Pinocchio from being bundled. -repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude libmujoco.so.3.2.6 --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" +repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} --exclude libmujoco.so.* --exclude libpinocchio_default.so.3.7.0 --exclude libpinocchio_parsers.so.3.7.0" [tool.scikit-build] build.verbose = true diff --git a/python/rcs/sim/composer.py b/python/rcs/sim/composer.py index 687160fc..c11b6a18 100644 --- a/python/rcs/sim/composer.py +++ b/python/rcs/sim/composer.py @@ -53,15 +53,10 @@ def _find_site(self, name: str) -> Optional[mujoco._specs.MjsSite]: return None def _find_body(self, name: str) -> Optional[mujoco._specs.MjsBody]: - if hasattr(self.spec, "find_body"): - try: - return self.spec.find_body(name) - except ValueError: - return None - for body in self.spec.bodies: - if body.name == name: - return body - return None + try: + return self.spec.body(name) + except ValueError: + return None def _find_camera(self, name: str) -> Optional[mujoco._specs.MjsCamera]: for camera in self.spec.cameras: @@ -73,30 +68,6 @@ def _apply_pose(self, body: mujoco._specs.MjsBody, pose: Pose): body.pos = list(pose.translation()) body.quat = list(pose.rotation_q_wxyz()) - def _attach_to_frame(self, frame: mujoco._specs.MjsFrame, child_spec: mujoco.MjSpec, prefix: str): - """Attach a child spec to a frame across MuJoCo model-editing API versions.""" - if hasattr(frame, "attach"): - return frame.attach(child_spec, prefix, "") - return self.spec.attach(child_spec, frame=frame, prefix=prefix, suffix="") - - def _attach_spec_body_to_site( - self, - site: mujoco._specs.MjsSite, - child_spec: mujoco.MjSpec, - body: mujoco._specs.MjsBody, - prefix: str, - ) -> mujoco._specs.MjsBody: - """Attach a body to a site across MuJoCo model-editing API versions.""" - if hasattr(site, "attach"): - return site.attach(body, prefix, "") - body_name = body.name - self.spec.attach(child_spec, prefix=prefix, suffix="", site=site) - attached_body = self._find_body(f"{prefix}{body_name}") - if attached_body is None: - msg = f"Could not find attached body '{prefix}{body_name}' after site attachment." - raise ValueError(msg) - return attached_body - def _prefixed_free_joint_names(self, spec: mujoco.MjSpec, prefix: str) -> list[str]: free_joint_type = int(mujoco.mjtJoint.mjJNT_FREE) return [f"{prefix}{joint.name}" for joint in spec.joints if joint.name and int(joint.type) == free_joint_type] @@ -131,10 +102,9 @@ def add_camera( msg = f"Attachment site '{site_name}' not found." raise ValueError(msg) - camera_spec = mujoco.MjSpec() - camera_mount = camera_spec.worldbody.add_body() + camera_mount = mujoco.MjSpec().worldbody.add_body() camera_mount.name = "mount" - camera_mount = self._attach_spec_body_to_site(attachment_site, camera_spec, camera_mount, f"{name}_") + camera_mount = attachment_site.attach_body(camera_mount, f"{name}_", "") self._apply_pose(camera_mount, pose) @@ -178,7 +148,7 @@ def add_camera_xml( if robot_prefix is None: attach_frame = self.spec.worldbody.add_frame() - self._attach_to_frame(attach_frame, camera_spec, prefix) + self.spec.attach(camera_spec, prefix=prefix, suffix="", frame=attach_frame) attached_root_name = f"{prefix}{root_body_name}" attached_root = self._find_body(attached_root_name) if attached_root is None: @@ -192,7 +162,7 @@ def add_camera_xml( msg = f"Attachment site '{site_name}' not found." raise ValueError(msg) - attached_root = self._attach_spec_body_to_site(attachment_site, camera_spec, root_body, prefix) + attached_root = attachment_site.attach_body(root_body, prefix=prefix, suffix="") self._apply_pose(attached_root, pose) @@ -217,14 +187,14 @@ def add_robot(self, xml_path: str, prefix: str, pose: Pose | None = None) -> muj child_spec = mujoco.MjSpec.from_file(xml_path) self._resolve_asset_paths(child_spec, xml_path) - child_root_name = child_spec.worldbody.first_body().name # 1. Use a frame to attach the child spec (most comprehensive) frame = self.spec.worldbody.add_frame() - self._attach_to_frame(frame, child_spec, prefix) + self.spec.attach(child_spec, prefix=prefix, frame=frame) # 2. Identify the robot root body (it was prefixed) - prefixed_root_name = f"{prefix}{child_root_name}" + child_root_name = child_spec.worldbody.first_body().name + prefixed_root_name = f"{child_root_name}" robot_root = self._find_body(prefixed_root_name) if not robot_root: @@ -260,7 +230,7 @@ def add_gripper( self._resolve_asset_paths(gripper_spec, xml_path) gripper_root = gripper_spec.worldbody.first_body() - gripper_root = self._attach_spec_body_to_site(attachment_site, gripper_spec, gripper_root, gripper_prefix) + gripper_root = attachment_site.attach_body(gripper_root, gripper_prefix, "") self._apply_pose(gripper_root, pose) if gripper_prefix: self._gravcomp_prefixes.add(gripper_prefix) @@ -292,7 +262,7 @@ def add_object_robot_frame( self.register_root_relative_replay_free_joints(self._prefixed_free_joint_names(object_spec, object_prefix)) object_root = object_spec.worldbody.first_body() - object_root = self._attach_spec_body_to_site(attachment_site, object_spec, object_root, object_prefix) + object_root = attachment_site.attach_body(object_root, prefix=object_prefix, suffix="") self._apply_pose(object_root, pose) return object_root @@ -316,14 +286,14 @@ def add_object_world_frame( # Load the child spec child_spec = mujoco.MjSpec.from_file(xml_path) + child_root_name = child_spec.worldbody.first_body().name self._resolve_asset_paths(child_spec, xml_path) if register_root_relative_replay_free_joints: self.register_root_relative_replay_free_joints(self._prefixed_free_joint_names(child_spec, object_prefix)) - child_root_name = child_spec.worldbody.first_body().name # Attach using a frame frame = self.spec.worldbody.add_frame() - self._attach_to_frame(frame, child_spec, object_prefix) + self.spec.attach(child_spec, prefix=object_prefix, suffix="", frame=frame) # Identify the root of the added object prefixed_root_name = f"{object_prefix}{child_root_name}" @@ -360,4 +330,4 @@ def _apply_gravcomp(self): for joint in self.spec.joints: if joint.name and any(joint.name.startswith(prefix) for prefix in self._gravcomp_prefixes): - joint.actgravcomp = True + joint.actgravcomp = True \ No newline at end of file From efee3d329e5a8db7ed16379855ab5c61cbd1f09a Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sun, 12 Jul 2026 15:31:47 +0200 Subject: [PATCH 77/87] fix: remove deprecated test --- python/tests/test_taxim_hold_open_task.py | 269 ---------------------- 1 file changed, 269 deletions(-) delete mode 100644 python/tests/test_taxim_hold_open_task.py diff --git a/python/tests/test_taxim_hold_open_task.py b/python/tests/test_taxim_hold_open_task.py deleted file mode 100644 index 95a866ab..00000000 --- a/python/tests/test_taxim_hold_open_task.py +++ /dev/null @@ -1,269 +0,0 @@ -from __future__ import annotations - -from pathlib import Path -import sys - -REPO_ROOT = Path(__file__).resolve().parents[2] -for candidate in (REPO_ROOT / "python", REPO_ROOT / "extensions" / "rcs_sb3" / "src"): - sys.path.insert(0, str(candidate)) - -import gymnasium as gym -import numpy as np - -from rcs.envs.tasks import MinOpenHoldRewardWrapper -from rcs_sb3.wrappers import TaximSB3ObservationWrapper - - -class _FakeJoint: - def __init__(self, qpos: np.ndarray): - self.qpos = qpos - - -class _FakeData: - def __init__(self, qpos: np.ndarray): - self._joint = _FakeJoint(qpos) - - def joint(self, _name: str) -> _FakeJoint: - return self._joint - - -class _FakeSim: - def __init__(self, qpos: np.ndarray): - self.data = _FakeData(qpos) - - -class _HoldEnv(gym.Env): - def __init__(self, qpos: np.ndarray, *, gripper_width: float, is_grasped: bool): - self.sim = _FakeSim(qpos) - self.action_space = gym.spaces.Dict( - { - "robot": gym.spaces.Dict( - { - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ) - } - ) - self.observation_space = gym.spaces.Dict( - { - "robot": gym.spaces.Dict( - { - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ) - } - ) - self._gripper_width = gripper_width - self._is_grasped = is_grasped - - def get_wrapper_attr(self, name: str): - return getattr(self, name) - - def reset(self, *, seed=None, options=None): - super().reset(seed=seed) - return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, {} - - def step(self, action): - obs = {"robot": {"gripper": np.array([1.0], dtype=np.float32)}} - info = {"gripper_width": self._gripper_width, "is_grasped": self._is_grasped} - return obs, 0.0, False, False, info - - -class _TaximObsEnv(gym.Env): - def __init__(self): - self.action_space = gym.spaces.Dict( - { - "robot": gym.spaces.Dict( - { - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ) - } - ) - self.observation_space = gym.spaces.Dict( - { - "frames": gym.spaces.Dict( - { - "tactile_left": gym.spaces.Dict( - { - "rgb": gym.spaces.Dict( - {"data": gym.spaces.Box(low=0, high=255, shape=(240, 320, 3), dtype=np.uint8)} - ) - } - ), - "tactile_right": gym.spaces.Dict( - { - "rgb": gym.spaces.Dict( - {"data": gym.spaces.Box(low=0, high=255, shape=(240, 320, 3), dtype=np.uint8)} - ) - } - ), - } - ), - "robot": gym.spaces.Dict( - { - "gripper": gym.spaces.Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32), - } - ), - } - ) - - def reset(self, *, seed=None, options=None): - super().reset(seed=seed) - obs = { - "frames": { - "tactile_left": {"rgb": {"data": np.zeros((240, 320, 3), dtype=np.uint8)}}, - "tactile_right": {"rgb": {"data": np.zeros((240, 320, 3), dtype=np.uint8)}}, - }, - "robot": {"gripper": np.array([1.0], dtype=np.float32)}, - } - return obs, {} - - def step(self, action): - obs, _ = self.reset() - return obs, 0.0, False, False, {} - - -class _FakeTaximWrapper(gym.Wrapper): - def __init__(self, env): - super().__init__(env) - self.observation_space = env.observation_space - - def observation(self, obs): - return obs - - -def test_min_open_hold_reward_prefers_more_open_gripper_when_holding(): - closed_env = MinOpenHoldRewardWrapper( - _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.25, is_grasped=True), - robot_name="robot", - obj_joint_name="box_joint", - ) - open_env = MinOpenHoldRewardWrapper( - _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=True), - robot_name="robot", - obj_joint_name="box_joint", - ) - - closed_env.reset() - _, closed_reward, *_ = closed_env.step({"robot": {"gripper": np.array([0.25], dtype=np.float32)}}) - - open_env.reset() - _, open_reward, *_ = open_env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) - - assert open_reward > closed_reward - - -def test_min_open_hold_reward_penalizes_drops(): - dropped_env = MinOpenHoldRewardWrapper( - _HoldEnv(np.array([0.0, 0.0, 0.45, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=False), - robot_name="robot", - obj_joint_name="box_joint", - ) - - dropped_env.reset() - _, reward, terminated, _, info = dropped_env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) - - assert reward == 0.0 - assert terminated is True - assert info["is_dropped"] is True - - -def test_min_open_hold_reward_truncates_after_100_steps(): - env = MinOpenHoldRewardWrapper( - _HoldEnv(np.array([0.0, 0.0, 0.50, 1.0, 0.0, 0.0, 0.0]), gripper_width=0.90, is_grasped=True), - robot_name="robot", - obj_joint_name="box_joint", - max_episode_steps=7, - ) - - env.reset() - truncated = False - for _ in range(7): - _, reward, terminated, truncated, _ = env.step({"robot": {"gripper": np.array([0.90], dtype=np.float32)}}) - assert reward > 0.0 - assert terminated is False - assert truncated is True - - -class _ResetRobot: - def __init__(self): - self._pose = None - - def get_joint_position(self): - return np.zeros(7) - - def get_cartesian_position(self): - return _Pose() - - def set_joint_position(self, _q): - pass - - -class _Pose: - def __mul__(self, other): - return other - - def translation(self): - return np.array([0.0, 0.0, 0.6]) - - def rotation_q_wxyz(self): - return np.array([1.0, 0.0, 0.0, 0.0]) - - -def test_taxim_observation_wrapper_exposes_tactile_images_to_actor(): - wrapped = TaximSB3ObservationWrapper(_FakeTaximWrapper(_TaximObsEnv()), left_frame_key="tactile_left", right_frame_key="tactile_right") - - obs, _ = wrapped.reset() - - assert set(obs) == {"left_rgb", "right_rgb", "state"} - assert obs["left_rgb"].shape == (3, 240, 320) - assert obs["right_rgb"].shape == (3, 240, 320) - assert obs["state"].shape == (1,) - - -def test_task_reset_places_cube_in_home_grasp_pose(): - from rcs.envs.tasks import StartGraspedWrapper - - class _FakeActuatorModel: - actuator_ctrlrange = np.array([[0.0, 1.0]]) - - class _FakeSim2: - def __init__(self): - self.model = _FakeActuatorModel() - self.data = type("D", (), {"ctrl": np.zeros(1), "joint": lambda self_, _name: type("J", (), {"qpos": np.zeros(7)})()})() - - def step(self, _n): - pass - - def sync_gui(self): - pass - - class _FakeGripper: - def get_config(self): - return type("C", (), {"actuator": "gripper", "max_actuator_width": 1.0, "min_actuator_width": 0.0})() - - def grasp(self): - pass - - class _HomeEnv(gym.Env): - def __init__(self): - self.sim = _FakeSim2() - self.action_space = gym.spaces.Dict({"robot": gym.spaces.Dict({"gripper": gym.spaces.Box(0.0, 1.0, (1,), np.float32)})}) - self.observation_space = self.action_space - self._robot = _ResetRobot() - self._gripper = {"robot": _FakeGripper()} - - def get_wrapper_attr(self, name): - return getattr(self, name) - - def reset(self, *, seed=None, options=None): - return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, {} - - def step(self, action): - return {"robot": {"gripper": np.array([1.0], dtype=np.float32)}}, 0.0, False, False, {} - - wrapped = StartGraspedWrapper(_HomeEnv(), robot_name="robot", obj_joint_name="box_joint") - obs, info = wrapped.reset() - assert obs["robot"]["gripper"].shape == (1,) - assert isinstance(info, dict) From 953051e4059732def6f7efd8be78a71cae3b1030 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sun, 12 Jul 2026 15:31:53 +0200 Subject: [PATCH 78/87] fix: correct version number --- extensions/rcs_taxim/src/rcs_taxim/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/rcs_taxim/src/rcs_taxim/__init__.py b/extensions/rcs_taxim/src/rcs_taxim/__init__.py index 63af8876..bc8c296f 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/__init__.py +++ b/extensions/rcs_taxim/src/rcs_taxim/__init__.py @@ -1 +1 @@ -__version__ = "0.6.3" +__version__ = "0.7.2" From dbd89fe6ae1093750d98fb3ec44b1fa9b6fa2816 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sun, 12 Jul 2026 15:34:30 +0200 Subject: [PATCH 79/87] format: pyformat --- extensions/rcs_taxim/examples/grasp_digit_demo.py | 2 +- python/rcs/sim/composer.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_taxim/examples/grasp_digit_demo.py b/extensions/rcs_taxim/examples/grasp_digit_demo.py index fc60b850..c1f29ca7 100644 --- a/extensions/rcs_taxim/examples/grasp_digit_demo.py +++ b/extensions/rcs_taxim/examples/grasp_digit_demo.py @@ -36,7 +36,7 @@ def get_object_pose(self, geom_name: str) -> Pose: geom_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) obj_pose_world_coordinates = Pose( translation=data.geom_xpos[geom_id], rotation=data.geom_xmat[geom_id].reshape(3, 3) - ) * Pose(rpy_vector=np.array([0, 0, -np.pi/4]), translation=np.array([0.0, 0.0, 0.0])) + ) * Pose(rpy_vector=np.array([0, 0, -np.pi / 4]), translation=np.array([0.0, 0.0, 0.0])) return self._robot.to_pose_in_robot_coordinates(obj_pose_world_coordinates) def generate_waypoints(self, start_pose: Pose, end_pose: Pose, num_waypoints: int) -> list[Pose]: diff --git a/python/rcs/sim/composer.py b/python/rcs/sim/composer.py index c11b6a18..c9e2bbb0 100644 --- a/python/rcs/sim/composer.py +++ b/python/rcs/sim/composer.py @@ -330,4 +330,4 @@ def _apply_gravcomp(self): for joint in self.spec.joints: if joint.name and any(joint.name.startswith(prefix) for prefix in self._gravcomp_prefixes): - joint.actgravcomp = True \ No newline at end of file + joint.actgravcomp = True From f0834bb6060c8ba21e231f2db67f535d0b36990f Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Sun, 12 Jul 2026 15:55:25 +0200 Subject: [PATCH 80/87] format: pyformat --- python/rcs/envs/tasks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/rcs/envs/tasks.py b/python/rcs/envs/tasks.py index a96ee408..db44ca8b 100644 --- a/python/rcs/envs/tasks.py +++ b/python/rcs/envs/tasks.py @@ -181,4 +181,4 @@ def add_task_env(cfg: PickTaskConfig, env: gym.Env, _simulation: Sim, env_cfg: S ) -rcs.TASKS["pick"] = PickTask \ No newline at end of file +rcs.TASKS["pick"] = PickTask From d30044dc3fc3cc05bb0926b1fff67e7a0b27e01f Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 07:13:30 +0000 Subject: [PATCH 81/87] fix: move the digit demo to rcs/examples --- .../rcs_taxim/examples => examples/taxim}/grasp_digit_demo.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {extensions/rcs_taxim/examples => examples/taxim}/grasp_digit_demo.py (100%) diff --git a/extensions/rcs_taxim/examples/grasp_digit_demo.py b/examples/taxim/grasp_digit_demo.py similarity index 100% rename from extensions/rcs_taxim/examples/grasp_digit_demo.py rename to examples/taxim/grasp_digit_demo.py From 88ca551912c8a359df24374b52b16fb933db9d57 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 07:13:40 +0000 Subject: [PATCH 82/87] fix: remove unnecessary files --- .devcontainer/devcontainer.json | 41 ----------------------------- Dockerfile | 46 --------------------------------- 2 files changed, 87 deletions(-) delete mode 100644 .devcontainer/devcontainer.json delete mode 100644 Dockerfile diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json deleted file mode 100644 index dd4a5767..00000000 --- a/.devcontainer/devcontainer.json +++ /dev/null @@ -1,41 +0,0 @@ -{ - "name": "rcs", - "build": { - "dockerfile": "../Dockerfile" - }, - "remoteUser": "vscode", - "runArgs": [ - "--gpus", - "all", - "--name", - "rcs", - "--ipc=host", - "--network=host", - "--env=DISPLAY=${localEnv:DISPLAY}", - "--env=XAUTHORITY=/tmp/.Xauthority", - "--volume=${localEnv:HOME}/.Xauthority:/tmp/.Xauthority:ro", - "--volume=/tmp/.X11-unix:/tmp/.X11-unix:rw" - ], - "shutdownAction": "stopContainer", - "postStartCommand": "bash -lc 'grep -qxF \"source /home/vscode/venv/bin/activate\" ~/.bashrc || echo \"source /home/vscode/venv/bin/activate\" >> ~/.bashrc'", - "customizations": { - "vscode": { - "settings": { - "terminal.integrated.defaultProfile.linux": "bash", - "python.defaultInterpreterPath": "/home/vscode/venv/bin/python" - }, - "extensions": [ - "charliermarsh.ruff", - "eamodio.gitlens", - "ms-python.debugpy", - "ms-python.python", - "ms-python.vscode-pylance", - "ms-python.vscode-python-envs", - "openai.chatgpt" - ] - } - }, - "mounts": [ - "source=/mnt/disk_air_fast_2/scannetpp,target=/workspaces/datasets,type=bind" - ], -} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index b5d276a7..00000000 --- a/Dockerfile +++ /dev/null @@ -1,46 +0,0 @@ -# Chose the base image from https://hub.docker.com/ -FROM nvidia/cuda:13.1.2-cudnn-devel-ubuntu24.04 - -# Set variables -ARG USERNAME=vscode -ARG USER_UID=1001 -ARG USER_GID=$USER_UID - -# Avoid interactive dialog -ARG DEBIAN_FRONTEND=noninteractive -ENV TZ=Etc/UTC - -# Create new user -RUN groupadd --gid $USER_GID $USERNAME \ - && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME \ - # - # [Optional] Add sudo support. Omit if you don't need to install software after connecting. - && apt-get update \ - && apt-get install -y sudo \ - && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \ - && chmod 0440 /etc/sudoers.d/$USERNAME - -# ******************************************************** -# * Anything else you want to do like clean up goes here * -# ******************************************************** - -# For example, install python 3.12, git and curl -RUN apt-get install -y tzdata -RUN apt-get install -y software-properties-common -RUN add-apt-repository ppa:deadsnakes/ppa -RUN apt update && apt install -y python3.11 python3.11-venv python3.11-dev curl liblz4-dev git libgl1-mesa-dev cmake build-essential -RUN apt install -y ffmpeg ca-certificates cmake curl git libgl1 libglib2.0-0 libglfw3-dev libpoco-dev ninja-build liburdfdom-dev - -# [Optional] Set the default user. Omit if you want to keep the default as root. -USER $USERNAME -WORKDIR /workspaces - -# Install python dependencies and renderpy -COPY . /workspaces -RUN python3.11 -m venv /home/$USERNAME/venv -RUN /home/$USERNAME/venv/bin/pip install --upgrade pip -RUN /home/$USERNAME/venv/bin/pip install --upgrade setuptools wheel ninja setuptools>=45 scikit-build-core>=0.3.3 mujoco>=3.3.5 pin==3.7.0 pybind11 cmake -RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -ve . -RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e extensions/rcs_sb3 -RUN /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e extensions/rcs_taxim -RUN cd norm2tex && /home/$USERNAME/venv/bin/pip install --no-build-isolation --no-cache-dir -e . \ No newline at end of file From 576c60b8eb1e130af9d956f6ced0018d3ff9a403 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 07:14:08 +0000 Subject: [PATCH 83/87] fix: remove hardcoded path and rename function more clearly --- extensions/rcs_taxim/src/rcs_taxim/creators.py | 9 ++------- extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 6 +++++- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/extensions/rcs_taxim/src/rcs_taxim/creators.py b/extensions/rcs_taxim/src/rcs_taxim/creators.py index f81eb984..23c6a910 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/creators.py +++ b/extensions/rcs_taxim/src/rcs_taxim/creators.py @@ -10,17 +10,12 @@ from rcs._core.sim import SimCameraConfig, SimGripperConfig from rcs.envs.base import ControlMode, RelativeTo from rcs.envs.configs import EmptyWorldFR3 -from rcs_taxim.taxim_wrapper import TaximSimWrapper +from rcs_taxim.taxim_wrapper import TaximSimWrapper, _robotiq2f85_digit_model_path import rcs _TAXIM_GRIPPER_TYPE = GripperType("Robotiq2F85Digit") - -def _digit_model_path() -> Path: - return Path("/home/sbien/Documents/Development/V2T/mujoco-taxim/assets/robotiq_2f85/robotiq_2f85.xml") - - def _prefixed(name: str) -> str: return f"gripper{name}" @@ -85,7 +80,7 @@ def __call__( msg = f"Unexpected keyword arguments: {unexpected}" raise TypeError(msg) - rcs.GRIPPER_PATHS[_TAXIM_GRIPPER_TYPE] = str(_digit_model_path()) + rcs.GRIPPER_PATHS[_TAXIM_GRIPPER_TYPE] = str(_robotiq2f85_digit_model_path()) scene = EmptyWorldFR3() cfg = scene.config() diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index 461997cd..0f1bae70 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -3,7 +3,11 @@ import gymnasium as gym import numpy as np +from TaximSensor import TaximSensor +from pathlib import Path +def _robotiq2f85_digit_model_path() -> str: + return str(Path(TaximSensor.__file__).parent.parent.parent / "assets/robotiq_2f85/robotiq_2f85.xml") class TaximSimWrapper(gym.Wrapper): """Wrapper to render TAXIM tactile observations alongside regular RCS observations.""" @@ -74,7 +78,7 @@ def __init__( def _ensure_initialized(self) -> None: if self.initialized: return - from TaximSensor import TaximSensor + for site, pad_geom in zip(self.taxim_sites, self.taxim_pad_geoms, strict=True): sensor = TaximSensor(resize=(240, 320), sensor_type=self.taxim_sensor_type, preprocess_bg=False) From 077b7fe311d8e7ab28c8c095d5998599c5eba68d Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 07:14:19 +0000 Subject: [PATCH 84/87] fix: add rcs_taxim extension to list --- pyproject.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index ed4da7fc..e472ace8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -225,6 +225,11 @@ version_files = [ "extensions/rcs_tacto/src/rcs_tacto/__init__.py:__version__", "extensions/rcs_tacto/pyproject.toml:\"rcs-core>=(.*)\"", + "extensions/rcs_taxim/pyproject.toml:version", + "extensions/rcs_taxim/src/rcs_taxim/__init__.py:__version__", + "extensions/rcs_taxim/pyproject.toml:\"rcs-core>=(.*)\"", + + "extensions/rcs_robotiq2f85/pyproject.toml:version", "extensions/rcs_robotiq2f85/src/rcs_robotiq2f85/__init__.py:__version__", "extensions/rcs_robotiq2f85/pyproject.toml:\"rcs-core>=(.*)\"", From e9a2c0ad7bbcd4f131c8ea16e04f9816e2ca07b0 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 08:23:24 +0000 Subject: [PATCH 85/87] fix: import the file instead of class --- extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index 0f1bae70..7fe60414 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -3,7 +3,7 @@ import gymnasium as gym import numpy as np -from TaximSensor import TaximSensor +import TaximSensor from pathlib import Path def _robotiq2f85_digit_model_path() -> str: @@ -81,7 +81,7 @@ def _ensure_initialized(self) -> None: for site, pad_geom in zip(self.taxim_sites, self.taxim_pad_geoms, strict=True): - sensor = TaximSensor(resize=(240, 320), sensor_type=self.taxim_sensor_type, preprocess_bg=False) + sensor = TaximSensor.TaximSensor(resize=(240, 320), sensor_type=self.taxim_sensor_type, preprocess_bg=False) sensor.add_camera_mujoco(site, self.model, self.data) sensor.change_bg(self.taxim_bg_idx) for geom, mesh in self.target_geom_mesh_dict.items(): From 2fcad40f71b67a007847e582f63d7c9e980e689b Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 14:47:57 +0200 Subject: [PATCH 86/87] format: pyformat and pylint --- extensions/rcs_taxim/src/rcs_taxim/creators.py | 2 +- extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/extensions/rcs_taxim/src/rcs_taxim/creators.py b/extensions/rcs_taxim/src/rcs_taxim/creators.py index 23c6a910..3ebd54f0 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/creators.py +++ b/extensions/rcs_taxim/src/rcs_taxim/creators.py @@ -1,7 +1,6 @@ from __future__ import annotations import copy -from pathlib import Path from typing import Any import gymnasium as gym @@ -16,6 +15,7 @@ _TAXIM_GRIPPER_TYPE = GripperType("Robotiq2F85Digit") + def _prefixed(name: str) -> str: return f"gripper{name}" diff --git a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py index 7fe60414..5915ba62 100644 --- a/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py +++ b/extensions/rcs_taxim/src/rcs_taxim/taxim_wrapper.py @@ -1,14 +1,16 @@ import copy +from pathlib import Path from typing import Any import gymnasium as gym import numpy as np import TaximSensor -from pathlib import Path + def _robotiq2f85_digit_model_path() -> str: return str(Path(TaximSensor.__file__).parent.parent.parent / "assets/robotiq_2f85/robotiq_2f85.xml") + class TaximSimWrapper(gym.Wrapper): """Wrapper to render TAXIM tactile observations alongside regular RCS observations.""" @@ -78,7 +80,6 @@ def __init__( def _ensure_initialized(self) -> None: if self.initialized: return - for site, pad_geom in zip(self.taxim_sites, self.taxim_pad_geoms, strict=True): sensor = TaximSensor.TaximSensor(resize=(240, 320), sensor_type=self.taxim_sensor_type, preprocess_bg=False) From 9a78b3441e6e54f48cb3b0b2542be8180281ebb1 Mon Sep 17 00:00:00 2001 From: Seongjin Bien Date: Thu, 16 Jul 2026 13:40:22 +0000 Subject: [PATCH 87/87] fix: change default name in EmptyWorldFR3 to robot --- python/rcs/envs/configs.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/rcs/envs/configs.py b/python/rcs/envs/configs.py index 2139c7d0..6b87fdd9 100644 --- a/python/rcs/envs/configs.py +++ b/python/rcs/envs/configs.py @@ -31,7 +31,7 @@ class EmptyWorldFR3(SimEnvCreator): - robot_prefix_template = "right" + robot_prefix_template = "robot" gripper_prefix_template = "gripper" def config(self) -> SimEnvCreatorConfig: