| import gymnasium as gym |
| import mujoco |
| import numpy as np |
| from gymnasium.spaces import Box |
| from pathlib import Path |
| import mujoco.viewer |
|
|
| class StackingEnv(gym.Env): |
| def __init__(self, render_mode="human"): |
| super().__init__() |
| self.render_mode = render_mode |
| |
| |
| xml_path = str(Path(__file__).parent.parent / "assets/stacking.xml") |
| print(f"Loading XML from: {xml_path}") |
| try: |
| self.model = mujoco.MjModel.from_xml_path(xml_path) |
| self.data = mujoco.MjData(self.model) |
| |
| |
| self.nq = self.model.nq |
| self.nv = self.model.nv |
| self.nu = self.model.nu |
| print(f"Model dimensions - nq: {self.nq}, nv: {self.nv}, nu: {self.nu}") |
| |
| |
| self.data.qpos = np.zeros(self.nq) |
| if self.nq >= 3: |
| self.data.qpos[0:3] = [0, 0, 0.1] |
| if self.nq >= 7: |
| self.data.qpos[3:7] = [1, 0, 0, 0] |
| mujoco.mj_forward(self.model, self.data) |
| |
| except ValueError as e: |
| print(f"Error loading model: {e}") |
| print("Check stacking.xml for valid qpos or keyframe definitions.") |
| raise |
|
|
| self.viewer = None |
| if render_mode == "human": |
| try: |
| self.viewer = mujoco.viewer.launch_passive(self.model, self.data) |
| print("Viewer initialized successfully") |
| except Exception as e: |
| print(f"Viewer initialization failed: {e}") |
|
|
| |
| self.observation_space = Box(low=-np.inf, high=np.inf, shape=(21,), dtype=np.float32) |
| self.action_space = Box(low=-1.0, high=1.0, shape=(9,), dtype=np.float32) |
|
|
| |
| self.block_ids = [] |
| for i in range(3): |
| block_id = mujoco.mj_name2id(self.model, mujoco.mjtObj.mjOBJ_BODY, f"block{i}") |
| self.block_ids.append(block_id if block_id != -1 else None) |
| print(f"Block IDs found: {[bid for bid in self.block_ids if bid is not None]}") |
| |
| self.target_zone_id = mujoco.mj_name2id(self.model, mujoco.mjtObj.mjOBJ_BODY, "target_zone") |
| print(f"Target zone ID: {self.target_zone_id if self.target_zone_id != -1 else 'Not found'}") |
| |
| |
| self.joint_ids = list(range(7, min(16, self.nq))) |
| self.finger_joint_ids = [14, 15] if self.nq >= 16 and 14 < self.nu and 15 < self.nu else [] |
|
|
| def reset(self, seed=None): |
| super().reset(seed=seed) |
| nq = self.model.nq |
| nv = self.model.nv |
| |
| |
| self.data.qpos = np.zeros(nq) |
| self.data.qvel = np.zeros(nv) |
| |
| if nq >= 3: |
| self.data.qpos[0:3] = [0, 0, 0.1] |
| if nq >= 7: |
| self.data.qpos[3:7] = [1, 0, 0, 0] |
| if nq > 7: |
| self.data.qpos[7:16] = np.zeros(9) |
| |
| |
| block_positions = [ |
| [0.2, 0.0, 0.025], |
| [0.25, 0.0, 0.025], |
| [0.3, 0.0, 0.025] |
| ] |
| for i, block_id in enumerate(self.block_ids): |
| if block_id is not None: |
| self.data.body(block_id).xpos = np.array(block_positions[i]) |
| |
| self.data.qvel[:] = 0.0 |
| mujoco.mj_forward(self.model, self.data) |
| return self._get_obs(), {} |
|
|
| def step(self, action): |
| |
| ctrl_size = min(len(action), self.nu) |
| clipped_action = np.clip(action[:ctrl_size], -1.0, 1.0) |
| self.data.ctrl[:ctrl_size] = clipped_action |
| |
| |
| if 1 < self.nu: |
| self.data.ctrl[1] = np.clip(action[1], -1.57, 1.57) |
| |
| |
| if len(action) >= 9 and self.finger_joint_ids and all(fid < self.nu for fid in self.finger_joint_ids): |
| self.data.ctrl[self.finger_joint_ids[0]] = np.clip(action[7], -1.0, 1.0) |
| self.data.ctrl[self.finger_joint_ids[1]] = np.clip(action[8], -1.0, 1.0) |
| |
| mujoco.mj_step(self.model, self.data) |
|
|
| reward = -0.01 if not self._is_stacked() else 10.0 |
| terminated = self._is_stacked() |
| truncated = False |
| obs = self._get_obs() |
| info = {"success": terminated} |
|
|
| if self.render_mode == "human" and self.viewer: |
| self.viewer.sync() |
|
|
| return obs, reward, terminated, truncated, info |
|
|
| def _get_obs(self): |
| block_pos = [self.data.body(bid).xpos[:3] if bid is not None else np.zeros(3) for bid in self.block_ids] |
| target_pos = self.data.body(self.target_zone_id).xpos[:3] if self.target_zone_id != -1 else np.zeros(3) |
| joint_pos = self.data.qpos[7:16] if self.nq > 7 else np.zeros(9) |
| |
| obs = np.concatenate([pos for pos in block_pos] + [target_pos] + [joint_pos]) |
| return obs.astype(np.float32) |
|
|
| def _is_stacked(self): |
| if not any(bid is not None for bid in self.block_ids) or self.target_zone_id == -1: |
| return False |
| |
| block_positions = [self.data.body(bid).xpos for bid in self.block_ids if bid is not None] |
| target_pos = self.data.body(self.target_zone_id).xpos |
| return all(np.linalg.norm(b[:2] - target_pos[:2]) < 0.05 for b in block_positions) |
|
|
| def close(self): |
| if self.viewer: |
| self.viewer.close() |
|
|
| if __name__ == "__main__": |
| import argparse |
| import time |
|
|
| parser = argparse.ArgumentParser() |
| parser.add_argument("--render_mode", default="human") |
| parser.add_argument("--fps", type=int, default=15, help="Frames per second") |
| args = parser.parse_args() |
|
|
| try: |
| env = StackingEnv(render_mode=args.render_mode) |
| obs, _ = env.reset() |
| print("Initial observation shape:", obs.shape) |
| print("Environment initialized successfully!") |
|
|
| if args.render_mode == "human": |
| print("Simulation started at", args.fps, "FPS. Use viewer 'Joint' or 'Control' tabs to adjust joints, with actuator 2 limited to 180-degree range (-90° to +90°).") |
| print("Press Ctrl+C to exit.") |
| step_delay = 1.0 / args.fps |
|
|
| try: |
| while env.viewer and env.viewer.is_running(): |
| mujoco.mj_step(env.model, env.data) |
| if env.render_mode == "human" and env.viewer: |
| env.viewer.sync() |
| time.sleep(step_delay) |
| except KeyboardInterrupt: |
| print("Stopped by user") |
| else: |
| print("Environment test completed successfully!") |
|
|
| except Exception as e: |
| print(f"Error: {e}") |
| print("\nTo debug this issue:") |
| print("1. Check stacking.xml for valid qpos or keyframe definitions") |
| print("2. Ensure qpos has exactly {env.model.nq} values") |
| print("3. Verify the joint structure in both XML files matches the code assumptions") |
|
|
| finally: |
| try: |
| env.close() |
| except: |
| pass |
