README.md

---
language:
- en
license: cc-by-nc-4.0
license_link: LICENSE
task_categories:
- other
tags:
- 3d
- shape
- primitives
- superfrustum
- superfit
- pickle
- point-cloud
size_categories:
- 1K<n<10K
configs:
- config_name: toys4k_cuboid
  data_files:
  - split: train
    path: manifest.jsonl
  default: false
- config_name: toys4k_superfrustum
  data_files:
  - split: train
    path: manifest.jsonl
  default: true
- config_name: partobjaverse_superfrustum
  data_files:
  - split: train
    path: manifest.jsonl
  default: false
---

# SuperFit Primitive Assembly Release

Pre-computed **primitive assemblies** produced by [SuperFit](https://github.com/BardOfCodes/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](https://github.com/BardOfCodes/superfit) 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](LICENSE). The small release helper scripts are MIT-licensed; see [LICENSE](LICENSE) for scope. Source 3D meshes are **not** redistributed here; you must obtain [Toys4K](https://rehg.org/publication/dataset2/) and [PartObjaverse](https://partobjaverse.github.io/) / [Objaverse](https://objaverse.allenai.org/) 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](https://github.com/BardOfCodes/superfit) 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:

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

### Manifest discovery (stdlib only)

```python
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](https://github.com/BardOfCodes/superfit):

```python
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:

```bash
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](https://github.com/BardOfCodes/superfit)
to your Python environment, load a saved expression, evaluate it as an SDF, and
use SuperFit's mesh extraction helper:

```python
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:

```bash
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:

```bash
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](LICENSE) - non-commercial research use only |
| **Release helper code** (`load_release.py`, `examples/*.py`, `scripts/*.py`) | [MIT](LICENSE) |
| **SuperFit codebase** | Distributed separately under its own license; see [SuperFit](https://github.com/BardOfCodes/superfit) |
| **Toys4K** source meshes | Request access via the [authors' form](https://forms.gle/w7Zf82umwaKxr9L7A); follow their terms |
| **PartObjaverse** (`dataset/partobjaverse/`) | Derived from [SAMPart3D](https://arxiv.org/abs/2411.07184) / Objaverse assets; cite Yang et al. (2024) below |
| **Objaverse** source meshes | Per-object licenses (CC-BY, CC-BY-NC, etc.); see [Objaverse](https://objaverse.allenai.org/) |

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](PROVENANCE.md).

## Citation

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

```bibtex
@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},
}
```

```bibtex
@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},
}
```

```bibtex
@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},
}
```

```bibtex
@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](https://bardofcodes.github.io/superfit)