RoboCloth

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/
• Code: https://github.com/theialab/robocloth (Apache-2.0)
• Checkpoints and render assets: koalapenguin/RoboCloth-assets — pretrained decoders and self-contained, renderable per-material checkpoints (no capture data needed to render them)

Quick start

pip install -U huggingface_hub numpy pillow
hf download koalapenguin/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)

import numpy as np; from huggingface_hub import hf_hub_download
obs = np.load(hf_hub_download("koalapenguin/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 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 koalapenguin/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

Per-field schema — array names, shapes, JSON keys

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

Capture rig and processing — how the data was made

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.

Splits — nested train/test lists

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

Download recipes — sample, sparse-only, everything

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):

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

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

Sample subset — what is and is not in sample/

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.

Size — per material and total

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

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{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},
  year   = {2026}
}

License and contact

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