README.md

metadata

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

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 (see issue #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 and decode each sample with bop_toolkit_lib.dataset.bop_webdataset.decode_sample (RGB is JPEG, so pass rgb_suffix=".jpg"):

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:

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

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

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