File size: 4,568 Bytes
21e1acb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | """GraspGen-style PCA/AABB grasp prior for ATEC Task E.
This mirrors the core idea used by the PiPER GraspGen demo: reconstruct the
segmented RGB-D points, run PCA, build an oriented AABB, and use its center as a
geometric grasp prior. The Task-E runner may still override orientation with
the calibrated Piper quaternion.
"""
from __future__ import annotations
import numpy as np
from scipy.spatial.transform import Rotation
from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays
def _masked_world_points(camera, mask: np.ndarray) -> np.ndarray:
_rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
if not np.any(valid):
raise RuntimeError("No valid masked depth points for PCA/AABB grasp.")
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)
rot_w_cam = Rotation.from_quat(
[quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
).as_matrix()
return (rot_w_cam @ pts_cam.T).T + pos_w
def _pca_aabb(points_w: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, int]:
pts = np.asarray(points_w, dtype=np.float64)
if pts.shape[0] < 4:
raise RuntimeError("Too few points for PCA/AABB grasp.")
centroid = np.mean(pts, axis=0)
centered = pts - centroid
covariance = (centered.T @ centered) / max(centered.shape[0] - 1, 1)
eigen_values, eigen_vectors = np.linalg.eigh(covariance)
ev = eigen_vectors.copy()
ev[:, 2] = np.cross(ev[:, 0], ev[:, 1])
ev[:, 1] = np.cross(ev[:, 2], ev[:, 0])
ev[:, 0] = np.cross(ev[:, 1], ev[:, 2])
for i in range(3):
norm = np.linalg.norm(ev[:, i])
if norm > 1e-10:
ev[:, i] /= norm
order = np.argsort(eigen_values)[::-1]
R = ev[:, order].copy()
if np.linalg.det(R) < 0:
R[:, 2] = -R[:, 2]
local = (R.T @ (pts - centroid).T).T
min_pt = np.min(local, axis=0)
max_pt = np.max(local, axis=0)
extents = max_pt - min_pt
center_local = (min_pt + max_pt) * 0.5
center_w = R @ center_local + centroid
grasp_axis = int(np.argmin(extents))
return center_w.astype(np.float64), R.astype(np.float64), extents.astype(np.float64), grasp_axis
def infer_pca_aabb_from_camera(camera, mask: np.ndarray, object_index: int | None = None) -> TaskEGrasp:
"""Return a GraspGen-style geometric grasp prior from segmented RGB-D."""
pts_w = _masked_world_points(camera, mask)
# Use the visible object body. Box/bottle masks are most stable with the
# upper visible surface median, while the banana's curved mask is less
# stable there and works better from the oriented AABB center.
center_w, R_pca, extents, grasp_axis = _pca_aabb(pts_w)
z_gate = float(np.percentile(pts_w[:, 2], 70))
upper = pts_w[pts_w[:, 2] >= z_gate]
exec_center = center_w.copy()
if object_index != 3 and len(upper) > 16:
exec_center[:2] = np.median(upper[:, :2], axis=0)
exec_center[2] = float(np.percentile(pts_w[:, 2], 85))
if grasp_axis == 0:
jaw_hint_w = R_pca[:, 1]
elif grasp_axis == 1:
jaw_hint_w = R_pca[:, 0]
else:
jaw_hint_w = R_pca[:, 0]
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 /= 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 /= max(np.linalg.norm(align_x), 1e-6)
jaw_y = np.cross(grip_z, align_x)
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)
width = float(extents[grasp_axis])
score = 1.0 / (1.0 + float(np.linalg.norm(extents)))
print(
f"[PCA_AABB] points={len(pts_w)} extents=({extents[0]:.3f},{extents[1]:.3f},{extents[2]:.3f}) "
f"axis={grasp_axis} width={width:.3f}"
)
return TaskEGrasp(
translation_w=exec_center.astype(np.float64),
quat_wxyz_w=quat_wxyz,
score=score,
width=width,
raw_translation_cam=np.zeros(3, dtype=np.float64),
)
|