"""Smoke-test a GraspNet-guided Task-E pick-and-place primitive. This is intentionally separate from ACT training. It tests whether TunTunClaw GraspNet can produce a usable grasp centre/yaw from Task-E RGB-D observations. """ from __future__ import annotations import argparse import os import subprocess import sys from pathlib import Path import json REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) from isaaclab.app import AppLauncher parser = argparse.ArgumentParser(description="Run one Task-E grasp-guided pick trial.") parser.add_argument("--grasp_provider", choices=["graspnet", "anygrasp", "pca"], default="graspnet") parser.add_argument("--object", type=int, default=1, choices=[1, 2, 3]) parser.add_argument("--seed", type=int, default=7) parser.add_argument("--video_path", default="logs/videos/task_e_graspnet/graspnet_pick_obj1.mp4") parser.add_argument("--tcp_z_offset", type=float, default=0.055) parser.add_argument("--close_z_offset", type=float, default=None) parser.add_argument("--pregrasp_z", type=float, default=0.30) parser.add_argument("--lift_z", type=float, default=0.30) parser.add_argument("--place_z", type=float, default=0.18) parser.add_argument("--release_z", type=float, default=0.32) parser.add_argument("--open_release_z", type=float, default=None) parser.add_argument("--place_x_offset", type=float, default=0.0) parser.add_argument("--place_y_offset", type=float, default=0.0) parser.add_argument("--basket_center_release", action=argparse.BooleanOptionalAction, default=True) parser.add_argument("--basket_servo_gain", type=float, default=1.0) parser.add_argument("--basket_servo_max_xy", type=float, default=0.30) parser.add_argument("--staged_transport", action=argparse.BooleanOptionalAction, default=True) parser.add_argument("--transport_servo_fraction", type=float, default=0.25) parser.add_argument("--basket_xy_tol", type=float, default=0.055) parser.add_argument("--basket_hold_steps", type=int, default=900) parser.add_argument("--basket_stable_steps", type=int, default=80) parser.add_argument("--basket_recovery_steps", type=int, default=900) parser.add_argument("--dynamic_finger_servo", action=argparse.BooleanOptionalAction, default=True) parser.add_argument("--close_steps", type=int, default=70) parser.add_argument("--preclose_insert_steps", type=int, default=0) parser.add_argument("--preclose_insert_dx", type=float, default=0.0) parser.add_argument("--preclose_insert_dy", type=float, default=0.0) parser.add_argument("--move_steps", type=int, default=160) parser.add_argument("--transport_steps", type=int, default=None) parser.add_argument("--place_steps", type=int, default=None) parser.add_argument("--settle_steps", type=int, default=120) parser.add_argument("--force_default_quat", action="store_true") parser.add_argument("--use_task_quat", action="store_true") parser.add_argument("--no_finger_servo", action="store_true") parser.add_argument("--no_object_offset", action="store_true") parser.add_argument("--post_push", action="store_true") parser.add_argument("--auto_table_push_on_slip", action=argparse.BooleanOptionalAction, default=True) parser.add_argument("--post_push_steps", type=int, default=600) parser.add_argument("--post_push_behind", type=float, default=0.075) parser.add_argument("--post_push_z", type=float, default=0.055) parser.add_argument("--drag_recovery_steps", type=int, default=1200) parser.add_argument("--mask_provider", choices=["oracle", "band", "sam3"], default="oracle") parser.add_argument( "--sam3_python", default="/home/ubuntu/Documents/01Proj/sam3d_gs/.venv/bin/python", help="Python executable for the isolated SAM3 environment.", ) parser.add_argument("--sam3_threshold", type=float, default=0.35) parser.add_argument("--sam3_mask_threshold", type=float, default=0.5) parser.add_argument( "--sam3_prompt", action="append", default=None, help="SAM3 text prompt. Can repeat. Defaults are selected from --object.", ) parser.add_argument("--save_debug_npz", default="logs/graspnet_task_e/latest_debug.npz") AppLauncher.add_app_launcher_args(parser) args_cli = parser.parse_args() args_cli.enable_cameras = True app_launcher = AppLauncher(args_cli) simulation_app = app_launcher.app import imageio.v2 as imageio import numpy as np import torch from isaaclab.actuators import ImplicitActuatorCfg from isaaclab.envs import ManagerBasedRLEnv from atec_rl_lab.tasks.task_e.env_cfg import ( BASKET_CENTER_X, BASKET_CENTER_Y, TABLE_TOP_Z, TaskEEnvPiperCfg, ) from atec_rl_lab.utils import CartesianController from scripts.act.task_e.collector import basket_status_lines, check_objects_in_basket from scripts.act.task_e.config import ( ACTION_SCALE, ACT_DAMPING, ACT_EFFORT_LIMIT, ACT_STIFFNESS, ACT_VEL_LIMIT, ARM_JOINT_NAMES, CARRY_Z, DEFAULT_PLACE_QUAT_W, EE_BODY_NAME, GRIPPER_CLOSE_POS, GRIPPER_JOINT_NAMES, GRIPPER_OPEN_POS, OBJ_GRASP_CENTER_OFFSETS, OBJ_GRASP_Z_OFFSETS, OBJ_CLOSE_Z_OFFSETS, OBJ_FINGER_CENTER_SERVO_GAIN, OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z, OBJ_FINGER_CENTER_SERVO_MAX_Z, RETRACT_POS_X, RETRACT_POS_Y, ) from scripts.act.task_e.state_machine import compute_grasp_quat from scripts.graspnet_task_e.tuntun_adapter import ( camera_arrays, infer_grasp_from_camera, oracle_object_mask, rgbd_band_object_mask, pos_to_torch, quat_wxyz_to_torch, ) from scripts.graspnet_task_e.anygrasp_adapter import infer_anygrasp_from_camera from scripts.graspnet_task_e.pca_aabb_adapter import infer_pca_aabb_from_camera GRASPNET_CLOSE_Z_DEFAULTS = { 3: -0.005, } SAM_MASK_P85_Z_MAX = { 1: TABLE_TOP_Z + 0.13, 2: TABLE_TOP_Z + 0.19, 3: TABLE_TOP_Z + 0.085, } def build_env() -> ManagerBasedRLEnv: cfg = TaskEEnvPiperCfg() cfg.seed = args_cli.seed cfg.scene.num_envs = 1 cfg.episode_length_s = 90.0 cfg.scene.robot.actuators["default"] = ImplicitActuatorCfg( joint_names_expr=[".*"], effort_limit=ACT_EFFORT_LIMIT, velocity_limit=ACT_VEL_LIMIT, stiffness=ACT_STIFFNESS, damping=ACT_DAMPING, ) return ManagerBasedRLEnv(cfg) def step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pos_w, quat_w, gripper, frames, camera, n_steps, *, obj_idx: int | None = None, obj=None, finger_body_indices: tuple[int, int] | None = None, servo_center_xy: np.ndarray | None = None, servo_current_object_xy: bool = False, finger_target_xy: np.ndarray | None = None, finger_target_z: float | None = None, finger_servo_gain: float = 1.0, finger_servo_max_xy: float = 0.12, finger_servo_max_z: float = 0.04, object_target_xy: np.ndarray | None = None, object_servo_gain: float = 1.0, object_servo_max_xy: float = 0.30, ) -> dict[str, float | list[float] | None]: dev = env.unwrapped.device pos_np = np.asarray(pos_w, dtype=np.float64) quat_t = quat_wxyz_to_torch(np.asarray(quat_w, dtype=np.float64), dev) grip_t = torch.tensor([gripper], dtype=torch.float32, device=dev) stats: dict[str, float | list[float] | None] = { "min_finger_dist": None, "min_finger_vec": None, "min_finger_gap": None, "min_finger_q": None, "last_finger_q": None, } for _ in range(n_steps): target_np = pos_np.copy() if obj is not None and object_target_xy is not None: obj_pos = obj.data.root_pos_w[0].detach() target_xy = torch.tensor(object_target_xy, dtype=torch.float32, device=dev) xy_error = target_xy - obj_pos[:2] correction = xy_error * object_servo_gain corr_norm = torch.linalg.norm(correction).clamp(min=1e-6) if corr_norm.item() > object_servo_max_xy: correction = correction / corr_norm * object_servo_max_xy target_np[:2] = target_np[:2] + correction.detach().cpu().numpy() if finger_body_indices is not None and not args_cli.no_finger_servo and ( finger_target_xy is not None or (obj_idx is not None and obj is not None and servo_center_xy 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) obj_pos = obj.data.root_pos_w[0].detach() if obj is not None else None if finger_target_xy is not None: target_xy = torch.tensor(finger_target_xy, dtype=torch.float32, device=dev) elif servo_current_object_xy and obj_pos is not None: target_xy = obj_pos[:2] else: target_xy = torch.tensor(servo_center_xy, dtype=torch.float32, device=dev) grasp_center = torch.tensor( [ float(target_xy[0].item()), float(target_xy[1].item()), float(obj_pos[2].item()) if obj_pos is not None else float(finger_center[2].item()), ], dtype=torch.float32, device=dev, ) finger_vec = finger_center - grasp_center finger_dist = float(torch.linalg.norm(finger_vec).item()) finger_gap = float(torch.linalg.norm(f0 - f1).item()) if stats["min_finger_dist"] is None or finger_dist < float(stats["min_finger_dist"]): stats["min_finger_dist"] = finger_dist stats["min_finger_vec"] = [float(v) for v in finger_vec.detach().cpu().tolist()] if stats["min_finger_gap"] is None or finger_gap < float(stats["min_finger_gap"]): stats["min_finger_gap"] = finger_gap q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy() stats["min_finger_q"] = [float(q[0]), float(q[1])] q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy() stats["last_finger_q"] = [float(q[0]), float(q[1])] xy_error = finger_center[:2] - target_xy if finger_target_xy is not None or servo_current_object_xy or torch.linalg.norm(xy_error).item() <= 0.18: gain = finger_servo_gain if finger_target_xy is not None else OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85) correction = -xy_error * gain max_xy = finger_servo_max_xy if finger_target_xy is not None else 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 target_np[:2] = target_np[:2] + correction.detach().cpu().numpy() if finger_target_z is not None: z_error = finger_target_z - float(finger_center[2].item()) z_correction = max(-finger_servo_max_z, min(finger_servo_max_z, z_error * gain)) target_np[2] = target_np[2] + z_correction elif obj_pos is not None 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)) target_np[2] = target_np[2] + z_correction pos_t = pos_to_torch(target_np, dev) arm_des = ik_ctrl.compute(pos_t, quat_t) target = robot.data.joint_pos.clone() target[:, arm_ids] = arm_des target[:, gripper_ids] = grip_t action = (target - default_jpos) / ACTION_SCALE env.step(action) robot.update(dt=env.unwrapped.physics_dt) if frames is not None: rgba = camera.data.output["rgb"][0].detach().cpu().numpy() frames.append(rgba[..., :3]) return stats def step_until_object_center_stable( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pos_w, quat_w, gripper, frames, camera, *, obj, target_xy: np.ndarray, xy_tol: float, stable_steps: int, max_steps: int, object_servo_gain: float, object_servo_max_xy: float, obj_idx: int | None = None, finger_body_indices: tuple[int, int] | None = None, servo_center_xy: np.ndarray | None = None, servo_current_object_xy: bool = True, ) -> dict[str, float | int | list[float]]: stable = 0 min_xy_err = 999.0 last_obj_pos = None for step in range(max_steps): step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pos_w, quat_w, gripper, frames, camera, 1, obj_idx=obj_idx, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=servo_current_object_xy, object_target_xy=target_xy, object_servo_gain=object_servo_gain, object_servo_max_xy=object_servo_max_xy, ) obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) last_obj_pos = obj_pos xy_err = float(np.linalg.norm(obj_pos[:2] - target_xy)) min_xy_err = min(min_xy_err, xy_err) if xy_err <= xy_tol: stable += 1 if stable >= stable_steps: break else: stable = 0 if last_obj_pos is None: last_obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) return { "steps": step + 1 if max_steps > 0 else 0, "stable": stable, "min_xy_err": min_xy_err, "final_xy_err": float(np.linalg.norm(last_obj_pos[:2] - target_xy)), "final_obj_pos": [float(v) for v in last_obj_pos.tolist()], } def sam3_prompts_for_object(obj_idx: int) -> list[str]: defaults = { 1: ["sugar box", "box", "rectangular object"], 2: ["mustard bottle", "bottle", "yellow bottle"], 3: ["banana", "curved yellow object"], } return defaults.get(obj_idx, ["object"]) def select_sam_candidate_by_world_band(candidates_path: Path, camera, obj_idx: int) -> np.ndarray | None: from scipy.spatial.transform import Rotation from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS if not candidates_path.exists(): return None data = np.load(candidates_path, allow_pickle=False) masks = data["masks"].astype(bool) metas = json.loads(str(data["metas"])) _rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) rot_w_cam = Rotation.from_quat( [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] ).as_matrix() y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx] scored = [] for idx, mask in enumerate(masks): valid = mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) ys, xs = np.where(valid) if len(xs) < 64: continue z = depth[ys, xs].astype(np.float64) x_cam = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z y_cam = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z pts_cam = np.stack([x_cam, y_cam, z], axis=1) pts_w = (rot_w_cam @ pts_cam.T).T + pos_w keep = ( (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.10) & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.10) & (pts_w[:, 1] >= y0 - 0.08) & (pts_w[:, 1] <= y1 + 0.08) & (pts_w[:, 2] >= TABLE_TOP_Z + 0.005) & (pts_w[:, 2] <= TABLE_TOP_Z + 0.26) ) band_count = int(np.count_nonzero(keep)) band_ratio = band_count / max(len(xs), 1) if band_count < 64: continue band_pts = pts_w[keep] p85_z = float(np.percentile(band_pts[:, 2], 85)) if p85_z > SAM_MASK_P85_Z_MAX.get(obj_idx, TABLE_TOP_Z + 0.18): continue score = float(metas[idx].get("score", 0.0)) # Prefer masks that live in the object's legal spawn band. Score is # secondary because open-vocabulary prompts can rate distractors high. scored.append((band_ratio, band_count, score, -p85_z, idx, keep, ys, xs)) if not scored: print("[SAM3] no candidate survived world-band filter; using best SAM3 mask") return None band_ratio, band_count, score, neg_p85_z, idx, keep, ys, xs = max(scored, key=lambda x: (x[1], x[0], x[2], x[3])) refined = np.zeros_like(masks[idx], dtype=np.bool_) refined[ys[keep], xs[keep]] = True meta = metas[idx] print( f"[SAM3] selected_candidate={idx} prompt={meta.get('prompt')} score={score:.3f} " f"band_ratio={band_ratio:.3f} band_pixels={band_count} p85_z={-neg_p85_z:.3f}" ) return refined def sam3_object_mask(camera, rgb: np.ndarray, obj_idx: int, debug_dir: Path) -> np.ndarray: if not Path(args_cli.sam3_python).exists(): raise RuntimeError(f"SAM3 python not found: {args_cli.sam3_python}") debug_dir.mkdir(parents=True, exist_ok=True) image_path = debug_dir / f"sam3_obj{obj_idx}_rgb.png" mask_path = debug_dir / f"sam3_obj{obj_idx}_mask.npy" meta_path = debug_dir / f"sam3_obj{obj_idx}_meta.json" candidates_path = debug_dir / f"sam3_obj{obj_idx}_candidates.npz" imageio.imwrite(str(image_path), rgb.astype(np.uint8)) prompts = args_cli.sam3_prompt or sam3_prompts_for_object(obj_idx) cmd = [ args_cli.sam3_python, str(Path(__file__).with_name("sam3_segment_image.py")), "--image", str(image_path), "--out_mask", str(mask_path), "--out_meta", str(meta_path), "--out_candidates", str(candidates_path), "--threshold", str(args_cli.sam3_threshold), "--mask_threshold", str(args_cli.sam3_mask_threshold), ] for prompt in prompts: cmd.extend(["--prompt", prompt]) print(f"[SAM3] prompts={prompts} image={image_path}") subprocess.run(cmd, check=True) mask = np.load(mask_path).astype(bool) if candidates_path.exists(): refined = select_sam_candidate_by_world_band(candidates_path, camera=camera, obj_idx=obj_idx) if refined is not None: mask = refined np.save(mask_path, mask.astype(np.bool_)) print(f"[SAM3] mask_pixels={int(mask.sum())} meta={meta_path}") return mask def object_z_gain(env, obj_idx: int, z0: float) -> float: pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] return float(pos[2].item() - z0) def run_table_push_recovery( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, topdown_quat, finger_body_indices: tuple[int, int] | None, ) -> None: cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) push_z = TABLE_TOP_Z + args_cli.post_push_z behind = args_cli.post_push_behind # Approach from the positive-Y side and push toward the basket center. This # is the deterministic fallback when the object has slipped back to the table. push_start = np.array([cur[0], cur[1] + behind, push_z], dtype=np.float64) push_mid = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind, push_z], dtype=np.float64) push_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind * 0.20, push_z], dtype=np.float64) print( f"[TABLE_PUSH] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) " f"start=({push_start[0]:.3f},{push_start[1]:.3f},{push_start[2]:.3f}) " f"mid=({push_mid[0]:.3f},{push_mid[1]:.3f},{push_mid[2]:.3f}) " f"end=({push_end[0]:.3f},{push_end[1]:.3f},{push_end[2]:.3f})" ) contact_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, 80, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_mid, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_mid[:2], finger_target_z=contact_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_end[:2], finger_target_z=contact_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80) def run_closed_drag_recovery( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, quat_w, finger_body_indices: tuple[int, int] | None, ) -> None: cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) drag_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025) # Keep the gripper closed and continue from the current contact region. # The intermediate target stays slightly behind the basket center so the # object is swept into the success box instead of being abandoned early. drag_start = np.array([cur[0], cur[1], drag_z], dtype=np.float64) drag_mid = np.array([BASKET_CENTER_X, (cur[1] + BASKET_CENTER_Y) * 0.5, drag_z], dtype=np.float64) drag_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y, drag_z], dtype=np.float64) print( f"[CLOSED_DRAG] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) " f"start=({drag_start[0]:.3f},{drag_start[1]:.3f},{drag_start[2]:.3f}) " f"mid=({drag_mid[0]:.3f},{drag_mid[1]:.3f},{drag_mid[2]:.3f}) " f"end=({drag_end[0]:.3f},{drag_end[1]:.3f},{drag_end[2]:.3f})" ) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_start, quat_w, GRIPPER_CLOSE_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=drag_start[:2], finger_target_z=drag_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_mid, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_mid[:2], finger_target_z=drag_z) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_end, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_end[:2], finger_target_z=drag_z) def main() -> None: env = build_env() dev = env.unwrapped.device env.reset() robot = env.unwrapped.scene.articulations["robot"] robot.write_joint_state_to_sim(robot.data.default_joint_pos, torch.zeros_like(robot.data.default_joint_vel)) default_jpos = robot.data.default_joint_pos.clone() arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES) gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES) link7_ids, _ = robot.find_bodies("link7") link8_ids, _ = robot.find_bodies("link8") finger_body_indices = None if len(link7_ids) > 0 and len(link8_ids) > 0: finger_body_indices = (int(link7_ids[0]), int(link8_ids[0])) camera = env.unwrapped.scene["video_cam"] ik_ctrl = CartesianController( robot=robot, ee_body_name=EE_BODY_NAME, arm_joint_names=ARM_JOINT_NAMES, num_envs=1, device=dev, command_type="pose", lambda_val=0.05, max_joint_delta=0.18, ) ik_ctrl.reset() frames: list[np.ndarray] = [] home = np.array([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], dtype=np.float64) topdown_quat = np.asarray(DEFAULT_PLACE_QUAT_W, dtype=np.float64) for _ in range(2): step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80) obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"] obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) debug_dir = Path(args_cli.save_debug_npz).with_suffix("") if args_cli.mask_provider == "band": mask = rgbd_band_object_mask(camera, args_cli.object) elif args_cli.mask_provider == "sam3": mask = sam3_object_mask(camera, rgb, args_cli.object, debug_dir) else: mask = oracle_object_mask(env, camera, args_cli.object) Path(args_cli.save_debug_npz).parent.mkdir(parents=True, exist_ok=True) np.savez_compressed( args_cli.save_debug_npz, rgb=rgb, depth=depth, mask=mask, K=K, camera_pos_w=pos_w, camera_quat_wxyz_ros=quat_wxyz_ros, object_initial=obj_initial, ) if args_cli.grasp_provider == "anygrasp": grasp = infer_anygrasp_from_camera(camera, mask) elif args_cli.grasp_provider == "pca": grasp = infer_pca_aabb_from_camera(camera, mask, object_index=args_cli.object) else: grasp = infer_grasp_from_camera(camera, mask) print( f"[GRASP] provider={args_cli.grasp_provider} obj={args_cli.object} " f"score={grasp.score:.4f} width={grasp.width:.4f} " f"t_w=({grasp.translation_w[0]:.3f},{grasp.translation_w[1]:.3f},{grasp.translation_w[2]:.3f})" ) pick_xy = grasp.translation_w[:2].copy() if not args_cli.no_object_offset: pick_xy += np.asarray(OBJ_GRASP_CENTER_OFFSETS.get(args_cli.object, (0.0, 0.0, 0.0))[:2], dtype=np.float64) grasp_z = max(float(grasp.translation_w[2] + args_cli.tcp_z_offset), TABLE_TOP_Z + 0.055) close_offset = ( GRASPNET_CLOSE_Z_DEFAULTS.get( args_cli.object, OBJ_CLOSE_Z_OFFSETS.get(args_cli.object, OBJ_GRASP_Z_OFFSETS.get(args_cli.object, args_cli.tcp_z_offset)), ) if args_cli.close_z_offset is None else args_cli.close_z_offset ) close_z = max(float(obj_initial[2] + close_offset), TABLE_TOP_Z + 0.030) if args_cli.force_default_quat: grasp_quat = topdown_quat elif args_cli.use_task_quat: grasp_quat = compute_grasp_quat(obj.data.root_quat_w[0], dev).detach().cpu().numpy().astype(np.float64) else: grasp_quat = grasp.quat_wxyz_w pre = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.pregrasp_z], dtype=np.float64) reach = np.array([pick_xy[0], pick_xy[1], grasp_z], dtype=np.float64) close = np.array([pick_xy[0], pick_xy[1], close_z], dtype=np.float64) lift = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.lift_z], dtype=np.float64) place = np.array( [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.place_z], dtype=np.float64, ) release = np.array( [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.release_z], dtype=np.float64, ) open_release = release.copy() if args_cli.open_release_z is not None: open_release[2] = TABLE_TOP_Z + float(args_cli.open_release_z) basket_target_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64) transport_steps = args_cli.transport_steps if args_cli.transport_steps is not None else args_cli.move_steps place_steps = args_cli.place_steps if args_cli.place_steps is not None else args_cli.move_steps print( f"[PLAN] pick=({pick_xy[0]:.3f},{pick_xy[1]:.3f}) " f"reach_z={reach[2]:.3f} close_z={close[2]:.3f} lift_z={lift[2]:.3f} " f"place=({place[0]:.3f},{place[1]:.3f},{place[2]:.3f}) " f"release=({release[0]:.3f},{release[1]:.3f},{release[2]:.3f}) " f"open_release=({open_release[0]:.3f},{open_release[1]:.3f},{open_release[2]:.3f}) " f"transport_steps={transport_steps} place_steps={place_steps} " f"quat=({grasp_quat[0]:.3f},{grasp_quat[1]:.3f},{grasp_quat[2]:.3f},{grasp_quat[3]:.3f})" ) servo_center_xy = pick_xy.astype(np.float64) close_servo_xy = servo_center_xy.copy() if args_cli.preclose_insert_steps > 0: close_servo_xy = close_servo_xy + np.array( [args_cli.preclose_insert_dx, args_cli.preclose_insert_dy], dtype=np.float64, ) print( f"[PRECLOSE_INSERT] steps={args_cli.preclose_insert_steps} " f"finger_target=({close_servo_xy[0]:.3f},{close_servo_xy[1]:.3f}) " f"offset=({args_cli.preclose_insert_dx:+.3f},{args_cli.preclose_insert_dy:+.3f})" ) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pre, grasp_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.move_steps) reach_stats = step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, reach, grasp_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, ) insert_stats = None if args_cli.preclose_insert_steps > 0: insert_stats = step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.preclose_insert_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, finger_target_xy=close_servo_xy, finger_target_z=close[2], finger_servo_gain=1.0, finger_servo_max_xy=0.16, finger_servo_max_z=0.04, ) close_stats = step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_CLOSE_POS, frames, camera, args_cli.close_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy, ) z_gain_close = object_z_gain(env, args_cli.object, float(obj_initial[2])) lift_stats = step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, lift, grasp_quat, GRIPPER_CLOSE_POS, frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy, ) z_gain_lift = object_z_gain(env, args_cli.object, float(obj_initial[2])) place_quat = grasp_quat if args_cli.object in (1, 2) else topdown_quat place_servo_xy = basket_target_xy if args_cli.basket_center_release else None release_stable = True if args_cli.staged_transport and transport_steps >= 3: servo_steps = int(round(transport_steps * max(0.0, min(1.0, args_cli.transport_servo_fraction)))) servo_steps = min(max(servo_steps, 1 if place_servo_xy is not None else 0), max(transport_steps - 2, 0)) carry_steps = max(transport_steps - servo_steps, 2) first_steps = max(carry_steps // 2, 1) second_steps = max(carry_steps - first_steps, 1) mid = np.array( [ (lift[0] + release[0]) * 0.5, (lift[1] + release[1]) * 0.5, max(lift[2], release[2]), ], dtype=np.float64, ) print( f"[TRANSPORT] staged first={first_steps} second={second_steps} servo={servo_steps} " f"mid=({mid[0]:.3f},{mid[1]:.3f},{mid[2]:.3f})" ) step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, mid, place_quat, GRIPPER_CLOSE_POS, frames, camera, first_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, ) step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, frames, camera, second_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, ) if servo_steps > 0: step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, frames, camera, servo_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, object_target_xy=place_servo_xy, object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, ) else: step_pose( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, frames, camera, transport_steps, obj_idx=args_cli.object, obj=obj, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, object_target_xy=place_servo_xy, object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, ) transport_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) transport_xy_err = float(np.linalg.norm(transport_pos[:2] - basket_target_xy)) print( f"[TRANSPORT_END] obj=({transport_pos[0]:.3f},{transport_pos[1]:.3f},{transport_pos[2]:.3f}) " f"xy_err={transport_xy_err:.3f} lifted_z_gain={transport_pos[2] - obj_initial[2]:.3f}" ) hold_stats = None if place_servo_xy is not None: hold_stats = step_until_object_center_stable( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, frames, camera, obj=obj, target_xy=place_servo_xy, xy_tol=args_cli.basket_xy_tol, stable_steps=args_cli.basket_stable_steps, max_steps=args_cli.basket_hold_steps, object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, obj_idx=args_cli.object, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, ) print(f"[BASKET_HOLD] {hold_stats}") if int(hold_stats["stable"]) < args_cli.basket_stable_steps: print("[BASKET_HOLD] not stable; keeping gripper closed and running recovery servo before release") hold_stats = step_until_object_center_stable( env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, place, place_quat, GRIPPER_CLOSE_POS, frames, camera, obj=obj, target_xy=place_servo_xy, xy_tol=args_cli.basket_xy_tol, stable_steps=args_cli.basket_stable_steps, max_steps=args_cli.basket_recovery_steps, object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, obj_idx=args_cli.object, finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, servo_current_object_xy=args_cli.dynamic_finger_servo, ) print(f"[BASKET_RECOVERY] {hold_stats}") if int(hold_stats["stable"]) < args_cli.basket_stable_steps: print("[BASKET_HOLD] still not stable; skipping open release to avoid early drop") place_steps = 0 release_stable = False open_target = open_release if args_cli.open_release_z is not None else release if args_cli.open_release_z is not None: step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 120) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 60) if place_steps > 0: step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_OPEN_POS, frames, camera, place_steps) slipped_to_table = float(obj.data.root_pos_w[0, 2].item()) <= TABLE_TOP_Z + 0.08 need_push = not check_objects_in_basket(env, [args_cli.object]) and ( args_cli.post_push or (args_cli.auto_table_push_on_slip and (slipped_to_table or not release_stable)) ) if need_push: run_closed_drag_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, place_quat, finger_body_indices) if not check_objects_in_basket(env, [args_cli.object]): run_table_push_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, topdown_quat, finger_body_indices) step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.settle_steps) final_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) inside = check_objects_in_basket(env, [args_cli.object]) print( f"[RESULT] obj={args_cli.object} inside={inside} " f"z_gain_close={z_gain_close:.3f} z_gain_lift={z_gain_lift:.3f} " f"final=({final_pos[0]:.3f},{final_pos[1]:.3f},{final_pos[2]:.3f})" ) print(f"[TRACE] reach={reach_stats} insert={insert_stats} close={close_stats} lift={lift_stats}") for line in basket_status_lines(env, [args_cli.object]): print(f"[BASKET] {line}") video_path = Path(args_cli.video_path) video_path.parent.mkdir(parents=True, exist_ok=True) if frames: imageio.mimwrite(str(video_path), frames, fps=50, quality=7) print(f"[VIDEO] {video_path.resolve()}") env.close() if __name__ == "__main__": try: main() finally: simulation_app.close()