harpreetsahota/omni6d-test-unseen

Dataset Card for Omni6D (test_unseen + test + Real subsets)

Installation

pip install -U fiftyone

Usage

import fiftyone as fo
from huggingface_hub import snapshot_download

# Download the dataset snapshot to the current working directory
snapshot_download(
    repo_id="<username>/omni6d-test-unseen",
    local_dir=".",
    repo_type="dataset",
)

# Load dataset from current directory using FiftyOne's native format
dataset = fo.Dataset.from_dir(
    dataset_dir=".",
    dataset_type=fo.types.FiftyOneDataset,
    name="omni6d-test-unseen",
)

# Launch the App
session = fo.launch_app(dataset)

Dataset Details

Dataset Description

Omni6D is a large-vocabulary category-level 6D object pose and size estimation dataset featuring synthetic RGBD captures. The dataset spans 166 object categories with 4,688 real-scanned instances, rendered across over 0.8 million captures. This repo combines three subsets:

• test_unseen — 4,762 scenes, 33 categories, held out to evaluate generalization to unseen object categories.
• test — 14,267 scenes, 170 categories, the standard (non-held-out) test split.
• real (Omni6D-Real) — 606 real Kinect captures across 22 scenes, 36 categories — genuine camera images rather than synthetic renders, for sim-to-real evaluation.

Each synthetic scene (test_unseen/test) contains 6–8 real-scanned object instances dropped into Replica room backgrounds, rendered from 10 random camera viewpoints per scene to simulate varied viewing angles and occlusions. The dataset addresses limitations in prior category-level pose estimation benchmarks (e.g., NOCS) by introducing complex scenes with occlusions, varied lighting, and a symmetry-aware evaluation metric. The real subset instead captures genuine tabletop scenes with a Kinect sensor, using a distinct, non-overlapping set of physical object instances.

• Curated by: Shanghai Artificial Intelligence Laboratory; authors Mengchen Zhang, Tong Wu, Tai Wang, Tengfei Wang, Ziwei Liu, Dahua Lin
• Funded by: [More Information Needed]
• Shared by: OpenXLab
• Language(s): Not applicable (computer vision dataset)
• License: CC BY 4.0

Dataset Sources

• Repository: https://github.com/3DTopia/Omni6D
• Paper: https://arxiv.org/abs/2409.18261 (ECCV 2024)
• OpenXLab: https://openxlab.org.cn/datasets/kszpxxzmcwww/Omni6D

Uses

Direct Use

• 6D pose estimation research — train and benchmark category-level pose estimators on a large-vocabulary dataset with complex scenes and occlusions.
• 3D object detection — leverage the 2D and 3D bounding boxes with instance masks for detection tasks (synthetic subsets only; real has 2D annotations only).
• Domain adaptation and sim-to-real — the test_unseen/test synthetic subsets can be used to pretrain models later evaluated on the included real Kinect captures, directly within this same repo.
• Shape prior modeling — use the NOCS coordinate maps and canonical point clouds (synthetic subsets) to train shape-aware methods.
• Instance segmentation research — apply the per-instance masks and instance linking across 2D and 3D views.
• Real-world generalization checks — use the real subset to sanity-check models trained purely on synthetic renders against genuine Kinect captures, without needing to source Omni6D-Real separately.

Out-of-Scope Use

• Real-world robotics applications without fine-tuning on real data (the test_unseen/test subsets are synthetic; a domain gap exists even though the real subset is included for reference).
• Applications requiring camera intrinsics beyond the fixed Replica/BlenderProc defaults (synthetic subsets) — no intrinsics are shipped for any subset, including real.
• Fine-grained distinctions between individual object scans (instance diversity is by category, not per-mesh).
• 3D pose/shape evaluation on the real subset — no canonical point clouds exist for its object instances, so only 2D annotations (boxes, masks, category, per-instance pose/size from _label.pkl) are available there.

Dataset Structure

Overview

This is a grouped multimodal dataset with 19,635 groups (one per render/capture) across three subsets, each containing up to two synchronized slices:

1. rgb slice (image, default) — RGB render/photo with instance masks, 2D boxes, and per-object 6D pose attributes. Present for every group (19,635 total).
2. scene slice (3d) — reconstructed point cloud (.fo3d scene) with aligned 3D cuboid detections. Present only for the synthetic subsets (test_unseen, test) where a canonical NOCS point cloud exists for every instance model — 19,029 groups, not the real subset (no matching canonical shapes for its physical object instances, so no 3D reconstruction is fabricated).

Subset (split value)	Groups	Categories	Resolution	3D scene slice	Notes
test_unseen	4,762	33	640×480	✅	held-out categories; full-scene depth Heatmap available
test	14,267	170	640×480	✅	no full-scene depth shipped for this split (no _depthfull.png)
real	606	36	1280×720	❌	genuine Kinect captures; native uint16 mm depth; no NOCS/symmetry

Total samples across both slices: 38,664 (19,635 rgb + 19,029 scene). 190 distinct categories overall.

Sample Fields

Field	FiftyOne type	Description
split	StringField	Which subset this sample belongs to: test_unseen, test, or real.
source	StringField	synthetic (BlenderProc renders, test_unseen/test) or real (Kinect captures, real).
scene_id	StringField	Split-namespaced scene identifier (e.g., test_unseen/00000, test/00030, real/000) — links all renders/captures of one scene.
render_id	StringField	Render/capture index within the scene (e.g., 0000–0009 for synthetic, 0000–0039 for real).
valid	BooleanField	Boolean flag indicating membership in the official valid set (per <split>_list.txt); always True for real (no separate valid-list file shipped).
ground_truth	Detections	2D instance detections (rgb slice, all subsets).
ground_truth_3d	Detections	3D cuboid detections (scene slice; test_unseen/test only — absent for real).
depth	Heatmap	Depth map in millimeters (rgb slice). test_unseen: decoded full-scene depth from .png encoding (B*65536 + G*256 + R) / 10000. real: native uint16 mm PNG, no decoding needed. Absent for test (no full-scene depth file shipped for that split).
nocs_map_path	StringField	Path to NOCS (Normalized Object Coordinate Space) map PNG. Synthetic subsets only (test_unseen/test) — absent for real.
mask_path	StringField	Path to instance mask PNG (pixel value = instance_id, 255 = background). All subsets.
cam2world	ListField(FloatField)	4×4 camera-to-world transformation matrix (flattened, row-major). Only present when the source scene shipped a gt.pkl (partial coverage on both synthetic splits); absent for real.

Label Types and Instance Linking

2D Detections (RGB slice: ground_truth)

Each Detection in ground_truth represents one object instance in the 2D image:

• label (str) — object category name (e.g., "chestnut", "toy_bus").
• bounding_box ([x, y, w, h]) — 2D axis-aligned box in relative coordinates ([0, 1]), origin top-left.
• mask (uint8 array) — binary instance mask, cropped to bbox; pixel value 1 = instance, 0 = background.
• mask_value (int) — instance ID matching the pixel value in mask_path PNG.
• instance (fo.Instance) — link object linking this 2D detection to its corresponding 3D cuboid (see below).

3D Detections (Scene slice: ground_truth_3d)

Each Detection in ground_truth_3d represents one object in 3D space:

• label (str) — same category name as 2D detection.
• location ([x, y, z]) — 3D center in camera frame (meters), converted to Z-up viewer frame for visualization.
• dimensions ([dx, dy, dz]) — 3D extent (meters), pre-scaled by per-instance scale factor.
• rotation ([rx, ry, rz]) — Euler angles (ZYX order, radians), converted to Z-up frame to align with point cloud.
• instance (fo.Instance) — same instance object as the linked 2D detection, enabling 2D↔3D selection in the App.

Shared Attributes (both 2D and 3D)

All detections carry:

• model_name (str) — instance model name (e.g., "toy_bus_067" synthetic, "bottle_03" real). For test_unseen/test, keys the canonical point cloud in the split's shape_data/camera_<split>.pkl. For real, this name does not key any canonical shape (see Point Cloud Reconstruction below).
• category_id (int) — class ID from the dataset's taxonomy.
• scale (float) — per-instance scalar scale applied to the NOCS-normalized shape (synthetic) or from _label.pkl (real).
• size ([sx, sy, sz]) — NOCS-normalized 3D extent (before scale), synthetic and real alike.
• translation ([tx, ty, tz]) — camera-frame translation from the label pickle (for reference/analysis).
• rotation (3D only, [rx, ry, rz]) — Euler angles on 3D detections. Not populated for real (no scene slice).
• sym_x, sym_y, sym_z (int) — rotational symmetry flags (0 = no symmetry, 1 = any-angle, 3 = 180°, etc.), from sym_info.csv. Only populated for test_unseen/test — real model names don't appear in sym_info.csv, so these attributes are omitted entirely on real detections rather than defaulted to a guessed value.

Point Cloud Reconstruction

For the synthetic subsets (test_unseen, test), the 3D scene slice's point cloud is reconstructed from:

• Canonical point clouds: 1,024 NOCS-normalized points per instance, stored in the split's shape_data/camera_<split>.pkl (dict: model_name → (1024, 3)).
• Per-instance transforms: pc_camera = scale * (R @ pts_nocs) + t, where R is the 3×3 rotation from the label pickle, t is translation, scale is the instance scale factor.
• Coordinate frame conversion: camera-frame points are swapped to Z-up viewer frame (x, z, -y) to align with the .fo3d scene's up="Z" setting.
• RGB coloring: each instance's points are colored by the mean visible RGB from the corresponding 2D instance mask.

No reconstruction for real: the physical object instances in Omni6D-Real (e.g. bottle_03, clock_01) do not appear as keys in any camera_{train,val,test,test_unseen}.pkl canonical-shape file, and no camera_real.pkl exists on the source. Rather than fabricate a shape match, real samples are imported with 2D annotations only — no scene slice, no ground_truth_3d.

FiftyOne Grouping

Samples are organized via a group field with two slices:

• rgb (default slice): images with 2D annotations.
• scene: 3D scenes with cuboid annotations.

Each group represents one (scene_id, render_id) pair. Selecting a sample in one slice automatically highlights all members of the group, enabling 2D-3D synchronized exploration.

Splits and Tags

• Split assignment: every sample carries both a split field and a matching sample tag (test_unseen, test, or real).
• test_unseen: 4,762 groups; held-out categories (33) for evaluating generalization. All scenes have complete rgb and scene slices (only 11 of 4,773 raw renders failed during derivation).
• test: 14,267 groups (170 categories), the standard test split. 9 of 14,276 raw renders failed derivation (missing files in source zip — negligible).
• real: 606 groups (36 categories) — all captures are usable; there's no separate valid-list file for this subset (valid=True for all).

Dataset Creation

Curation Rationale

The original Omni6D dataset was constructed to address key limitations in prior category-level 6D pose estimation benchmarks:

1. Limited category scope: existing datasets (e.g., NOCS) cover only a narrow range of object types; Omni6D expands to 166 categories.
2. Simplistic scenes: prior benchmarks use isolated objects or simple backgrounds; Omni6D includes complex Replica room scenes with 6–8 objects, varied lighting, and occlusions.
3. Narrow instance diversity: Omni6D includes 4,688 real-scanned instances (multiple per category) to test generalization within categories.
4. Symmetry-aware evaluation: the dataset annotates rotational symmetry and includes a dedicated symmetry-aware metric, addressing a known challenge in pose estimation.

The test_unseen subset was specifically reserved to evaluate generalization to novel object categories seen during training only within other categories' shape contexts; test provides standard (non-held-out) evaluation; real was added to bridge the sim-to-real gap by providing genuine camera captures within the same taxonomy.

Source Data

Data Collection and Processing

Synthetic subsets (test_unseen, test):

• Source: 4,688 real-scanned object meshes from OmniObject3D, selected to span 166 distinct categories.
• Rendering tool: BlenderProc 2.x with Replica dataset room backdrops (9 room models for main dataset; 8 for Omni6D-xl).
• Synthetic capture: each scene was rendered from 10 camera viewpoints at pseudo-random angles, with per-scene object placement (free-fall in a region, 0.8–1.2× scale jitter).
• Resolution: 640×480 pixels per render.
• Split allocation: instances were stratified by category, then randomly split into training (7), validation (2), and test (1) in a 7:2:1 ratio; test_unseen additionally holds out entire categories not seen in training.

real subset (Omni6D-Real):

• Source: genuine tabletop scenes captured with a Kinect-class RGBD sensor — physical objects distinct from (though category-overlapping with) the synthetic instance pool.
• Resolution: 1280×720 pixels per capture, native uint16 millimeter depth (no synthetic encoding trick).
• Scale: 22 scenes, ~40 captures per scene (606 total usable captures).
• Labeling: per-instance 6D pose/size, bounding boxes, and masks provided per capture (_label.pkl), same schema as the synthetic label pickles, but without a matching canonical NOCS point cloud or symmetry annotation for the physical instances used.

Who are the source data producers?

• Dataset authors: Mengchen Zhang, Tong Wu, Tai Wang, Tengfei Wang, Ziwei Liu, Dahua Lin (Shanghai AI Lab / Zhejiang University / NTU).
• Mesh source: OmniObject3D dataset (which aggregates real-scanned models from ShapeNet, Objaverse, and other sources).
• Curation: dataset authors; see paper for sampling rationale and instance selection criteria.

Annotations

Annotation process

Synthetic subsets (test_unseen, test) annotations were generated via BlenderProc rendering and pose tracking:

1. 6D pose and size: automatically derived from each render's camera extrinsics, object placement (location, rotation, scale), and Blender mesh geometry.
2. Instance masks: rendered per-instance; pixel value = instance ID.
3. NOCS maps: computed per-pixel as the normalized object coordinates (relative to each object's canonical pose, range [0, 1] per axis).
4. Depth encoding: float32 depth (EXR) scaled by 10,000 and encoded across RGB channels in PNG format to reduce storage (25% of EXR size). Note: test split ships only per-object _depth.png, no full-scene _depthfull.png.
5. Symmetry annotations: manually assigned to each instance based on 3D mesh analysis (rotational invariance around x, y, z axes).

No human labeling was required for the synthetic subsets; all annotations are synthetic/deterministic from the rendering pipeline.

real subset: 6D pose/size, bounding boxes, and instance masks were provided per capture in the same _label.pkl schema as the synthetic pickles; the collection/annotation methodology for the physical Kinect captures is not detailed beyond what's in the paper.

Who are the annotators?

For the synthetic subsets (test_unseen, test): not applicable — annotations are deterministic outputs of the BlenderProc rendering engine and pose-tracking code. For real: annotator identity is not documented beyond what's in the paper.

Personal and Sensitive Information

The synthetic subsets contain no personal or sensitive information (fully synthetic renders). The real subset consists of tabletop object captures (household/office items) with no visible people, biometric data, or other personal information identified.

Citation

BibTeX:

@misc{zhang2024omni6dlargevocabulary3dobject,
      title={Omni6D: Large-Vocabulary 3D Object Dataset for Category-Level 6D Object Pose Estimation},
      author={Mengchen Zhang and Tong Wu and Tai Wang and Tengfei Wang and Ziwei Liu and Dahua Lin},
      year={2024},
      eprint={2409.18261},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2409.18261}
}

APA:

Zhang, M., Wu, T., Wang, T., Wang, T., Liu, Z., & Lin, D. (2024). Omni6D: Large-vocabulary 3D object dataset for category-level 6D object pose estimation. In Proceedings of the European Conference on Computer Vision (ECCV) (pp. 13). https://arxiv.org/abs/2409.18261

More Information

Source Data and Mesh Availability

• The original 3D object meshes are not released by the authors due to size constraints and because point clouds suffice for the task.
• Per-instance canonical point clouds (1,024 and 2,048 points, NOCS-normalized) are provided per split in shape_data/camera_<split>.pkl and H5 files.
• For access to the full mesh geometry, the authors recommend consulting OmniObject3D (https://github.com/omniobject3d/OmniObject3D).
• No canonical shapes exist for the real subset's physical instances — 3D reconstruction was not attempted there (see Point Cloud Reconstruction above).

Dataset Variants

• Omni6D (base): ~344 GB compressed, 0.8M renders across 166 categories, all splits (train/val/test/test_unseen). This repo includes the test_unseen and test splits from this variant.
• Omni6D-xl: ~660 GB compressed, extended vocabulary and per-split room diversity. Not included in this repo.
• Omni6D-Real: 0.74 GB, 606 usable real Kinect captures across 22 scenes (36 categories) for sim-to-real evaluation. Fully included in this repo as the real subset.
• Not included: the base Omni6D train split (313 GB, 9 zip chunks) and val split (47 GB) were left out of this repo due to size; download them directly from OpenXLab if needed for training.

FiftyOne Parsing Details

• Coordinate frame: All 3D reconstructions use a Z-up viewer frame (converted from camera-frame x-right, y-down, z-forward).
• Instance linking: 2D and 3D detections of the same object share an fo.Instance object, enabling linked selection in the FiftyOne App (synthetic subsets only).
• Depth decoding: synthetic depth PNGs encode meters as (B*65536 + G*256 + R) / 10000, where B is the most-significant byte (not R). real depth is a direct native uint16 mm PNG — no decoding needed.
• Depth variants: test_unseen ships both depth.png (objects only, background = sentinel) and depthfull.png (full scene, used for the depth Heatmap field); test ships only depth.png and has no depth Heatmap field at all; real ships one direct-depth PNG per capture, used as-is for its depth Heatmap field.
• Undocumented, inconsistently-present test-split files skipped: _size.txt (60% of renders, meaning unclear) and _depth.tiff (3% of renders, isolated to a few scenes) were not parsed to avoid fabricating semantics for unreliable fields.
• Class taxonomy: 190 distinct categories appear across all three subsets combined (33 in test_unseen, 170 in test, 36 in real, with overlap between them).
• Scene ID namespacing: scene_id is prefixed by split (e.g. test/00030, real/000) since raw scene numbering restarts from 00000 independently in each source zip.

Dataset Card Authors

• Recon & FiftyOne ingestion: Harpreet Sahota (voxel51)

Dataset Card Contact

For questions or issues regarding the FiftyOne dataset format, please open an issue on the Omni6D repository or contact the FiftyOne team.