| |
| """Project released Human Hand validation joints onto released top_head frames. |
| |
| The script reads one local public validation episode. It contains no episode |
| inventory, server path, credential, private calibration constant, or other |
| non-public metadata. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
|
|
|
|
| HAND_EDGES = ( |
| (0, 1), (1, 2), (2, 3), (3, 4), |
| (0, 5), (5, 6), (6, 7), (7, 8), |
| (0, 9), (9, 10), (10, 11), (11, 12), |
| (0, 13), (13, 14), (14, 15), (15, 16), |
| (0, 17), (17, 18), (18, 19), (19, 20), |
| (5, 9), (9, 13), (13, 17), |
| ) |
|
|
| REQUIRED_NPZ_KEYS = ( |
| "left_positions_camera", |
| "right_positions_camera", |
| "left_valid", |
| "right_valid", |
| "camera_valid", |
| "camera_position_world", |
| "camera_quaternion_world_xyzw", |
| ) |
|
|
|
|
| def quaternion_xyzw_to_matrix(quaternion: np.ndarray) -> np.ndarray: |
| """Convert an XYZW quaternion to a 3-by-3 rotation matrix.""" |
| q = np.asarray(quaternion, dtype=np.float64) |
| if q.shape != (4,): |
| raise ValueError(f"expected quaternion shape (4,), got {q.shape}") |
| norm = np.linalg.norm(q) |
| if not np.isfinite(norm) or norm < 1e-8: |
| raise ValueError("invalid quaternion") |
| x, y, z, w = q / norm |
| return np.asarray( |
| [ |
| [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)], |
| [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)], |
| [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)], |
| ], |
| dtype=np.float64, |
| ) |
|
|
|
|
| def xyz(record: dict) -> np.ndarray: |
| return np.asarray([record["x"], record["y"], record["z"]], dtype=np.float64) |
|
|
|
|
| def xyzw(record: dict) -> np.ndarray: |
| return np.asarray( |
| [record["x"], record["y"], record["z"], record["w"]], |
| dtype=np.float64, |
| ) |
|
|
|
|
| def project_joints( |
| points_stored: np.ndarray, |
| camera_position_world: np.ndarray, |
| camera_quaternion_world_xyzw: np.ndarray, |
| top_head: dict, |
| ) -> tuple[np.ndarray, np.ndarray]: |
| """Apply the released camera transforms and virtual pinhole projection.""" |
| points_stored = np.asarray(points_stored, dtype=np.float64) |
| if points_stored.shape != (21, 3): |
| raise ValueError(f"expected 21x3 hand joints, got {points_stored.shape}") |
|
|
| |
| rotation_world_from_left = quaternion_xyzw_to_matrix( |
| camera_quaternion_world_xyzw |
| ) |
| points_left = ( |
| rotation_world_from_left.T |
| @ (points_stored - np.asarray(camera_position_world, dtype=np.float64)).T |
| ).T |
|
|
| |
| extrinsic = top_head["extrinsics"]["extrinsic_head_fisheye_T_left"] |
| rotation_left_from_fisheye = quaternion_xyzw_to_matrix( |
| xyzw(extrinsic["rotation"]) |
| ) |
| translation_left_from_fisheye = xyz(extrinsic["translation"]) |
| points_fisheye = ( |
| rotation_left_from_fisheye.T |
| @ (points_left - translation_left_from_fisheye).T |
| ).T |
|
|
| |
| rotation_virtual_from_fisheye = np.asarray( |
| top_head["rectification"]["source_to_virtual_rotation"], |
| dtype=np.float64, |
| ) |
| if rotation_virtual_from_fisheye.shape != (3, 3): |
| raise ValueError("source_to_virtual_rotation must be a 3x3 matrix") |
| points_virtual = (rotation_virtual_from_fisheye @ points_fisheye.T).T |
|
|
| |
| intrinsics = top_head["intrinsics"] |
| depth_valid = points_virtual[:, 2] > 1e-6 |
| pixels = np.full((21, 2), np.nan, dtype=np.float64) |
| pixels[depth_valid, 0] = ( |
| float(intrinsics["Fx"]) |
| * points_virtual[depth_valid, 0] |
| / points_virtual[depth_valid, 2] |
| + float(intrinsics["Cx"]) |
| ) |
| pixels[depth_valid, 1] = ( |
| float(intrinsics["Fy"]) |
| * points_virtual[depth_valid, 1] |
| / points_virtual[depth_valid, 2] |
| + float(intrinsics["Cy"]) |
| ) |
| return pixels, depth_valid |
|
|
|
|
| def draw_hand( |
| image: np.ndarray, |
| pixels: np.ndarray, |
| depth_valid: np.ndarray, |
| color: tuple[int, int, int], |
| label: str, |
| ) -> None: |
| """Draw a 21-joint hand skeleton inside the image bounds.""" |
| height, width = image.shape[:2] |
| visible = ( |
| depth_valid |
| & np.isfinite(pixels).all(axis=1) |
| & (pixels[:, 0] >= 0) |
| & (pixels[:, 0] < width) |
| & (pixels[:, 1] >= 0) |
| & (pixels[:, 1] < height) |
| ) |
| rounded = np.rint(pixels).astype(np.int32, casting="unsafe", copy=False) |
| for start, end in HAND_EDGES: |
| if visible[start] and visible[end]: |
| cv2.line( |
| image, tuple(rounded[start]), tuple(rounded[end]), color, 3, |
| cv2.LINE_AA, |
| ) |
| for index, point in enumerate(rounded): |
| if visible[index]: |
| radius = 7 if index == 0 else 4 |
| cv2.circle(image, tuple(point), radius, (255, 255, 255), -1, cv2.LINE_AA) |
| cv2.circle(image, tuple(point), radius, color, 2, cv2.LINE_AA) |
| if visible[0]: |
| anchor = tuple(rounded[0] + np.asarray([8, -8])) |
| cv2.putText( |
| image, label, anchor, cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2, |
| cv2.LINE_AA, |
| ) |
|
|
|
|
| def list_frames(frames_dir: Path) -> list[Path]: |
| frames = sorted(frames_dir.glob("frame_*.jpg")) |
| if not frames: |
| frames = sorted(frames_dir.glob("frame_*.png")) |
| if not frames: |
| raise FileNotFoundError(f"no frame_*.jpg or frame_*.png in {frames_dir}") |
| return frames |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Visualize one released Human Hand validation episode." |
| ) |
| parser.add_argument("--npz", type=Path, required=True) |
| parser.add_argument("--calibration", type=Path, required=True) |
| parser.add_argument("--frames-dir", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument("--fps", type=float, default=15.0) |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if args.fps <= 0: |
| raise ValueError("fps must be positive") |
|
|
| calibration = json.loads(args.calibration.read_text(encoding="utf-8")) |
| top_head = calibration["cameras"]["top_head"] |
| frames = list_frames(args.frames_dir) |
| with np.load(args.npz, allow_pickle=False) as archive: |
| missing = [key for key in REQUIRED_NPZ_KEYS if key not in archive] |
| if missing: |
| raise KeyError(f"NPZ is missing required arrays: {', '.join(missing)}") |
| data = {key: archive[key] for key in REQUIRED_NPZ_KEYS} |
|
|
| frame_count = len(frames) |
| mismatched = { |
| key: len(value) |
| for key, value in data.items() |
| if len(value) != frame_count |
| } |
| if mismatched: |
| raise ValueError( |
| f"frame count is {frame_count}, but NPZ lengths differ: {mismatched}" |
| ) |
|
|
| sample = cv2.imread(str(frames[0]), cv2.IMREAD_COLOR) |
| if sample is None: |
| raise FileNotFoundError(frames[0]) |
| height, width = sample.shape[:2] |
| header_height = 54 |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| writer = cv2.VideoWriter( |
| str(args.output), |
| cv2.VideoWriter_fourcc(*"mp4v"), |
| args.fps, |
| (width * 2, height + header_height), |
| ) |
| if not writer.isOpened(): |
| raise RuntimeError(f"cannot open output video: {args.output}") |
|
|
| try: |
| for frame_index, frame_path in enumerate(frames): |
| raw = cv2.imread(str(frame_path), cv2.IMREAD_COLOR) |
| if raw is None: |
| raise FileNotFoundError(frame_path) |
| if raw.shape[:2] != (height, width): |
| raise ValueError(f"inconsistent frame size: {frame_path}") |
| overlay = raw.copy() |
|
|
| camera_valid = bool(data["camera_valid"][frame_index]) |
| hands = ( |
| (data["left_positions_camera"][frame_index], |
| bool(data["left_valid"][frame_index]), (0, 220, 0), "L"), |
| (data["right_positions_camera"][frame_index], |
| bool(data["right_valid"][frame_index]), (0, 80, 255), "R"), |
| ) |
| for joints, hand_valid, color, label in hands: |
| if camera_valid and hand_valid: |
| pixels, depth_valid = project_joints( |
| joints, |
| data["camera_position_world"][frame_index], |
| data["camera_quaternion_world_xyzw"][frame_index], |
| top_head, |
| ) |
| draw_hand(overlay, pixels, depth_valid, color, label) |
|
|
| canvas = np.zeros( |
| (height + header_height, width * 2, 3), dtype=np.uint8 |
| ) |
| canvas[header_height:] = np.hstack([raw, overlay]) |
| cv2.putText( |
| canvas, "Released top_head frame", (12, 34), |
| cv2.FONT_HERSHEY_SIMPLEX, 0.66, (245, 245, 245), 2, |
| cv2.LINE_AA, |
| ) |
| cv2.putText( |
| canvas, |
| f"Released joint projection | frame {frame_index:05d}", |
| (width + 12, 34), cv2.FONT_HERSHEY_SIMPLEX, 0.66, |
| (245, 245, 245), 2, cv2.LINE_AA, |
| ) |
| writer.write(canvas) |
| finally: |
| writer.release() |
|
|
| print(f"Wrote {frame_count} frames to {args.output}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
