---
license: cc-by-4.0
pretty_name: RoboCloth
language:
- en
size_categories:
- n<1K
task_categories:
- image-to-3d
- other
tags:
- brdf
- btf
- cloth
- materials
- reflectance
- robotics
- hdr
- 3d
- computer-graphics
- inverse-rendering
- material-capture
- multi-view
- multi-light
configs:
- config_name: index
  data_files: index/*.parquet
  default: true
---

# RoboCloth

![Left: the robotic capture rig with one captured frame inset. Right: held-out RoboCloth materials path-traced as the sofa, curtain, pillow and carpet fabrics of a room scene.](https://huggingface.co/datasets/theialab/RoboCloth-assets/resolve/main/media/teaser.png)

**500 real cloth materials, each imaged in ≈580 calibrated 16-bit linear HDR frames by a
robotic camera-and-light rig.** Two robot arms move the camera and a single LED over a
turntable, so view and light directions are sampled freely across the hemisphere instead of
on a fixed gantry grid. Camera poses are refined by structure-from-motion and aligned to the
robot frame, and every material ships with its HDR frames, a sparse surface point cloud and
a structured per-point observation tensor (≈1.6×10⁸ RGB observations per material, ≈80
billion in total) that feeds neural-material training directly. 400 materials are for
training and 100 are held out. The released two-stage pipeline turns each material into a
compact neural BRDF that renders in Mitsuba 3 or any real-time shader that can evaluate a
small MLP.

- **Project page:** <https://theialab.github.io/robocloth/>
- **Paper:** <https://arxiv.org/abs/2610.21090>
- **Code:** <https://github.com/theialab/robocloth> (Apache-2.0)
- **Checkpoints and render assets:** [`theialab/RoboCloth-assets`](https://huggingface.co/datasets/theialab/RoboCloth-assets)
  — pretrained decoders and self-contained, renderable per-material checkpoints (no capture
  data needed to render them)

## Quick start

```bash
pip install -U huggingface_hub numpy pillow
hf download theialab/RoboCloth --repo-type dataset \
    --include "globals/*" --include "examples/*" --include "materials/145/*" --local-dir ./RoboCloth   # one material, 3-10 GB
python RoboCloth/examples/load_material.py --mid 145   # prints every array, extracts one frame from hdr.tar
                                                      # (fetches through the Hub cache, not from ./RoboCloth)
```

```python
import numpy as np; from huggingface_hub import hf_hub_download
obs = np.load(hf_hub_download("theialab/RoboCloth", "materials/145/observations_structured.npz", repo_type="dataset"))
rgbs, xyz = obs["rgbs"], obs["xyz"]                     # (K,V,3) uint16, 0 = unobserved · (V,3) float32 m
cam_pos, light_pos = obs["cam_pos"], obs["light_pos"]   # (K,3) float32 mm: robot-logged gripper / LED positions
                                                        # (= scan_log.json), not the SfM camera centres
```

Splits: `globals/training_list_500.txt` (400 ids) and `globals/test_list_500.txt` (100 ids).
Quote every `--include` pattern. A 0.5 GB [sample subset](#whats-in-a-material-folder) and
more download recipes are under Details below.


**Browse before downloading:** the *Data Studio* tab shows `index/robocloth_index.parquet`, one row per material: `thumbnail` (one frontal frame, rectified to the sample square), `split`, `width_cm` / `height_cm` (sample size), `frames` (HDR frames in `hdr.tar`), `lights` (distinct light positions), `observations` / `points` (rows and surface points of the observation tensor), `thumb_mean_srgb` (mean colour of the thumbnail — not an albedo), `hdr_frames_gb` (size of `hdr.tar`), `observation_tensor_gb` (size of `observations_structured.npz`), and links to the interactive viewer and the material's folder. To fetch a material you found there: `hf download theialab/RoboCloth --repo-type dataset --include "globals/*" --include "materials/<id>/*" --local-dir ./RoboCloth`.

## What's in a material folder

`materials/{0..499}/` — one folder per material (ids are not zero-padded):

| File | What it is |
|---|---|
| `hdr.tar` | ≈580 registered frames as full-size (3072×2048) 16-bit linear-RGB PNGs, masked to the sample polygon |
| `observations_structured.npz` | Training tensor: per-point RGB per frame, plus the robot-logged gripper/light positions |
| `point_positions.npz` | Sparse SfM surface point cloud (m, turntable-aligned frame) |
| `rotated_camera.json` | Per-frame SfM-refined camera pose, turntable-aligned frame (mm) |
| `scan_log.json` | Per-frame rig log: gripper, light and turntable state (mm, deg) |
| `point_metadata.json` | Point and observation counts |
| `bbox.json` | Bounding box of the cropped sample (m) |
| `hdr_crop_bboxes.json` | Camera intrinsics and the per-frame sample mask (pixel box + polygon) |
| `unmatched_scan_ids.json` | Frames SfM never registered |

Stage-1 decoder training reads only `observations_structured.npz`, `scan_log.json`,
`rotated_camera.json` and `point_metadata.json`; `hdr.tar` is needed for stage 2 and for
image-space evaluation.

`globals/` — shared by all materials:

| File | What it is |
|---|---|
| `camera_factor.json` | Exposure regime (camera-factor index) per material-id range |
| `emitter_calibration.json` | LED angular falloff Λ(θ), 1° bins, plus radiance scale |
| `sample_size.json` | Physical sample width × length per material-id range (m) |
| `training_list_{100,300,442,500}.txt`, `test_list_{…}.txt` | Train / test material ids, one per line |

`sample/`, `examples/` and the root:

| Path | What it is |
|---|---|
| `sample/material_{156,249,309,428,483}/` | Five test-split materials; `hdr.tar` keeps ≈12 frames, no observation tensor |
| `sample/README.md` | Notes on the subset |
| `examples/load_material.py` | Minimal loader for every file type |
| `croissant.jsonld`, `LICENSE` | Croissant metadata; CC BY 4.0 text |

## Details

<details>
<summary><b>Per-field schema</b> — array names, shapes, JSON keys</summary>

`K` = frames in `scan_log.json` (≈580, all scheduled frames; rows of frames SfM did not
register are all zero); `V` = surface points. All imagery is linear (no gamma). Two frames are
used: `point_positions.npz`, `bbox.json`, `xyz` and `rotated_camera.json` are in the
**turntable-aligned frame** (robot base axes with the turntable rotation undone, so the sample
is static); `scan_log.json` and the npz `cam_pos`/`light_pos` are raw robot logs in each arm's
base frame. The hand–eye, turntable-axis and base-to-base transforms that connect the two are
in the code repository (`configs/renderer/rig_constants.yaml`). See the units column.

| File | Format | Contents | Units |
|---|---|---|---|
| `hdr.tar` | tar of 16-bit PNG | `hdr/*.png`, full 3072×2048 frames, registered frames only; linear RGB, Menon-2007 demosaiced, white-balance gains applied; pixels outside the (16 px dilated) sample polygon are zero | px |
| `observations_structured.npz` | npz | `rgbs (K,V,3) uint16` (0 = unobserved), `xyz (V,3) float32`, `point_ids (V,) int32`, `cam_pos (K,3) float32`, `light_pos (K,3) float32` (copies of the `scan_log.json` gripper and LED positions; the SfM camera centres are in `rotated_camera.json`) | `xyz` m; `cam_pos`, `light_pos` mm |
| `point_positions.npz` | npz | `point_ids (V,) int64`, `positions (V,3) float32` | m |
| `rotated_camera.json` | list, one per registered frame | `overall_id`, `camera_id`, `position` (3), `rotation_matrix` (3×3, camera→turntable-aligned frame; includes the Umeyama scale — renormalize the columns for a pure rotation) | mm |
| `scan_log.json` | list, one per scheduled frame | `id`, `scan_id`, `camera_id`, `light_id`, `filename`, gripper `position` + `rotation_matrix` (gripper→base), `position_light` + `rotation_matrix_light` (light arm, in its own base), `servo_angle`, `servo_angle_light`, `turn_angle` | mm, deg |
| `point_metadata.json` | json | `num_points`, `num_observations` (sizes the stage-1 latent bank); `observations_folder` (internal path, present in 346 of 500 materials) | — |
| `bbox.json` | json | `bbox_min`, `bbox_max`, `bbox_center`, `bbox_size`, `num_points` | m |
| `hdr_crop_bboxes.json` | json | `intrinsics` (`width`, `height`, `focal_length`, `cx`, `cy`, `distortion`; 3072×2048 sensor), `dilate_px`, `bbox_center`, `bbox_size`, `bboxes {scan id: [x0,y0,x1,y1]}` (pixel box of the unmasked region), `polygons {scan id: 4 corners}` | px; bbox in m |
| `unmatched_scan_ids.json` | json | list of scan ids SfM never registered | — |
| `globals/camera_factor.json` | json | `description`, `camera_factor_segments: [{id_start, id_end, factor}]` — exposure-regime index (1, 2 or 3) per material-id range; the radiance scale of each regime is in the code repository (`configs/renderer/rig_constants.yaml`) | — |
| `globals/emitter_calibration.json` | json | `resolution_degrees`, `angle_range`, `max_cam_rad_ratio` (camera radiance scale), `epoch`, `data: {angle: ratio}` | deg |
| `globals/sample_size.json` | json | `sample_sizes: [{id_start, id_end, width, length}]` — footprint used to crop the point cloud | m |

</details>

<details>
<summary><b>Capture rig and processing</b> — how the data was made</summary>

Two robot arms move a machine-vision camera and a single LED emitter over a turntable that
holds a flat-mounted cloth sample; the turntable adds a third degree of freedom, so the
view–light hemisphere is sampled densely rather than on a fixed gantry grid. Each material is
captured in one automated session of ≈20 minutes. Every frame is recorded as a 14-bit Bayer
mosaic (stored in a 16-bit PNG), demosaiced (Menon 2007), white-balanced and kept linear — no gamma anywhere in the
release. Camera poses come from a COLMAP structure-from-motion reconstruction registered into
the turntable-aligned robot frame by a Umeyama alignment against the robot-logged camera poses; frames whose
alignment residual exceeds 16 mm are dropped (`unmatched_scan_ids.json`). The same
reconstruction yields the sparse point cloud, cropped to the physical footprint of the sample
(`globals/sample_size.json`). Per-point radiance observations are then gathered across all
registered frames into one tensor per material. The released frames keep the full sensor
resolution with everything outside the sample polygon set to zero. Camera intrinsics
(`hdr_crop_bboxes.json`), the LED angular falloff and the per-material exposure-regime index
(`globals/`) ship with the data; the hand–eye, turntable-axis and radiometric-scale constants
are in the code repository (`configs/renderer/rig_constants.yaml`); per-frame camera and gripper
poses are in `rotated_camera.json` and `scan_log.json`.

The accompanying two-stage pipeline (code repository): stage 1 trains a shared MLP decoder on
the corpus to learn cloth material priors; stage 2 freezes that decoder and fits a dense
2048×2048 latent texture to each target material. A decoder trained on these captures
outperforms decoders trained on existing measured reflectance datasets and analytic PBR
fitting, and transfers to unseen acquisition systems (the UBO2014 benchmark) without
modification.

</details>

<details>
<summary><b>Splits</b> — nested train/test lists</summary>

The suffix `N` is the total of a train + test pair, and the splits are nested subsets, so you
can shrink the corpus without changing the held-out family. The five materials used for the
paper's per-material tables (145, 226, 314, 370, 452) are in every test list from 442 up.

| Split pair | Train | Test | Use |
|---|---|---|---|
| `*_list_100.txt` | 80 | 20 | small-scale ablations |
| `*_list_300.txt` | 240 | 60 | medium-scale benchmarks |
| `*_list_442.txt` | 353 | 89 | curated subset frozen before the corpus was complete (58 ids left out, several with sparse reconstructions); every id is valid in the `_500` lists |
| `*_list_500.txt` | 400 | 100 | all 500 materials |

</details>

<details>
<summary><b>Download recipes</b> — sample, sparse-only, everything</summary>

The `hf` command ships with `huggingface_hub` (`pip install -U huggingface_hub`).
Quote every `--include` pattern: an unquoted `*` is expanded by the shell before it reaches
the include filter.

Sample subset plus all calibration and split files (≈0.5 GB):

```bash
hf download theialab/RoboCloth --repo-type dataset \
    --include "sample/*" --include "globals/*" --include "examples/*" \
    --local-dir ./robocloth-sample
```

Sparse only (≈490 GB) — everything stage-1 decoder training needs, without the HDR frames:

```bash
hf download theialab/RoboCloth --repo-type dataset \
    --include "globals/*" \
    --include "materials/*/observations_structured.npz" \
    --include "materials/*/scan_log.json" \
    --include "materials/*/rotated_camera.json" \
    --include "materials/*/point_metadata.json" \
    --local-dir ./RoboCloth
```

Everything (3.39 TB):

```bash
hf download theialab/RoboCloth --repo-type dataset --local-dir ./RoboCloth
```

The code repository wraps these in `scripts/download_material.sh <id>`,
`scripts/download_dataset_stage1.sh` and `scripts/download_dataset_full.sh`, which also
flatten `materials/<id>/` into the training-ready `DATA_ROOT/<id>/` layout and untar the HDR
frames.

</details>

<details>
<summary><b>Sample subset</b> — what is and is not in <code>sample/</code></summary>

`sample/material_<id>/` corresponds to `materials/<id>/`. The five materials (156, 249, 309,
428, 483) are drawn from the test split and span different physical sample sizes. `hdr.tar`
keeps ≈12 evenly spaced frames instead of ≈580; the JSON files and `point_positions.npz` are
identical to the full release. `observations_structured.npz` is not included — pull it from
`materials/<id>/` if you need the tensor. See [`sample/README.md`](sample/README.md).

</details>

<details>
<summary><b>Size</b> — per material and total</summary>

| Component | Per material | Total |
|---|---|---|
| `hdr.tar` | 5.8 GB avg (3.1–8.0 GB) | 2.89 TB |
| `observations_structured.npz` | 0.98 GB avg | 488 GB |
| `point_positions.npz` | 5.5 MB avg | 2.8 GB |
| JSON metadata | ≈1.2 MB | 0.6 GB |
| **Repository total** | **≈6.8 GB** | **3.39 TB** |

</details>

<details>
<summary><b>Limitations</b></summary>

- Single capture rig: its lens model, LED falloff and geometric layout are baked into the
  data. Samples are flat-mounted, so cloth deformation and drape are not captured.
- Very specular or very dark materials can still clip at grazing angles despite the 16-bit
  linear encoding. Geometry is a sparse SfM point cloud, not a dense scan.
- The material collection reflects what was available to the capture lab and is not a
  representative cross-section of global textile diversity.
- No people, faces or personally identifying information appear anywhere in the data.

</details>

## Citation

```bibtex
@article{li2026robocloth,
  title   = {RoboCloth: A Large-Scale Real Cloth Material Dataset for Neural Reflectance Reconstruction},
  author  = {Li, Zhen and Qin, Haoran and Di Sario, Francesco and Rebain, Daniel and Tagliasacchi, Andrea},
  journal = {arXiv preprint arXiv:2610.21090},
  year    = {2026}
}
```

## License and contact

Dataset: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) ([`LICENSE`](LICENSE));
machine-readable metadata in [`croissant.jsonld`](croissant.jsonld). Code: Apache-2.0.
Questions, corrections or bad files: open a discussion here or an issue on
<https://github.com/theialab/robocloth>.