MotionAnymesh: Physics-Grounded Articulation for Simulation-Ready Digital Twins¶

Conference: ECCV 2026
Paper: ECCV Official Page
Area: 3D Vision
Keywords: Articulated Object Modeling / Kinematic Segmentation / Physics-Constrained Optimization / Simulation-Ready Digital Twins / URDF

TL;DR¶

MotionAnymesh grounds VLM part grouping with SP4D kinematic priors, then estimates joints via a two-stage "contact-interface geometric initialization + physics-constrained trajectory optimization" scheme, turning a single static mesh zero-shot into a collision-free URDF digital twin with joint limits — reaching 0.86 segmentation mIoU and 87% physical executability in SAPIEN (versus 46% for the best prior method).

Background & Motivation¶

Embodied AI and robotic manipulation simulation demand large numbers of articulated assets with kinematic structure, yet the vast majority of models in large open-source 3D libraries such as Objaverse are purely static meshes — lacking both part-level physical boundaries and joint parameters. Converting them into URDF models that a physics engine can load directly has traditionally required time-consuming and costly manual modeling. Existing automatic articulation pipelines follow two main routes, each with its own hard failure. The first is 2D-to-3D mask lifting: performing 2D segmentation on rendered views and projecting back to 3D. This view-dependent mechanism fragments the geometric continuity of the 3D shape, yielding jagged, physically unclean part boundaries, and it fails outright on self-occluded internal structures. The second is to use a vision-language model (VLM) directly for open-vocabulary part decomposition: such models rely on semantic priors rather than physical constraints, so when confronted with complex or irregular mechanical components that lack explicit semantic names they exhibit severe "kinematic hallucination" — erroneously merging two distinct movable parts into one, or over-segmenting a monolithic structure.

Joint parameter estimation suffers from the same missing ingredient. Axes and origins produced by generative or regression-based approaches often look plausible in isolation, but even a marginal geometric deviation accumulates violently during long-range actuation. When these assets are imported into a strict physics engine like SAPIEN, they frequently violate non-interpenetration constraints, exhibiting catastrophic non-physical behavior: severe mesh inter-penetration, structural detachment, or kinematic freezing. This exposes the real core tension: existing visual perception pipelines optimize for "does it look right," whereas an executable digital twin requires "does it move through its whole range without penetrating." The gap is not one of accuracy but of physical grounding — there is no layer that writes motion feasibility explicitly into the objective. This paper's goal is to supply that layer, producing physics-engine-ready articulated assets from a single static mesh, zero-shot.

The angle of attack is decoupling: boundary extraction and semantic reasoning are separated. Geometric boundaries are extracted entirely in 3D-native space to preserve geometric purity, while semantic grouping is anchored by an explicit kinematic prior — SP4D multi-view motion masks synthesized from a single reference image — which demotes the VLM to a constrained spatial reasoning agent that "assembles parts following a physical manual" rather than a free-form semantic segmenter. Joint parameters then follow a two-stage scheme of type-aware geometric initialization plus physics-constrained trajectory optimization, in which inter-penetration becomes an explicit penalty term in the objective. Core idea: use SP4D motion priors to constrain the VLM's part grouping to coarse physically movable regions so kinematic hallucination disappears, then infer joint type and axes from the geometric degeneracy pattern of the contact interface and enforce, via unified surface distance minimization over the entire virtual range of motion, that the contact interface stays flush against the parent — turning a static mesh into a collision-free URDF digital twin that drops straight into a physics engine.

Method¶

Overall Architecture¶

MotionAnymesh is a zero-shot pipeline: it takes a static triangle mesh \(M\) and outputs a URDF articulated asset that a physics engine can import directly. The chain has three serial stages. Stage one is kinematic-aware part segmentation: a 3D-native segmentation model first over-segments the mesh into geometrically pure, disjoint primitives, which are then fed to a VLM together with SP4D-generated multi-view motion masks so that the VLM groups the fragments into kinematically coherent parts. Stage two is joint estimation and optimization: the VLM infers parent-child dependencies among parts and their joint types from the visual identifiers assigned during clustering, after which "type-aware kinematic initialization" derives initial axes, pivots, or sliding directions from the geometry of the contact interface, and "physics-constrained trajectory optimization" refines those parameters over the full virtual range of motion. Stage three finalizes a usable asset: forward-simulation collision detection determines each joint's range of motion, original textures are preserved (or optionally regenerated), and everything is assembled into a standard URDF.

One boundary of this paper's input setting deserves emphasis: it consumes a single static mesh — no video, no multi-state observations, no interaction trajectories. Joint types and axes are decided jointly by the VLM's semantic and mechanical common sense, the geometric degeneracy pattern of the contact patch, and physical feasibility verification, not fitted from observed motion.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Static mesh M"] --> B["SP4D-grounded part segmentation<br/>3D-native primitives + kinematic grouping"]
    B --> C["Type-aware kinematic initialization<br/>contact interface -> PCA / RANSAC"]
    C --> D["Physics-constrained trajectory optimization<br/>unified surface distance minimization"]
    D --> E["Simulation-ready limits and asset finalization<br/>forward-sim limits + texture -> URDF"]
    E --> F["Digital twin importable by a physics engine"]

Key Designs¶

1. SP4D-grounded part segmentation: locking the VLM's spatial reasoning inside a physical motion prior

This step must solve two things at once: boundaries have to come from the 3D geometry itself, and semantic grouping has to be anchored by physical constraints. For the first, a 3D-native segmentation foundation model (P3-SAM) cuts low-level geometric boundaries directly on the mesh based on spatial concavity and structural connectivity, producing geometrically pure but semantically fragmented primitives \(\mathcal{P} = \{p_1, \dots, p_m\}\) — a single drawer, for instance, is shattered into a handle, a front panel, and sliding rails. Their physical boundaries are perfect, but they carry no high-level kinematic semantics. The second part is the hard one: letting the VLM group primitives from rendered images alone is precisely where hallucination comes from.

The authors' answer is to give the VLM two complementary visual inputs. One is the over-segmented mesh rendered from multiple viewpoints, with a unique visual ID (its own color plus a numerical tag) assigned to each primitive; this set supplies fine-grained geometric IDs. The other is obtained by feeding a single rendered reference image of the object into SP4D, which infers and synthesizes consistent multi-view kinematic segmentation masks; this set supplies coarse, cross-view-consistent functional movable regions. Given both, the VLM is asked to perform visual correspondence: to group fine-grained primitive IDs under SP4D's motion regions. Its role is deliberately restricted — it is a constrained spatial reasoning agent that only groups, and never regresses any joint parameter. The resulting parts \(K_i = \bigcup_{j \in I_i} p_j\) (with \(I_i\) the index set of primitives belonging to the \(i\)-th kinematic part) inherit two properties at once: geometric purity of boundaries from 3D-native segmentation, and correct kinematic hierarchy from SP4D's priors. This explains the asymmetry in the ablation — removing SP4D costs only 0.18 mIoU but an equally large amount of count accuracy, showing that pure semantic reasoning mainly gets the topology wrong (one cut too many or one part too few), not the boundary positions.

2. Type-aware kinematic initialization: reading joint type and axis off the geometric degeneracy of the contact patch

Segmentation yields kinematic parts, but they still lack structural connectivity and motion semantics: the VLM infers parent-child dependencies from the visual identifiers assigned during clustering, builds an articulation tree, and broadly classifies each movable part's joint as Revolute (further split into Spin and Hinge) or Prismatic. With that tree in hand, the remaining problem is computing the axes accurately from geometry. The motivation the authors stress repeatedly is that initialization error is amplified during long-range actuation, so one cannot "guess a plausible-looking axis"; instead one exploits a physical fact — the mechanical constraint of a joint is anchored at the spatial intersection between the movable part \(K_i\) and its parent \(K_{P(i)}\) — so the shape of the contact region itself encodes the joint type.

The contact interface is extracted first: \(S_{contact} = \{ x \in \partial K_i \mid \mathrm{dist}(x, K_{P(i)}) \le \tau \}\), i.e. the surface vertices of the movable part close enough to the parent body, with the threshold \(\tau\) set to 0.01 m. From there, each joint type follows a different geometric strategy. For Spin joints (wheels, knobs) the visible mechanical connection is typically an axially symmetric interface, and its contact point cloud forms a disc or shallow annular band: applying principal component analysis to \(S_{contact}\), since these intersection points spread mainly along the radial cross-section rather than stacking along the axis, the eigenvector of the smallest eigenvalue \(n\) robustly captures the orthogonal normal of that distribution and is taken directly as the initial rotational axis \(v_{init} = n\). To localize the pivot accurately under surface noise, the authors build a local 2D coordinate frame perpendicular to \(n\), project each contact point into it, and use RANSAC to iteratively fit a 2D circle — which simultaneously handles outliers and partial observation (a half-circle of contact points is enough) — and map the fitted center back into 3D as the pivot \(q_{init}\). For Hinge joints (door hinges, laptop screens) the contact region is characteristically distributed along the axis of rotation with a dominant longitudinal span (true whether the connection is a continuous strip or several discrete anchors), so the largest-eigenvalue principal direction \(v_1\) becomes the rotational axis, representing the global hinge line; and since such contact distributions are approximately symmetric along the axis, the point cloud centroid \(\bar{x}\) is taken directly as the pivot.

Prismatic joints are different: the sliding axis is dictated by the part's global geometry rather than the local contact patch. Global PCA over the entire point cloud of \(K_i\) first yields three bounding-box candidate axes \(V_{cands} = \{v_1, v_2, v_3\}\), and a "normalized dual-penalty trajectory verification" picks the true sliding direction among them. The physical intuition is plain: a correct sliding axis must let the part slide without penetrating the parent body, and without detaching from its mechanical rails. So the part is virtually translated along each candidate by a set of discrete steps \(d \in D\) (covering both directions), and each candidate is scored as

\[\mathcal{C}(\mathbf{v}) = \mathcal{L}_{collide}(\mathbf{v}) + \omega \, \mathcal{L}_{derail}(\mathbf{v})\]

where \(\mathcal{L}_{collide}\) is the normalized fraction of moved-part points that inter-penetrate the static parent (a penetration event being defined by a strict distance threshold \(\epsilon_c = 0.005\) m), and \(\mathcal{L}_{derail}\) is the average absolute divergence of the original stationary contact points from the newly translated surface, which prevents the part from sliding off its rails. The two terms have different units — a dimensionless probability versus an absolute spatial deviation — so a weight \(\omega = 20\) equalizes their scales; the candidate with the minimum cost becomes the final sliding direction. Pivots are mathematically undefined and unnecessary for prismatic joints.

3. Physics-constrained trajectory optimization: keeping the contact interface flush against the parent over the whole range instead of penetrating it

Initialization produces a macro-level plausible mechanical layout, but PCA-derived axes are often slightly tilted relative to the true rails, and that micro-misalignment turns into friction or penetration during long-range motion. The authors refine the parameters with a continuous non-linear optimization whose constraint is shared by all joint types — unified surface distance minimization. The physical picture is that during articulation the contact interface should play the role of a perfect bearing or sliding rail, gliding flush against the parent surface without detaching and without intersecting. Let \(T(x; v, q, \phi)\) denote the 3D rigid transformation applied to a contact point \(x\) during motion (for revolute joints \(\phi = \theta\) is the rotation angle about \(v\) anchored at \(q\); for prismatic joints \(\phi = d\) is the translation distance along \(v\), reducing the transform to \(T(x; v, d) = x + d \cdot v\)). Over a set of discrete virtual states \(\Phi\) (angular steps \(\Theta\) or spatial steps \(D\)), the trajectory deviation is minimized:

\[\mathcal{L}_{opt}(\mathbf{v}, \mathbf{q}) = \sum_{\phi \in \Phi} \sum_{x \in S_{contact}} \left\| D_{SDF}\big(T(x; \mathbf{v}, \mathbf{q}, \phi),\, M_{static}\big) \right\|_2^2\]

where \(D_{SDF}(\cdot, \cdot)\) computes the signed distance field relative to the static environment. The elegance of this formulation is that the penalty is symmetric: penetrating the parent yields a large distance, and drifting off it yields a large distance too, so only the "flush but not penetrating" manifold minimizes the loss and micro-misalignment in any direction is pushed back. This is precisely where it differs from prior practice of fitting a single static pose — the constraint is imposed over the entire motion, not over one configuration. ⚠️ The Method section states the objective is solved with Levenberg-Marquardt while the implementation details state SciPy's Nelder-Mead; the two disagree, so refer to the original paper.

4. Simulation-ready joint limits and asset finalization: giving the URDF its range boundaries and its appearance

Even with correct geometry and parameters the asset is not yet simulation-ready — an unconstrained joint shows up in a simulator as a door rotating into a wall or a drawer flying out of a cabinet. The authors deduce kinematic limits automatically with a forward-simulation collision detection mechanism. For revolute joints, starting from rest at 0°, the movable part is rotated incrementally in both directions up to ±180°, and the exact angles at which a geometric collision with the static base occurs (judged by mesh intersection) define the limits \([\theta_{min}, \theta_{max}]\). For prismatic joints the two directions use two different criteria: the inward pushing direction is typically bounded by collision (a drawer hitting the cabinet's backplate), while the outward pulling direction uses a new "contact-loss" criterion — the part is incrementally translated along its optimized axis \(v^*\) while the mutual contact area with the parent is continuously monitored, and the point where that area drops to zero defines the maximum extension \(d_{max}\), physically corresponding to the moment a sliding component detaches from its rails. This criterion avoids reconstructing the actual rail assembly geometry and is a cheap yet physically defensible substitute.

On the appearance side, the pipeline inherently preserves the input mesh's original UV mapping and textures, so textured assets keep their look after decomposition; but genuine 3D segmentation inevitably exposes texture-less internal cross-sections, so the authors add an optional generative re-texturing module that uses a 3D generative model such as Hunyuan3D to independently generate new textures for each isolated part from user text prompts (which also supports customized visual editing). Finally the textured parts, together with the optimized kinematic parameters, are automatically assembled into a standard URDF.

A Worked Example¶

Walking a cabinet-type asset from the paper's qualitative figures through the chain (the counts are illustrative; what matters is how state progressively narrows): the input is a static cabinet mesh, and P3-SAM cuts it by concavity into twenty-odd geometric primitives — handle, drawer front, sliding rails, door panel, and cabinet side walls each standing alone. In parallel the cabinet's single rendered image goes into SP4D, which returns motion masks across viewpoints marking coarse regions such as "this front panel moves outward as one piece" and "the door panel rotates about one side." What the VLM receives is a set of multi-view primitive images with unique colors and numerical tags plus a set of SP4D motion masks; what it outputs is only a grouping — handle + front panel + rails become one kinematic part, the door panel another, the cabinet body the root. The VLM then labels the front panel Prismatic and the door panel Revolute-Hinge on the articulation tree. At initialization, the contact interface pulls out the vertices of "front panel + rails" and of the door panel that lie near the cabinet body: the door panel's contact cloud is elongated along the rotation axis, so the largest PCA eigenvector becomes the hinge axis and the centroid becomes the pivot; the front panel's branch instead runs dual-penalty verification over three bounding-box candidates, where the cabinet-depth direction wins for causing no inter-penetration and minimal contact-point divergence. Trajectory optimization then fine-tunes that axis to minimize SDF distance over the whole sweep. Finally forward collision detection yields a door-panel rotation limit of roughly ±90° and truncates the front panel's outward \(d_{max}\) where the contact area reaches zero; parameters and textured meshes are written out as URDF, and the asset can be actuated through its full valid range in SAPIEN without manual correction.

Loss & Training¶

This is a zero-shot, training-free pipeline: no module is trained on the paper's data; all capability comes from off-the-shelf models plus geometric and physical optimization. The three off-the-shelf components are P3-SAM (3D-native geometric primitive extraction), SP4D (multi-view kinematic mask synthesis from a single reference image), and GPT-4o (serving as the VLM for primitive grouping and articulation tree inference), with Hunyuan3D for the optional generative re-texturing. The only optimization objective is the unified surface distance minimization loss \(\mathcal{L}_{opt}\) above; the SDF is computed with Trimesh, and the non-linear solver is SciPy (the Method section says Levenberg-Marquardt while the implementation details say Nelder-Mead — ⚠️ refer to the original paper). All thresholds are empirically set constants: contact proximity threshold \(\tau = 0.01\) m, RANSAC inlier distance threshold \(\delta = 0.005\) m, penetration threshold \(\epsilon_c = 0.005\) m, and dual-penalty balance weight \(\omega = 20\). All experiments run on three NVIDIA RTX 4090 GPUs.

Key Experimental Results¶

Main Results¶

Data comes from three sources: PartNet-Mobility (providing standard ground-truth URDF for exact metric computation), Objaverse (open-vocabulary static meshes without predefined templates), and generative assets from recent text/image-to-3D models (to stress-test robustness). The latter two unstructured domains have no existing ground truth, so the authors manually authored their ground-truth URDFs including part masks and joint parameters. Metrics fall in three groups: segmentation uses mIoU and Count Acc (the fraction of instances where the inferred number of active kinematic links exactly matches ground truth); joint parameters use Type Err (a binary indicator of joint-type misclassification), Axis Err (angular deviation between predicted and ground-truth axes, normalized to \([0,\pi]\)), and Pivot Err (L2 distance between predicted and actual pivot locations); physical executability loads the generated URDF into SAPIEN and measures the success rate of assets that can be fully actuated along their valid ranges without severe inter-penetration, structural detachment, or kinematic freezing.

Method	mIoU ↑	Count Acc ↑	Type Err ↓	Axis Err ↓	Pivot Err ↓	Executability ↑
PARIS	0.17	0.23	0.67	1.56	1.14	11%
URDFormer	0.21	0.33	0.72	1.31	1.53	21%
SINGAPO	0.52	0.66	0.24	0.73	0.57	43%
Articulate-Anything	0.47	0.61	0.21	0.86	0.64	46%
Articulate-AnyMesh	0.59	0.74	0.35	0.64	0.44	35%
MotionAnymesh (Ours)	0.86	0.92	0.08	0.12	0.10	87%

Ablation Study¶

The paper ablates its two core modules separately. On the segmentation side, removing the SP4D multi-view motion masks forces the VLM to aggregate primitives from visual semantics alone; on the joint side, skipping the non-linear trajectory refinement outputs the initialized parameters directly.

Config	mIoU ↑	Count Acc ↑	Note
Pure VLM semantics (w/o SP4D)	0.68	0.81	With no kinematic prior, the VLM wrongly merges visually similar but distinct parts, or over-segments monolithic structures lacking explicit semantic labels
SP4D-guided clustering (Ours)	0.86	0.92	Strictly bounds the VLM's reasoning within physically movable regions

Joint estimation method	Axis Err ↓	Pivot Err ↓	Executability ↑
Kinematic initialization (w/o Opt.)	0.23	0.27	65%
Physics-constrained optimization (Ours)	0.12	0.10	87%

Key Findings¶

The SP4D prior mainly buys topological correctness, not just boundary precision. Without it mIoU drops from 0.86 to 0.68 and Count Acc from 0.92 to 0.81 — both collapse in the same direction, showing that pure semantic reasoning fails on "how many pieces should there be" rather than on where the boundary lies. That maps exactly onto the two canonical forms of VLM hallucination (wrong merge and over-segmentation).
The improvement in static geometric metrics is grossly disproportionate to the improvement in dynamic executability. Trajectory optimization drives Axis Err from 0.23 to 0.12 and Pivot Err from 0.27 to 0.10 — a seemingly routine gain — yet executability jumps from 65% to 87%. In other words, initialization already "looked right," and more than a third of assets still penetrated or froze during long-range actuation. This contrast is itself the paper's strongest argument that static metrics cannot predict simulation readiness.
Segmentation quality and simulation readiness are not monotonically related. Articulate-AnyMesh's segmentation metrics (mIoU 0.59, Count Acc 0.74) are clearly better than Articulate-Anything's (0.47 / 0.61), yet its executability is lower (35% vs 46%) — it estimates joints via 2D-to-3D VLM projection heuristics whose 3D spatial hallucination produces large axis deviations. Conversely, this paper's Axis Err of 0.12 and Pivot Err of 0.10 are the direct cause of its 87% executability.
Retrieval- and CAD-library-based methods fail catastrophically on novel geometry. URDFormer and PARIS sit at the bottom across every metric (11%–21% executability); the qualitative comparison in Fig. 3 shows such paradigms working on in-domain objects (e.g. a storage cabinet) but producing severe boundary mismatches or entirely irrelevant structures on novel geometries like a robot arm.
The operating envelope is explicit: the method is strongest on assets whose parts are geometrically separable and whose contact regions are well defined (both diverse handcrafted assets and AI-generated meshes are handled); for severely fused scans, meshes with missing surfaces, or objects with highly ambiguous contact regions, the authors state plainly that cleaner geometry or limited manual correction is still required.

Highlights & Insights¶

Demoting the VLM from "segmenter" to "constrained assembler" is the cleverest move in this paper. Rather than trying to fix VLM hallucination, it changes the VLM's task: group primitives only across the coarse physically movable regions SP4D provides, and forbid it from regressing any joint parameter. The room for hallucination shrinks from unbounded to a discrete grouping problem, and the 0.81 → 0.92 Count Acc gain in the ablation is the direct payoff of that constraint.
"The shape of the contact patch encodes the joint type" is a reusable geometric prior. A spin joint's contact cloud is a disc or annular band (PCA smallest eigenvector = axis), a hinge's is elongated (largest eigenvector = axis), and a prismatic joint ignores the local patch entirely in favor of the global bounding box. Replacing "guess the axis" with "read the degeneracy direction" needs neither training nor data, and is naturally robust to surface noise — which is also why a RANSAC 2D circle fit is used rather than the raw centroid.
Dual-penalty trajectory verification is a zero-shot criterion transferable to any "choose an axis" setting. Virtually translate along each candidate and score it with two penalties — no inter-penetration and no derailment — then use \(\omega\) to bring a dimensionless probability and an absolute distance onto the same scale. The broader idea of "score candidates by how physical simulation fails" transfers directly to grasp point selection, assembly path search, and even robot base placement: anywhere a feasible solution must be picked from a finite candidate set.
Writing the physical constraint as symmetric surface distance minimization is more elegant than an explicit collision penalty. Because the SDF distance grows both when the part penetrates and when it drifts away, a single loss rules out penetration and detachment simultaneously — no extra separation term, and no need for separate losses for rotation and translation. Revolute and prismatic joints share the same \(\mathcal{L}_{opt}\), only the meaning of \(\phi\) differs.
One practically useful engineering observation: "contact area reaching zero" works as a proxy for rail detachment, truncating a prismatic joint's outward travel. It sidesteps the hard problem of exactly reconstructing the rail assembly geometry and is a cheap trick worth remembering.

Limitations & Future Work¶

The paper does not estimate mass or inertia. The output URDF contains geometry, joint types, axes/pivots, limits, and textures, but rigid-body dynamics in a physics engine also need a mass and inertia tensor per link. For contact-rich tasks like manipulation policy learning, "it moves without penetrating" and "its dynamics are faithful" are two different things, and this paper's notion of simulation-ready only guarantees the former. This is the most visible gap relative to a full sim-to-real requirement, and it explains why the real-robot deployment experiment emphasizes parameter accuracy rather than dynamic fidelity.
Zero-shot means many thresholds are hand-set constants. The contact proximity threshold \(\tau = 0.01\) m, the RANSAC inlier threshold \(\delta\), the penetration threshold \(\epsilon_c = 0.005\) m, and the balance weight \(\omega = 20\) are all described as empirically set. No sensitivity analysis is given, yet \(\tau\) directly determines the size of the contact point cloud and \(\omega\) directly determines whether collision or derailment dominates. In an open world with objects spanning orders of magnitude in scale (a millimeter-scale knob versus a meter-scale cabinet), fixed metric thresholds are a liability.
Failure modes the authors acknowledge: severely fused scans, missing surfaces, and objects with highly ambiguous contact regions still need cleaner geometry or limited manual correction. This is inherent to a mesh-first pipeline — every geometric prior in the chain rests on the premise that functional parts are geometrically separable. Once that premise fails (soft bodies, fabric, parts left incomplete by occlusion during scanning), both the clustering and the joint estimation lose their footing.
The evaluation ground truth is partly hand-authored. Ground-truth URDFs for the Objaverse and generative-asset domains were manually written by the authors (including part masks and joint parameters), with no third-party cross-validation of annotation quality or consistency; metrics from those domains — especially the absolute values of Axis and Pivot Err — should be read with caution.
Directions for improvement: fold in mass and inertia estimation (material inference plus volume integration) to upgrade the URDF from kinematically correct to dynamically usable; replace fixed metric thresholds with relative-scale ones; and, as the authors themselves suggest, integrate stronger 3D-native perception and geometric repair models to handle fused and incomplete inputs.

vs visual reconstruction methods (Ditto, PARIS, ArticulatedGS, GaussianArt, etc.): they capture kinematics quite precisely from observations, but require dense spatio-temporal observations — multi-view or multi-state inputs — which caps scalability to the small set of objects with interaction data. This paper consumes a single static mesh, paying for it by compensating for the missing motion information with priors (SP4D masks plus contact geometry).
vs Articulate-Anything: it likewise uses a VLM for open-vocabulary articulation modeling, but derives joints from 2D-to-3D VLM projection heuristics, so 3D spatial hallucination shows up directly as large axis deviation (Axis Err 0.86 versus 0.12 here). This paper adds an entire layer of geometric initialization and physical optimization on top, lifting executability from 46% to 87%.
vs Articulate-AnyMesh: the most direct point of comparison. It is also zero-shot and also handles arbitrary meshes, and its segmentation is even better than Articulate-Anything's (mIoU 0.59), but its joints rely entirely on open-vocabulary VLM reasoning, causing severe over-segmentation on irregular internal mechanisms and yielding only 35% executability — precisely demonstrating that "segments well" does not imply "simulates well." The difference here can be summarized as narrowing the VLM's reasoning space with SP4D motion priors (fixing topology) and then adding physics-constrained optimization (fixing parameters).
vs retrieval/procedural methods (URDFormer, SINGAPO): they depend on predefined mesh libraries or templates, hold only on in-domain objects, and sit at the bottom of every metric (URDFormer 21% and PARIS 11% executability). This paper's open-world capability comes from not retrieving at all — only geometry plus physics.
vs generative-prior methods (DreamArt, FreeArt3D, SPARK, etc.): they lean on diffusion or motion-video synthesis priors and are prone to geometric inter-penetration and motion distortion under strict 3D topological constraints, unable to provide the high-precision physical guidance that deeply nested internal structures require. This paper inverts the relationship and writes the physical constraint directly into the objective.
Transferable insight: the overall paradigm here — "let a generative model supply a coarse physical/semantic prior, use it to constrain a restricted reasoner, then hand final feasibility to explicit physical optimization" — transfers to any task where perceptual output must be physically executable (graspability prediction, assembly sequence generation, deformable object manipulation). The core move is turning feasibility from an evaluation metric into an optimization term.

Rating¶

Novelty: ⭐⭐⭐⭐ Using SP4D motion priors as physical grounding for a VLM, and the type-aware initialization that reads joint type off contact-patch shape, are both concrete and non-trivial designs; but the whole is still a new combination of known modules (P3-SAM / SP4D / GPT-4o), with more ambition at the paradigm level than a single technical breakthrough.
Experimental Thoroughness: ⭐⭐⭐⭐ Three data sources cover standard ground truth, open-vocabulary assets, and generative assets; metrics span segmentation, joints, and SAPIEN physical execution, with two independent ablations and two downstream applications (including real-robot deployment). Points off for the absence of sensitivity analysis on the core thresholds and for hand-authored ground truth in two of the three domains.
Writing Quality: ⭐⭐⭐ The motivation and the geometric rationale are clearly laid out and the method chain is complete; however, equations (2)(3)(4)(6)(7) are garbled in the original and the solver is described contradictorily (Levenberg-Marquardt versus Nelder-Mead), leaving uncertainty for reproduction.
Value: ⭐⭐⭐⭐ It pushes the "static mesh → simulation-ready articulated asset" path to 87% physical executability, with direct value for asset generation in embodied AI and robotics simulation; adding mass and inertia estimation would raise that value further.