This dataset contains first-person video of people at work. By requesting access you agree: (1) to use it for non-commercial research only unless you hold a separate commercial licence from BitRobot; (2) not to attempt to identify any person, business or location shown; (3) not to redistribute the raw data; (4) to remove the data on request from BitRobot.

RoboCap LiDAR-100

Five seconds from four episodes, one per row: stir frying rice, slicing salmon, wrapping meat and fitting drum brake springs. Left to right: the head camera, the LiDAR range image (320 x 240), and the same scan as a coloured point cloud seen from just behind the sensor.

One hundred hours of first-person recordings of people at work in restaurant kitchens, an auto repair shop and a car detailing shop in Southeast Asia, released in two 50-hour tranches. This repository currently holds the first tranche: 50 cleaned, verified hours. The second 50 hours will be added once cleared, and all tables and charts below describe the released 50 hours only. The capture unit is worn on a cap and records a solid-state LiDAR (320 x 240 range image, 76,800 points per scan, 30 or 10 Hz), a fisheye RGB camera (1600 x 1200 at 30 fps) and an IMU (870 Hz) on one timeline. The release is 1,964 task episodes from 132 recording sessions, every one with an environment, scene, task category, action and caption.

It is built for egocentric manipulation and perception research: metric depth for every frame from a wearable LiDAR, action recognition in cluttered real workplaces, and video-to-robot policy pretraining.

Overview


Episodes	1,964	Hours released	50.0 of 100
Sessions	132	Sites	5 (3 restaurant kitchens, 1 auto repair shop, 1 car detailing shop)
MCAP payload	about 3.4 TB, one file per episode	Episode length	median 61 s, mean 92 s, max 300 s
Environments	6	Venue types	12
Scenes	19	Task categories	37
Distinct actions	196	LiDAR rate	30 Hz (23.1 h) and 10 Hz (26.9 h)

How the first 50 hours were chosen

This release is a curated subset of an 88.5-hour verified pool (3,657 episodes, every one with a passed MCAP payload digest, recorded SHA-256 and sidecar QA). Hours were allocated across the 37 task categories by a fair-share water-fill (small categories keep everything, large ones are capped), then the same allocation was applied across action labels within each category, and episodes were drawn round-robin across recording sessions to spread sites, workers and scenes. The result keeps every keepable task category, 196 of 196 selected action labels across all five sites, and flattens the long tail: the largest action (stir frying food) is 2.3 h, 4.6 percent of the release. A small amount of desk-writing and document-handling footage in the pool was excluded as out of scope.

Capture device

A single calibrated head unit worn on a cap: a solid-state LiDAR that returns a dense 320 x 240 range image per scan, a fisheye RGB camera and an IMU, all time-stamped on one clock.

Stream	Specification
LiDAR	320 x 240 range image per scan (76,800 points), about 125 x 89 deg field of view; 30 Hz on cap-01 and cap-02, 10 Hz on cap-03
Per point	xyz in metres, intensity, projected RGB, time offset within the scan
Camera	1600 x 1200 JPEG at 30 fps, equidistant fisheye, intrinsics and distortion per session
IMU	870 Hz gyroscope and accelerometer
Calibration	camera intrinsics, LiDAR field of view and camera-to-LiDAR extrinsics in each session's `calibration.yaml`

The sensor looks forward and down from the forehead, so hands and work surfaces fill the frame; ceilings, walls behind the worker and far corners are rarely captured.

Diversity

Top 40 of 196 actions. The largest, stir frying food, is 2.3 h (4.6 percent). Full vocabularies with counts and hours are in metadata/taxonomy.md.

Median 61 s, max 300 s.

Total hours per session-length band. A session is one worker at one site in one continuous recording.

README.md                         this card
assets/                           the clip and charts above
metadata/
  episodes.parquet                one row per episode (1,964 rows); also as episodes.csv
  cut_list_50h.csv                the 1,964 released episodes with source segment, camera frame
                                  indices, UTC-nanosecond windows and per-file MCAP size and SHA-256
  sessions.csv                    one row per recording: session id, site type, cap, LiDAR Hz, episodes, hours
  taxonomy.md                     label vocabularies with counts and hours
calibration/<session_id>/
  calibration.yaml                camera intrinsics and distortion, LiDAR fov, camera-LiDAR extrinsics
episodes/<session_id>/
  <episode_id>.mcap               one file per released episode: LiDAR, camera and IMU for that time span,
                                  with calibration.yaml (and lidar_angle_vectors.bin where used) as attachments

Channel contract

Every episode is one .mcap file (zstd chunks, protobuf messages) with the topics of the recording it was cut from.

Topic	Message	Contents
/rs_lidar/points	PointCloudFrame (protobuf)	one 320 x 240 LiDAR scan (76,800 points) per message: planes x_f32, y_f32, z_f32 (or distance_f32, see below), intensity_u8, r_u8, g_u8, b_u8, time_offset_i32; scan start and end timestamps
/rs_camera/color/image_raw	MonoImage (protobuf)	JPEG 1600 x 1200, sensor timestamp
/rs_imu	Imu (protobuf)	angular velocity, linear acceleration, timestamps (orientation fields unfilled)
/tf, /rs_camera/color/camera_info	standard	static transforms and camera model

Three point-cloud encodings exist across sessions and a loader should handle all three:

Native schema: xyz planes filled, float32 per axis.
Sessions tagged _newversion_: xyz planes empty and a distance_f32 plane instead; the attachment lidar_angle_vectors.bin holds 76,800 interleaved int16 xyz triples, divide by 32767 for the unit ray of each pixel, then xyz = distance x direction. The rays match the native sessions exactly.
Sessions HU3AQO and WELCZW (restaurant B, cap-02, 12 episodes, 0.17 h in this release) were recorded with the foxglove schemas instead: /rs_lidar/points is a foxglove.PointCloud whose data holds 76,800 packed 24-byte records (x, y, z float32 at bytes 0-11; intensity, r, g, b, a uint8 at bytes 12-16; 3 bytes padding; per-point time offset float32 at bytes 20-23), and the camera topic is a foxglove.CompressedImage carrying the same JPEG bytes.

The LiDAR grid is a true range image (320 columns across about 125 degrees of yaw, 240 rows across about 89 degrees of pitch) and reads upright after a 180-degree rotation. Invalid pixels carry zero or non-finite range, typically 15 percent or more of a kitchen frame, more on dark or specular surfaces. calibration.yaml gives a pinhole model with equidistant distortion (four coefficients), the 3 x 3 intrinsic matrix, the camera-to-LiDAR rotation as a quaternion, and the LiDAR yaw and pitch limits in degrees. Cap clocks reset at power-on, so there are no wall-clock timestamps; durations and within-session ordering are exact.

Episode table

metadata/episodes.parquet lists the 1,964 episodes, one row each:

Column	Meaning
episode_id, session_id	stable integer id; 6-character code of the recording
site_type, cap, lidar_hz	restaurant_a / restaurant_b / restaurant_c / auto_repair_shop / detailing_shop; cap-01..03; 30 or 10
start_s, end_s, duration_s	offset within the session, seconds, measured from the session's first released episode
environment, venue_type, scene	e.g. food_and_beverage / restaurant / commercial_kitchen
task_category, action, caption	e.g. kitchen_prep / trimming_vegetables, plus a one-sentence description

Download and loading

Pick episodes from the table, then download only those files:

import pandas as pd, numpy as np
from huggingface_hub import snapshot_download
from mcap.reader import make_reader
from mcap_protobuf.decoder import DecoderFactory

repo = "BitRobot/RoboCap-LiDAR-100"
root = snapshot_download(repo, repo_type="dataset", allow_patterns=["metadata/*", "calibration/*"])
episodes = pd.read_parquet(f"{root}/metadata/episodes.parquet")
pick = episodes[(episodes.task_category == "dishwashing") & (episodes.lidar_hz == 30)].head(5)

files = [f"episodes/{r.session_id}/{r.episode_id}.mcap" for r in pick.itertuples()]
root = snapshot_download(repo, repo_type="dataset", allow_patterns=files)

with open(f"{root}/{files[0]}", "rb") as f:
    reader = make_reader(f, decoder_factories=[DecoderFactory()])
    rays = {a.name: a.data for a in reader.iter_attachments()}.get("lidar_angle_vectors.bin")   # present in _newversion_ sessions
    for schema, channel, message, msg in reader.iter_decoded_messages(topics=["/rs_lidar/points"]):
        if msg.distance_f32:                                            # range plus fixed ray directions
            rng = np.frombuffer(msg.distance_f32, "<f4").reshape(240, 320)
            dirs = (np.frombuffer(rays, "<i2").astype(np.float32) / 32767).reshape(240, 320, 3)
            xyz = rng[..., None] * dirs
        else:                                                            # xyz planes
            xyz = np.stack([np.frombuffer(getattr(msg, k), "<f4") for k in ("x_f32", "y_f32", "z_f32")], -1).reshape(240, 320, 3)
        rgb = np.stack([np.frombuffer(getattr(msg, k), "u1") for k in ("r_u8", "g_u8", "b_u8")], -1).reshape(240, 320, 3)
        break

Camera frames are JPEG bytes in msg.data on /rs_camera/color/image_raw; IMU samples are angular_velocity_* and linear_acceleration_* on /rs_imu. A 60 s episode at 30 Hz (1,800 LiDAR scans of 76,800 points plus 1,800 camera frames) is about 2 GB, so download by session or by label rather than cloning the whole repo. Requires mcap, mcap-protobuf-support, numpy, zstandard, huggingface_hub.

Citation

@misc{robocap_lidar_100_2026,
  title        = {RoboCap LiDAR-100: head-mounted LiDAR, camera and IMU recordings of restaurant, auto repair and car detailing work},
  author       = {{BitRobot}},
  organization = {BitRobot},
  year         = {2026},
  url          = {https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100}
}

Contact

Commercial licensing and takedown requests: contact@bitrobot.ai. Report label errors as issues on this repo.

Downloads last month: 51

Total file size:

3.4 TB

Request access to RoboCap LiDAR-100