Datasets:

maxwildersmith
/

splataverse-smithsonian-full

Size:

Tags:

License:

Dataset card Files Files and versions

xet

Community

You need to agree to share your Hugging Face information to access this dataset

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

This dataset is derived from Smithsonian Open Access 3D models (CC0). Please acknowledge the Smithsonian Institution as the source and cite Splataverse if you use it.

Splataverse: Smithsonian (full, with provenance)

This dataset contains the curated Smithsonian Open Access 3D models, converted to 3D Gaussian splats with the Splataverse closed-form mesh-to-Gaussian converter. The splats are at the full, texel-matched Gaussian count, without the 1.5M cap of the main splataverse-smithsonian release. Each object also comes with a per-Gaussian sidecar that records where each Gaussian came from: its source face, barycentric position, PBR material channels and material ID. These are stored in the same order as the .spz file.

Summary: 2,340 objects, 14.08B Gaussians in total (median 5.5M per object), 137 GB.

Layout

data/shard_XXXX.tar        # ~25 objects each, uncompressed tar of:
    <title>__<uid>.spz              # Gaussians (Niantic SPZ v4, SH degree 0)
    <title>__<uid>.sidecar.npz      # per-Gaussian provenance + PBR, aligned 1:1 with the .spz order
    <title>__<uid>.provenance.json  # source, hashes, converter version and parameters
manifest/all.parquet       # one row per object (uid, title, source_url, shard, n_gaussians, PBR flags, sizes)
manifest/shard_XXXX.parquet
load_spz.py                # standalone .spz reader (numpy + zstandard)

Sidecar fields (`.sidecar.npz`)

Every array has one row per Gaussian, in the same order as the .spz file.

key	dtype, shape	meaning
`face_id`	uint32 (G,)	index of the source triangle in the decoded glTF mesh (all primitives concatenated, in file order)
`bary`	float16 (G,2)	barycentric coordinates (b0, b1) of the Gaussian centre in that triangle; b2 = 1 - b0 - b1
`material_id`	uint16 (G,)	index of the glTF primitive/material the face belongs to
`base_color`	uint8 (G,3)	glTF base colour (texture x factor), as stored (sRGB-encoded)
`roughness`, `metallic`	uint8 (G,)	glTF metallic-roughness channels x factors, in [0,255]
`occlusion`	uint8 (G,)	ambient occlusion map (255 = unoccluded if the material has none)
`emissive`	uint8 (G,3)	emissive texture x factor (zeros if none)
`normal_oct`	int16 (G,2)	shading normal with the normal map applied, octahedral snorm16, in the same frame as the `.spz` positions
`sidecar_version`	uint8 scalar	1

The per-object flags has_base_color_tex, has_mr_tex, has_occlusion_tex, has_normal_tex and has_emissive in the manifest and provenance file record which channels come from real texture maps and which are constant material factors. Most Smithsonian models are photogrammetry scans: they have base colour, normal and occlusion maps, and constant roughness/metallic factors.

Loading

import io, tarfile, numpy as np
from huggingface_hub import hf_hub_download
from load_spz import load_spz   # hf_hub_download("maxwildersmith/splataverse-smithsonian-full", "load_spz.py", repo_type="dataset")

tar = hf_hub_download("maxwildersmith/splataverse-smithsonian-full", "data/shard_0000.tar", repo_type="dataset")
with tarfile.open(tar) as tf:
    stem = next(n[:-4] for n in tf.getnames() if n.endswith(".spz"))
    open("obj.spz", "wb").write(tf.extractfile(stem + ".spz").read())
    g = load_spz("obj.spz")                                   # xyz, rgb, log_scales, quats (wxyz), opacity
    side = np.load(io.BytesIO(tf.extractfile(stem + ".sidecar.npz").read()))
assert side["face_id"].shape[0] == g["xyz"].shape[0]          # one sidecar row per Gaussian, same order

def oct_decode(e):
    xy = e.astype(np.float32) / 32767.0
    z = 1.0 - np.abs(xy).sum(1); t = np.clip(-z, 0, None)
    n = np.stack([xy[:, 0] + np.where(xy[:, 0] >= 0, -t, t), xy[:, 1] + np.where(xy[:, 1] >= 0, -t, t), z], 1)
    return n / np.linalg.norm(n, axis=1, keepdims=True)

normals = oct_decode(side["normal_oct"])
roughness = side["roughness"] / 255.0

Recovering the source mesh: each centre equals b0*v[f,0] + b1*v[f,1] + b2*v[f,2] for its face f, so the vertices can be recovered by sparse least squares from the Gaussians alone. Semantic or part labels defined on the source mesh's faces carry over to the Gaussians exactly, through face_id.

Conversion

Each object goes through the following steps:

Downloaded from the Smithsonian 3D API through Objaverse-XL.
Draco-decoded with a Blender 3.0.1 glTF round trip.
Converted with the closed-form converter at its derived, texel-matched density: no cap, no optimisation, opacity 0.99.

The converter's commit and parameters are recorded in each provenance.json. Before packing, every .spz is read back and checked against the arrays the sidecar was built from. The Gaussian count must match, and every position must round-trip within the SPZ fixed-point step.

Curation: we started from all Smithsonian objects in Splataverse split v5. All of them pass the quality filter. We removed one object whose source converts to an empty splat (chandra-x-ray-observatory). Objects that fail to download or convert are listed under "Known gaps" below.

Known gaps

1 curated objects could not be included:

47023011-c20a-5934-85b1-54772477b3a3: download/decode failed

Licence and attribution

The source models are released by the Smithsonian Institution under CC0 (Smithsonian Open Access). The derived splats and sidecars are also released under CC0. Please acknowledge the Smithsonian Institution, and cite Splataverse:

@inproceedings{splataverse2027,
  title  = {Splataverse: Closed-Form Mesh-to-Gaussian Conversion and a Two-Million-Object Splat Corpus},
  author = {Anonymous},
  year   = {2027}
}

CPU analytical balanced full-PBR PLY variant

The original uncapped SPZ/sidecar release above remains unchanged. A separate analytical CPU balanced PBR PLY export is available under balanced_pbr_ply_cpu_v1/. Its coverage/index report states exactly which objects/shards are verified and whether the2340-object export is complete. The profile uses one source-error analysis and one CPU conversion, without render-based count search; it does not claim an LPIPS guarantee.