Create process_data_for_evac.py

process_data_for_evac.py

@@ -0,0 +1,387 @@
+"""
+Prepare EVAC inference inputs from RLBench-style episode data.
+
+Input layout:
+    episodes_root/
+    ├── episode_0/
+    │   ├── actions.npy                    # (T_act, 8), single-hand [xyz, quat_xyzw, gripper]
+    │   ├── view1/
+    │   │   ├── rgb/video.mp4
+    │   │   └── camera_params.json         # {"<frame_id>": {"extrinsics":..., "intrinsics":...}}
+    │   └── view2/ ...
+    ├── episode_1/
+    │   └── ...
+
+Output layout:
+    <user-specified output_root>/
+    ├── episode_0/
+    │   ├── <view1>/                       # only FIXED-camera views
+    │   │   ├── frame.png                  # video frame at t_start (first frame gripper visible)
+    │   │   ├── actions.npy                # (T + 3, 16), dual-hand, history-padded
+    │   │   ├── extrinsics.npy             # (4, 4) c2w
+    │   │   └── intrinsics.npy             # (3, 3) K (abs-valued fx, fy)
+    │   └── <view2>/ ...
+    └── ...
+
+Pipeline:
+    1. Discover view folders (contain camera_params.json).
+    2. Filter: keep views whose extrinsics are identical across all recorded frames.
+    3. Map each video frame t -> action[round(t * T_action / T_video)] (handles
+       non-exact ratios like 41:163 or 41:164 by clamping at the tail).
+    4. Find t_start: first video frame where right-hand EEF projects inside
+       the image with positive depth (gripper enters camera view).
+    5. Slice: frames [t_start, T_video), actions aligned to those frames.
+    6. Convert 8D single-hand -> 16D dual-hand (real on right, placeholder on left).
+    7. Prepend (n_previous - 1) copies of first frame to align with EVAC's history slots.
+    8. Write frame.png from video at t_start; write actions.npy; write K and c2w.
+
+Usage:
+    python prepare_evac_input.py -i /path/to/episodes_root -o /path/to/out
+    python prepare_evac_input.py -i ... -o ... --hand right
+    python prepare_evac_input.py -i ... -o ... --fix_tol 1e-6 --n_previous 4
+    python prepare_evac_input.py -i ... -o ... --episodes episode_0 episode_5
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+# ---------------------------------------------------------------------------
+# Action conversion
+# ---------------------------------------------------------------------------
+
+def single_to_dual(actions_8d: np.ndarray, hand: str = "right") -> np.ndarray:
+    """[T, 8] -> [T, 16]. Real data on `hand`, placeholder on the other."""
+    assert actions_8d.ndim == 2 and actions_8d.shape[1] == 8
+    T = actions_8d.shape[0]
+    out = np.zeros((T, 16), dtype=np.float32)
+
+    if hand == "right":
+        out[:, 3:7]   = np.array([0, 0, 0, 1], dtype=np.float32)   # identity quat
+        out[:, 7]     = 1.0                                         # gripper open
+        out[:, 8:11]  = actions_8d[:, 0:3]
+        out[:, 11:15] = actions_8d[:, 3:7]
+        out[:, 15]    = actions_8d[:, 7]
+    elif hand == "left":
+        out[:, 0:3]   = actions_8d[:, 0:3]
+        out[:, 3:7]   = actions_8d[:, 3:7]
+        out[:, 7]     = actions_8d[:, 7]
+        out[:, 11:15] = np.array([0, 0, 0, 1], dtype=np.float32)
+        out[:, 15]    = 1.0
+    else:
+        raise ValueError(f"hand must be 'left' or 'right', got {hand!r}")
+    return out
+
+
+def prepend_history_pad(actions_16d: np.ndarray, n_previous: int) -> np.ndarray:
+    """Prepend (n_previous - 1) copies of the first frame."""
+    if n_previous <= 1:
+        return actions_16d
+    return np.concatenate([actions_16d[:1]] * (n_previous - 1) + [actions_16d], axis=0)
+
+
+# ---------------------------------------------------------------------------
+# Camera handling
+# ---------------------------------------------------------------------------
+
+def load_camera_params(camera_params_path: Path):
+    """Parse camera_params.json -> sorted frame_ids, (T, 4, 4) ext, (T, 3, 3) K."""
+    with open(camera_params_path, "r") as f:
+        data = json.load(f)
+    frame_ids = sorted(data.keys())
+    ext = np.stack([np.array(data[k]["extrinsics"],  dtype=np.float64) for k in frame_ids])
+    K   = np.stack([np.array(data[k]["intrinsics"],  dtype=np.float64) for k in frame_ids])
+    return frame_ids, ext, K
+
+
+def is_fixed_camera(ext: np.ndarray, tol: float = 1e-6) -> bool:
+    """True if extrinsics are identical across all frames (within tol)."""
+    if ext.shape[0] < 2:
+        return True
+    return np.abs(ext - ext[0:1]).max() < tol
+
+
+def normalize_intrinsic(K_3x3: np.ndarray) -> np.ndarray:
+    """Fix RLBench/OpenGL-style negative fx/fy by taking absolute values."""
+    K_out = K_3x3.astype(np.float32).copy()
+    K_out[0, 0] = abs(K_out[0, 0])
+    K_out[1, 1] = abs(K_out[1, 1])
+    return K_out
+
+
+# ---------------------------------------------------------------------------
+# Gripper-in-view detection via projection
+# ---------------------------------------------------------------------------
+
+def project_points_world_to_pixel(points_world: np.ndarray,
+                                  c2w: np.ndarray,
+                                  K: np.ndarray):
+    """
+    points_world: (N, 3) world-frame 3D points
+    c2w: (4, 4) camera-to-world; we invert to get world-to-camera
+    K:   (3, 3) intrinsic
+    Returns: (N, 2) pixel coords (u, v), (N,) camera-frame z depth
+    """
+    w2c = np.linalg.inv(c2w)
+    N = points_world.shape[0]
+    pts_h = np.concatenate([points_world, np.ones((N, 1))], axis=1)    # (N, 4)
+    pts_cam = (w2c @ pts_h.T).T[:, :3]                                  # (N, 3)
+    uv_h = (K @ pts_cam.T).T                                            # (N, 3)
+    # Avoid divide by zero / behind camera
+    z = uv_h[:, 2]
+    uv = np.zeros((N, 2), dtype=np.float64)
+    valid = np.abs(z) > 1e-8
+    uv[valid] = uv_h[valid, :2] / z[valid, None]
+    return uv, pts_cam[:, 2]
+
+
+def find_gripper_entry_frame(eef_world_per_video_frame: np.ndarray,
+                             c2w: np.ndarray, K: np.ndarray,
+                             H: int, W: int,
+                             margin: int = 0) -> int:
+    """
+    Find first t such that EEF at video-frame t projects inside [margin, W-margin) x
+    [margin, H-margin) with positive depth.
+
+    eef_world_per_video_frame: (T_video, 3)
+    Returns index in [0, T_video), or -1 if never visible.
+    """
+    uv, z_cam = project_points_world_to_pixel(eef_world_per_video_frame, c2w, K)
+    u = uv[:, 0]
+    v = uv[:, 1]
+    in_view = (
+        (u >= margin) & (u < W - margin) &
+        (v >= margin) & (v < H - margin) &
+        (z_cam > 0.0)
+    )
+    idx = np.where(in_view)[0]
+    return int(idx[0]) if len(idx) > 0 else -1
+
+
+# ---------------------------------------------------------------------------
+# Video I/O
+# ---------------------------------------------------------------------------
+
+def read_video_frame(video_path: Path, frame_idx: int) -> np.ndarray:
+    """Return a single frame (H, W, 3) in BGR order from an .mp4 at frame_idx."""
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video: {video_path}")
+    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+    ok, frame = cap.read()
+    cap.release()
+    if not ok:
+        raise IOError(f"Cannot read frame {frame_idx} from {video_path}")
+    return frame  # BGR
+
+
+def video_frame_count_and_size(video_path: Path):
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video: {video_path}")
+    n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    cap.release()
+    return n, h, w
+
+
+# ---------------------------------------------------------------------------
+# Action-to-video mapping
+# ---------------------------------------------------------------------------
+
+def frame_to_action_index(frame_idx: int, num_frames: int, num_actions: int) -> int:
+    """
+    Map a video frame index to its corresponding action index.
+
+    Handles non-exact ratios (e.g. 41 video frames : 163 actions = 3.976:1)
+    by rounding and clamping to [0, num_actions - 1]. The last video frame
+    always maps to the last action, absorbing the ±1 ragged tail.
+    """
+    if num_frames <= 1:
+        return 0
+    # Pin the last video frame to the last action.
+    if frame_idx >= num_frames - 1:
+        return num_actions - 1
+    ratio = num_actions / num_frames
+    act_idx = int(round(frame_idx * ratio))
+    return max(0, min(act_idx, num_actions - 1))
+
+
+def build_action_for_video_frames(actions_8d_full: np.ndarray,
+                                  n_video: int) -> np.ndarray:
+    """Return (n_video, 8) by mapping each video frame idx -> action idx."""
+    T_act = actions_8d_full.shape[0]
+    idxs = np.array([frame_to_action_index(t, n_video, T_act)
+                     for t in range(n_video)], dtype=np.int64)
+    return actions_8d_full[idxs]
+
+
+# ---------------------------------------------------------------------------
+# Per-episode per-view processing
+# ---------------------------------------------------------------------------
+
+def process_view(episode_dir: Path, view_dir: Path, out_view_dir: Path,
+                 actions_8d_full: np.ndarray,
+                 n_previous: int, hand: str,
+                 fix_tol: float, margin: int, observation_offset: int,
+                 verbose: bool = True):
+    """Returns a status string for logging."""
+    cam_path = view_dir / "camera_params.json"
+    video_path = view_dir / "rgb" / "video.mp4"
+
+    if not cam_path.exists():
+        return f"SKIP (no camera_params.json)"
+    if not video_path.exists():
+        return f"SKIP (no rgb/video.mp4)"
+
+    # Camera params
+    frame_ids, ext, K_stack = load_camera_params(cam_path)
+    if not is_fixed_camera(ext, tol=fix_tol):
+        max_diff = float(np.abs(ext - ext[0:1]).max())
+        return f"SKIP (camera not fixed, max ext diff={max_diff:.4f})"
+
+    c2w = ext[0].astype(np.float32)                     # (4, 4)
+    K   = normalize_intrinsic(K_stack[0])               # (3, 3)
+
+    # Video
+    n_video, H, W = video_frame_count_and_size(video_path)
+    if n_video < 2:
+        return f"SKIP (video has {n_video} frame(s))"
+
+    # Align actions to video frames via ratio mapping.
+    # For each video frame t in [0, n_video), pick action[round(t * T_act / n_video)].
+    # This handles non-exact ratios (e.g. 163:41 or 164:41) by clamping at the tail.
+    T_act_full = actions_8d_full.shape[0]
+    actions_video_rate = build_action_for_video_frames(actions_8d_full, n_video)  # (n_video, 8)
+
+    # Detect gripper entry frame using right-hand EEF xyz (cols 0:3 in the 8D layout).
+    eef_world_seq = actions_video_rate[:, 0:3].astype(np.float32)   # (n_video, 3)
+    t_entry = find_gripper_entry_frame(eef_world_seq, c2w, K,
+                                       H=H, W=W, margin=margin)
+    if t_entry < 0:
+        return f"SKIP (gripper never projects into view; video={n_video})"
+
+    # Apply observation offset: start a few frames AFTER entry so the gripper
+    # is meaningfully inside the frame, not just clipping the edge.
+    t_start = t_entry + observation_offset
+    if t_start >= n_video - 1:
+        return (f"SKIP (t_start={t_start} (entry={t_entry} + offset={observation_offset}) "
+                f">= n_video={n_video})")
+
+    # Slice from t_start
+    actions_sliced_8d = actions_video_rate[t_start:]    # (T_out, 8)
+    T_out = actions_sliced_8d.shape[0]
+
+    # Convert to dual-hand + history pad
+    a16 = single_to_dual(actions_sliced_8d, hand=hand)
+    a16 = prepend_history_pad(a16, n_previous=n_previous)   # (T_out + 3, 16)
+
+    # Grab video frame at t_start (BGR); save as PNG
+    frame_bgr = read_video_frame(video_path, t_start)
+
+    # Write outputs
+    out_view_dir.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(out_view_dir / "frame.png"), frame_bgr)
+    np.save(out_view_dir / "actions.npy",    a16)
+    np.save(out_view_dir / "extrinsics.npy", c2w)
+    np.save(out_view_dir / "intrinsics.npy", K)
+
+    return (f"OK (entry={t_entry}, t_start={t_start}, T_out={T_out}, padded={a16.shape[0]}, "
+            f"video={n_video}x{H}x{W}, actions={T_act_full}, ratio={T_act_full/n_video:.3f})")
+
+
+# ---------------------------------------------------------------------------
+# Top-level walker
+# ---------------------------------------------------------------------------
+
+def process_episode(ep_dir: Path, out_ep_dir: Path,
+                    n_previous: int, hand: str,
+                    fix_tol: float, margin: int, observation_offset: int,
+                    verbose: bool = True):
+    actions_path = ep_dir / "actions.npy"
+    if not actions_path.exists():
+        print(f"[{ep_dir.name}] SKIP: no actions.npy")
+        return
+
+    actions_8d_full = np.load(actions_path)
+    if actions_8d_full.ndim != 2 or actions_8d_full.shape[1] != 8:
+        print(f"[{ep_dir.name}] SKIP: actions.npy shape {actions_8d_full.shape} != (T, 8)")
+        return
+
+    view_dirs = [d for d in sorted(ep_dir.iterdir())
+                 if d.is_dir() and (d / "camera_params.json").exists()]
+    if not view_dirs:
+        print(f"[{ep_dir.name}] SKIP: no view folders with camera_params.json")
+        return
+
+    for view_dir in view_dirs:
+        out_view_dir = out_ep_dir / view_dir.name
+        status = process_view(
+            episode_dir=ep_dir, view_dir=view_dir, out_view_dir=out_view_dir,
+            actions_8d_full=actions_8d_full,
+            n_previous=n_previous, hand=hand,
+            fix_tol=fix_tol, margin=margin,
+            observation_offset=observation_offset,
+            verbose=verbose,
+        )
+        print(f"[{ep_dir.name}/{view_dir.name}] {status}")
+
+
+def main():
+    p = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter, description=__doc__
+    )
+    p.add_argument("-i", "--input_root",  required=True, type=Path,
+                   help="Root folder containing episode_* subfolders")
+    p.add_argument("-o", "--output_root", required=True, type=Path,
+                   help="Output folder (will be created)")
+    p.add_argument("--episodes", nargs="*", default=None,
+                   help="Only process these episode subfolder names (default: all)")
+    p.add_argument("--n_previous", type=int, default=4,
+                   help="EVAC history length to pad (default 4)")
+    p.add_argument("--hand", choices=["left", "right"], default="right",
+                   help="Which side of the 16D layout gets the real data")
+    p.add_argument("--fix_tol", type=float, default=1e-6,
+                   help="Max per-element extrinsics diff to count as 'fixed camera'")
+    p.add_argument("--margin", type=int, default=0,
+                   help="Pixel margin for gripper-in-view check (default 0)")
+    p.add_argument("--observation_offset", type=int, default=3,
+                   help="Number of video frames to advance past the gripper-entry "
+                        "frame before taking observation (default 2)")
+    args = p.parse_args()
+
+    if not args.input_root.exists():
+        raise FileNotFoundError(args.input_root)
+    args.output_root.mkdir(parents=True, exist_ok=True)
+
+    # Discover episode folders
+    ep_dirs = sorted([d for d in args.input_root.iterdir() if d.is_dir()])
+    if args.episodes:
+        wanted = set(args.episodes)
+        ep_dirs = [d for d in ep_dirs if d.name in wanted]
+
+    print(f"Found {len(ep_dirs)} episode(s) to process in {args.input_root}")
+    print(f"Output -> {args.output_root}")
+    print(f"Params: n_previous={args.n_previous}, hand={args.hand}, "
+          f"fix_tol={args.fix_tol}, margin={args.margin}, "
+          f"observation_offset={args.observation_offset}")
+    print("-" * 70)
+
+    for ep_dir in ep_dirs:
+        out_ep_dir = args.output_root / ep_dir.name
+        process_episode(
+            ep_dir=ep_dir, out_ep_dir=out_ep_dir,
+            n_previous=args.n_previous,
+            hand=args.hand, fix_tol=args.fix_tol, margin=args.margin,
+            observation_offset=args.observation_offset,
+        )
+
+
+if __name__ == "__main__":
+    main()