Datasets:

noitomrobotics
/

HiPHI-Hand

pretty_name: HiPHI-Hand
viewer: false
language:
  - en
license: other
license_name: modalitynet-open-research-license
license_link: LICENSE.md
extra_gated_heading: Request Access to ModalityNet Dataset
extra_gated_description: >-
  Please complete the questionnaire below and confirm your agreement with the
  [ModalityNet Open Research
  License](https://modalitynet.com/Open-Research-License) to gain access. For
  commercial licensing, you can contact us at
  [info@modalitynet.com](mailto:info@modalitynet.com).
extra_gated_prompt: >-
  Enter an email address that you can access. Use a company, organization, or
  university email when possible. By submitting this form, you confirm that the
  information is accurate, agree to the dataset terms as well as receiving
  followups from our research team.
extra_gated_button_content: Submit Request
extra_gated_fields:
  First Name: text
  Last / Family Name: text
  Company / Institution: text
  Affiliation:
    type: select
    options:
      - Academia
      - Industry
      - Personal
  Professional / Company Email: text
  Intended Use Case:
    type: select
    options:
      - Academic Research
      - Commercial Evaluation
      - Non-profit / Personal
      - Other
  Country: country
  I confirm that I agree with the ModalityNet Open Research License agreement: checkbox
tags:
  - motion-capture
  - human-motion
  - humanoid-robotics
  - human-object-interaction
  - whole-body-motion
  - bvh
  - framenet
size_categories:
  - 10K<n<100K

# Hand Skeleton Dataset

Numbered stereo fisheye clips, each with two hand-skeleton annotations in the same IMU frame. Clips are grouped into five datasets. Each dataset has its own camera calibration, shared by every clip in that dataset.

Clip folders are 0001/, 0002/, and so on, and the numbering restarts inside each dataset. A clip number is only an index within that dataset. The same number in two datasets is not the same recording. Each clip has its own frame count. Inside one clip, both videos and both annotation files cover the same frames, index 0 … T−1. Frame t in a CSV is video frame t of that clip.

Directory Structure

HiPhi-Hand/
├── README.md
├── visualize.py
├── dataset_01/                 clips 0001–0208 (208 clips)
│   ├── calibration.json
│   └── data/
│       ├── 0001/
│       │   ├── video/
│       │   │   ├── rgb_left.mp4
│       │   │   └── rgb_right.mp4
│       │   ├── annotation/
│       │   │   ├── mediapipe21.csv
│       │   │   └── vicon25.csv
│       │   └── visualization/
│       │       └── stereo_overlay.mp4
│       ├── 0002/
│       └── …
├── dataset_02/                 clips 0001–0156 (156 clips)
├── dataset_03/                 clips 0001–0120 (120 clips)
├── dataset_04/                 clips 0001–0206 (206 clips)
└── dataset_05/                 clips 0001–0104 (104 clips)

dataset_02 through dataset_05 use the same layout as dataset_01: calibration.json next to data/<clip>/.

video/rgb_left.mp4, video/rgb_right.mp4: hardware-synchronized fisheye views, 1360×1360, H.264, 30 fps.
annotation/mediapipe21.csv: 21 MediaPipe hand joints per hand, IMU coordinates, meters.
annotation/vicon25.csv: 25 Vicon hand-skeleton joints per hand, same IMU frame, plus a global orientation quaternion.
visualization/stereo_overlay.mp4: left and right images side by side (2720×1360) with the MediaPipe21 skeleton drawn on.
calibration.json: stereo fisheye calibration for the clips in that dataset. Use the file that sits beside data/, not a copy from another dataset.
visualize.py: redraws the overlay from a clip's videos, CSVs, and that dataset's calibration.

Coordinate Frame

Annotations and calibration use one frame, named imu in calibration.json:

Axis	Direction
+x	wearer's right
+y	up
+z	backward

Unit is meters. Left / Right are the wearer's hands, not the left and right image.

Annotation CSVs

Both files are UTF-8 CSV. A clip is complete when every frame has both hands and every joint has a finite position. visualize.py rejects a clip that is missing rows.

Common columns:

Column	Meaning
`frame_index`	Frame number inside this clip, `0 … T−1`. Equals that clip's video frame index.
`hand_index`	`0` left, `1` right.
`hand`	`Left` or `Right`. Must match `hand_index`.
`joint_index`	Joint number inside that hand. See the tables below.
`joint_name`	Joint name. Must match `joint_index`.
`x_imu_m`, `y_imu_m`, `z_imu_m`	Joint position in the IMU frame, meters.

mediapipe21.csv has 42 rows per frame (2 hands × 21 joints). vicon25.csv has 50 rows per frame (2 hands × 25 joints) and four extra columns:

Column	Meaning
`global_quat_x_imu`	Quaternion x
`global_quat_y_imu`	Quaternion y
`global_quat_z_imu`	Quaternion z
`global_quat_w_imu`	Quaternion w (scalar)

These are unit quaternions, stored in (x, y, z, w) order. The column names describe a global orientation expressed in the IMU frame. The position columns are enough to draw or compare the skeleton; the overlay script does not use the quaternions.

Vicon joint Hand (index 1) is the same 3D point as MediaPipe WRIST (index 0).

MediaPipe21 order

Same names for both hands. Skeleton links used by the overlay: wrist to each finger, then along the finger.

Index	Name
0	`WRIST`
1–4	`THUMB_CMC`, `THUMB_MCP`, `THUMB_IP`, `THUMB_TIP`
5–8	`INDEX_FINGER_MCP`, `INDEX_FINGER_PIP`, `INDEX_FINGER_DIP`, `INDEX_FINGER_TIP`
9–12	`MIDDLE_FINGER_MCP`, `MIDDLE_FINGER_PIP`, `MIDDLE_FINGER_DIP`, `MIDDLE_FINGER_TIP`
13–16	`RING_FINGER_MCP`, `RING_FINGER_PIP`, `RING_FINGER_DIP`, `RING_FINGER_TIP`
17–20	`PINKY_MCP`, `PINKY_PIP`, `PINKY_DIP`, `PINKY_TIP`

Vicon25 order

joint_name is the side prefix plus the suffix below (LeftHand, RightForeArm, …). Overlay links: 0–1, then each finger chain starting at Hand (index 1). Index continues through HandIndex; the other fingers start directly at Hand.

Index	Suffix	Role
0	`ForeArm`	forearm
1	`Hand`	wrist
2	`HandIndex`	index metacarpal
3–6	`HandIndex1` … `HandIndex4`	index finger
7–10	`HandMiddle1` … `HandMiddle4`	middle finger
11	`HandRing`	ring metacarpal
12–15	`HandRing1` … `HandRing4`	ring finger
16	`HandPinky`	pinky metacarpal
17–20	`HandPinky1` … `HandPinky4`	pinky finger
21–24	`HandThumb1` … `HandThumb4`	thumb

calibration.json

Stereo fisheye calibration. format_version is 2.0-stereo. The overlay script rejects any other version.

calibration.json
├── format_version          "2.0-stereo"
├── coordinate_frame        IMU frame of the 3D points
├── transform_convention    how to read the 4×4 matrices
├── projection              which points are in front of the camera
└── cameras
    ├── left
    └── right

transform_convention:

Matrices are named T_target_source: T_camera_imu takes an IMU point into that camera.
Vectors are column vectors.
p_camera = R_camera_imu @ p_imu + t_camera_imu, where R is the top-left 3×3 of T_camera_imu and t is the top-right 3×1.
T_imu_camera is the inverse of T_camera_imu. The script checks T_camera_imu @ T_imu_camera = I, that R is a rotation (det(R) = 1), and that both cameras are present.

projection.front_condition is camera_z_m > 1e-6. Points on or behind the camera are not drawn.

Each of cameras.left and cameras.right has:

Field	Meaning
`image_size_px`	`[width, height]`, here `[1360, 1360]`. Must match the video.
`intrinsics.fx_fy_cx_cy`	`[fx, fy, cx, cy]` in pixels.
`intrinsics.K`	3×3 pinhole matrix built from those four values. The script requires the two to agree.
`distortion.model`	`opencv_equidistant_fisheye` (OpenCV `cv2.fisheye`).
`distortion.coefficients`	`[k1, k2, k3, k4]`.
`extrinsics.T_camera_imu`	4×4 IMU → this camera.
`extrinsics.T_imu_camera`	4×4 this camera → IMU.

Distortion is the OpenCV equidistant fisheye model. With normalized camera coordinates (x, y) = (X/Z, Y/Z):

r = hypot(x, y)
theta = atan(r)
theta_d = theta * (1 + k1*theta^2 + k2*theta^4 + k3*theta^6 + k4*theta^8)
scale = 1            if r is about 0, else theta_d / r
u = fx * x * scale + cx
v = fy * y * scale + cy

A point is visible when Z > 1e-6 and (u, v) lies inside the image.

Minimal projection:

import json
import numpy as np

calibration = json.load(open("dataset_01/calibration.json"))
camera = calibration["cameras"]["left"]
T = np.asarray(camera["extrinsics"]["T_camera_imu"])
point_imu = np.array([-0.10, -0.28, -0.48])          # one CSV row, meters
point_camera = T[:3, :3] @ point_imu + T[:3, 3]

Apply the fisheye model above to point_camera to get a pixel in rgb_left.mp4. Use cameras.right for the right video. The same point_imu is projected into both images; do not transform it from one camera to the other first.

Visualization Script

Requirements:

pip install numpy opencv-python

Run from HiPhi-Hand/. For a clip at dataset_XX/data/<clip>, the script looks for calibration.json two directories above the clip, which is dataset_XX/calibration.json.

python visualize.py --clip dataset_01/data/0001 --output check.mp4

Replace dataset_01/data/0001 with any other clip. Pass --calibration only when the calibration file is not in that default place.

Optional arguments:

--layer mediapipe21     # default
--layer vicon25
--layer both
--max-frames 30

The output is a side-by-side MPEG-4 Part 2 video at the source frame rate. The wearer's left hand is drawn cyan and the right hand orange. VLC and similar players can open it; some browser players cannot.