500 real cloth materials, each imaged in ~580 calibrated HDR frames by a robotic camera-and-light rig. Fit with the released two-stage pipeline, every material becomes a compact neural BRDF that runs as an online or offline shader — a path tracer such as Mitsuba 3, or any real-time renderer that can evaluate a small MLP.

Code: https://github.com/colinzhenli/robocloth (Apache-2.0)
Project page: https://colinzhenli.github.io/BRDF-Fipt/
Checkpoints and render assets: koalapenguin/RoboCloth-assets
Croissant metadata: croissant.jsonld · License: LICENSE (CC BY 4.0)

Dataset summary

RoboCloth is a dataset of 500 real cloth materials captured under flexible, calibrated camera and lighting configurations, where both camera and light are robotically controlled during acquisition. Each material is imaged in approximately 580 high-dynamic-range frames spanning a wide view–light hemisphere. Camera poses are refined via structure-from-motion and aligned to the robot frame, yielding per-material sparse surface geometry and structured per-point reflectance observations that are ready for neural material training.

The accompanying two-stage neural reconstruction pipeline demonstrates the value of the data: 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 without modification.

Capture setup

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. Every frame is captured as a 16-bit Bayer mosaic, demosaiced (Menon 2007), white-balanced and kept linear — no gamma is applied anywhere in the release. Camera poses come from a COLMAP structure-from-motion reconstruction that is registered into the robot base frame by a Umeyama alignment against the recorded gripper poses, and frames that fail a 16 mm alignment gate are dropped. The same reconstruction yields the sparse surface point cloud, which is cropped to the physical footprint of the sample. Per-point radiance observations are then gathered across all registered frames into one structured tensor per material. Rig intrinsics, hand–eye transforms, the LED angular falloff and the radiometric exposure factors are all released as calibration files (see Globals).

Dataset structure

materials/{0..499}/
  hdr.tar                        # ~580 cropped 16-bit linear-RGB PNG frames
  observations_structured.npz    # the training tensor (per-point radiance)
  point_positions.npz            # sparse surface point cloud
  rotated_camera.json            # per-frame camera pose in the robot frame
  scan_log.json                  # per-frame rig log (gripper, light, turntable)
  point_metadata.json            # point / observation counts
  bbox.json                      # cropped-sample bounding box
  hdr_crop_bboxes.json           # per-view crop applied to the released frames
  unmatched_scan_ids.json        # frames never registered by SfM

globals/                         # calibration + train/test splits (see below)
sample/                          # small self-contained subset, same file layout
examples/load_material.py        # minimal loader
web/                             # project-page video
croissant.jsonld  LICENSE  README.md

Per-material schema

All lengths are millimetres in the robot base frame; all imagery is linear. K = number of registered frames for the material (~580), V = number of surface points.

File	Format	Contents
`hdr.tar`	tar of 16-bit PNG	`hdr/*.png`, linear RGB, Menon-2007 demosaiced with white-balance gains applied, cropped to the sample
`observations_structured.npz`	npz	`rgbs (K,V,3) uint16` (0 = unobserved), `xyz (V,3) float32`, `point_ids (V,) int32`, `cam_pos (K,3)`, `light_pos (K,3)`
`point_positions.npz`	npz	`point_ids (V,) int`, `positions (V,3) float32`
`rotated_camera.json`	json	per frame: `camera_id`, `position` (3), `rotation_matrix` (3×3, camera→base, includes the Umeyama scale — renormalize the columns for a pure rotation)
`scan_log.json`	json	per frame: `filename`, `scan_id`, `overall_id`, `camera_id`, gripper `position` + `rotation_matrix` (gripper→base), `position_light`, `turn_angle` (deg), `emitter_id`
`point_metadata.json`	json	`num_points`, `num_observations` (sizes the stage-1 latent bank)
`bbox.json`	json	`bbox_min` / `bbox_max` / `bbox_center` / `bbox_size`, `num_points`
`hdr_crop_bboxes.json`	json	per-view crop polygon applied to the released frames
`unmatched_scan_ids.json`	json	scan ids that SfM never registered

Stage-1 decoder training reads only observations_structured.npz, scan_log.json, rotated_camera.json and point_metadata.json; the HDR frames are needed for stage 2 (dense per-material fitting) and for any image-space evaluation.

Globals and splits

File	Contents
`globals/camera_factor.json`	`camera_factor_segments: [{id_start, id_end, factor}]` — maps material-id ranges to the exposure regime used at capture time
`globals/emitter_calibration.json`	LED angular falloff: `resolution_degrees`, `angle_range`, `max_cam_rad_ratio` (camera radiance scale), `data: {angle: ratio}`
`globals/sample_size.json`	`sample_sizes: [{id_start, id_end, width, length}]` — physical footprint used to crop the point cloud
`globals/training_list_{N}.txt`, `globals/test_list_{N}.txt`	material-id splits, one id per line

The splits are nested subsets — the suffix N is the total of that train + test pair, so you can shrink the corpus without changing the held-out set 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	full corpus excluding materials with degenerate reconstructions
`*_list_500.txt`	400	100	all 500 materials

Size

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

Download

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

Just look around (~0.5 GB) — the sample subset plus all calibration and split files:

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

One full material (~7 GB), e.g. 145:

hf download koalapenguin/RoboCloth --repo-type dataset \
    --include "globals/*" --include "materials/145/*" \
    --local-dir ./RoboCloth

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

hf download koalapenguin/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):

hf download koalapenguin/RoboCloth --repo-type dataset --local-dir ./RoboCloth

The code repository wraps these three cases 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.

Loading

examples/load_material.py downloads one material, prints every array it contains, and extracts a single frame from hdr.tar without unpacking the archive (pip install huggingface_hub numpy pillow && python examples/load_material.py --mid 145). The core of it:

import numpy as np
from huggingface_hub import hf_hub_download

obs_path = hf_hub_download("koalapenguin/RoboCloth", "materials/145/observations_structured.npz",
                           repo_type="dataset")
obs = np.load(obs_path)
rgbs, xyz = obs["rgbs"], obs["xyz"]          # (K,V,3) uint16, (V,3) float32
cam_pos, light_pos = obs["cam_pos"], obs["light_pos"]   # (K,3) mm each
observed = rgbs.any(axis=-1)                 # (K,V) bool — 0 means "not seen"

Sample subset

sample/ holds a few complete materials drawn from the test split, spanning different physical sample sizes. Every per-material file is byte-identical to the full release except hdr.tar, which keeps ~12 evenly spaced frames instead of the full ~580 — so array names and dtypes match the main tree exactly, at a fraction of the size. sample/material_<id>/ corresponds to materials/<id>/. See sample/README.md.

Checkpoints and render assets

Pretrained decoders, per-material stage-2 checkpoints (each a complete, renderable neural material), the bundled Mitsuba 3 scenes and the capture video live in a companion repository: koalapenguin/RoboCloth-assets. You do not need this dataset to render the released materials — a stage-2 checkpoint is self-contained.

Limitations

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.

Citation

@misc{robocloth2026,
  title  = {RoboCloth: A Large-Scale Real Cloth Material Dataset for Neural Reflectance Reconstruction},
  author = {Anonymous},
  year   = {2026},
  note   = {Under review},
  url    = {https://huggingface.co/datasets/koalapenguin/RoboCloth}
}

License and contact

The dataset is released under CC BY 4.0 — see LICENSE. The code repository is Apache-2.0. The paper is under review, so the authors are anonymous for now; please open a discussion on this repository or an issue on https://github.com/colinzhenli/robocloth for questions, corrections, or bad files.

Downloads last month: 535

Total file size:

3.39 TB