"""Small Task-E bridge around the TunTunClaw GraspNet API. The GraspNet model predicts grasps in the camera/ROS frame. Task E executes a top-down Piper grasp in world frame, so this adapter intentionally uses GraspNet for the contact centre and jaw yaw, then forces a stable top-down orientation for the Piper gripper. """ from __future__ import annotations from dataclasses import dataclass from functools import lru_cache from pathlib import Path import os import sys import numpy as np import torch from scipy.spatial.transform import Rotation REPO_ROOT = Path(__file__).resolve().parents[2] TUNTUN_ROOT = REPO_ROOT / "third_party" / "tuntunclaw" GRASPNET_ROOT = TUNTUN_ROOT / "graspnet-baseline" CHECKPOINT_PATH = TUNTUN_ROOT / "temp" / "logs" / "log_rs" / "checkpoint-rs.tar" def _ensure_tuntun_paths() -> None: paths = [ GRASPNET_ROOT / "models", GRASPNET_ROOT / "dataset", GRASPNET_ROOT / "utils", GRASPNET_ROOT / "graspnetAPI", TUNTUN_ROOT / "manipulator_grasp", ] for path in paths: p = str(path) if p not in sys.path: sys.path.insert(0, p) @dataclass(frozen=True) class TaskEGrasp: translation_w: np.ndarray quat_wxyz_w: np.ndarray score: float width: float raw_translation_cam: np.ndarray def camera_arrays(camera) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: """Return RGB, depth, K, camera position and ROS-frame quaternion.""" rgb = camera.data.output["rgb"][0].detach().cpu().numpy()[..., :3] depth = camera.data.output["depth"][0].detach().cpu().numpy() if depth.ndim == 3: depth = depth[..., 0] K = camera.data.intrinsic_matrices[0].detach().cpu().numpy() pos_w = camera.data.pos_w[0].detach().cpu().numpy() quat_wxyz_ros = camera.data.quat_w_ros[0].detach().cpu().numpy() return rgb, depth.astype(np.float32), K.astype(np.float32), pos_w.astype(np.float64), quat_wxyz_ros.astype(np.float64) def project_world_points_to_image(points_w: np.ndarray, K: np.ndarray, pos_w: np.ndarray, quat_wxyz_ros: np.ndarray) -> np.ndarray: """Project world points into a ROS camera image.""" rot_w_cam = Rotation.from_quat( [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] ).as_matrix() pts_cam = (rot_w_cam.T @ (points_w - pos_w).T).T z = np.clip(pts_cam[:, 2], 1e-6, None) u = K[0, 0] * pts_cam[:, 0] / z + K[0, 2] v = K[1, 1] * pts_cam[:, 1] / z + K[1, 2] return np.stack([u, v, pts_cam[:, 2]], axis=1) def oracle_object_mask(env, camera, obj_idx: int, pad_px: int = 24) -> np.ndarray: """Create a temporary ROI mask by projecting the known simulated object bbox. This is for fast grasp primitive debugging. Once the primitive is stable, replace this mask provider with RGB-D segmentation/VLM masks for submission. """ from atec_rl_lab.tasks.task_e.env_cfg import OBJ_HALF_EXTENTS, TABLE_TOP_Z rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) h, w = depth.shape[:2] obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] center = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) hx, hy = OBJ_HALF_EXTENTS[f"object_{obj_idx}"] z_lo = TABLE_TOP_Z + 0.005 z_hi = max(center[2] + 0.16, TABLE_TOP_Z + 0.08) corners = np.array( [ [center[0] + sx * hx, center[1] + sy * hy, z] for sx in (-1.0, 1.0) for sy in (-1.0, 1.0) for z in (z_lo, z_hi) ], dtype=np.float64, ) uvz = project_world_points_to_image(corners, K, pos_w, quat_wxyz_ros) valid = uvz[:, 2] > 0.02 mask = np.zeros((h, w), dtype=np.uint8) if not np.any(valid): return mask u = uvz[valid, 0] v = uvz[valid, 1] x1 = int(np.clip(np.floor(u.min()) - pad_px, 0, w - 1)) y1 = int(np.clip(np.floor(v.min()) - pad_px, 0, h - 1)) x2 = int(np.clip(np.ceil(u.max()) + pad_px, 0, w - 1)) y2 = int(np.clip(np.ceil(v.max()) + pad_px, 0, h - 1)) if x2 > x1 and y2 > y1: mask[y1 : y2 + 1, x1 : x2 + 1] = 255 # Remove obvious background/table pixels while keeping the object surface. obj_depth = depth[mask > 0] obj_depth = obj_depth[np.isfinite(obj_depth) & (obj_depth > 0.0)] if obj_depth.size: d_min = float(np.percentile(obj_depth, 3)) d_max = float(np.percentile(obj_depth, 70)) mask[(depth < d_min - 0.03) | (depth > d_max + 0.06)] = 0 # Debug oracle refinement: keep only RGB-D points whose reconstructed # world coordinates lie inside the selected object's AABB. The first # rectangular ROI can include neighboring objects for banana/long # shapes, which shifts GraspNet's execution centre by tens of cm. ys, xs = np.where((mask > 0) & np.isfinite(depth) & (depth > 0.0)) if len(xs) > 0: 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) rot_w_cam = Rotation.from_quat( [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] ).as_matrix() pts_w = (rot_w_cam @ pts_cam.T).T + pos_w keep = ( (pts_w[:, 0] >= center[0] - hx - 0.025) & (pts_w[:, 0] <= center[0] + hx + 0.025) & (pts_w[:, 1] >= center[1] - hy - 0.025) & (pts_w[:, 1] <= center[1] + hy + 0.025) & (pts_w[:, 2] >= TABLE_TOP_Z - 0.010) & (pts_w[:, 2] <= center[2] + 0.180) ) refined = np.zeros_like(mask) refined[ys[keep], xs[keep]] = 255 if np.count_nonzero(refined) > 128: mask = refined return mask _BAND_Z_LIMITS = { 1: (0.035, 0.130), # sugar box: reject table pixels and high gripper links 2: (0.020, 0.190), # mustard bottle 3: (0.012, 0.095), # banana } def rgbd_band_object_mask(camera, obj_idx: int, margin_y: float = 0.045) -> np.ndarray: """Segment a Task-E object from RGB-D using legal scene priors. The official randomizer keeps each object type in a distinct world-Y band. Reconstructing the video camera depth into world coordinates lets us isolate the object without reading simulator object state. This is the intended replacement for ``oracle_object_mask`` in submission-style tests. """ from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS from atec_rl_lab.tasks.task_e.env_cfg import TABLE_TOP_Z rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) valid = np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) ys, xs = np.where(valid) mask = np.zeros(depth.shape[:2], dtype=np.uint8) if len(xs) == 0: return mask 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) rot_w_cam = Rotation.from_quat( [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] ).as_matrix() pts_w = (rot_w_cam @ pts_cam.T).T + pos_w y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx] z_min_rel, z_max_rel = _BAND_Z_LIMITS.get(obj_idx, (0.006, 0.24)) rgb_pts = rgb[ys, xs].astype(np.float32) maxc = rgb_pts.max(axis=1) minc = rgb_pts.min(axis=1) sat = maxc - minc non_gray = (sat > 18.0) | (maxc > 170.0) world_keep = ( (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.08) & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.08) & (pts_w[:, 1] >= y0 - margin_y) & (pts_w[:, 1] <= y1 + margin_y) & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel) & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel) & non_gray ) mask[ys[world_keep], xs[world_keep]] = 255 # Fill the component's rectangular holes lightly; GraspNet expects enough # depth samples and the box has large white low-saturation areas. if np.count_nonzero(mask) > 0: yy, xx = np.where(mask > 0) x1, x2 = int(xx.min()), int(xx.max()) y1p, y2p = int(yy.min()), int(yy.max()) roi = np.zeros_like(mask) roi[y1p : y2p + 1, x1 : x2 + 1] = 255 fill_keep = roi[ys, xs] > 0 fill_keep &= ( (pts_w[:, 1] >= y0 - margin_y) & (pts_w[:, 1] <= y1 + margin_y) & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel) & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel) ) mask[ys[fill_keep], xs[fill_keep]] = 255 return mask @lru_cache(maxsize=1) def _load_graspnet_model(): _ensure_tuntun_paths() if not CHECKPOINT_PATH.exists(): raise FileNotFoundError( f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. " "Download official checkpoint-rs.tar there first." ) from graspnet import GraspNet net = GraspNet( input_feature_dim=0, num_view=300, num_angle=12, num_depth=4, cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01, 0.02, 0.03, 0.04], is_training=False, ) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net.to(device) checkpoint = torch.load(CHECKPOINT_PATH, map_location=device) net.load_state_dict(checkpoint["model_state_dict"]) net.eval() return net def _run_graspnet(rgb: np.ndarray, depth: np.ndarray, mask: np.ndarray, K: np.ndarray): _ensure_tuntun_paths() import open3d as o3d from collision_detector import ModelFreeCollisionDetector from data_utils import CameraInfo, create_point_cloud_from_depth_image from graspnet import pred_decode from graspnetAPI import GraspGroup color = rgb.astype(np.float32) / 255.0 height, width = depth.shape[:2] camera_info = CameraInfo(width, height, float(K[0, 0]), float(K[1, 1]), float(K[0, 2]), float(K[1, 2]), 1.0) cloud = create_point_cloud_from_depth_image(depth, camera_info, organized=True) valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) cloud_masked = cloud[valid] color_masked = color[valid] if len(cloud_masked) == 0: raise RuntimeError("No valid masked depth points for GraspNet.") num_point = 5000 if len(cloud_masked) >= num_point: idxs = np.random.choice(len(cloud_masked), num_point, replace=False) else: idxs = np.concatenate( [np.arange(len(cloud_masked)), np.random.choice(len(cloud_masked), num_point - len(cloud_masked), replace=True)] ) cloud_sampled = torch.from_numpy(cloud_masked[idxs][None].astype(np.float32)).to( torch.device("cuda:0" if torch.cuda.is_available() else "cpu") ) end_points = {"point_clouds": cloud_sampled, "cloud_colors": color_masked[idxs]} net = _load_graspnet_model() with torch.no_grad(): end_points = net(end_points) grasp_preds = pred_decode(end_points) gg = GraspGroup(grasp_preds[0].detach().cpu().numpy()).nms().sort_by_score() if len(gg) > 128: gg = gg[:128] cloud_o3d = o3d.geometry.PointCloud() cloud_o3d.points = o3d.utility.Vector3dVector(cloud_masked.astype(np.float32)) cloud_o3d.colors = o3d.utility.Vector3dVector(color_masked.astype(np.float32)) try: detector = ModelFreeCollisionDetector(np.asarray(cloud_o3d.points, dtype=np.float32), voxel_size=0.01) collision_mask = detector.detect(gg, approach_dist=0.05, collision_thresh=0.01) gg = gg[~collision_mask] except Exception as exc: print(f"[graspnet] collision check skipped: {exc}") gg = gg.sort_by_score() grasps = list(gg) if not grasps: raise RuntimeError("No GraspNet candidates after filtering.") center = np.mean(cloud_masked, axis=0) # TunTunClaw's empirical selector: prefer grasps near the segmented object centre. max_dist = max(np.linalg.norm(g.translation - center) for g in grasps) or 1.0 best = max(grasps, key=lambda g: float(g.score) * 0.1 + (1.0 - np.linalg.norm(g.translation - center) / max_dist) * 0.9) out = GraspGroup() out.add(best) return out def _load_graspnet(): _ensure_tuntun_paths() if not CHECKPOINT_PATH.exists(): raise FileNotFoundError( f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. " "Download official checkpoint-rs.tar there first." ) return _run_graspnet def infer_grasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp: """Run TunTunClaw GraspNet and convert the selected grasp to Task-E world pose.""" rgb, depth, _K, pos_w, quat_wxyz_ros = camera_arrays(camera) run_grasp_inference = _load_graspnet() gg = run_grasp_inference(rgb, depth, mask, _K) if len(gg) == 0: raise RuntimeError("GraspNet returned no grasps.") grasp = list(gg)[0] rot_w_cam = Rotation.from_quat( [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] ).as_matrix() t_cam = np.asarray(grasp.translation, dtype=np.float64) t_w = rot_w_cam @ t_cam + pos_w valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) if np.any(valid): ys, xs = np.where(valid) z = depth[ys, xs].astype(np.float64) x = (xs.astype(np.float64) - float(_K[0, 2])) / float(_K[0, 0]) * z y = (ys.astype(np.float64) - float(_K[1, 2])) / float(_K[1, 1]) * z pts_cam = np.stack([x, y, z], axis=1) pts_w = (rot_w_cam @ pts_cam.T).T + pos_w # For top-down Piper execution, the upper object-surface cloud is more # stable than a single GraspNet seed point on box/bottle edges. Keep # GraspNet's yaw/width/score, recenter only the execution target. z_gate = float(np.percentile(pts_w[:, 2], 70)) upper = pts_w[pts_w[:, 2] >= z_gate] if len(upper) > 16: # The highest-score GraspNet seed often sits on a visible edge for # Task-E boxes/bottles. Piper's parallel jaw is more reliable when # executed through the segmented object's robust surface centre. t_w[:2] = np.median(upper[:, :2], axis=0) else: t_w[:2] = np.median(pts_w[:, :2], axis=0) t_w[2] = float(np.percentile(pts_w[:, 2], 85)) # GraspNet's first column is the approach axis. We keep its jaw hint but # force the Piper tool z-axis downward because the Task-E IK/top-down setup # is much more stable than arbitrary 6-DoF wrist poses. R_cam_grasp = np.asarray(grasp.rotation_matrix, dtype=np.float64) jaw_hint_w = rot_w_cam @ R_cam_grasp[:, 1] jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64) if np.linalg.norm(jaw_xy) < 1e-6: jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64) jaw_xy = jaw_xy / np.linalg.norm(jaw_xy) grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64) align_x = np.cross(jaw_xy, grip_z) align_x = align_x / max(np.linalg.norm(align_x), 1e-6) jaw_y = np.cross(grip_z, align_x) jaw_y = jaw_y / max(np.linalg.norm(jaw_y), 1e-6) R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1) quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat() quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64) return TaskEGrasp( translation_w=t_w.astype(np.float64), quat_wxyz_w=quat_wxyz, score=float(grasp.score), width=float(grasp.width), raw_translation_cam=t_cam, ) def quat_wxyz_to_torch(quat_wxyz: np.ndarray, device: str) -> torch.Tensor: return torch.tensor([quat_wxyz], dtype=torch.float32, device=device) def pos_to_torch(pos: np.ndarray, device: str) -> torch.Tensor: return torch.tensor([pos], dtype=torch.float32, device=device)