# PartPacker Thought Differences

Date: 2026-04-20 UTC

## 1. Is `teapot formal` a real official inference result?

Yes.

The `teapot formal` result came from the official `PartPacker` CLI:

```bash
cd /data/250010098/PartPacker
HF_ENDPOINT=https://hf-mirror.com PYTHONPATH=. \
  /opt/miniconda3/envs/trellis2/bin/python flow/scripts/infer.py \
  --input assets/images/teapot.png \
  --output_dir /data/250010098/physxanything_stage1_experiments/runs/partpacker_formal_20260419 \
  --num_steps 50 \
  --num_repeats 1 \
  --grid_res 384
```

The output directory is:

`/data/250010098/physxanything_stage1_experiments/runs/partpacker_formal_20260419/flow_big_parts_strict_pvae_20260419_233623`

Key exported files:

- `teapot_0.glb`
- `teapot_0_part0.glb`
- `teapot_0_part1.glb`
- `teapot_0_part2.glb`
- `teapot_0_part3.glb`
- `teapot_0_vol0.glb`
- `teapot_0_vol1.glb`

This is not a manual assembly and not a reused dataset asset. It is a direct output of the official `flow/scripts/infer.py`.

## 2. What is the core idea of PartPacker?

The central idea is:

`single-view image -> two packed 3D volumes -> separable parts`

PartPacker does not start from 2D segmentation priors. Instead, it tries to solve part-level generation inside the 3D latent model itself.

Its key move is `dual volume packing`:

- Build a part-contact graph.
- Convert it into a bipartite graph by heuristic edge contraction.
- Pack the two color groups into two separate 3D volumes.
- Denoise the two latents jointly.
- Decode the two volumes, then split connected components to obtain parts.

The purpose is not only correctness, but efficiency:

- fixed-length output
- parallel generation of multiple disjoint parts
- less reliance on external segmentation pipelines

## 3. Difference from SceneTransporter

SceneTransporter mainly solves:

`which image patch should belong to which part / instance`

Its strongest idea is explicit routing:

- patch-to-part assignment
- OT-based capacity-constrained matching
- edge-aware regularization

So SceneTransporter is strongest at:

- structural separation
- reducing over-sharing and redundancy between parts

But by itself it is not a full articulated-object generator, and in our simplified prototype it was not yet stronger than a strong pixel-space segmenter for direct 3D part lifting.

In short:

- `SceneTransporter`: assignment mechanism first
- `PartPacker`: native 3D part generation first

## 4. Difference from PAct

PAct is closer to:

`part-aware input -> articulated structure/tree -> geometry + joints`

Its strengths are:

- explicit articulated tree
- explicit joint type / axis / range
- strong structured output format

Its cost is strong sensitivity to:

- mask quality
- part labeling consistency

Compared with PAct:

- `PartPacker` is cleaner for pure part geometry generation
- `PAct` is stronger when the target is articulated object structure and motion parameters

## 5. Difference from TRELLIS2

TRELLIS2 is strongest as a high-quality whole-object latent generator.

Its default form is:

`single-view image -> whole object 3D latent -> fused 3D object`

It has structured latent hints such as sparse structure and subs, but it is not natively trained to emit semantic parts directly.

Compared with TRELLIS2:

- `TRELLIS2`: whole-object generation is the native task
- `PartPacker`: part-level generation is the native task

This is why PartPacker is a much cleaner baseline when the target is:

`single image -> separable complete parts`

## 6. Practical interpretation

For our current project, the methods play different roles:

- `TRELLIS2`: best base generator for strong whole-shape priors
- `PAct`: best structured articulation head among currently tested released methods
- `SceneTransporter`: best conceptual tool for routing / assignment / part disentanglement
- `PartPacker`: best direct baseline for pure part-level 3D generation without asking for joints

So if the immediate task is:

`Can we directly generate usable independent parts from one image?`

PartPacker is the most on-target released method we currently have in the workspace.