| --- |
| pretty_name: ZereData Bin Picking Dataset v1.1 |
| license: cc-by-4.0 |
| task_categories: |
| - object-detection |
| - image-segmentation |
| size_categories: |
| - 10K<n<100K |
| tags: |
| - synthetic-data |
| - bin-picking |
| - robotics |
| - 6d-pose |
| - pose-estimation |
| - depth-estimation |
| - instance-segmentation |
| - warehouse |
| - coco |
| - yolo |
| - bop |
| - pbr |
| - computer-vision |
| language: |
| - en |
| --- |
| |
| # ZereData Bin Picking Dataset v1.1 |
|
|
|    |
|
|
| 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 via physically-based ray tracing in Blender Cycles, this dataset delivers dense, photorealistic scenes of cluttered bins at warehouse scale. Each scene includes RGB, 32-bit 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. |
|
|
| ## Dataset Statistics |
|
|
| | Metric | Value | |
| |--------|-------| |
| | Total scenes | 10,000 | |
| | Train split | 8,000 | |
| | Val split | 2,000 | |
| | Resolution | 1280x720 | |
| | Object instances | 296,603 | |
| | Object categories | 4 | |
| | Modalities | 6 (RGB, depth, mask, pose, bboxes, visibility) | |
| | Total size on disk | 14.8 GB | |
|
|
| ## Modalities |
|
|
| - **RGB** — 1280×720 PNG per scene. The primary input for detection, segmentation, and pose models. |
| - **Depth** — 32-bit EXR in metres. 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`). Supervises pose regression heads. |
| - **2D bounding boxes** — derived from masks, included in COCO and YOLO formats. |
| - **Visibility ratio** — BOP `visib_fract` per instance; 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`). Load with the BOP toolkit. 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: |
|
|
| ```python |
| 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`. |
|
|
| ## Data Format |
|
|
| This dataset is packaged as per-format zip archives, mirroring the [bop-benchmark](https://huggingface.co/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` | 27 GLB object models | `models/*.glb` | |
|
|
| ### Download and extract only what you need |
|
|
| ```python |
| from huggingface_hub import hf_hub_download |
| import zipfile |
| |
| REPO = 'zeredata/bin-picking-v1' |
| # 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: |
|
|
| ```bash |
| huggingface-cli download --repo-type dataset zeredata/bin-picking-v1 --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 |
| ```python |
| 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 |
| ```python |
| # 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']) |
| ``` |
|
|
| _A `datasets.load_dataset()` loader is planned for v1.1._ |
|
|
| ## 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 |
|
|
| This release (v1.0 and v1.1) ships 6D poses in **OpenGL/Blender camera convention** (camera looks down `-Z`, in-front objects have `cam_t_m2c.z < 0`) rather than the BOP-standard **OpenCV 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 against bop_toolkit_lib, MegaPose, FoundationPose, CosyPose, or any OpenCV-convention model must apply `diag(1, -1, -1)` to the GT `cam_R_m2c` and `cam_t_m2c` from `scene_gt.json` before evaluation**, otherwise pose errors blow up to the order of the object diameter (~150 mm) and any AR comparison is meaningless. |
| |
| ZereData's evaluation harness exposes this via the `--legacy-gl-convention` flag on `eval.scorer.BopScorer`, `eval.adapter.gt_as_predictions`, and the eval CLIs (`gt_sanity`, `run_megapose_eval`, `rescore`, `_perturb_probe`, `rescore_h1`). Pass it when scoring v1.0 or v1.1; omit it for v1.2 onward, which ships in OpenCV convention at the producer. |
| |
| This deviation was identified post-publication. v1.0 and v1.1 remain available unchanged on HuggingFace for reproducibility; **v1.2 supersedes them for new integrations** and ships BOP-spec compliant out of the box. 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** — only the 6D pose serialisation deviates from the BOP spec. |
| |
| ## Limitations and Known Issues |
| |
| - **BOP pose convention deviation.** Object pose extrinsics in `scene_gt.json` ship in OpenGL convention, not BOP-spec OpenCV. See the **Pose convention** section above for the basis change and the `--legacy-gl-convention` flag. v1.2 supersedes this with a producer-side fix. |
| - **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. |
|
|
| ## Evaluation |
|
|
| Benchmark evaluation on LM-O is forthcoming; see [ZereData](https://zeredata.com) for updates. |
|
|
| ## 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, render at the same scale and quality as this release, and ship in days. Pricing is per-dataset, with design-partner terms for early customers. |
|
|
| If you're training bin-picking models for a specific picking environment, email **engineering@zeredata.com** — design partners welcome. |
|
|
| ## Citation |
|
|
| ```bibtex |
| @dataset{zeredata_binpicking_2026, |
| author = {Umit Kavala}, |
| title = {ZereData Bin Picking Dataset v1.1}, |
| year = {2026}, |
| publisher = {HuggingFace}, |
| url = {https://huggingface.co/datasets/zeredata/bin-picking} |
| } |
| ``` |
|
|
| ## License |
|
|
| Released under [CC BY 4.0](LICENSE). Attribution required. Commercial use permitted. |
|
|
| ## Contact and Links |
|
|
| - Website: [https://zeredata.com](https://zeredata.com) |
| - Contact: [engineering@zeredata.com](mailto:engineering@zeredata.com) |
|
|
