Upload hand_reader.py

ARCTICHUGGFACE/hand_reader.py

@@ -0,0 +1,202 @@
+"""
+ARCTIC Hand Data Reader
+Only reads hand (MANO) parameters from raw_seqs.
+No body model forward pass, no object data, no splits needed.
+
+Usage:
+    python scripts_data/hand_reader.py
+    python scripts_data/hand_reader.py --mano_p ./unpack/arctic_data/data/raw_seqs/s01/box_grab_01.mano.npy
+    python scripts_data/hand_reader.py --mano_p ./unpack/arctic_data/data/raw_seqs/s01/box_grab_01.mano.npy --frame 10
+"""
+
+import argparse
+import json
+import os.path as op
+import sys
+from glob import glob
+
+import numpy as np
+import torch
+
+sys.path = ["."] + sys.path
+
+DATA_ROOT = "./data"
+
+# view 0 = ego cam (head-mounted, moves every frame)
+# view 1-8 = 8 fixed allocentric cameras
+VIEW_NAMES = ["ego", "allo_1", "allo_2", "allo_3", "allo_4",
+              "allo_5", "allo_6", "allo_7", "allo_8"]
+
+
+def load_hand_seq(mano_p):
+    """
+    Load one sequence. Mirrors construct_loader() in
+    src/arctic/preprocess_dataset.py but keeps only hand fields.
+
+    Returns a dict with:
+      right / left  -> MANO params (tensors)
+      ego_cam       -> per-frame ego camera (world2ego, K, dist8)
+      static_cams   -> 8 fixed allo cameras from misc.json (world2cam, K)
+      meta          -> sid, seq_name, num_frames, gender
+    """
+    # -- MANO (same loading as preprocess_dataset.py construct_loader) --
+    data = np.load(mano_p, allow_pickle=True).item()
+    num_frames = len(data["right"]["rot"])
+
+    def _load_hand(side):
+        return {
+            "rot":         torch.FloatTensor(data[side]["rot"]),                       # (F, 3)
+            "pose":        torch.FloatTensor(data[side]["pose"]),                      # (F, 45)
+            "trans":       torch.FloatTensor(data[side]["trans"]),                     # (F, 3)
+            "shape":       torch.FloatTensor(data[side]["shape"]).repeat(num_frames, 1),  # (F, 10)
+            "fitting_err": data[side]["fitting_err"],                                  # (F,)
+        }
+
+    right = _load_hand("right")
+    left  = _load_hand("left")
+
+    # sanity check from preprocess_dataset.py
+    assert len(right["fitting_err"]) > 50, f"Too few frames: {mano_p}"
+
+    # -- Ego camera (same as preprocess_dataset.py construct_loader) --
+    ego_p  = mano_p.replace("mano.npy", "egocam.dist.npy")
+    egocam = np.load(ego_p, allow_pickle=True).item()
+
+    R_ego = torch.FloatTensor(egocam["R_k_cam_np"])   # (F, 3, 3)
+    T_ego = torch.FloatTensor(egocam["T_k_cam_np"])   # (F, 3, 1)
+    K_ego = torch.FloatTensor(egocam["intrinsics"])   # (3, 3)
+    dist8 = torch.FloatTensor(egocam["dist8"])        # (8,)
+
+    # build homogeneous transform, same as preprocess_dataset.py
+    world2ego = torch.zeros((num_frames, 4, 4))
+    world2ego[:, :3, :3] = R_ego
+    world2ego[:, :3, 3]  = T_ego[:, :, 0]
+    world2ego[:, 3, 3]   = 1.0
+
+    # -- Static allo cameras (same as process_seqs.py statcams) --
+    sid    = mano_p.split("/")[-2]
+    misc_p = op.join(DATA_ROOT, "misc.json")
+    with open(misc_p) as f:
+        misc = json.load(f)
+
+    sub    = misc[sid]
+    world2cam  = torch.FloatTensor(np.array(sub["world2cam"]))   # (8, 4, 4)
+    allo_K     = torch.FloatTensor(np.array(sub["intris_mat"]))  # (8, 3, 3)
+    image_size = np.array(sub["image_size"])                     # (9, 2)  [w, h]
+
+    seq_name = mano_p.split("/")[-1].replace(".mano.npy", "")
+
+    return {
+        "right": right,
+        "left":  left,
+        "ego_cam": {
+            "world2ego": world2ego,  # (F, 4, 4)
+            "K":         K_ego,      # (3, 3)
+            "dist8":     dist8,      # (8,)
+        },
+        "static_cams": {
+            "world2cam":  world2cam,   # (8, 4, 4)  world -> each allo cam
+            "K":          allo_K,      # (8, 3, 3)
+            "image_size": image_size,  # (9, 2)
+        },
+        "meta": {
+            "sid":        sid,
+            "seq_name":   seq_name,
+            "num_frames": num_frames,
+            "gender":     sub["gender"],
+        },
+    }
+
+
+def get_frame(seq_data, idx):
+    """Return data for a single frame (0-indexed)."""
+    n = seq_data["meta"]["num_frames"]
+    assert 0 <= idx < n, f"Frame {idx} out of range (0-{n-1})"
+
+    def _frame_hand(h):
+        return {k: (v[idx] if isinstance(v, torch.Tensor) else v[idx])
+                for k, v in h.items()}
+
+    frame = {
+        "right":       _frame_hand(seq_data["right"]),
+        "left":        _frame_hand(seq_data["left"]),
+        "world2ego":   seq_data["ego_cam"]["world2ego"][idx],  # (4, 4)
+        "K_ego":       seq_data["ego_cam"]["K"],               # (3, 3)
+        "dist8":       seq_data["ego_cam"]["dist8"],           # (8,)
+        "static_cams": seq_data["static_cams"],
+    }
+
+    # attach image paths if cropped_images are available
+    img_dir = op.join(DATA_ROOT, "cropped_images",
+                      seq_data["meta"]["sid"], seq_data["meta"]["seq_name"])
+    if op.exists(img_dir):
+        fname = f"{idx + 1:05d}.jpg"
+        frame["images"] = {
+            name: p for name, view_id in zip(VIEW_NAMES, range(9))
+            if op.exists(p := op.join(img_dir, str(view_id), fname))
+        }
+
+    return frame
+
+
+# --------------------------------------------------------------------------
+# CLI helpers
+# --------------------------------------------------------------------------
+
+def print_summary(seq_data):
+    m = seq_data["meta"]
+    print(f"\n=== Sequence: {m['sid']}/{m['seq_name']} ===")
+    print(f"Frames : {m['num_frames']}")
+    print(f"Subject: {m['sid']}  gender={m['gender']}")
+    print(f"\nRight hand shape (10,): {seq_data['right']['shape'][0].numpy()}")
+    print(f"Left  hand shape (10,): {seq_data['left']['shape'][0].numpy()}")
+    print(f"\nEgo cam K (3x3):\n{seq_data['ego_cam']['K'].numpy()}")
+    print(f"Ego cam dist8: {seq_data['ego_cam']['dist8'].numpy()}")
+    print(f"\nAllo cams: {seq_data['static_cams']['world2cam'].shape[0]}")
+    print(f"Image sizes (w x h):\n{seq_data['static_cams']['image_size']}")
+
+
+def print_frame(frame, idx):
+    print(f"\n--- Frame {idx} ---")
+    for side in ["right", "left"]:
+        h = frame[side]
+        print(f"\n[{side} hand]")
+        print(f"  rot   (3,)  : {h['rot'].numpy()}")
+        print(f"  trans (3,)  : {h['trans'].numpy()}")
+        print(f"  pose  (45,) first 6: {h['pose'].numpy()[:6]}")
+        print(f"  shape (10,) : {h['shape'].numpy()}")
+        print(f"  fitting_err : {h['fitting_err']:.4f}")
+    print(f"\n[Ego world2ego row 0-1]:\n{frame['world2ego'].numpy()[:2]}")
+    if "images" in frame:
+        print(f"\n[Available images]")
+        for view, path in frame["images"].items():
+            print(f"  {view:8s}: {path}")
+
+
+def construct_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--mano_p", type=str, default=None)
+    parser.add_argument("--frame",  type=int, default=0)
+    return parser.parse_args()
+
+
+def main():
+    args = construct_args()
+
+    if args.mano_p is not None:
+        mano_p = args.mano_p
+    else:
+        candidates = glob(op.join(DATA_ROOT, "raw_seqs", "*", "*.mano.npy"))
+        assert candidates, "No .mano.npy files found. Unzip raw_seqs.zip first."
+        mano_p = sorted(candidates)[0]
+
+    print(f"Loading: {mano_p}")
+    seq_data = load_hand_seq(mano_p)
+
+    print_summary(seq_data)
+    frame = get_frame(seq_data, args.frame)
+    print_frame(frame, args.frame)
+
+
+if __name__ == "__main__":
+    main()