zeredata/bin-picking

ZereData Bin Picking Dataset v1.2

Synthetic training data for robotic bin picking — RGB, depth, instance masks, 6D pose, 2D bounding boxes, and per-instance visibility, in BOP/COCO/YOLO formats.

Overview

Generated with GPU-accelerated, physically based ray tracing, this dataset delivers photorealistic scenes of cluttered bins at warehouse scale. Each scene includes RGB, depth, instance segmentation, camera intrinsics/extrinsics, and per-instance 6D pose with visibility ratios.

The dataset's value is simple: synthetic renders give perfect ground truth annotations impossible to obtain from real cameras, at a scale and cost real-world collection cannot match. Use it to train 6D pose estimators, bin-picking grasp predictors, and warehouse perception systems — then validate sim-to-real transfer on smaller real-world test sets.

v1.2 is the recommended version for new integrations. It ships BOP-spec pose convention at the producer, real per-instance visibility, object models with symmetry annotations, and corrected object placement. See Versions below for what changed and why v1.0/v1.1 remain available.

Dataset Statistics

Metric	Value
Total scenes	10,000
Train split	8,000
Val split	2,000
Resolution	1280x720
Object instances	162,897
Object instances per scene	16.29 ± 10.23
Object categories	4 (bottle, box, can, pouch)
Distinct object models (SKUs)	24
Modalities	6 (RGB, depth, mask, pose, bboxes, visibility)
Total size on disk	8.8 GB

Modalities

• RGB — 1280×720 PNG per scene. The primary input for detection, segmentation, and pose models.
• Depth — 16-bit (uint16) single-channel PNG in millimetres, read as mm = pixel * depth_scale using the per-scene depth_scale in scene_camera.json; a pixel value of 0 means "no measurement". Train depth-conditioned pose models or use as a second-channel input.
• Instance mask — colour-coded PNG per scene, one colour per object instance. Drives instance segmentation and occlusion reasoning.
• 6D pose — per-instance rotation and translation in camera frame (BOP cam_R_m2c, cam_t_m2c), in OpenCV convention as the BOP spec requires. Supervises pose regression heads.
• 2D bounding boxes — amodal (bbox_obj) and visible (bbox_visib), included in COCO and YOLO formats.
• Visibility ratio — BOP visib_fract per instance, computed from amodal vs visible pixel counts; lets you weight the training loss by occlusion severity.

Formats

BOP (primary)

Canonical BOP directory layout under data/train/ and data/val/. Each scene folder contains scene_camera.json (cam_K, depth_scale), scene_gt.json (per-object cam_R_m2c, cam_t_m2c, obj_id), and scene_gt_info.json (bbox_obj, bbox_visib, visib_fract). models/ ships the 24 object meshes as obj_NNNNNN.ply — load these with the BOP toolkit — alongside models_info.json (mm units, computed from the PLY geometry, including per-model symmetry annotations). The same 24 models also ship as .glb for visualization/CAD use, indexed by models_index.json; both the PLY pack and the GLB index are keyed by the same obj_id as scene_gt.json. Object IDs are ZereData-specific, not BOP canonical — see Limitations.

COCO

Merged annotations/coco_train.json and annotations/coco_val.json with images, annotations (bboxes + masks), and categories. Loads cleanly with pycocotools:

from pycocotools.coco import COCO
coco = COCO('annotations/coco_train.json')

YOLO

Per-image .txt label files under annotations/yolo_train/ and yolo_val/, with normalized class_id cx cy w h entries. Class IDs are consistent across both splits; see annotations/yolo_classes.txt and annotations/yolo_data.yaml.

Versions

Version	Status	Pose convention	Notes
v1.0	Superseded, retained	OpenGL (see below)	First public release.
v1.1	Superseded, retained	OpenGL (see below)	Packaging and metadata pass over v1.0.
v1.2	Recommended	OpenCV (BOP spec)	Producer-side convention fix, real visib_fract, amodal + visible boxes, symmetry annotations, object models shipped, corrected placement geometry.

v1.0 and v1.1 remain available unchanged for reproducibility. v1.2 is not a drop-in replacement for a pipeline already calibrated against v1.1: the pose convention differs, and the scene composition differs (see Dataset characteristics below).

Generation stack per version

v1.0 and v1.1 were generated on the previous production rendering stack; v1.2 is generated on the current one. Both stacks use the same GPU path tracer and the same scene-generation code path. Renders are reproducible at the dataset level — same scene count, same modalities, same export formats, same configuration — and are not bit-reproducible: re-running a scene with the same seed produces a visually equivalent but not pixel-identical image. This is a property of the pipeline and is true within a single stack as well as across stacks. If you need bit-exact inputs, pin the published archives rather than regenerating.

Dataset characteristics

These are properties of how the dataset is composed, not defects. They matter if you are sizing a training run for a particular class.

• Class mix is not balanced, and box instances are sparse. Scenes are drawn from two object-size groups: a small-object group that admits up to 33 objects per scene, and a large-object group capped at 7. All six box models fall in the large-object group, so boxes appear in roughly half the scenes and only a few at a time. Boxes are 9.1% of all object instances in v1.2, against roughly 26% in v1.1 — about one third the box instances per scene. Bottles, cans and pouches carry the remainder. If you are training a box detector, size your run against the box instance count, not the scene count. This composition is deliberate and is not tuned toward a target class balance; a production dataset is built around the customer's own SKUs and bin geometry, which sets the mix directly.
• A small number of scenes contain no box instances despite drawing from the box-bearing group. Where a scene draws a single box and that box does not fit the remaining space, the scene ships without it. Measured at 0.4% (36 of 10,000) of scenes. Scenes are individually correct — the annotation matches the image — but a per-scene guarantee of box presence is not one of them.
• Objects per scene varies widely by size group. Small-object scenes are dense; the large-object scenes are sparse by construction. The per-scene instance count in the statistics table is a mean across both.
• One pouch model. The pouch class is represented by a single mesh, so pouch appearance variation comes from pose, lighting and materials rather than shape.

Data Format

This dataset is packaged as per-format zip archives, mirroring the bop-benchmark HF layout convention (one zip per logical split) adapted for multi-format shipping. Loose files — README, LICENSE, CITATION, metadata.json, preview images — remain at the repository root so the HF dataset page renders a preview.

Archive	Contents	On-extract layout
bin_picking_train_bop.zip	BOP-format train split (rgb/depth/mask + scene_camera.json / scene_gt.json / scene_gt_info.json per scene)	data/train/{000000..007999}/...
bin_picking_val_bop.zip	BOP-format val split	data/val/{000000..001999}/...
bin_picking_coco.zip	coco_train.json, coco_val.json (merged, BOP obj IDs remapped to COCO categories)	annotations/coco_*.json
bin_picking_yolo.zip	YOLO labels per split + yolo_classes.txt + yolo_data.yaml	annotations/yolo_{train,val}/*.txt, annotations/yolo_*.{txt,yaml}
bin_picking_native.zip	Per-scene native annotations (full pre-export ZereData scene graph)	annotations/scene_NNNN.json
bin_picking_models.zip	24 BOP-toolkit PLY meshes + 24 GLB object models + models_info.json (from the PLY geometry) + models_index.json (obj_id → GLB filename)	models/*.ply, models/*.glb, models/models_info.json, models/models_index.json

Download and extract only what you need

from huggingface_hub import hf_hub_download
import zipfile

REPO = 'zeredata/bin-picking'
# BOP train split
p = hf_hub_download(repo_id=REPO, filename='bin_picking_train_bop.zip', repo_type='dataset')
with zipfile.ZipFile(p) as z:
    z.extractall('./zd_bp')   # rehydrates ./zd_bp/data/train/...

Or the whole dataset in one shot:

huggingface-cli download --repo-type dataset zeredata/bin-picking --local-dir ./zd_bp
cd ./zd_bp && for z in bin_picking_*.zip; do unzip -q "$z"; done

All zip extractions share the same root-relative layout, so unzipping all six archives into one directory rehydrates the canonical flat tree.

Loading the Dataset

These snippets assume you have already extracted the relevant zip(s) into a working directory (see Data Format above). Paths are relative to that root.

PyTorch Dataset over BOP structure

from pathlib import Path
from torch.utils.data import Dataset
from PIL import Image
import json

class BopBinPicking(Dataset):
    def __init__(self, root, split='train'):
        # root must contain data/<split>/... (extract bin_picking_<split>_bop.zip there first)
        self.scene_dirs = sorted((Path(root) / 'data' / split).iterdir())
    def __len__(self):
        return len(self.scene_dirs)
    def __getitem__(self, idx):
        sd = self.scene_dirs[idx]
        rgb = Image.open(sd / 'rgb' / '000000.png')
        gt = json.loads((sd / 'scene_gt.json').read_text())
        cam = json.loads((sd / 'scene_camera.json').read_text())
        return rgb, gt, cam

COCO via pycocotools

# After extracting bin_picking_coco.zip:
from pycocotools.coco import COCO
coco = COCO('annotations/coco_train.json')
img_ids = coco.getImgIds()
for ann in coco.loadAnns(coco.getAnnIds(imgIds=img_ids[0])):
    print(ann['bbox'], ann['category_id'])

Intended Use

Training 6D pose estimation models, bin-picking grasp models, and warehouse robotics perception systems. Synthetic data for sim-to-real transfer research.

Pose convention

v1.2 ships 6D poses in OpenCV camera convention (camera looks down +Z, in-front objects have cam_t_m2c.z > 0), as the BOP spec requires. No transform is needed to score against bop_toolkit_lib, MegaPose, FoundationPose, CosyPose, or any other OpenCV-convention model.

v1.0 and v1.1 shipped poses in OpenGL convention (camera looks down -Z, in-front objects have cam_t_m2c.z < 0). The two differ by the basis change diag(1, -1, -1) applied to the camera frame. Anyone scoring v1.0 or v1.1 must apply diag(1, -1, -1) to the GT cam_R_m2c and cam_t_m2c before evaluation, otherwise pose errors blow up to the order of the object diameter and any comparison is meaningless.

ZereData's evaluation harness exposes this via the --legacy-gl-convention flag. Pass it when scoring v1.0 or v1.1; omit it for v1.2. The legacy flag is supported indefinitely so downstream code that already ingests v1.0/v1.1 keeps working.

RGB, depth, masks, COCO 2D boxes, and YOLO labels are unaffected in every version — only the 6D pose serialisation deviated.

Limitations and Known Issues

• Object IDs are ZereData-specific. obj_id values index this dataset's own 24-model library and do not correspond to any BOP canonical object set. models_info.json, models/*.ply, models/models_index.json, and models/*.glb are all keyed by the same obj_id as scene_gt.json — models/ is the authority for what each ID is.
• Warehouse-specific lighting. The three lighting profiles model warehouse conditions and may not transfer directly to outdoor, medical, or agricultural domains:
  • bin_picking_overhead — bright fluorescent overhead panels, typical of distribution-center shelving aisles.
  • bin_picking_mixed — mixed overhead + rim lighting with warmer colour temperature, mimicking older facilities with partial skylights.
  • studio — three-point studio lighting setup shared across ZereData scenarios; in bin-picking scenes, produces low-light conditions with deep shadows. Each scene's variety.lighting_profile annotation tag records which profile was used.
• Procedural materials. Material variation uses procedural textures, not photoscanned assets. High-frequency surface detail may look synthetic under close inspection.
• Geometric occlusion only. No category-level occlusion modelling — occlusion is derived from geometry alone.
• Simulated camera intrinsics. The intrinsic matrix is synthetic, not drawn from real sensor calibration.
• Class mix and per-scene box presence. See Dataset characteristics above.

Comparison to Related Datasets

HOPE, T-LESS, and YCB-Video are excellent real-world datasets with limited scale and fixed object sets. This dataset is synthetic-only, scales without bound, and supports customer-specific object libraries. Treat the two as complementary: real data for evaluation, synthetic data for training.

Custom Datasets

This release is a research dataset. The categories (bottle, box, can, pouch), SKU shapes, and bin geometry are intentionally generic — useful for benchmarking, pretraining, and sanity-checking a 6D pose pipeline before you invest in real-world data collection.

For production use, ZereData generates the same kind of dataset matched to your warehouse's actual SKUs and bin geometry. Customer-specific datasets ingest CAD files or reference photos and render at the same scale and quality as this release.

If you're training bin-picking models for a specific picking environment, email engineering@zeredata.com — design partners welcome.

Citation

@dataset{zeredata_binpicking_2026,
  author = {Umit Kavala},
  title = {ZereData Bin Picking Dataset v1.2},
  year = {2026},
  publisher = {HuggingFace},
  url = {https://huggingface.co/datasets/zeredata/bin-picking}
}

License

Released under CC BY 4.0. Attribution required. Commercial use permitted.

Contact and Links

• Website: https://zeredata.com
• Contact: engineering@zeredata.com