bardofcodes/superfit-primitive-assemblies

SuperFit Primitive Assembly Release

Pre-computed primitive assemblies produced by SuperFit (CVPR 2026) on two public 3D shape benchmarks. Each instance stores the fitted primitive parameters, optimization statistics, and optional per-instance evaluation metrics as serialized Python pickles alongside the hyperparameter config.json used for fitting.

The manifest files can be inspected with standard-library Python only. Loading primitive-assembly pickles, recovering expressions, or generating meshes requires the SuperFit codebase and its runtime dependencies.

Intended use: The dataset materials in this release are provided for non-commercial research use only under CC BY-NC 4.0. The small release helper scripts are MIT-licensed; see LICENSE for scope. Source 3D meshes are not redistributed here; you must obtain Toys4K and PartObjaverse / Objaverse under their respective terms before comparing to ground-truth geometry. Commercial use of this Dataset, in whole or in part, requires prior written permission from the authors.

Dataset structure

sf_release/
├── manifest.jsonl          # one row per (subset, method, object)
├── metadata.json           # counts and schema summary
├── load_release.py         # stdlib manifest index + pickle helper
├── scripts/                # build, sanitize, validate (maintainers)
├── examples/               # usage examples
└── dataset/                # primitive-assembly artifacts
    ├── toys4k/
    │   ├── cuboid/             # 500 instances + eval_summary_*
    │   ├── sf_cvpr/            # 500 instances + eval_summary_*
    │   ├── sp_proto/           # 500 instances
    │   ├── superfrustum/       # 4000 instances + eval_summary_*
    │   ├── supergeon/          # 500 instances
    │   └── superquadric/       # 500 instances
    └── partobjaverse/
        └── superfrustum/       # 200 instances + eval_summary_*

Subsets and methods

Subset	Method folder	Primitive type (PRIM_TYPE)	Instances
toys4k	superfrustum	VarAxisSF (SuperFrustum)	4000
toys4k	cuboid	Cuboid	500
toys4k	sf_cvpr	SuperFrustum	500
toys4k	sp_proto	VarAxisSPP	500
toys4k	supergeon	VarAxisSG	500
toys4k	superquadric	VarAxisSQ	500
partobjaverse	superfrustum	VarAxisSF	200

Toys4K instance directories are named {category}_{id} (e.g. airplane_003). PartObjaverse instances use the 32-character Objaverse UID as the directory name.

Per-instance files

File	Required	Description
config.json	yes	Fit hyperparameters (AlgorithmConfig); AOT_ARTIFACT_FILE is nulled in the release
primitive_assembly.pkl	usually	Flat dict of optimization / assembly statistics from SuperFit (Stats.get_dict())
primitive_assembly_eval.pkl	optional	Per-instance evaluation metrics
primitive_assembly_error.pkl	optional	Partial stats from runs where fitting failed (present in lieu of primitive_assembly.pkl for ~45 instances)
primitive_assembly.pkl_textured.pkl	optional	Textured assembly (partobjaverse only)

Every instance directory contains either primitive_assembly.pkl (success) or primitive_assembly_error.pkl (failure). Filter on has_primitive_assembly in the manifest if you only want successful fits.

Method-level aggregates (where present):

• eval_summary_start0_end500.md / .pkl — mean metrics over Toys4K eval splits
• eval_summary_start0_end200.md / .pkl — mean metrics over PartObjaverse (200 objects)

Pickle schema

primitive_assembly.pkl is a flat Python dict produced by SuperFit's statistics manager. Keys are dot-separated paths (e.g. iter_0.pruned_program, evaluation.iou@128, input_mesh_file, timing scopes). Values are floats, strings, NumPy arrays, PyTorch tensors, nested dicts, or serialized SuperFit / GeoLIPI expression metadata. Loading primitive assemblies requires Python 3.10+ and usually the SuperFit runtime, including PyTorch / NumPy and the expression classes used by the saved programs.

See the SuperFit repository for the supported runtime and code that consumes these artifacts.

Pickle safety

Pickle files can execute arbitrary code during pickle.load. Only load artifacts from this official dataset repository (or your own trusted mirror). Do not unpickle files from untrusted third parties.

Usage

Clone and enable Git LFS

Binary artifacts are stored with Git LFS. After cloning:

git lfs install
git clone https://huggingface.co/datasets/<org>/superfit-primitive-assemblies
cd superfit-primitive-assemblies
git lfs pull

Manifest discovery (stdlib only)

from pathlib import Path
from load_release import ReleaseIndex, load_metadata

root = Path(".")
print(load_metadata(root)["total_instances"])  # 6700

index = ReleaseIndex(root)
row = index.get("toys4k", "superfrustum", "airplane_002")
print(row["primitive_assembly_path"])

Loading artifacts (requires SuperFit runtime)

Primitive assemblies are Python pickles. Unpickling them can require SuperFit, PyTorch, NumPy, and expression dependencies from the SuperFit repository:

from pathlib import Path
from load_release import ReleaseIndex

root = Path(".")
index = ReleaseIndex(root)
row = index.get("toys4k", "superfrustum", "airplane_002")
assembly = index.load(row)  # trusted pickle; requires SuperFit/PyTorch stack
print(type(assembly), list(assembly.keys())[:5])

Command-line example:

python examples/load_artifact.py --source toys4k --method cuboid --object-id airplane_003
python examples/load_artifact.py --source partobjaverse --method superfrustum --artifact eval

Export a mesh with SuperFit

The released files store primitive expressions, not pre-meshed OBJ/GLB files. To generate a mesh, install or add SuperFit to your Python environment, load a saved expression, evaluate it as an SDF, and use SuperFit's mesh extraction helper:

from pathlib import Path

from geolipi.torch_compute import Sketcher, recursive_evaluate
from load_release import ReleaseIndex
from superfit.symbolic.utils import fetch_singular_expr_eval
from superfit.utils.io import get_best_expr
from superfit.utils.mesh_sdf import sdf_to_mesh

root = Path(".")
index = ReleaseIndex(root)
row = index.get("toys4k", "superfrustum", "airplane_002")
info = index.load(row)  # trusted pickle; requires SuperFit runtime

expr = get_best_expr(info, prog_type="pruned_program")
expr = fetch_singular_expr_eval(
    expr.tensor(device="cuda"),
    temperature=10000.0,
    relaxed_eval=True,
    remove_marker=True,
    device="cuda",
)

sketcher = Sketcher(resolution=128, n_dims=3, device="cuda")
sdf = recursive_evaluate(expr.tensor(device="cuda"), sketcher)
mesh = sdf_to_mesh(sdf, sketcher)
mesh.export("airplane_002.obj")

The same flow is available as:

python examples/export_mesh_with_superfit.py \
  --source toys4k \
  --method superfrustum \
  --object-id airplane_002 \
  --output airplane_002.obj

SuperFit's current mesh extraction path uses PyTorch/Kaolin/FlexiCubes and is normally run on CUDA.

Rebuild manifest / validate before upload

Maintainers can regenerate indexes and run checks from the repo root:

python scripts/sanitize_configs.py      # null local AOT paths (idempotent)
python scripts/build_manifest.py        # writes manifest.jsonl + metadata.json
python scripts/build_manifest.py --checksums  # optional sha256 columns
python scripts/validate_release.py

Limitations

• Not a Parquet/Arrow dataset: the Hugging Face Dataset Viewer will not render pickle contents; use manifest.jsonl for discovery.
• No source meshes: only fitted assemblies and configs are provided.
• Incomplete eval coverage: dataset/toys4k/superfrustum has per-instance eval pickles on a subset of instances; see has_primitive_assembly_eval in the manifest.
• Environment coupling: manifest discovery is stdlib-only, but unpickling primitive assemblies, recovering expressions, and exporting meshes require the SuperFit stack.

Licensing and provenance

Component	License / terms
Dataset materials (assemblies, configs, eval summaries, manifests, metadata, docs)	CC BY-NC 4.0 - non-commercial research use only
Release helper code (load_release.py, examples/*.py, scripts/*.py)	MIT
SuperFit codebase	Distributed separately under its own license; see SuperFit
Toys4K source meshes	Request access via the authors' form; follow their terms
PartObjaverse (dataset/partobjaverse/)	Derived from SAMPart3D / Objaverse assets; cite Yang et al. (2024) below
Objaverse source meshes	Per-object licenses (CC-BY, CC-BY-NC, etc.); see Objaverse

We recommend publishing this Hugging Face repo as gated until you confirm redistribution of derived fits is compatible with your Toys4K and Objaverse agreements.

This dataset release is not licensed under the Adobe Research License; that license applies to the separate SuperFit codebase. Details on source datasets and release posture: PROVENANCE.md.

Citation

If you use this release, please cite SuperFit and the source datasets:

@misc{ganeshan2026superfit,
  title         = {Residual Primitive Fitting of 3D Shapes with SuperFrusta},
  author        = {Aditya Ganeshan and Matheus Gadelha and Thibault Groueix and Zhiqin Chen and Siddhartha Chaudhuri and Vladimir G. Kim and Wang Yifan and Daniel Ritchie},
  year          = {2026},
  booktitle     = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  month         = {June},
}

@inproceedings{stojanov2021toys4k,
  title     = {Using Shape to Categorize: Low-Shot Learning with an Explicit Shape Bias},
  author    = {Stefan Stojanov and Anh Thai and James M. Rehg},
  booktitle = {CVPR},
  year      = {2021},
}

@article{yang2024sampart3d,
  author  = {Yang, Yunhan and Huang, Yukun and Guo, Yuan-Chen and Lu, Liangjun and Wu, Xiaoyang and Lam, Edmund Y. and Cao, Yan-Pei and Liu, Xihui},
  title   = {SAMPart3D: Segment Any Part in 3D Objects},
  journal = {arXiv preprint arXiv:2411.07184},
  year    = {2024},
}

@article{deitke2023objaverse,
  title   = {Objaverse: A Universe of Annotated 3D Objects},
  author  = {Matt Deitke and Dustin Schwenk and Jordi Salvador and Luca Weihs and others},
  journal = {arXiv:2212.08051},
  year    = {2023},
}

Contact

Questions: adityaganeshan@gmail.com · Project page