Update ARCTICHUGGFACE/hand_reader.py

ARCTICHUGGFACE/hand_reader.py

@@ -2,11 +2,10 @@
 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
+    python scripts_data/hand_reader.py --mano_p ./data/raw_seqs/s01/box_grab_01.mano.npy
+    python scripts_data/hand_reader.py --mano_p ./data/raw_seqs/s01/box_grab_01.mano.npy --frame 10
 """
 
 import argparse
@@ -22,6 +21,7 @@ sys.path = ["."] + sys.path
 
 DATA_ROOT = "./data"
 
+# the view information contained in misc.json
 # 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",
@@ -32,7 +32,6 @@ 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)
@@ -45,11 +44,20 @@ def load_hand_seq(mano_p):
 
     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,)
+            # (F, 3)
+            "rot":         torch.FloatTensor(data[side]["rot"]),    
+            # (F, 45)                   
+            #posture
+            "pose":        torch.FloatTensor(data[side]["pose"]),       
+            # (F, 3)               
+            #location
+            "trans":       torch.FloatTensor(data[side]["trans"]),               
+            # (F, 10)      
+            #mano shape
+            "shape":       torch.FloatTensor(data[side]["shape"]).repeat(num_frames, 1),  
+            #an error, lower error means more confident
+            # (F,)
+            "fitting_err": data[side]["fitting_err"],                                  
         }
 
     right = _load_hand("right")
@@ -61,11 +69,17 @@ def load_hand_seq(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,)
+    #direction of camera under world coordinate
+    # (F, 3, 3)
+    R_ego = torch.FloatTensor(egocam["R_k_cam_np"])   
+    #location world coordinate
+    # (F, 3, 1)
+    T_ego = torch.FloatTensor(egocam["T_k_cam_np"])   
+    # intrinsics
+    # (3, 3)
+    K_ego = torch.FloatTensor(egocam["intrinsics"])   
+    # (8,)
+    dist8 = torch.FloatTensor(egocam["dist8"])        
 
     # build homogeneous transform, same as preprocess_dataset.py
     world2ego = torch.zeros((num_frames, 4, 4))
@@ -74,8 +88,8 @@ def load_hand_seq(mano_p):
     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")
+    sid    = op.basename(op.dirname(mano_p))
+    misc_p = op.join(DATA_ROOT, "meta", "misc.json")
     with open(misc_p) as f:
         misc = json.load(f)
 
@@ -84,7 +98,7 @@ def load_hand_seq(mano_p):
     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", "")
+    seq_name = op.basename(mano_p).replace(".mano.npy", "")
 
     return {
         "right": right,
@@ -173,10 +187,104 @@ def print_frame(frame, idx):
             print(f"  {view:8s}: {path}")
 
 
+def project_point(pt_world, world2cam, K):
+    """Project a 3D world point to 2D image coords via a camera."""
+    pt_h = np.array([*pt_world, 1.0], dtype=np.float32)       # (4,)
+    pt_cam = (world2cam @ pt_h)[:3]                            # (3,)
+    if pt_cam[2] <= 0:
+        return None
+    x = K[0, 0] * pt_cam[0] / pt_cam[2] + K[0, 2]
+    y = K[1, 1] * pt_cam[1] / pt_cam[2] + K[1, 2]
+    return (float(x), float(y))
+
+
+def visualize_wrists(frame, idx, seq_data):
+    """
+    For each allo camera that has a cropped image, overlay the projected
+    right (red) and left (blue) wrist positions on the image.
+    """
+    import matplotlib.pyplot as plt
+    import matplotlib.image as mpimg
+    import matplotlib.patches as mpatches
+
+    if "images" not in frame:
+        print("No cropped images found — run unzip first.")
+        return
+
+    world2cam = seq_data["static_cams"]["world2cam"].numpy()  # (8, 4, 4)
+    K_allo    = seq_data["static_cams"]["K"].numpy()          # (8, 3, 3)
+
+    trans_r = frame["right"]["trans"].numpy()   # (3,)
+    trans_l = frame["left"]["trans"].numpy()    # (3,)
+
+    # collect allo views (view_id 1-8 → cam index 0-7)
+    allo_items = [(name, path) for name, path in frame["images"].items()
+                  if name.startswith("allo")]
+
+    if not allo_items:
+        print("No allo images found for this frame.")
+        return
+
+    ncols = len(allo_items)
+    fig, axes = plt.subplots(1, ncols, figsize=(5 * ncols, 5))
+    if ncols == 1:
+        axes = [axes]
+
+    for ax, (view_name, img_path) in zip(axes, allo_items):
+        cam_idx = int(view_name.split("_")[1]) - 1   # "allo_1" → 0
+        W2C = world2cam[cam_idx]                     # (4, 4)
+        K   = K_allo[cam_idx]                        # (3, 3)
+
+        img = mpimg.imread(img_path)
+        crop_h, crop_w = img.shape[:2]
+
+        # project both wrists to full-image coords
+        pt_r = project_point(trans_r, W2C, K)
+        pt_l = project_point(trans_l, W2C, K)
+
+        # estimate crop center as midpoint of the two wrists (heuristic,
+        # since we don't have the exact bbox without splits data)
+        if pt_r is not None and pt_l is not None:
+            crop_cx = (pt_r[0] + pt_l[0]) / 2
+            crop_cy = (pt_r[1] + pt_l[1]) / 2
+        elif pt_r is not None:
+            crop_cx, crop_cy = pt_r
+        elif pt_l is not None:
+            crop_cx, crop_cy = pt_l
+        else:
+            ax.imshow(img)
+            ax.set_title(f"{view_name}  frame {idx}")
+            ax.axis("off")
+            continue
+
+        # place image so estimated crop center aligns with wrist midpoint
+        extent = [crop_cx - crop_w / 2, crop_cx + crop_w / 2,
+                  crop_cy + crop_h / 2, crop_cy - crop_h / 2]
+        ax.imshow(img, extent=extent, aspect="auto")
+        ax.set_title(f"{view_name}  frame {idx}")
+        ax.axis("off")
+
+        for pt, color in [(pt_r, "red"), (pt_l, "blue")]:
+            if pt is not None:
+                ax.plot(*pt, "o", color=color, markersize=10, markeredgewidth=2,
+                        markeredgecolor="white")
+
+    r_patch = mpatches.Patch(color="red",  label="right wrist")
+    l_patch = mpatches.Patch(color="blue", label="left wrist")
+    fig.legend(handles=[r_patch, l_patch], loc="lower center", ncol=2, fontsize=12)
+    plt.tight_layout()
+    plt.savefig(f"wrist_vis_frame{idx}.png", dpi=100)
+    plt.show()
+    print(f"Saved to wrist_vis_frame{idx}.png")
+
+
 def construct_args():
     parser = argparse.ArgumentParser()
+    #mano_p: information of position and shape
     parser.add_argument("--mano_p", type=str, default=None)
-    parser.add_argument("--frame",  type=int, default=0)
+    # for a specific frame
+    parser.add_argument("--frame",  type=int, default=55)
+    parser.add_argument("--vis",    action="store_true", default=True, help="visualize wrist projection")
     return parser.parse_args()
 
 
@@ -197,6 +305,10 @@ def main():
     frame = get_frame(seq_data, args.frame)
     print_frame(frame, args.frame)
 
+    if args.vis:
+        visualize_wrists(frame, args.frame, seq_data)
+
 
 if __name__ == "__main__":
     main()
+