"""AnyGrasp SDK bridge for ATEC Task E. AnyGrasp predicts grasp candidates from RGB-D point clouds in the camera frame. For Task E we keep the same execution contract as the TunTun/GraspNet adapter: use the model for contact centre, jaw yaw, score and width, then hand a top-down-friendly world-frame ``TaskEGrasp`` to the existing Piper primitive. """ from __future__ import annotations from functools import lru_cache from pathlib import Path import ctypes import os import sys import numpy as np from scipy.spatial.transform import Rotation from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays REPO_ROOT = Path(__file__).resolve().parents[2] ANYGRASP_ROOT = REPO_ROOT / "third_party" / "anygrasp_sdk" DETECTION_ROOT = ANYGRASP_ROOT / "grasp_detection" CHECKPOINT_PATH = DETECTION_ROOT / "log" / "checkpoint_detection.tar" SSL11_DIR = Path( "/home/ubuntu/projects/manipdojo2026/micromamba/envs/genmanip-sim/lib/python3.10/site-packages/" "isaacsim/exts/omni.isaac.ros2_bridge/humble/lib" ) TOOLS_DIR = REPO_ROOT / "tools" / "anygrasp" def _ensure_anygrasp_paths() -> None: det = str(DETECTION_ROOT) if det not in sys.path: sys.path.insert(0, det) tools = str(TOOLS_DIR) old_path = os.environ.get("PATH", "") if TOOLS_DIR.exists() and tools not in old_path.split(":"): os.environ["PATH"] = f"{tools}:{old_path}" if old_path else tools ssl = str(SSL11_DIR) old_ld = os.environ.get("LD_LIBRARY_PATH", "") if SSL11_DIR.exists() and ssl not in old_ld.split(":"): os.environ["LD_LIBRARY_PATH"] = f"{ssl}:{old_ld}" if old_ld else ssl # lib_cxx.so is linked against OpenSSL 1.1. In long-running Isaac Python # processes, changing LD_LIBRARY_PATH after startup is not enough, so load # the exact libraries by absolute path before importing gsnet/lib_cxx. for name in ("libcrypto.so.1.1", "libssl.so.1.1"): path = SSL11_DIR / name if path.exists(): ctypes.CDLL(str(path), mode=ctypes.RTLD_GLOBAL) def _check_anygrasp_files() -> None: missing = [] for path in [ DETECTION_ROOT / "gsnet.so", DETECTION_ROOT / "lib_cxx.so", DETECTION_ROOT / "license" / "licenseCfg.json", CHECKPOINT_PATH, ]: if not path.exists(): missing.append(str(path)) if missing: raise FileNotFoundError("AnyGrasp SDK is not fully installed:\n" + "\n".join(missing)) @lru_cache(maxsize=1) def _load_anygrasp_detector(): _ensure_anygrasp_paths() _check_anygrasp_files() from argparse import Namespace from gsnet import AnyGrasp cfg = Namespace( checkpoint_path=str(CHECKPOINT_PATH), max_gripper_width=0.085, gripper_height=0.03, top_down_grasp=True, debug=False, ) detector = AnyGrasp(cfg) detector.load_net() return detector def _points_from_rgbd( rgb: np.ndarray, depth: np.ndarray, mask: np.ndarray, K: np.ndarray, *, expand_px: int = 0, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: use_mask = mask > 0 if expand_px > 0 and np.any(use_mask): ys0, xs0 = np.where(use_mask) y1 = max(int(ys0.min()) - expand_px, 0) y2 = min(int(ys0.max()) + expand_px + 1, mask.shape[0]) x1 = max(int(xs0.min()) - expand_px, 0) x2 = min(int(xs0.max()) + expand_px + 1, mask.shape[1]) use_mask = np.zeros_like(use_mask, dtype=bool) use_mask[y1:y2, x1:x2] = True valid = use_mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) ys, xs = np.where(valid) if len(xs) == 0: raise RuntimeError("No valid masked depth points for AnyGrasp.") z = depth[ys, xs].astype(np.float32) x = (xs.astype(np.float32) - float(K[0, 2])) / float(K[0, 0]) * z y = (ys.astype(np.float32) - float(K[1, 2])) / float(K[1, 1]) * z points = np.stack([x, y, z], axis=1).astype(np.float32) colors = (rgb[ys, xs, :3].astype(np.float32) / 255.0).astype(np.float32) return points, colors, np.stack([ys, xs], axis=1) def _lims_for_points(points: np.ndarray, pad: float = 0.04) -> list[float]: lo = points.min(axis=0) hi = points.max(axis=0) return [ float(lo[0] - pad), float(hi[0] + pad), float(lo[1] - pad), float(hi[1] + pad), float(max(0.0, lo[2] - pad)), float(hi[2] + pad), ] def _select_anygrasp_candidate(gg, points_cam: np.ndarray): if gg is None or len(gg) == 0: raise RuntimeError("AnyGrasp returned no grasps after filtering.") gg = gg.nms().sort_by_score() grasps = list(gg) if not grasps: raise RuntimeError("AnyGrasp returned no grasps after filtering.") center = np.median(points_cam, axis=0) spread = float(np.linalg.norm(np.percentile(points_cam, 90, axis=0) - np.percentile(points_cam, 10, axis=0))) spread = max(spread, 1e-3) def rank(g) -> float: dist = float(np.linalg.norm(np.asarray(g.translation, dtype=np.float64) - center)) # Keep score dominant, but reject edge candidates that are far from the # segmented object core. This mirrors the proven GraspNet selector. return float(g.score) * 0.65 + max(0.0, 1.0 - dist / spread) * 0.35 return max(grasps[:128], key=rank) def infer_anygrasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp: """Run AnyGrasp SDK and convert the selected grasp to Task-E world pose.""" rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) detector = _load_anygrasp_detector() attempts = [ (0, 0.04, True, False, True), (0, 0.08, False, False, False), (24, 0.08, False, False, False), ] last_error: Exception | None = None points_cam = colors = None grasp = None for expand_px, lim_pad, apply_object_mask, dense_grasp, collision_detection in attempts: try: points_cam, colors, _pixels = _points_from_rgbd(rgb, depth, mask, K, expand_px=expand_px) if len(points_cam) < 64: raise RuntimeError(f"Too few masked points for AnyGrasp: {len(points_cam)}") lims = _lims_for_points(points_cam, pad=lim_pad) print( "[ANYGRASP] " f"points={len(points_cam)} expand_px={expand_px} lim_pad={lim_pad:.3f} " f"object_mask={apply_object_mask} dense={dense_grasp} collision={collision_detection}", flush=True, ) gg, _cloud = detector.get_grasp( points_cam, colors, lims=lims, apply_object_mask=apply_object_mask, dense_grasp=dense_grasp, collision_detection=collision_detection, ) grasp = _select_anygrasp_candidate(gg, points_cam) break except Exception as exc: last_error = exc print(f"[ANYGRASP] attempt failed: {exc}", flush=True) if grasp is None or points_cam is None: raise RuntimeError(f"AnyGrasp failed for all attempts: {last_error}") 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 pts_w = (rot_w_cam @ points_cam.astype(np.float64).T).T + pos_w z_gate = float(np.percentile(pts_w[:, 2], 70)) upper = pts_w[pts_w[:, 2] >= z_gate] if len(upper) > 16: 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)) 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, )