Superquadrics · Counterfactual edit probe · Updated August 2026

The Shape Doppelganger Problem

Surface fit is not editability.

Two hand-specified 3D programs can draw almost the same object. Ask both to realize the same part-level intention, and their behavior can diverge.

Before the editThey look alike.
After the editThey behave differently.
Try the edit Read the argument
Keep reading ↓
00 In one minute

A good reconstruction can hide a bad abstraction.

A shape program is useful for more than reproducing a surface. Its controls should match the things a person wants to change.

This controlled probe compares two authored templates built from the same deformable-superquadric vocabulary. One exposes human-facing groups—handle, neck, pull. The other exposes local pieces. Major surfaces are optimized against the original object; the edit-critical chains and both program-space edit mappings are authored. The result is a concrete counterexample, not a learned-method leaderboard.

Static test “Does it look right?”

Both programs pass.

Behavioral test “Does the right part move?”

The programs separate.

+0.0012 mean static distance gap
local − semantic
+0.0202 mean edited distance gap
local − semantic
2.42x error amplification
local vs semantic

Scope: 3 procedural objects × 2 authored program families × 6 optimization restarts. Semantic correspondence is supplied; uncertainty is not estimated.

The distinction Reconstruction asks where the surface is. Editability asks what should change together.
01 The vocabulary

Start with a shape you can understand.

A superquadric is a compact recipe for a 3D surface. A few numbers control its width, height, roundness, pose, bend, and taper. Change the numbers and the same recipe becomes a sphere, a rounded box, a rod, or a curved part. It sits between an opaque triangle mesh and a full CAD history: expressive enough to model parts, simple enough to inspect. Barr, 1981

The primitives below use the same superquadric surface code as the comparison—drag them to orbit, then adjust the highlighted shape and deformation parameters. Notice that geometry and control structure are different things: several small primitives can look like one handle, but they do not automatically behave like one handle.

Primitive one posed, scaled, possibly bent or tapered superquadric.
Program a set of primitives plus grouping metadata for edit controls.
Control the unit a user edits, such as one part or a linked group.
Doppelganger a surface-similar program whose controls behave differently.
Show the superquadric parameterization
\[ \mathbf{r}(\eta,\omega)= \begin{bmatrix} a_1\,\operatorname{sgn}(\cos\eta)|\cos\eta|^{\epsilon_1} \operatorname{sgn}(\cos\omega)|\cos\omega|^{\epsilon_2} \\ a_2\,\operatorname{sgn}(\cos\eta)|\cos\eta|^{\epsilon_1} \operatorname{sgn}(\sin\omega)|\sin\omega|^{\epsilon_2} \\ a_3\,\operatorname{sgn}(\sin\eta)|\sin\eta|^{\epsilon_1} \end{bmatrix} \]

The implementation applies bend and taper inside this sampled surface, not as visual post-processing. Where the fit mask allows it, those parameters can be optimized; either way, one primitive can represent a curved or width-varying part. Tavernini et al., 2026

Smooth Superellipsoidexponents near one keep the surface round and ellipsoid-like.shape: epsilon near 1
Box-Like Superquadricsmaller exponents flatten faces and sharpen the transitions.shape: epsilon below 1
Elongated Primitiveone dominant scale turns the same surface family into a rod.scale: a1 much larger
Bent Superquadricthe implemented bend parameter curves the sampled local surface.deform: bend k = 1.35
Tapered Superquadricthe implemented taper changes both cross-section axes along local x.deform: taper y,z = −0.68
Grouped SQ Programfive visible SQ segments can share one user-facing handle label without becoming one smooth mesh.structure: 5 SQs → 1 group
02 The blind spot

Looks are not behavior.

A shape doppelganger is a pair of reconstructions that are almost indistinguishable under a surface metric but behave differently when treated as programs. The failure is easy to miss because both reconstructions can look correct in the original pose. A mug or lamp can use the same chain of SQ segments while attaching different control metadata to that chain. A drawer pull can look similar with four grouped handle pieces or six locally labeled pieces. Static geometry alone does not tell us which user-level action either program exposes.

The difference matters only when the representation is used. If a user says "widen the handle," the human semantic object has two obvious parts: the container and the handle. If a program exposes five local pieces whose boundaries do not match that human description, the edit has to be projected onto the wrong controls. The edited result can tear, drift, over-rotate, or move the wrong endpoint even though the original reconstruction was visually fine.

A low surface error does not imply a correct edit program.

That is why I make the test below behavioral. It does not ask only "How close is the reconstructed surface?" It also asks "If a semantic edit is applied, does the recovered program produce the expected counterfactual object?"

How this connects to prior work

The point is close to the motivation behind recent primitive-based decomposition work, but the measurement is different. Learnable superquadrics use primitives as parsimonious shape abstractions Paschalidou et al., 2019. Hierarchical primitive models emphasize part structure and part relations Paschalidou et al., 2020. SuperDec targets compact superquadric scene representations for downstream use Fedele et al., 2025. Light-SQ explicitly frames generated-mesh abstraction around reconstruction quality and primitive-level editability Wang et al., 2025. A surface metric checks one side of that story. The doppelganger test checks the other side: whether the recovered parts are still meaningful when they become controls. Shape-program work makes the same broad distinction from another direction: a representation can be valuable because its variables are interpretable and editable, not only because it reconstructs geometry Jones et al., 2020.

03 The intervention

Do not grade the answer before the question changes.

An edit is a part-level counterfactual intervention. It is not an image morph, not a deformation applied to the final rendering, and not a second optimization pass. Each case defines an original procedural target \(T\), an edited target \(E_T(T,u)\), and a named intention \(u\). Major trainable surfaces in each program are adjusted using samples from \(T\) only. A separately authored program executor \(E_P(P,u)\) then updates that template's primitive parameters. I compare its endpoint with the edited target. Distinguishing \(E_T\) from \(E_P\) matters: the two program families do not receive the same low-level parameter update.

The semantic region is known because I control the generator. The generator names object components, and each program template declares which primitives belong to each user-facing control. For the mug, the cup body, rim, foot ring, and attachment pads stay fixed while the side loop moves outward. For the desk lamp, the base and lower stem stay fixed while the flexible neck bends downward and carries the lamp head. For the drawer pull, the face stays fixed while the posts and curved grip move outward as one pull. I am therefore not claiming to solve open-world semantic part discovery. I am asking a narrower question: once a template claims to expose a part control, can an authored executor for that control produce the intended counterfactual shape?

Defineauthor an original object, an edited target, and a named intention.
Fitadjust the templates' trainable major surfaces using the original only.
Executeapply a family-specific authored parameter mapping for that intention.
Comparescore each edited endpoint against the known edited target.

The crucial—and limiting—step is the edit transfer for the local-piece program. This template represents the original object with local SQ pieces whose boundaries do not coincide with the intended semantic control. The author must distribute the same high-level intention across several parameter updates. In these examples that distribution is chosen to illustrate drift. The result therefore establishes a counterexample to surface-only evaluation, not a causal estimate of what an automatically learned executor would do.

For example, the semantic-control mug program has a container control and a handle control. The handle control is implemented as a linked group of small SQ segments, because that renders a cleaner handle than forcing a single primitive to do everything. Widening the handle moves that group coherently: the mounts shift slightly, the outer arc shifts more, and the loop remains attached. The local-piece mug program uses a similar-looking set of local SQs, but those pieces are not one edit control. The same instruction has to be distributed across pieces, and the authored local executor in this construction is where drift appears.

There is no hidden semantic oracle inside the optimizer. The target generator provides the part labels, the program templates provide the primitive-to-control labels, and the edit operator is a deterministic authored update on those controls. The edit-critical chains are template-fixed; only selected major surfaces are trainable. The edited target is excluded from fitting and restart selection, so no program is re-fit to the edited answer—but the supplied labels and executors mean this is not a test of part discovery or edit learning.

Inspect the exact edit operators

The actual edit operator

Formally, a program is a list of primitives \(P=\{(\theta_i,g_i,c_i)\}_i\). The vector \(\theta_i\) stores the SQ scales, exponents, pose, bend, and taper; \(g_i\) is the procedural component label used for evaluation; and \(c_i\) is the user-facing edit control. A family-specific executor \(E_{P,f}\) selects one or more controls and applies a deterministic parameter update to their primitives. Primitives outside the edited controls keep their fitted parameters. Primitives inside them receive prescribed translations, rotations, bends, tapers, or scale changes. No parameter is reoptimized after this step.

The table below gives the actual local-coordinate executors used by the page. These constants are hand-authored as part of the controlled illustration, just like a robotics benchmark might specify a grasp motion or an articulation target. Both executors aim at the same target-level intention, but they are separately chosen mappings. That asymmetry is visible here rather than hidden behind the phrase “same edit.”

Mug: widen handle loop Target loop: mounts move from x=0.30 to x=0.36; the outer arc moves from x=0.74 to x=0.90. Semantic executor: mounts use tx += 0.06; handle endpoints use tx += 0.06; mid segments use tx += 0.11; the middle segment uses tx += 0.16 and sx *= 1.06. Local executor: middle pieces use tx += 0.22 and sx *= 0.92; upper and lower pieces use smaller tx shifts plus opposite z shifts and y rotations.
Desk lamp: bend neck downward Target lamp: the neck control points move downward; the shade moves tx 0.66->0.80, tz 0.32->0.16, and ry 0.46->0.63. Semantic executor: linked neck pieces receive increasing offsets along the curve: lower tx += 0.02, tz -= 0.06; middle tx += 0.08, tz -= 0.11; upper tx += 0.16, tz -= 0.16. The shade group changes pose; the opening and bulb keep fixed local offsets inside the shade. Local executor: every local neck piece gets rx += 0.14, then lower/middle/upper pieces receive different tx, tz, and ry offsets.
Drawer pull: pull handle outward Target pull: drawer face stays fixed; the pull control moves from y=-0.12 to y=-0.28. Semantic executor: posts use ty -= 0.08 and sx *= 1.55; the curved bar uses ty -= 0.18 and sz *= 1.05. Local executor: middle local pieces use ty -= 0.22 and rz += 0.08; side pieces use ty -= 0.10 with opposite x rotations.
04 The test

Fit first. Intervene second. Never refit.

I compare two hand-specified SQ template families. Both use the same optimizer and parameter vocabulary, and both are adjusted against noisy samples from the original target. Their public difference is the control graph: which primitives are grouped for a user-facing edit. Their edit executors are also separately authored, so this is a diagnostic construction rather than a fair learned-method comparison.

Semantic-control program Authored SQ primitives carry human-facing group labels such as container plus handle, lamp plus neck, or drawer face plus pull.
Local-piece program Authored local SQ pieces trace the same region but do not expose one equivalent semantic group.

For each object and family, selected SQ parameters are optimized with Adam and a symmetric nearest-neighbor loss. Six random initializations are search restarts, not independent trials. The retained restart minimizes an original-only score containing the evaluation distance, a fixed primitive-count term, and an overlap proxy. The same original evaluation samples are used for selection and reporting, so the table is descriptive rather than a held-out uncertainty estimate. Only after selection is the authored executor applied, without refitting.

The optimizer is intentionally plain. Each primitive has scale, pose, shape exponents, bend, and taper parameters. A mask decides which parameters are trainable for a given primitive. Decorative parts and the edit-critical handle, neck, and pull chains are template-fixed; selected major surfaces are allowed to adjust. I am not trying to introduce a new state-of-the-art fitter here. I only need a controlled pair of reconstructions that are close enough for the evaluation question to matter.

Show the metrics and equations
\[ r(A\!\to\!B)= \sqrt{\frac{1}{|A|}\sum_{a\in A}\min_{b\in B}\|a-b\|_2^2} \] \[ d_\text{eval}(A,B)=\tfrac12\left[r(A\!\to\!B)+r(B\!\to\!A)\right] \] \[ d_\text{surface}(P)=d_\text{eval}(T,\hat{T}_P) \] \[ d_\text{edit}(P)=d_\text{eval}(E_T(T,u),E_P(P,u)) \] \[ G_\text{edit}= \left[d_\text{edit}(P_\text{local})- d_\text{edit}(P_\text{semantic})\right]- \left[d_\text{surface}(P_\text{local})- d_\text{surface}(P_\text{semantic})\right] \] \[ \rho(P)=\frac{d_\text{edit}(P)} {\max(d_\text{surface}(P),10^{-4})} \]
Static evaluation distance the average of two directional RMS nearest-neighbor distances between original target samples and the fitted program. Lower is better.
Edited evaluation distance the same distance between the edited target and the authored program executor's endpoint. Lower is better.
Fit-corrected edit gap (local − semantic) edited gap minus the corresponding static gap. Positive means the local endpoint deteriorated more.
Edit amplification edited distance divided by static distance, with a 10⁻⁴ floor in the denominator.

The sharpest failure mode is a rank inversion: the local-piece program is slightly better before the edit but worse afterward. Only the lamp is a strict inversion here. The mug is an exact static tie that splits, and the drawer begins with a static gap that grows. Keeping these three patterns separate avoids turning a small constructed probe into a broad empirical claim.

\(G_\text{edit}\) is the fit-corrected edit gap. Positive values mean the local-piece endpoint lost more under the intervention than the original static gap alone would predict. Samples are uniform in each component's native UV grid, not area-uniform, and the procedural objects are not normalized after construction. The target and program therefore share object-coordinate units, but absolute values should be interpreted only within this artifact.

3 procedural objects × 2 authored program families × 6 optimization restarts

05 Interactive evidence

Interrogate the construction.

Pick an object and switch between its original and edited states. The pale overlay is the intended destination. At 0%, inspect the actual SQ meshes used by the metric. At 100%, compare both authored executors with that destination. The numerical cards are endpoint measurements and do not vary along the illustrative interpolation between 0% and 100%.

3D view Pointer users can drag any panel to orbit. All three cameras stay synchronized; double-click or reset to recenter.

Scroll or swipe sideways to compare the three synchronized views.

The live 3D panels are unavailable. Use the endpoint measurements and the static poster; the full protocol and limitations remain readable.
Ground Truth target object
Semantic-Control Program semantic controls
Local-Piece Program local controls
Handled Mug Loading pattern

Loading experiment...

Edit: --

The experiment artifact is loading. If this message stays visible, run the local server from the repository root.

Static gap · local − semantic --
Edited gap · local − semantic --
Fit-corrected edit gap --
Semantic amplification --
Local amplification --
06 Result

Three patterns, one warning.

The most diagnostic case is a rank inversion: the local-piece program wins narrowly before the edit and loses clearly afterward. That occurs for the lamp. The mug supplies a static tie that splits; the drawer supplies a pre-existing gap that widens. Together they show why the two axes should be reported separately, without pretending all three rows carry the same evidential weight.

All distances below are the symmetric directional-RMS metric defined above, in each procedural object's own coordinate units; lower is better. “Static” scores the selected original programs. “Edited” scores the endpoints of the family-specific authored executors. The gap direction is always local minus semantic, so positive means the local endpoint is worse. The table is descriptive and contains no confidence intervals.

Across this 3-object controlled probe, the local-piece program is 0.0012 higher on the static evaluation distance on average and 0.0202 higher after the edits. One row is a rank inversion, one a tie that splits, and one a gap that widens.

Static and edited evaluation distances for the three constructed object cases.
Object / pattern Semantic static Local static Semantic edited Local edited Fit-corrected gap Amp ratio
Handled MugTie → split 0.015760.015760.017360.02863+0.011271.65x
Desk LampRank inversion 0.008540.008490.012000.04611+0.034163.86x
Drawer PullGap widens 0.012230.015800.015940.03125+0.011741.52x

Why this is stronger than a reconstruction table

A reconstruction table reports only the starting geometry. The counterfactual table adds a second axis: how a specified program-space executor lands relative to an edited target. The general proposal is simple—report both. This artifact illustrates the proposal; it does not validate a learned executor.

The result should be read as a diagnostic rather than as a leaderboard. Local decompositions are not automatically wrong, and semantic templates are not automatically right. The claim is narrower: a reconstruction metric can prefer, or at least fail to reject, a program that fails the edit it was supposed to make possible. That is the dangerous case because it can look successful in a static paper figure.

Observation 1: the surface winner can be the edit loser

The lamp is the single strict rank inversion in this artifact: its local-piece template is better by 0.00005 before the edit and worse by 0.03411 afterward. The mug is a tie, and the drawer is not an inversion.

Observation 2: editability needs a counterfactual target

Without the edited target, edit quality is mostly a visual judgment. With the edited target, the endpoint distance and any rank inversion become explicit—provided the executor itself is disclosed.

Observation 3: the protocol is small but falsifiable

Because both edit mappings are authored, the construction cannot show that semantic grouping causes the advantage. It can falsify the idea that one static surface number fully specifies future edit behavior.

07 Limits & implications

A diagnostic, not a leaderboard.

This is a constructed illustration, not an unbiased benchmark. The semantic decomposition, both program templates, and both program-space executors are supplied. The edit-critical SQ chains are fixed rather than learned. Consequently, the result does not establish that semantic grouping causes better editability; it shows that surface-similar programs can be paired with materially different edit behavior.

What I am proposing is an evaluation principle. If a primitive representation is advertised as editable, compositional, or useful for manipulation, evaluate it under counterfactual part edits. A static reconstruction metric can be necessary and still not sufficient. The extra test is simple: fit the object, edit the program, and score the edited program.

A defensible benchmark would go further. It would use a single representation-agnostic edit executor, or measure the best achievable constrained edit under equal information and optimization budget. It would separate model selection from evaluation, sample surfaces by area, normalize scale, retain all runs, and report uncertainty. It could then pair many objects with a library of attachment-preserving edits: loop widening, curve bending, symmetric spreading, articulation, part deletion, and part insertion. A method would receive only the original geometry, produce its primitive program, and then be evaluated both before and after the specified interventions. That would turn "this decomposition looks plausible" into a measurable claim about how the decomposition behaves.

Local pieces are not inherently wrong, and semantic templates are not automatically right. If the goal is surface coverage, local pieces may be ideal. If the claim is part-level manipulation, evaluation should include that manipulation—and should disclose how the user-level intention is mapped onto each representation.

The object is not only the triangles it occupies. For an editable representation, the object is also defined by what changes together.
08 Reproduce

Reproducibility Notes

The data behind the page is generated by experiments/sq_doppelganger.py. The script samples noisy points from procedural mesh targets, optimizes selected parameters in two authored SQ template families, applies the disclosed family-specific executors, and exports data/doppelganger_results.json and data/doppelganger_results.js for the static page.

python3 experiments/sq_doppelganger.py --iters 900 --seeds 6 --device auto --out data/doppelganger_results.json

The artifact uses three procedural objects, six optimization restarts per family, and 900 iterations per fit. Its original evaluation samples are separate from Adam's noisy fitting samples but are reused for restart selection and the reported static score; the edited samples are used only after selection. The page needs no application build at runtime. A small, deterministic script regenerates the classic browser bundle from the readable source modules so local files and GitHub Pages stay in sync.

Download result JSON View generator View source on GitHub
09 References

Related Work

  1. Alan H. Barr. Superquadrics and Angle-Preserving Transformations . IEEE Computer Graphics and Applications, 1981.
  2. Despoina Paschalidou, Ali Osman Ulusoy, Andreas Geiger. Superquadrics Revisited: Learning 3D Shape Parsing beyond Cuboids . CVPR 2019.
  3. Despoina Paschalidou, Luc Van Gool, Andreas Geiger. Learning Unsupervised Hierarchical Part Decomposition of 3D Objects from a Single RGB Image . CVPR 2020.
  4. Elisabetta Fedele, Boyang Sun, Leonidas Guibas, Marc Pollefeys, Francis Engelmann. SuperDec: 3D Scene Decomposition with Superquadric Primitives . ICCV 2025.
  5. Yuhan Wang, Weikai Chen, Zeyu Hu, Runze Zhang, Yingda Yin, Ruoyu Wu, Keyang Luo, Shengju Qian, Yiyan Ma, Hongyi Li, Yuan Gao, Yuhuan Zhou, Hao Luo, Wan Wang, Xiaobin Shen, Zhaowei Li, Kuixin Zhu, Chuanlang Hong, Yueyue Wang, Lijie Feng, Xin Wang, Chen Change Loy. Light-SQ: Structure-aware Shape Abstraction with Superquadrics for Generated Meshes . SIGGRAPH Asia 2025.
  6. Gabriel Tavernini, Elisabetta Fedele, Tiago Novello, Leonidas Guibas, Marc Pollefeys, Francis Engelmann. SuperFlex: Deformable Superquadrics for Point Cloud Decomposition . arXiv preprint, July 2026.
  7. R. Kenny Jones, Theresa Barton, Xianghao Xu, Kai Wang, Ellen Jiang, Paul Guerrero, Niloy J. Mitra, Daniel Ritchie. ShapeAssembly: Learning to Generate Programs for 3D Shape Structure Synthesis . SIGGRAPH Asia 2020.