README.md

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

![license](https://img.shields.io/badge/license-CC--BY--4.0-blue) ![scenes](https://img.shields.io/badge/scenes-10,000-green) ![size](https://img.shields.io/badge/size-14.8GB-orange)

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.

![preview](preview/0001_scene_0016.png) ![preview](preview/0002_scene_0059.png) ![preview](preview/0003_scene_0001.png) ![preview](preview/0004_scene_0004.png)

## Overview

Generated via physically-based ray tracing with 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 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)