Dataset Viewer
The dataset could not be loaded because the splits use different data file formats, which is not supported. Read more about the splits configuration. Click for more details.
Couldn't infer the same data file format for all splits. Got {NamedSplit('train'): ('text', {}), NamedSplit('validation'): ('webdataset', {}), NamedSplit('test'): ('webdataset', {})}
Error code:   FileFormatMismatchBetweenSplitsError

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

SynCrack3D Dataset

Synthetic images of cracked walls with pixel-exact labels, rendered by the SynCrack3D generator with Blender Cycles.

Each scene is one room, built around one inspection wall, with fixtures (doors, windows, vents, pipes, cables, panel seams) and at most one prop. The inspection wall has one of ten finishes (plaster, stucco, concrete, brick, tile, large tile, marble, stone block, cobble wall, sandstone) and one to three cracks. Cracks are displaced geometry inside the wall material, and their edges depend on the finish: coatings tear, chip or lift along the crack, and uncoated surfaces show a plain groove. Every label (class mask, instance mask, box, depth and wall relief) is written from the same render as the image.

Split Rooms Views Seeds List
Train A 100 593 910000–910099 splits/train_100.txt
Train B 250 1,447 910000–910249 splits/train_250.txt
Train C 500 2,972 910000–910499 splits/train_500.txt
Train D (full train) 1,000 5,927 910000–910999 splits/train.txt
Validation 200 1,184 901000–901199 splits/val.txt
Test 300 1,789 900000–900299 splits/test.txt

Splits are by room: no room appears in two splits. Train A–D are the nested training sets of the SynCrack3D paper (the first N training rooms in seed order); each contains the smaller ones. They are lists, not separate files. For storage the training rooms are packed in two chunks, train_a (rooms 910000–910499, which is exactly Train C) and train_b (910500–910999); the chunk names are not the paper's set names.

Files

README.md
SHA256SUMS
splits/*.txt                  view ids of each split and nested training set (pack image names without .png)
pack/<chunk>.tar              training pack of one chunk (test, val, train_a, train_b)
raw/<chunk>.tar               per-room scene records and every rendered pass of one chunk

Extract every tar into one folder to get <chunk>/pack/ and <chunk>/walls/:

hf download shiven2001/syncrack3d-dataset --repo-type dataset --local-dir syncrack3d
cd syncrack3d && sha256sum -c SHA256SUMS
for t in pack/*.tar raw/*.tar; do tar -xf "$t"; done

pack/ alone (9.5 GB) is enough to train and evaluate. raw/ (25.0 GB) holds the per-room records and the rendered passes the pack was exported from.

Pack (<chunk>/pack/)

Every view has the same id in every folder, for example seed_900000_rig0_resample0_frame0001_camera_0.

Folder Content
images/ RGB, 640 × 640 PNG
masks/ class mask, uint8 PNG: grey level = class id × 60 (crack = 60)
ignore_masks/ 255 where the label is uncertain (soft coverage, under-resolved crack), else 0
instance_masks/ .npz: instance_id (uint32), soft_instance_id, ownership_coverage (float16), ambiguous, under_resolution
instances/ per-view instance records joined to the wall's crack manifest
bboxes/ per-view JSON: one box per visible crack instance, inclusive pixel coordinates
bboxes_yolo/ YOLO text labels (class 0 = crack)
annotations_coco.json COCO instances for the views kept for detection (see curation.json)
depth/ camera-axis depth, uint16 PNG: metres = value × 1e-4; 0 = no surface
wall_relief/ offset from the wall plane, uint16 PNG: millimetres = (value − 32768) × 0.01; 0 = not the main wall
cameras/ per-view JSON: intrinsics K, cam_to_world (OpenCV convention), image size and the depth encodings
class_names.txt class ids and the mask encoding
curation.json which views enter the COCO file and why others do not

Only class 1 (crack) occurs. class_names.txt also lists paint peeling (2) and paint blistering (3) because the exporter shares its class table with sibling generators; neither appears here.

All 8,900 views have masks, depth, relief and camera files. annotations_coco.json lists the 7,346 views kept for detection; curation.json counts the views left out (close-ups dropped as unusable, and views whose crack pixels do not form a box above the instance threshold).

Each chunk also has contract.txt (label-contract report: instance ids, classes and boxes agree on every frame) and depth_added.json (see below); test and val also keep their export manifest.json.

Decoding in Python:

import cv2, json, numpy as np
vid = "seed_900000_rig0_resample0_frame0001_camera_0"
p = "test/pack/"
rgb   = cv2.imread(f"{p}images/{vid}.png")[..., ::-1]
crack = ((cv2.imread(f"{p}masks/{vid}.png", 0).astype(int) + 30) // 60) == 1
ignore = cv2.imread(f"{p}ignore_masks/{vid}.png", 0) == 255
d = cv2.imread(f"{p}depth/{vid}.png", -1).astype(np.float64)
depth_m = np.where(d > 0, d * 1e-4, np.nan)
r = cv2.imread(f"{p}wall_relief/{vid}.png", -1).astype(np.float64)
relief_mm = np.where(r > 0, (r - 32768) * 0.01, np.nan)
cam = json.load(open(f"{p}cameras/{vid}.json"))   # cam["K"], cam["cam_to_world"]
inst = np.load(f"{p}instance_masks/{vid}.npz")["instance_id"]

Raw (<chunk>/walls/)

seed_<seed>/scene.json             wall, material, cracks, fixtures, props, cameras, lights, settings
seed_<seed>/defect_instances.json  one record per crack: style, width, depth, host finish, status
frames/seed_<seed>/<Pass>/camera_0/<Pass>_<rig>_<resample>_<frame>_<camera>.<ext>

Passes: Image, DefectCrack (crack coverage), DefectInstance, DefectInstanceCoverage, DefectInstanceSquared, DefectViewMeta, Materials, MaterialSegmentation, Depth, WallRelief, Camera. Pack ids map to frame stems as seed_<seed>_rig<r>_resample<s>_frame<f>_camera_<c> → <r>_<s>_<f>_<c>. Some instance records keep the absolute render-time path of their source files; the same files are under <chunk>/walls/ here.

How it was made

python syncrack3d/build_dataset.py --recipe unified --seeds <seeds> --output <chunk>/walls --keep-going --resume
python tools/prepare_defect_annotated_dataset.py -i <chunk>/walls/frames -o <chunk>/pack \
  --aov-masks on --instance-masks on --with-bboxes --max-negative-fraction 1
python tools/check_instance_contract.py --pack <chunk>/pack

--recipe unified: 640 px, 64 Cycles samples, two close-up views per crack plus wider context views per wall, lighting sampled per wall, exposure and white balance per view. The same seed always gives the same wall, cameras and lights.

Depth, wall relief and camera files were added after the RGB render with tools/add_depth_to_dataset.py: each wall is rebuilt from its seed and rendered at one sample with only the depth, position and object-index passes. A wall is accepted only if its rebuilt scene.json equals the released one, and all 1,500 were. On test walls checked against a full render, the depth-only output is byte-identical. depth_added.json records the method and the code commit for each chunk. In the current generator, depth export is on by default.

Licence and citation

The data are released under CC BY 4.0. The generator code is BSD 3-Clause; it includes a modified subset of Infinigen (BSD 3-Clause, Princeton University). All scene content is procedural; no third-party photographs or textures are included.

A paper describing SynCrack3D is in preparation. Until then, please cite this dataset and the generator repository.

TODO: Add the SynCrack3D paper citation here.

Downloads last month
60