Every9D

From the paper Every9D-21M: Large-Scale Real-World 9D Canonicalization of Everyday Objects.

Every9D gives the videos of uCO3D category-level 9-D object poses: rotation, translation and 3-D size, expressed in one canonical frame per category.

Split	Sequences	Frames in frames	Categories
train	110,543	1,768,255	894
test	3,651	58,382	898
Total	114,194	1,826,637	959

The tforms config holds one row per sequence, so 114,194 rows in total.

Config	What it holds	Size	Needs uCO3D?
tforms	One rigid transform per sequence, plus size and symmetry. Gives a pose for every frame of a uCO3D video	~20 MB	yes, for images and cameras
frames	Ready-to-train RGB-D crops at 256 × 256, up to 16 frames per sequence	~270 GB	no
frames_meshes	The alpha500 mesh of each sequence, used for the amodal masks	~1 GB	no

Train and test are disjoint, and no object appears in both. The 65 categories with a single sequence appear in test only, so they have no train object.

Option A: use the crops

No uCO3D download is needed. Stream the data, as the full train split is about 260 GB:

from datasets import load_dataset
import numpy as np, pyarrow as pa

def decode(t):
    """Decode one stored tensor into a numpy array."""
    raw = t["data"]
    if t["z"] == "zstd":
        raw = pa.Codec("zstd").decompress(raw, decompressed_size=t["nbytes"], asbytes=True)
    if t["pack"] == "bits":
        n = int(np.prod(t["shape"]))
        return np.unpackbits(np.frombuffer(raw, np.uint8), count=n).astype(bool).reshape(t["shape"])
    if t["q"]:
        a = np.frombuffer(raw, np.uint8 if t["q"] == "u8" else np.uint16).astype(np.float32)
        return (a / np.float32(t["scale"])).reshape(t["shape"])
    return np.frombuffer(raw, np.dtype(t["dtype"])).reshape(t["shape"])

ds = load_dataset("GenIntelLab/Every9D", "frames", split="test", streaming=True)
row = next(iter(ds))
rgb  = decode(row["rgb"])               # (3, 256, 256) float32 in [0, 1]
pose = decode(row["cam_tform4x4_obj"])  # (4, 4)

Tensors are stored compressed, so the Hub viewer shows them as binary. Always go through decode. Each row has these fields:

Field	Shape	Meaning
frame_id	str	<category>/<sequence>/<frame_number>
object_id	str	<category>/<sequence>
category, category_id	str, int	Every9D category
rgb	(3, 256, 256)	float32 in [0, 1]
depth, depth_mask	(256, 256)	depth in the sequence's units (see below), valid pixels
fo_mask	(256, 256)	visible object mask
fo_mask_amodal, fo_mask_amodal_dt	(256, 256)	alpha500 mesh rendered under the pose, and its distance transform
cam_intr4x4	(4, 4)	intrinsics of the crop
cam_tform4x4_obj	(4, 4)	object → camera, rigid
obj_ncds0c_tform4x4_obj	(4, 4)	normalised object coordinates → object space
cam_tform4x4_obj_ncds	(4, 4)	cam_tform4x4_obj @ obj_ncds0c_tform4x4_obj
obj_size3d	(3,)	box side lengths along X, Y, Z
obj_syms	(3,)	per-axis symmetry code
cam_bbox2d, cam_bbox3d	(4,), (8, 3)	object boxes in the crop and in camera space

Option B: poses for every frame of a uCO3D video

Download uCO3D's metadata.sqlite, and any videos you need, with its download script. Then combine its cameras with the tforms table:

import sqlite3, struct
import numpy as np
from datasets import load_dataset

tforms = {}
for split in ("train", "test"):
    for r in load_dataset("GenIntelLab/Every9D", "tforms", split=split):
        tforms[r["sequence_name"]] = r

# uCO3D (PyTorch3D) camera -> Every9D camera (OpenGL: +X right, +Y up, -Z forward)
CAM = np.diag([-1.0, 1.0, -1.0, 1.0])

def cam_tform4x4_obj(R_blob, T_blob, world_tform4x4_obj):
    """Object -> camera, from uCO3D's _viewpoint_R and _viewpoint_T."""
    cam_tform4x4_world = np.eye(4)
    cam_tform4x4_world[:3, :3] = np.array(struct.unpack("<9f", R_blob)).reshape(3, 3).T
    cam_tform4x4_world[:3, 3] = struct.unpack("<3f", T_blob)
    return CAM @ cam_tform4x4_world @ world_tform4x4_obj

def cam_intr3x3(f_blob, p_blob, size_blob):
    """Pixel intrinsics of the full frame, for intrinsics format ndc_isotropic."""
    (fx, fy), (px, py) = struct.unpack("<2f", f_blob), struct.unpack("<2f", p_blob)
    h, w = struct.unpack("<2I", size_blob)
    s = min(h, w) / 2.0
    return np.array([[fx * s, 0, -px * s + w / 2], [0, fy * s, -py * s + h / 2], [0, 0, 1]])

db = sqlite3.connect("metadata.sqlite")
sequence = "109-89486-96842"
t = tforms[sequence]
world_tform4x4_obj = np.array(t["world_tform4x4_obj"]).reshape(4, 4)

poses = {}
for frame, R, T, f, p, size in db.execute(
    "SELECT frame_number, _viewpoint_R, _viewpoint_T, _viewpoint_focal_length,"
    " _viewpoint_principal_point, _image_size FROM frame_annots"
    " WHERE sequence_name = ? ORDER BY frame_number", (sequence,)):
    poses[frame] = (cam_tform4x4_obj(R, T, world_tform4x4_obj), cam_intr3x3(f, p, size))

From uCO3D's camera pose to Every9D's

cam_tform4x4_obj above takes three steps from uCO3D's camera to the Every9D pose:

cam_tform4x4_obj = CAM @ cam_tform4x4_world @ world_tform4x4_obj

1. Build uCO3D's camera matrix, cam_tform4x4_world. _viewpoint_R and _viewpoint_T use PyTorch3D's row-vector convention, x_cam = x_world R + T. As a matrix for column vectors, the rotation block is therefore R.T and the translation is T. The result maps the sequence's SfM frame into uCO3D's camera, with +X left, +Y up and +Z forward.
2. Change the object frame with world_tform4x4_obj. Multiplying on the right replaces the arbitrary SfM frame with the Every9D object frame. This matrix already includes the category's canonical rotation and axis order. It is rigid, so the result stays in the sequence's SfM units.
3. Change the camera to OpenGL with CAM = diag(-1, 1, -1, 1). Multiplying on the left negates camera X and Z, which gives +X right, +Y up and -Z forward. For OpenCV instead (+X right, +Y down, +Z forward), use diag(-1, -1, 1, 1).

For frames that are in the frames config, the OpenGL result equals the stored cam_tform4x4_obj. The intrinsics do not: cam_intr3x3 gives those of the full frame, while the stored cam_intr4x4 belongs to the 256 × 256 crop.

Projecting points

To project an object point x in object space, apply cam_tform4x4_obj to get (X, Y, Z) with Z < 0, then u = cx + fx * X / -Z and v = cy - fy * Y / -Z.

Each row of tforms has these fields:

Field	Meaning
sequence_name	Join key. Unique in uCO3D, and the same name as in metadata.sqlite
uco3d_category	Category as uCO3D spells it (pug-dog)
category	Category as Every9D spells it (pug_dog), as in frame_id
split	train or test
world_tform4x4_obj	16 floats, row-major: rigid, Every9D object frame → uCO3D sequence (SfM) frame
obj_ncds0c_tform4x4_obj	16 floats, row-major: normalised object coordinates → object frame
obj_size3d	Box side lengths along X, Y, Z
obj_syms	Per-axis symmetry code

Join on sequence_name, not on the category: the two spellings differ for a few categories.

Conventions

• Camera: OpenGL, with +X right, +Y up and -Z forward. Objects in front of the camera have negative camera Z.
• Object frame: X = right, Y = top, Z = back of the category's canonical orientation.
• Object origin: the origin of the object frame is not the object's centre. For a centred pose use cam_tform4x4_obj @ obj_ncds0c_tform4x4_obj, which maps a normalised object, centred with its longest side spanning [-1, 1], into the camera.
• Units: translations, depth and obj_size3d are in the units of each sequence's SfM reconstruction, not metres. An aerosol can may be 1.4 units tall, so do not compare absolute sizes across sequences.

Limitations

• Poses inherit uCO3D's cameras. Canonical orientations were reviewed per category, but individual sequences can still be wrong.
• alpha500 meshes are alpha-shape reconstructions from uCO3D's segmented point clouds, not artist meshes. Thin parts can be missing, so the amodal masks are approximate.
• frames holds up to 16 frames per sequence, and at least 9. Use Option B to reach the rest.
• frames_meshes has 10 sequences stored twice (9 in train, 1 in test), as identical copies, so it has 10 more rows than there are sequences.

License and citation

Released under CC BY 4.0. The images, depth and cameras derive from uCO3D, also CC BY 4.0, so please credit both.

@misc{sommer2026every9d21mlargescalerealworld9d,
      title={Every9D-21M: Large-Scale Real-World 9D Canonicalization of Everyday Objects}, 
      author={Leonhard Sommer and Emil Akopyan and Adam Kortylewski},
      year={2026},
      eprint={2605.28270},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2605.28270}, 
}

@misc{liu2025uncommonobjects3d,
      title={UnCommon Objects in 3D}, 
      author={Xingchen Liu and Piyush Tayal and Jianyuan Wang and Jesus Zarzar and Tom Monnier and Konstantinos Tertikas and Jiali Duan and Antoine Toisoul and Jason Y. Zhang and Natalia Neverova and Andrea Vedaldi and Roman Shapovalov and David Novotny},
      year={2025},
      eprint={2501.07574},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2501.07574}, 
}