README.md

---
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<n<100K
---

# MicroDPad (μDPad)

**Project page:** [siplab.org/projects/microDPad](https://siplab.org/projects/microDPad) ·
**Paper:** [μDPad: A Large-Scale Multimodal PPG and IMU Dataset for Wrist-Worn Microgesture Recognition](https://doi.org/10.1145/3776574.3831197) (ICMI '26)

MicroDPad is a dataset of **wrist-worn spatial PPG and IMU recordings of micro-gestures**.
Participants wore a watch-like device with an **8-channel spatial PPG** sensor (green and infrared
light, 8 photodiodes arranged around the wrist), a 3-axis accelerometer and a 3-axis gyroscope, and
performed 11 hand micro-gestures (swipes, taps, pinches and rotations) prompted on a screen. A
synchronized webcam video is available for 94 of the sessions.

For details on the device, the recording protocol and the participants,
we refer to [the paper](https://doi.org/10.1145/3776574.3831197).

| | |
|---|---|
| Participants | **65** (pseudonymous IDs `P01`–`P65`) |
| Sessions | **250** (55 participants × 4 sessions, 10 participants × 3 sessions; ≈5.1 min each) |
| Sensor data | **21.4 h** of PPG + IMU at ≈112.3 Hz |
| Labelled gestures | **37,356** (+ 13,501 "Nothing" windows as negative class) |
| Video | **94 videos, 8.5 h** from 24 participants (13,003 gestures on video) |
| Size | sensor data 0.74 GB, videos 32 GB |

The figures in the paper refer to all recorded data; this is an updated release of the dataset that contains the 250 processed sessions summarised above.

## Repository layout

```
MicroDPad/
├── README.md
├── sensor_data/                     # 0.74 GB, everything needed for sensor-based models
│   ├── P01/
│   │   ├── S1/P01_S1.hdf5
│   │   ├── S2/P01_S2.hdf5
│   │   └── …
│   └── … P65/
└── videos/                          # 32 GB, optional
    ├── sync.csv                     # video <-> 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
`<code>_<index>` (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/<participant>/S<session>/…mp4` and the sensor file `sensor_data/<participant>/S<session>/…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}
}
```