README.md

---
license: cc-by-4.0
pretty_name: ocdit
tags:
- bop
- 6d-pose
- synthetic
- webdataset
task_categories:
- object-detection
- image-segmentation
size_categories:
- 1M<n<10M
---

# ocdit

This dataset was generated as part of the ICCV 2025 publication *Conditional Latent Diffusion Models for Zero-Shot Instance Segmentation* (see [Citation](#citation)).

Synthetic, BOP-format training data for unseen object computer vision tasks, such as 6D pose estimation, instance segmentation, and detection. Scenes are physically rendered with BlenderProc; every object
instance carries a 6D pose, amodal + visible masks, bounding boxes, and a visibility fraction.
Alongside the scenes we ship the source **meshes** (`.glb`) and precomputed
**templates** (`.h5`) so the data is self-contained for training. 

Object identity is **name-based**: the string `obj_id` in each annotation is the
object label, and it matches the mesh and template filename stems exactly
(e.g. `obj_id: "11pro_SL_TRX_FG"` ↔ `meshes/gso/11pro_SL_TRX_FG.glb` ↔
`templates/gso/11pro_SL_TRX_FG.h5`).

## Structure

```
.
├── shards/                     # WebDataset tar shards (BOP samples)
│   ├── gso.random/             # shard-NNNNNN.tar
│   ├── gso.flying/
│   ├── oo3d.random/
│   └── oo3d.flying/
├── meshes/                     # source geometry, one file per object
│   ├── gso/<label>.glb
│   └── oo3d/<label>.glb
└── templates/                  # precomputed reference views, one file per object
    ├── gso/<label>.h5
    └── oo3d/<label>.h5
```

Splits are named `<source>.<scene_type>`:

- **source** — `gso` or `oo3d` (the object bank).
- **scene_type** — `random` (objects dropped onto a plane) or `flying`
  (hdri rendered objects suspended in free space).

| split | shards | samples | size |
|-------|-------:|--------:|-----:|
| `gso.random`  | 1000 | ~1.0M | 299 GB |
| `gso.flying`  |  500 | ~0.5M | 110 GB |
| `oo3d.random` | 1000 | ~1.0M | 288 GB |
| `oo3d.flying` |  490 | ~0.49M | 102 GB |

| assets | gso | oo3d |
|--------|----:|-----:|
| meshes (`.glb`) | 1029 | 5672 |
| templates (`.h5`) | 1029 | 5672 |

Each shard holds 1000 samples (RGB frames). Sample keys are
`{scene_id:06d}_{frame_id:06d}` and are globally unique within a split.
Per sample, a shard contains:

| file | content |
|------|---------|
| `<key>.rgb.jpg`        | RGB image, 640×480 |
| `<key>.depth.png`      | 16-bit depth (see `depth_scale` in the camera file) |
| `<key>.camera.json`    | `cam_K`, `cam_R_w2c`, `cam_t_w2c`, `depth_scale` |
| `<key>.gt.json`        | per-instance `cam_R_m2c`, `cam_t_m2c` (mm), string `obj_id` |
| `<key>.gt_info.json`   | per-instance `bbox_obj`, `bbox_visib`, `px_count_*`, `visib_fract` |
| `<key>.mask.json`      | amodal masks (RLE) |
| `<key>.mask_visib.json`| visible masks (RLE) |

This is the BOP `train_pbr` schema, packed as WebDataset. Translations are in
millimeters; `cam_K` is the 3×3 intrinsics in row-major order.

> **Note — pixel-accurate visible masks.** `mask_visib` (and the derived `visib_fract`) are computed directly from Blender's native instance segmentation rather than BlenderProc's BopWriterUtility default depth-thresholding, which can assign a pixel to multiple objects and leaves artifacts where foreground depth changes sharply. This dataset was rendered with the fix from BlenderProc PR [#1229](https://github.com/DLR-RM/BlenderProc/pull/1229) (see issue [#1228](https://github.com/DLR-RM/BlenderProc/issues/1228)); the PR was not yet merged upstream at publication time.

## Loading the shards

Shards decode with the BOP toolkit's WebDataset helper. Iterate the tars with
[`webdataset`](https://github.com/webdataset/webdataset) and decode each sample
with `bop_toolkit_lib.dataset.bop_webdataset.decode_sample` (RGB is JPEG, so
pass `rgb_suffix=".jpg"`):

```python
import glob
import webdataset as wds
from bop_toolkit_lib.dataset import bop_webdataset

shards = sorted(glob.glob("shards/gso.random/shard-*.tar"))
ds = wds.WebDataset(shards, shardshuffle=True)

for sample in ds:
    data = bop_webdataset.decode_sample(
        sample,
        decode_camera=True,
        decode_rgb=True,
        decode_depth=True,
        decode_gt=True,
        decode_gt_info=True,
        decode_mask=True,
        decode_mask_visib=True,
        rgb_suffix=".jpg",
    )
    scene_id, view_id = str(sample["__key__"]).split("_")
    rgb = data["im_rgb"]                 # (H, W, 3) uint8
    labels = [ann["obj_id"] for ann in data["gt"]]          # string object names
    poses = [(ann["cam_R_m2c"], ann["cam_t_m2c"]) for ann in data["gt"]]
    visib = [i["visib_fract"] for i in data["gt_info"]]
```

## Loading the templates

Each `templates/<source>/<label>.h5` holds a single `images` dataset: rows of
**JPEG-encoded bytes**, one per reference view. Rows are ordered
`[0, 42)` = 42 icosphere views (canonical viewpoints on a sphere) followed by
`[42, 512)` = in-the-wild crops. Decode a row with PIL:

```python
import io
import h5py
import numpy as np
from PIL import Image

with h5py.File("templates/gso/11pro_SL_TRX_FG.h5", "r") as f:
    images = f["images"]                # (N,) variable-length JPEG bytes
    icosphere = [np.array(Image.open(io.BytesIO(images[i]))) for i in range(42)]
    wild      = [np.array(Image.open(io.BytesIO(images[i]))) for i in range(42, images.shape[0])]
```

`h5py` does not support fancy indexing, so read with sorted integer indices or a
contiguous slice.

## Loading the meshes

`meshes/<source>/<label>.glb` is the source geometry for object `<label>`, in
glTF binary. Load with any glTF reader, e.g.:

```python
import trimesh
mesh = trimesh.load("meshes/gso/11pro_SL_TRX_FG.glb")
```

Pose annotations (`cam_R_m2c`, `cam_t_m2c`) map this mesh's model coordinates
into the camera frame; translations are in millimeters.

## Citation
```bibtex
@inproceedings{ulmer2025conditional,
  title={Conditional Latent Diffusion Models for Zero-Shot Instance Segmentation},
  author={Ulmer, Maximilian and Boerdijk, Wout and Triebel, Rudolph and Durner, Maximilian},
  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
  pages={24360--24369},
  year={2025}
}
```

## License
This dataset is released under the [`CC BY 4.0`](https://creativecommons.org/licenses/by/4.0/). This subset bundles two upstream object banks, each retaining its own license:

| source | upstream | license |
|--------|----------|---------|
| `gso`  | Google Scanned Objects | CC-BY-4.0 |
| `oo3d` | OmniObject3D | CC BY 4.0 |

By using this data you agree to the terms of the respective upstream datasets.