--- pretty_name: MicroDPad license: cc-by-nc-nd-4.0 tags: - gesture - wearable - imu - ppg - photoplethysmography - gesture-recognition - smartwatch - time-series - video size_categories: - 10K sensor synchronisation (one row per video) ├── P02/ │ ├── S1/P02_S1.mp4 │ └── … └── … ``` Sensor data and videos are separate top-level folders, so you can download only what you need. A video `videos/Pxx/Sy/Pxx_Sy.mp4` belongs to the sensor file `sensor_data/Pxx/Sy/Pxx_Sy.hdf5`. Session numbers are the original recording session numbers (1–4); a missing number means that session is not part of the release. ## Download Sensor data only (recommended starting point, 0.74 GB): ```python from huggingface_hub import snapshot_download root = snapshot_download( repo_id="eth-siplab/microdpad", repo_type="dataset", allow_patterns=["README.md", "sensor_data/*"], ) ``` Other useful patterns: `["videos/sync.csv", "videos/*"]` (all videos, 32 GB), `["sensor_data/P44/*", "videos/P44/*", "videos/sync.csv"]` (one participant). Command line equivalent: ```bash huggingface-cli download eth-siplab/microdpad --repo-type dataset \ --include "sensor_data/*" --local-dir MicroDPad ``` ## Sensor data (HDF5) Each session is one self-contained HDF5 file. All signals are stored in the group `data/` as 1-D `float64` arrays of equal length *N* (one value per sample): | Dataset | Description | Unit | |---|---|---| | `timestamp` | time since the first sample of the session | s | | `acc_x`, `acc_y`, `acc_z` | IMU accelerometer | m/s² | | `gyro_x`, `gyro_y`, `gyro_z` | IMU gyroscope (range ±1024 °/s; the fastest rotations saturate at this limit) | °/s | | `acc_ppg_x`, `acc_ppg_y`, `acc_ppg_z` | accelerometer on the PPG sensor board | m/s² | | `ppg_green_1` … `ppg_green_8` | PPG, green LED, photodiodes 1–8 | raw ADC counts | | `ppg_ir_1` … `ppg_ir_8` | PPG, infrared LED, photodiodes 1–8 | raw ADC counts | | `ppg_amb_1` … `ppg_amb_8` | ambient light (no LED), photodiodes 1–8 — only in 94 sessions | raw ADC counts | For the device and the arrangement of photodiodes 1–8 around the wrist, we refer to [the paper](https://doi.org/10.1145/3776574.3831197). **Time axis.** `data/timestamp` gives the time of every sample. Signals are sampled at ≈112.3 Hz; the exact rate differs slightly per session (112.20–112.35 Hz), and four sessions (`P10` S1–S3, `P58` S4) contain gaps. Always use `timestamp` rather than assuming a constant rate. All times are relative to the session start; absolute recording dates and times have been removed. **Labels.** Every labelled window is a group at the root of the file (next to `data/`), named `_` (e.g. `a_0030`), with five scalar datasets: | Field | Description | |---|---| | `label` | gesture code (string, see table below) | | `start_index`, `end_index` | sample range in the `data/` arrays (end exclusive) | | `start_time`, `end_time` | the same window in seconds since session start | Gesture windows are about 1.3 s long and follow each other back to back during the gesture blocks. Prefer the sample indices; the times are given for convenience. | Code | Gesture | Count | |---|---|---| | `p` | Fast Pinch | 4,988 | | `pc` | Pinch Hold | 4,033 | | `po` | Pinch Open | 4,019 | | `c` | Swipe Left | 3,857 | | `sp` | Side Tap | 3,853 | | `a` | Swipe Forward | 3,851 | | `d` | Swipe Right | 3,850 | | `b` | Swipe Backward | 3,849 | | `pbd` | Back to Default | 2,524 | | `prl` | Rotate Left | 1,269 | | `prr` | Rotate Right | 1,263 | | `o` | Nothing (negative class: windows without a gesture) | 13,501 | | `s` | start marker of the recording (not a gesture) | 498 | Rotations only occur inside the sequence *Pinch Hold → Rotate Left/Right → Pinch Open → Back to Default*. "Nothing" windows are sampled from periods without gestures and may overlap each other. ### Loading a session ```python import h5py import numpy as np def load_session(path): with h5py.File(path, "r") as f: data = {name: f["data"][name][:] for name in f["data"]} labels = [] for name, g in f.items(): if name == "data": continue code = g["label"][()] labels.append(dict( label=code.decode() if isinstance(code, bytes) else str(code), start_index=int(g["start_index"][()]), end_index=int(g["end_index"][()]), start_time=float(g["start_time"][()]), end_time=float(g["end_time"][()]), )) labels.sort(key=lambda l: l["start_index"]) return data, labels data, labels = load_session(f"{root}/sensor_data/P44/S1/P44_S1.hdf5") # all gesture windows as (label, [channels x samples]) pairs channels = [f"ppg_green_{i}" for i in range(1, 9)] + ["acc_x", "acc_y", "acc_z", "gyro_x", "gyro_y", "gyro_z"] signals = np.stack([data[c] for c in channels]) windows = [(l["label"], signals[:, l["start_index"]:l["end_index"]]) for l in labels if l["label"] not in ("o", "s")] ``` ## Videos `videos/Pxx/Sy/Pxx_Sy.mp4` shows the participant's hand from a webcam (H.264, no audio). The videos cover 8.5 h of 94 sessions of 24 participants: * 75 videos: 1280×720, constant 30 fps. * 19 videos: 1920×1080, **variable frame rate** (≈21–31 fps). For these the per-frame timestamps are irregular — never compute time as `frame_number / fps`; use each frame's presentation timestamp (PTS), as in the example below. The top-left corner of the original webcam image contained the on-screen instruction shown to the participant; this band is still visible in the videos. The instruction precedes the actual movement — use the labels in the HDF5 files, not the overlay text. ### Synchronisation (`videos/sync.csv`) One row per video: | Column | Meaning | |---|---| | `participant`, `session` | identifies the video `videos//S/…mp4` and the sensor file `sensor_data//S/…hdf5` | | `video_start_s` | time on the sensor `timestamp` axis at which the video starts (its first frame, video time 0) | A video frame shown at video time `v` (seconds, the frame's presentation timestamp) belongs to sensor time `v + video_start_s`. A positive value means the video started after the sensor recording, a negative value that it started before it. The synchronisation is accurate to about ±1 video frame (≈33 ms). ```python import csv import cv2 import numpy as np sync = {(r["participant"], int(r["session"])): float(r["video_start_s"]) for r in csv.DictReader(open(f"{root}/videos/sync.csv"))} pid, session = "P44", 1 video_start = sync[(pid, session)] data, labels = load_session(f"{root}/sensor_data/{pid}/S{session}/{pid}_S{session}.hdf5") t = data["timestamp"] cap = cv2.VideoCapture(f"{root}/videos/{pid}/S{session}/{pid}_S{session}.mp4") while True: ok, frame = cap.read() if not ok: break v = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0 # video time of this frame sample = int(np.clip(np.searchsorted(t, v + video_start), 0, len(t) - 1)) # matching sensor sample # ... frame <-> data[...][sample] ``` ## Data collection For details on the device, the recording protocol and the participants, we refer to [the paper](https://doi.org/10.1145/3776574.3831197). ## Licence This dataset is released under the [Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International licence (CC BY-NC-ND 4.0)](https://creativecommons.org/licenses/by-nc-nd/4.0/). ## Citation If you use this dataset, please cite: ```bibtex @inproceedings{10.1145/3776574.3831197, author = {Hauptmann, Lars and Hollidt, Dominik and Liu, Xintong and Meier, Manuel and Holz, Christian}, title = {μDPad: A Large-Scale Multimodal PPG and IMU Dataset for Wrist-Worn Microgesture Recognition}, year = {2026}, isbn = {9798400723186}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3776574.3831197}, doi = {10.1145/3776574.3831197}, abstract = {Gestures provide a natural interaction modality for mobile and wearable devices. However, most prior work focuses on macro gestures involving large wrist or arm movements, which are fatiguing and socially conspicuous. In contrast, microgestures, subtle, low-effort finger movements that can be performed one-handed and without visual attention, offer a promising alternative but remain significantly harder to sense and recognize. In this work, we present a large-scale multimodal dataset for wrist-based microgesture recognition, collected with an integrated wearable prototype that combines an IMU with an 8-channel spatial PPG sensor configuration similar to one emerging in commercial fitness watches. Because such devices typically do not expose raw optical signals, our goal is to provide the community with a resource for studying whether spatial PPG can capture the minute tissue deformations associated with microgestures. Our dataset comprises 25 hours of synchronized IMU and PPG recordings from 66 participants, including 9 hours of aligned video annotations, and captures substantial variability in users, hand poses, and execution styles. To establish reference performance, we benchmark a range of recognition pipelines and present a simple multimodal baseline. This baseline already shows that adding spatial PPG improves microgesture detection over IMU-only sensing, reaching 83.7\% accuracy with a 3.7\% false-positive rate, while also underscoring that microgesture recognition remains substantially harder than recognizing coarser macro-gesture vocabularies. By releasing the dataset, we aim to enable more substantive algorithmic advances toward practical, low-effort, and socially acceptable microgesture interaction on future wrist-worn devices. Project page: siplab.org/projects/microDPad.}, booktitle = {Proceedings of the 28th International Conference On Multimodal Interaction}, pages = {837–850}, numpages = {14}, keywords = {Microinteractions, microgestures, smartwatch input, wrist-worn sensing, IMU, photoplethysmography (PPG), online decoding.}, location = {Napoli, Italy}, series = {ICMI '26} } ```