#!/usr/bin/env python3 """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}") # Stored/world-referenced points -> tracked camera reference frame L. 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 # Tracked camera reference frame L -> physical fisheye optical frame F. 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 # Physical fisheye F -> rectified virtual top_head camera V. 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 # Virtual pinhole camera -> image pixels; points behind it are invalid. 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()