macpaw-research/asset-alignment-pairs-905k

Asset Alignment Pairs 905k

Dataset for the paper "Rigid 3D Object Alignment: Optimization vs. Feed-Forward Prediction".

Large-scale dataset for rigid 3D asset alignment: given an independently generated 3D asset (src) and a target object (tgt), predict the rigid transformation that places the asset onto the target object.

Each row is one source–target pair, rendered from three canonical orthogonal viewpoints with RGB, metric depth, camera extrinsics, and the ground-truth transformation parameters, as well as tgt center and src center.

The Dataset Viewer is disabled because depth is stored as float32 TIFF, which the viewer cannot process. The data itself is fine when loading with HF datasets.

Splits

Split	Rows	Size
train	905,312	3027.08 GB
validation	9,856	33.04 GB
test	4,720	15.75 GB

Rows average ~3.3 MB (six 512×512 images each). Stream unless you genuinely need the whole split on disk. train, validation and test are split with GroupShuffleSplit grouped on asset_name, so no scene appears in more than one split.

Quick start

from datasets import load_dataset

ds = load_dataset("macpaw-research/asset-alignment-pairs-905k",
                  split="test", streaming=True)
sample = next(iter(ds))

Schema

Field	Type	Description
asset_name	string	Scene / asset UUID, inherited from PartVerse-XL
part_idx	int32	Index of the part designated as the source in that scene
right_image	Image	RGB render, ZY-plane projection, 512×512 PNG
back_image	Image	RGB render, ZX-plane projection, 512×512 PNG
upper_image	Image	RGB render, XY-plane projection, 512×512 PNG
right_depth	Image	float32 TIFF depth, ZY view, 512×512
back_depth	Image	float32 TIFF depth, ZX view, 512×512
upper_depth	Image	float32 TIFF depth, XY view, 512×512
camera_extrinsics	Array3D(3,4,4) float32	World→camera matrices, ordered [right, back, upper]
action	list[float32] (3 or 9)	Ground-truth translation t if length 3, t, R if length 9
tgt_center	list[float32] (3)	Centroid of the target object; model conditioning input
src_center	list[float32] (3)	Centroid c_src of the source part; rotation pivot
intersection_3d	bool	Whether source and target volumes intersect in 3D
intersection_2d	bool	Whether source and target overlap in the 2D projections
valid_depth	bool	Whether depth is trustworthy for this sample

(asset_name, part_idx) is not unique

The pipeline applies 16 augmented spatial variations per unique source–target configuration: 8 translation-only, 8 rotation + translation. Rows sharing an asset_name and part_idx are augmented views of the same underlying pair.

The task and the label

The transformation is defined relative to the source centroid, so that rotation is invariant to the asset's global position (Eq. 1 in the paper):

Φ(x; τ) = R (x − c_src) + c_src + t

where τ = {R, t} is the rigid transformation, R is a rotation in SO(3), t is a translation in R³, and c_src is the source centroid (src_center). The transform is applied only to the source object, so that the target object is never moved or deformed.

Data Collection Pipeline

Source geometry comes from PartVerse-XL (Ding et al., 2025), derived from Objaverse-XL. For each scene, one part is designated the source and the remaining parts form a composite target. Pairs are kept only if the two are of comparable scale, enforced by a relative volume filter

min(V_src / V_tgt, V_tgt / V_src) > λ,   λ = 0.1

so both objects remain legible at a fixed camera distance.

Render

Produced with Blender EEVEE, 512×512, RGB PNG, four area lights co-located with the camera positions.

The RGB views carry Set-of-Marks visual prompting (Yang et al., 2023): the source and target objects are annotated with src / tgt marks to strengthen the VLA model's spatial grounding. See Fig. 2 of the paper. If you are training a purely geometric model, be aware these overlays are part of the pixels.

The intersection_* flags are derived from these renders: intersection_3d is computed on the meshes in 3D space, intersection_2d on their projections onto the image plane.

Depth

Depth is the Z pass, measuring distance along the camera view axis in scene units, from the same viewpoints as the RGB renders.

Background is -1 where no geometry is visible, so mask it before use:

import numpy as np

d = np.asarray(sample["right_depth"], dtype=np.float32)   # (512, 512)
mask = d >= 0                                             # True on geometry
valid = d[mask]

Some meshes did not render their depth pass correctly; those rows are marked valid_depth = False.

Additional files

• dataset.json — overall dataset statistics
• meshes.tar.zst — the GLB meshes for the rendered pairs
• assets/ — normalization statistics for each split, used in the training code

Licensing

Renders, depth maps, camera extrinsics, and transformation labels are released under the MIT License.

The underlying geometry is not ours to license. This dataset derives from Objaverse-XL via PartVerse-XL; Objaverse-XL is distributed under ODC-By 1.0, which covers the database as a whole and does not license the individual 3D objects. Users are responsible for verifying per-object compliance for their intended use. Attribution to Objaverse-XL is required under ODC-By 1.0.