TouchScale

Egocentric Human Vision and Touch for Visual–Tactile Learning

🌐 Project Page · 📄 Paper

Release status: this repository currently hosts 100 hours of TouchScale. The full 500-hour dataset is planned for public release before November 2026.

Overview

TouchScale captures how people see and feel everyday manipulation. Participants wear a unified capture rig — a head-mounted RGB-D camera, two wrist cameras and full-hand tactile gloves with 880 taxels per hand — and perform short, instructed tasks across laboratory, kitchen, workbench, office, medical, bedroom and packing environments. Every stream is recorded on a shared clock, so each frame of video is paired with dense, bimanual contact measurements.

This repository currently hosts 100 hours of the 500-hour TouchScale dataset: 15,324 episodes, 929 tasks and 22 scene types, each with an English natural-language instruction. The full 500 hours are planned for public release before November 2026.

Demo

_{Wring out a wet cloth once with both hands. Head RGB, head depth, both wrist views, per-hand total force and full-hand tactile maps, all time-aligned. Full episode (1080p)}

Place gauze and secure it with tape · Medical / First Aid · full episode (1080p)	Seal a carton with a tape dispenser · Parcel / Packing · full episode (1080p)
Pour water into a spray bottle · Household · full episode (1080p)	Pour from a lab scoop into a cylinder · Laboratory · full episode (1080p)

Every episode also has its own preview video — open the Dataset Viewer above (preview subset) to browse and play any of the 15,324 episodes alongside its task and instruction.

Key Features

🖐️ Dense bimanual touch

Full-hand tactile gloves on both hands with 880 taxels per hand (1.5 × 1.5 mm cells) over all five fingers and the palm, recording per-taxel normal force.

👁️ Egocentric RGB-D with wrist views

A head-mounted RGB-D camera captures the whole interaction; two palm-side wrist cameras capture close-up hand–object contact that the head view often cannot see.

⏱️ One consistent, synchronized pipeline

All recordings use the same generation of hardware and the same synchronization pipeline. Every sample keeps its original timestamps, so streams can be aligned at any rate.

📝 Language-annotated tasks

Each episode comes with a task name and a step-by-step instruction describing the initial state, the actions (including which hand leads), and the completion state.

✅ Quality-controlled

Every episode passes automated checks on completeness, frame timing, cross-stream synchronization, video integrity, visual quality and tactile signal validity (see Quality Control).

Dataset at a Glance

Episodes	15,324
Duration	100.0 h in this release (of 500 h; full release planned before November 2026)
Tasks	929
Scene types	22
Objects	905+
Participants	24 (pseudonymous ids)
Episode length	median 21.9 s (5th–95th percentile 11.3–42.6 s)
Size	~1.05 TB in 430 WebDataset shards (full) + per-episode previews

Hours by scene (table)

Scene	Tasks	Episodes	Hours
Laboratory	163.0	2,881.0	15.0
Lab Apparatus & Assembly Workbench	90.0	1,268.0	13.8
Break-Room Supply & Display Cabinet	77.0	1,494.0	12.6
Kitchen Prep Workbench	65.0	1,206.0	11.1
Medical / First Aid	51.0	1,187.0	7.5
Kitchen	47.0	1,105.0	6.0
Office	46.0	1,070.0	5.9
Parcel / Packing	39.0	907.0	5.7
Tool Bench	34.0	771.0	4.5
Bedroom	29.0	663.0	3.5
Test Tube & Beaker Workbench	17.0	398.0	2.2
Lab Assembly Station	41.0	391.0	1.8
Fragile Food & Portioning Station	123.0	313.0	1.6
Layered Materials & Filing Station	26.0	374.0	1.6
Bedroom / Laundry	10.0	224.0	1.5
Household Cleaning / Organizing	8.0	186.0	1.2
Tools & Continuous-Contact Workbench	11.0	261.0	1.2
Deformable Objects & Tactile Judgment Station	10.0	167.0	1.0
Kitchen Prep Counter	18.0	164.0	0.8
Insertion & Press-Fit Workbench	7.0	139.0	0.7
Break-Room Supply Cabinet	16.0	142.0	0.5
Lab Bench	1.0	13.0	0.1

Sensors and Modalities

Stream	Sensor	File	Rate	Format
Head RGB	Orbbec Gemini 345Lg	rgb_head.mp4	30 fps	H.264, 1280×720
Head depth	Orbbec Gemini 345Lg (registered to head RGB)	depth_head.mkv	30 fps	FFV1, 16-bit, millimetres, 1280×720
Left / right wrist RGB	Intel RealSense D405	wrist_left.mp4, wrist_right.mp4	30 fps	H.264, 1280×720
Tactile gloves	full-hand tactile gloves, 880 taxels/hand	left_hand_data.npz, right_hand_data.npz	35–90 Hz (timestamped)	per-pad taxel grids
Head IMU	Orbbec Gemini 345Lg	imu.txt	~200 Hz	accel (m/s²) + gyro (rad/s)
Aligned episode	—	episode.h5	30 Hz timeline	timestamps, IMU, tactile, task, calibration

Every video has a per-frame timestamp file (*.csv: frame_index,timestamp_s, Unix seconds) on the shared clock; wrist and head cameras are aligned to within 0.1 s. Camera intrinsics are in head_param.json and a Kalibr-format RGB / depth / IMU calibration in kalibr_parameters.yaml.

Tactile glove layout

Each glove has 15 sensor pads. In the NPZ files, pad k is stored as tactile_<k> with shape (T, rows, cols) (normal force per taxel, newtons), plus tf_tactile_x_<k> / tf_tactile_y_<k> (tangential components) and timestamps. Exact 2-D taxel positions for both hands are provided in metadata/glove_geometry_left.json and metadata/glove_geometry_right.json.

Dataset Structure

TouchScale/
├── README.md
├── assets/                           # figures and demo videos shown on this card
├── metadata/
│   ├── episodes.parquet              # one row per episode (fields below)
│   ├── glove_geometry_left.json      # taxel layout of the left glove
│   └── glove_geometry_right.json
├── previews/train/                   # `preview` subset (Dataset Viewer): one preview video per episode
│   ├── metadata.parquet
│   └── 000/ … 429/*.mp4
└── data/                             # full data: all raw streams, WebDataset shards (~2.5 GB each)
    ├── train-00000-of-00430.tar
    └── …

Inside a shard, all files of an episode share the key <episode_id>:

<episode_id>.json                    episode metadata
<episode_id>.rgb_head.mp4            <episode_id>.rgb_head.csv
<episode_id>.depth_head.mkv          <episode_id>.depth_head.csv
<episode_id>.wrist_left.mp4          <episode_id>.wrist_left.csv
<episode_id>.wrist_right.mp4         <episode_id>.wrist_right.csv
<episode_id>.left_hand_data.npz      <episode_id>.right_hand_data.npz
<episode_id>.glove_left_calib.json   <episode_id>.glove_right_calib.json
<episode_id>.imu.txt                 <episode_id>.episode.h5
<episode_id>.head_param.json         <episode_id>.kalibr_parameters.yaml

Episode metadata

Field	Description
episode_id	unique episode id
task_id	task identifier (same task → same id)
task_name	short task name
scene	scene / workstation type
instruction	full instruction: initial state, actions, completion state, suggested duration
items	objects involved
primary_hand	leading hand for mirrored task variants (left / right, null if unspecified)
duration_s, num_frames	episode length (head camera)
collection_date	recording date
actor_id, actor_gender	pseudonymous participant id and gender
glove_rate_hz	tactile sampling rate of the episode
tactile_contact_frac_left / _right	fraction of glove samples with summed normal force > 3 N
head_gyro_p95_rad_s	95th-percentile head angular speed
quality_score	quality score in [0, 1] from the QC pipeline
shard	tar shard containing the episode

episode.h5

metadata/                  attrs: schema_name, schema_version, nominal_fps, n_hands, ...
time/timestamp_ns          (N,)   30 Hz episode timeline
obs/video/<stream>/        epoch (N,), src_idx (N,)     frame index into each video per timeline step
obs/imu/                   epoch, accel (M,3), gyro (M,3)
obs/tactile/raw/<hand>/    t_epoch, pad_<k>, shear_x_<k>, shear_y_<k>   (trimmed to the episode)
task/                      name, task_id, steps, success, seg_start, seg_end
calibration/               head_param, kalibr, glove_left, glove_right

Usage

Browse the previews (the default subset). Install torchcodec to decode the videos, or call .decode(False) to get file references only:

from datasets import load_dataset

previews = load_dataset("2077AIDataFoundation/TouchScale", split="train", streaming=True)
row = next(iter(previews.decode(False)))
print(row["task_name"], "-", row["instruction"])
print(row["video"]["path"])

Stream the full data with the WebDataset loader (no full download needed):

from datasets import load_dataset

ds = load_dataset("webdataset", data_files={"train": "hf://datasets/2077AIDataFoundation/TouchScale/data/train-*.tar"},
                  split="train", streaming=True).decode(False)
ep = next(iter(ds))
meta = ep["json"]                              # episode metadata (dict)
glove = ep["right_hand_data.npz"]              # dict of arrays: timestamps, tactile_<k>, ...
open("rgb_head.mp4", "wb").write(ep["rgb_head.mp4"]["bytes"])
open("episode.h5", "wb").write(ep["episode.h5"]["bytes"])

Select episodes by metadata, then read only the shards you need with webdataset:

import io, numpy as np, pandas as pd, webdataset as wds
from huggingface_hub import hf_hub_download

meta = pd.read_parquet(hf_hub_download("2077AIDataFoundation/TouchScale", "metadata/episodes.parquet", repo_type="dataset"))
shards = sorted(meta[meta.scene == "Kitchen"].shard.unique())
urls = [f"https://huggingface.co/datasets/2077AIDataFoundation/TouchScale/resolve/main/{s}" for s in shards]

for ep in wds.WebDataset(urls):
    right = np.load(io.BytesIO(ep["right_hand_data.npz"]))
    fingertip = right["tactile_3"]          # index fingertip, (T, 9, 8) normal force in N
    t = right["timestamps"]                 # Unix seconds, same clock as the videos

Decode depth (16-bit, millimetres):

import subprocess, numpy as np
raw = subprocess.run(["ffmpeg", "-v", "error", "-i", "depth_head.mkv", "-f", "rawvideo",
                      "-pix_fmt", "gray16le", "-"], capture_output=True).stdout
depth_mm = np.frombuffer(raw, np.uint16).reshape(-1, 720, 1280)

Quality Control

Every released episode passes all of the following automated checks:

• Completeness — all video, depth, tactile, IMU and calibration files present and non-empty; 5 s ≤ duration ≤ 120 s.
• Timing — per stream ≤ 2 % dropped frames, no gap > 0.25 s, monotonic timestamps; wrist streams within 0.1 s of the head camera; IMU 180–220 Hz without gaps.
• Video integrity — container frame counts match the timestamp logs; no truncated, dark or covered camera streams.
• Visual quality — head video sampled at 2 fps: no substantial dark, over-exposed, frozen or blurry segments.
• Tactile validity — no missing values, no sampling gaps > 0.25 s, and measurable contact (> 3 N) during the task.

Limitations

• Participants are predominantly male (95 of 15,324 episodes are by female participants).
• The tactile sampling rate differs between recording sessions (about 35, 57 or 65–90 Hz); always use the per-sample timestamps.
• Tactile values are the glove's calibrated output in newtons.
• All episodes are successful demonstrations; there are no failure examples.

License

TouchScale is released under CC BY-NC 4.0: free for non-commercial research and education with attribution. For commercial use, please contact 2077AI.

Citation

If you use TouchScale, please cite:

@article{li2026touchscale,
  title   = {TouchScale: 500 Hours of Human Vision and Touch for Visual-Tactile Learning},
  author  = {Li, Dayou and Wang, Hao and Yang, Qianqian and Zhu, Zihao and Fang, Haoquan and Zeng, Ziyao and Han, Yan and Wang, Zihan and Wang, Yan and Huang, Baoru and Wang, Dilin and Shimada, Kenji and Luo, Yiyue and Li, Manling and Lv, Teresa and Mukadam, Mustafa and Ranjan, Rakesh and Zhang, Ruohan and He, Qi and Liu, Changliu and Chen, Xu and Pavone, Marco and Liu, Bangya and Li, Jiachen and Tomizuka, Masayoshi and Fan, Zhiwen},
  journal = {arXiv preprint arXiv:2610.10288},
  year    = {2026}
}