"""Single-episode demo collection and success checking for Task E.""" import numpy as np import torch from isaaclab.envs import ManagerBasedRLEnv from atec_rl_lab.utils import CartesianController from atec_rl_lab.tasks.task_e.env_cfg import ( TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z, BASKET_CENTER_X, BASKET_CENTER_Y, ) from .config import ( ACTION_SCALE, EE_BODY_NAME, GRIPPER_OPEN_POS, GRIPPER_CLOSE_POS, OBJ_GRIPPER_CLOSE_POS, RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z, DEFAULT_PLACE_QUAT_W, BASKET_IN_X, BASKET_IN_Y, OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Z, OBJ_SPAWN_Y_BANDS, OBJ_HALF_EXTENTS, OBJ_BBOX_MARGIN, OBJ_GRASP_CENTER_OFFSETS, OBJ_FINGER_CENTER_SERVO_STATES, OBJ_FINGER_CENTER_SERVO_GAIN, OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z, OBJ_FINGER_CENTER_SERVO_MAX_Z, WARMUP_STEPS, SETTLE_STEPS, ) from .state_machine import PickPlaceStateMachine def _rerandomize_objects(env: ManagerBasedRLEnv, rng: np.random.Generator) -> None: """Place each object randomly with AABB-based overlap rejection.""" placed: dict[int, tuple[float, float]] = {} # obj_idx -> (x, y) for obj_idx in [1, 2, 3]: obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] y_min, y_max = OBJ_SPAWN_Y_BANDS[obj_idx] hx, hy = OBJ_HALF_EXTENTS[obj_idx] x = y = None for _ in range(200): cx = float(rng.uniform(OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX)) cy = float(rng.uniform(y_min, y_max)) # AABB overlap check against all already-placed objects ok = all( abs(cx - px) >= hx + OBJ_HALF_EXTENTS[pi][0] + OBJ_BBOX_MARGIN or abs(cy - py) >= hy + OBJ_HALF_EXTENTS[pi][1] + OBJ_BBOX_MARGIN for pi, (px, py) in placed.items() ) if ok: x, y = cx, cy break if x is None: # fallback: band centre x = (OBJ_SPAWN_X_MIN + OBJ_SPAWN_X_MAX) / 2.0 y = (y_min + y_max) / 2.0 placed[obj_idx] = (x, y) state = obj.data.default_root_state[0:1].clone() state[0, 0] = x state[0, 1] = y state[0, 2] = OBJ_SPAWN_Z state[0, 7:] = 0.0 # zero velocities obj.write_root_state_to_sim(state) env.unwrapped.scene.write_data_to_sim() env.unwrapped.sim.forward() _BASKET_MAX_Z = TABLE_TOP_Z + 0.15 # keep aligned with Task-E reward/termination bounds def check_objects_in_basket(env: ManagerBasedRLEnv, pick_objects: list[int]) -> bool: """Return True only if every picked object is inside the basket region and settled.""" for obj_idx in pick_objects: pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] if (abs(pos[0].item() - BASKET_CENTER_X) > BASKET_IN_X or abs(pos[1].item() - BASKET_CENTER_Y) > BASKET_IN_Y or pos[2].item() > _BASKET_MAX_Z): return False return True def basket_status_lines(env: ManagerBasedRLEnv, pick_objects: list[int]) -> list[str]: """Return compact debug lines for picked objects against basket bounds.""" lines = [] for obj_idx in pick_objects: pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] dx = pos[0].item() - BASKET_CENTER_X dy = pos[1].item() - BASKET_CENTER_Y z = pos[2].item() inside = abs(dx) <= BASKET_IN_X and abs(dy) <= BASKET_IN_Y and TABLE_TOP_Z <= z <= _BASKET_MAX_Z lines.append( f"object_{obj_idx}: pos=({pos[0].item():.3f},{pos[1].item():.3f},{z:.3f}) " f"d=({dx:+.3f},{dy:+.3f}) inside={inside}" ) return lines def collect_one_demo( env: ManagerBasedRLEnv, robot, ik_ctrl: CartesianController, arm_ids: list[int], gripper_ids: list[int], pick_objects: list[int], device: str, default_jpos: torch.Tensor, rng: np.random.Generator, camera=None, trace: bool = False, abort_failed_lift: bool = False, ) -> dict | None: """Run one full episode and return recorded data, or None on early termination. Returns a dict with keys: qpos (T, 8) absolute joint positions qvel (T, 8) joint velocities ee_pos (T, 3) end-effector position (world frame) ee_quat (T, 4) end-effector quaternion (w,x,y,z) action (T, 8) env action = (joint_target - default_jpos) / ACTION_SCALE frames (T, H, W, 3) RGB uint8 — only present when camera is given """ env.reset() robot.write_joint_state_to_sim( robot.data.default_joint_pos, torch.zeros_like(robot.data.default_joint_vel), ) _rerandomize_objects(env, rng) # write new object positions to sim + sim.forward() default_jpos = robot.data.default_joint_pos.clone() ee_home = torch.tensor([[RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z]], dtype=torch.float32, device=device) eq_home = torch.tensor([DEFAULT_PLACE_QUAT_W], dtype=torch.float32, device=device) g_open = torch.tensor([GRIPPER_OPEN_POS], dtype=torch.float32, device=device) robot.update(dt=env.unwrapped.physics_dt) ik_ctrl.reset() # Warm-up: drive arm to HOME position (not recorded) for _ in range(WARMUP_STEPS): _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, ee_home, eq_home, g_open, default_jpos) # Pre-compute grasp quaternions from actual object orientations after reset sm = PickPlaceStateMachine(pick_objects, device) for obj_idx in pick_objects: obj_quat = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] \ .data.root_state_w[0, 3:7] sm.set_grasp_quat(obj_idx, obj_quat) # Settle for _ in range(SETTLE_STEPS): _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, ee_home, eq_home, g_open, default_jpos) ik_ctrl.reset() # ---- Recording loop ---- # qpos_buf, qvel_buf, ee_pos_buf, ee_quat_buf, action_buf = [], [], [], [], [] frames_buf = [] if camera is not None else None trace_stats: dict[str, dict] | None = {} if trace else None ee_body_idx = None finger_body_indices: tuple[int, int] | None = None ee_body_ids, _ = robot.find_bodies(EE_BODY_NAME) if len(ee_body_ids) > 0: ee_body_idx = int(ee_body_ids[0]) link7_ids, _ = robot.find_bodies("link7") link8_ids, _ = robot.find_bodies("link8") if len(link7_ids) > 0 and len(link8_ids) > 0: finger_body_indices = (int(link7_ids[0]), int(link8_ids[0])) def _finger_center() -> torch.Tensor | None: if finger_body_indices is None: return None f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach() f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach() return 0.5 * (f0 + f1) def _servo_target_to_fingers( state_name: str, obj_key: str, obj_pos: torch.Tensor, ee_pos_des: torch.Tensor, ) -> torch.Tensor: obj_idx = int(obj_key.rsplit("_", 1)[1]) if state_name not in OBJ_FINGER_CENTER_SERVO_STATES.get(obj_idx, ()): return ee_pos_des finger_center = _finger_center() if finger_center is None: return ee_pos_des grasp_offset = torch.tensor( OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)), dtype=torch.float32, device=device, ) grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos xy_error = finger_center[:2] - grasp_center[:2] err_norm = torch.linalg.norm(xy_error) if err_norm.item() > 0.18: return ee_pos_des gain = OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85) correction = -xy_error * gain max_xy = OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08) corr_norm = torch.linalg.norm(correction).clamp(min=1e-6) if corr_norm.item() > max_xy: correction = correction / corr_norm * max_xy ee_pos_des = ee_pos_des.clone() ee_pos_des[:2] = ee_pos_des[:2] + correction if state_name in ("REACH", "CLOSE") and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z: target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx] z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item()) max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02) z_correction = min(0.0, max(-max_z, z_error * gain)) ee_pos_des[2] = ee_pos_des[2] + z_correction return ee_pos_des def _update_trace(state_name: str, obj_key: str, obj_pos: torch.Tensor) -> None: if trace_stats is None: return obj_idx = int(obj_key.rsplit("_", 1)[1]) grasp_offset = torch.tensor( OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)), dtype=torch.float32, device=device, ) grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos if ee_body_idx is not None: ee_pos = robot.data.body_pos_w[0, ee_body_idx, :3].detach() else: ee_pos = ik_ctrl.ee_pos_w[0].detach() finger_center_dist = None finger_body_gap = None if finger_body_indices is not None: f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach() f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach() finger_center = 0.5 * (f0 + f1) finger_center_dist = float(torch.linalg.norm(grasp_center - finger_center).item()) finger_body_gap = float(torch.linalg.norm(f0 - f1).item()) finger_center_vec = [float(v) for v in (finger_center - grasp_center).detach().cpu().tolist()] else: finger_center_vec = None gripper_jpos = robot.data.joint_pos[0, gripper_ids].detach() gripper_gap = abs(float(gripper_jpos[0].item() - gripper_jpos[1].item())) ee_dist = float(torch.linalg.norm(obj_pos - ee_pos).item()) ee_vec = [float(v) for v in (ee_pos - obj_pos).detach().cpu().tolist()] obj_pos_cpu = [float(v) for v in obj_pos.detach().cpu().tolist()] obj_stats = trace_stats.setdefault( obj_key, { "initial_pos": obj_pos_cpu, "final_pos": obj_pos_cpu, "max_z": obj_pos_cpu[2], "min_ee_dist": ee_dist, "min_ee_vec": ee_vec, "min_gripper_gap": gripper_gap, "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0, "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None, "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0, "states": {}, }, ) obj_stats["final_pos"] = obj_pos_cpu obj_stats["max_z"] = max(float(obj_stats["max_z"]), obj_pos_cpu[2]) if ee_dist < float(obj_stats["min_ee_dist"]): obj_stats["min_ee_dist"] = ee_dist obj_stats["min_ee_vec"] = ee_vec obj_stats["min_gripper_gap"] = min(float(obj_stats["min_gripper_gap"]), gripper_gap) if finger_center_dist is not None: if finger_center_dist < float(obj_stats["min_finger_center_dist"]): obj_stats["min_finger_center_dist"] = finger_center_dist obj_stats["min_finger_center_vec"] = finger_center_vec if finger_body_gap is not None: obj_stats["min_finger_body_gap"] = min(float(obj_stats["min_finger_body_gap"]), finger_body_gap) st = obj_stats["states"].setdefault( state_name, { "steps": 0, "start_pos": obj_pos_cpu, "end_pos": obj_pos_cpu, "max_z": obj_pos_cpu[2], "min_ee_dist": ee_dist, "min_ee_vec": ee_vec, "min_gripper_gap": gripper_gap, "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0, "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None, "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0, }, ) st["steps"] += 1 st["end_pos"] = obj_pos_cpu st["max_z"] = max(float(st["max_z"]), obj_pos_cpu[2]) if ee_dist < float(st["min_ee_dist"]): st["min_ee_dist"] = ee_dist st["min_ee_vec"] = ee_vec st["min_gripper_gap"] = min(float(st["min_gripper_gap"]), gripper_gap) if finger_center_dist is not None: if finger_center_dist < float(st["min_finger_center_dist"]): st["min_finger_center_dist"] = finger_center_dist st["min_finger_center_vec"] = finger_center_vec if finger_body_gap is not None: st["min_finger_body_gap"] = min(float(st["min_finger_body_gap"]), finger_body_gap) def _gripper_target_values(obj_key: str, gripper_cmd: str) -> list[float]: if gripper_cmd == "open": return GRIPPER_OPEN_POS obj_idx = int(obj_key.rsplit("_", 1)[1]) return OBJ_GRIPPER_CLOSE_POS.get(obj_idx, GRIPPER_CLOSE_POS) while not sm.done: state_name = sm.state obj_key = sm.current_object_key obj_pos_w = env.unwrapped.scene.rigid_objects[sm.current_object_key] \ .data.root_pos_w[0].clone() ee_pos_des, ee_quat_des, gripper_cmd = sm.tick(obj_pos_w) ee_pos_des = _servo_target_to_fingers(state_name, obj_key, obj_pos_w, ee_pos_des) arm_jpos_des = ik_ctrl.compute(ee_pos_des.unsqueeze(0), ee_quat_des.unsqueeze(0)) gripper_vals = _gripper_target_values(obj_key, gripper_cmd) gripper_target = torch.tensor([gripper_vals], dtype=torch.float32, device=device) full_target = robot.data.joint_pos.clone() full_target[:, arm_ids] = arm_jpos_des full_target[:, gripper_ids] = gripper_target env_action = (full_target - default_jpos) / ACTION_SCALE # Record BEFORE stepping (obs at time t, action at time t) qpos_buf.append(robot.data.joint_pos[0].cpu().numpy()) qvel_buf.append(robot.data.joint_vel[0].cpu().numpy()) ee_pos_buf.append(ik_ctrl.ee_pos_w[0].cpu().numpy()) ee_quat_buf.append(ik_ctrl.ee_quat_w[0].cpu().numpy()) action_buf.append(env_action[0].cpu().numpy()) if frames_buf is not None: rgba = camera.data.output["rgb"][0].cpu().numpy() frames_buf.append(rgba[:, :, :3]) _update_trace(state_name, obj_key, obj_pos_w) _, _, terminated, truncated, _ = env.step(env_action) if abort_failed_lift and state_name == "LIFT" and sm.state != "LIFT": final_obj_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0] lift_gain = float((final_obj_pos[2] - obj_pos_w[2]).item()) trace_gain = None if trace_stats is not None and obj_key in trace_stats: obj_stats = trace_stats[obj_key] trace_gain = float(obj_stats["max_z"] - obj_stats["initial_pos"][2]) effective_gain = max(lift_gain, trace_gain if trace_gain is not None else lift_gain) if effective_gain < 0.035: print( f"[WARN] {obj_key} failed lift gate " f"(z_gain={effective_gain:.3f}) - aborting attempt." ) return None if terminated.any() or truncated.any(): if check_objects_in_basket(env, pick_objects): print("[INFO] Episode ended after basket success; keeping demo.") break print("[WARN] Episode ended early — skipping demo.") return None result = { "qpos": np.stack(qpos_buf), "qvel": np.stack(qvel_buf), "ee_pos": np.stack(ee_pos_buf), "ee_quat": np.stack(ee_quat_buf), "action": np.stack(action_buf), } if frames_buf is not None: result["frames"] = np.stack(frames_buf) if trace_stats is not None: for obj_idx in pick_objects: obj_key = f"object_{obj_idx}" if obj_key not in trace_stats: continue final_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0] final_pos_cpu = [float(v) for v in final_pos.detach().cpu().tolist()] obj_stats = trace_stats[obj_key] obj_stats["final_pos"] = final_pos_cpu obj_stats["z_gain"] = float(obj_stats["max_z"] - obj_stats["initial_pos"][2]) obj_stats["lifted"] = bool(obj_stats["z_gain"] >= 0.035) obj_stats["reward_lifted"] = bool(obj_stats["max_z"] >= TABLE_TOP_Z + 0.15) obj_stats["basket_inside"] = check_objects_in_basket(env, [obj_idx]) result["trace"] = trace_stats return result # ------------------------------------------------------------------ # # Internal helper # ------------------------------------------------------------------ # def _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, ee_pos, ee_quat, gripper_target, default_jpos): """Single IK step toward a target pose (utility used during warm-up/settle).""" arm_des = ik_ctrl.compute(ee_pos, ee_quat) tgt = robot.data.joint_pos.clone() tgt[:, arm_ids] = arm_des tgt[:, gripper_ids] = gripper_target env.step((tgt - default_jpos) / ACTION_SCALE) robot.update(dt=env.unwrapped.physics_dt)