Datasets:

BitRobot
/

RoboCap-LiDAR-100

---
license: cc-by-nc-4.0
pretty_name: RoboCap LiDAR-100 (Southeast Asia egocentric LiDAR pilot)
language:
  - en
task_categories:
  - robotics
  - depth-estimation
  - video-classification
tags:
  - egocentric
  - lidar
  - point-cloud
  - depth
  - imu
  - fisheye
  - mcap
  - kitchen
  - restaurant
  - auto-repair
  - car-detailing
  - embodied-ai
  - manipulation
size_categories:
  - 1K<n<10K
extra_gated_heading: Request access to RoboCap LiDAR-100
extra_gated_prompt: >-
  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.
extra_gated_fields:
  Name: text
  Affiliation: text
  Intended use: text
  I agree to the terms above: checkbox
---

# RoboCap LiDAR-100

<video controls autoplay muted loop playsinline width="640" poster="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples_poster.jpg" src="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples.mp4">
  <img src="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples.gif" alt="Four task examples, one per row: head camera, LiDAR range image and first-person LiDAR point cloud" width="640">
</video>

*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

![Hours by action](assets/hours_by_action.png)

*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`.*

![Hours by episode length](assets/episode_length.png)

*Median 61 s, max 300 s.*

![Hours by session length](assets/session_length.png)

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

## Contents

```text
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:

1. Native schema: xyz planes filled, float32 per axis.
2. 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.
3. 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:

```python
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

```bibtex
@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.

	---
	license: cc-by-nc-4.0
	pretty_name: RoboCap LiDAR-100 (Southeast Asia egocentric LiDAR pilot)
	language:
	- en
	task_categories:
	- robotics
	- depth-estimation
	- video-classification
	tags:
	- egocentric
	- lidar
	- point-cloud
	- depth
	- imu
	- fisheye
	- mcap
	- kitchen
	- restaurant
	- auto-repair
	- car-detailing
	- embodied-ai
	- manipulation
	size_categories:
	- 1K<n<10K
	extra_gated_heading: Request access to RoboCap LiDAR-100
	extra_gated_prompt: >-
	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.
	extra_gated_fields:
	Name: text
	Affiliation: text
	Intended use: text
	I agree to the terms above: checkbox
	---


	# RoboCap LiDAR-100

	<video controls autoplay muted loop playsinline width="640" poster="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples_poster.jpg" src="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples.mp4">
	<img src="https://huggingface.co/datasets/BitRobot/RoboCap-LiDAR-100/resolve/main/assets/task_examples.gif" alt="Four task examples, one per row: head camera, LiDAR range image and first-person LiDAR point cloud" width="640">
	</video>

	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

	![Hours by action](assets/hours_by_action.png)

	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`.

	![Hours by episode length](assets/episode_length.png)

	Median 61 s, max 300 s.

	![Hours by session length](assets/session_length.png)

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

	## Contents

	```text
	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:

	1. Native schema: xyz planes filled, float32 per axis.
	2. 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.
	3. 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:

	```python
	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

	```bibtex
	@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.