💻 computer science

Functionalization via Structure Completion and Motion Rectification

This paper introduces "object functionalization," a novel task that transforms non-functional 3D models into physically operable ones by using a neural Graph Functionalizer to complete structural graphs and rectify motion errors, validated on a new furniture dataset and benchmarked against state-of-the-art methods.

Original authors: Mingrui Zhao, Sai Raj Kishore Perla, Kai Wang, Sauradip Nag, Duc Anh Nguyen, Jiayi Peng, Ruiqi Wang, Angel X. Chang, Manolis Savva, Ali Mahdavi-Amiri, Hao Zhang

Published 2026-05-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mingrui Zhao, Sai Raj Kishore Perla, Kai Wang, Sauradip Nag, Duc Anh Nguyen, Jiayi Peng, Ruiqi Wang, Angel X. Chang, Manolis Savva, Ali Mahdavi-Amiri, Hao Zhang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a digital 3D model of a kitchen cabinet. It looks perfect on the screen, but if you tried to open the door or pull out a drawer, nothing would happen. The door is floating in mid-air with no hinges, the drawer is stuck because it has no rails, and sometimes the door is even stuck inside the cabinet frame because the designer forgot to leave room for it to swing open.

Most 3D models we find online are like this: they look good, but they don't actually work.

This paper introduces a new system called GraFu (Graph Functionalizer) that acts like a digital "fix-it" mechanic. Its job is to take these broken, non-functional 3D models and turn them into objects that actually move and function the way they are supposed to.

Here is how the process works, broken down into simple steps:

1. The "Blueprint" Phase (The Graph)

First, the computer looks at the 3D model and turns it into a diagram (or a "graph").

Nodes: Every piece of the furniture (the door, the side panel, the drawer) becomes a dot on the diagram.
Edges: The lines connecting the dots represent how those pieces should relate. For example, a line labeled "hinge" means the door should be attached to the frame.

In a broken model, this diagram is incomplete. It might be missing the "hinge" line entirely, or it might have a "drawer" dot that isn't connected to anything. GraFu's job is to look at this broken diagram and fill in the missing pieces. It predicts: "Ah, this door needs a hinge here," or "This drawer needs a rail there," or "This cabinet is missing a top shelf."

2. The "Construction" Phase (Geometric Realization)

Once GraFu has fixed the diagram, it moves to the second stage: building the actual parts.

Adding Hardware: It doesn't just say "hinge exists"; it actually inserts a 3D model of a hinge into the scene. It snaps the hinge onto the door and the frame perfectly.
Adding Missing Parts: If the model was missing a handle or a top panel, GraFu generates those shapes and places them where they belong.
The Magic Fix (Motion Rectification): This is the cleverest part. Sometimes, the original 3D model has a door that is positioned in a way that would crash into the wall if it opened. Because GraFu installs a real physical hinge with a specific axis of rotation, the computer can now calculate exactly how the door moves. This often automatically fixes the crash. The door swings open smoothly because the hinge forces it to move in the correct path, correcting the errors made by the original human designer.

3. The "Human-in-the-Loop" Tool

The researchers built a special tool (an add-on for the popular 3D software Blender) that lets a human look at the work. If the computer adds a handle in the wrong spot, the human can drag it to the right place. It's like having a robot assistant that does 90% of the heavy lifting, but leaves the final 10% for you to tweak.

What Did They Test?

To prove this works, they created a dataset called FurFun-233, which contains 233 pairs of furniture models: one "broken" version and one "fixed" version. They trained their AI on these pairs.

When they tested it against other top methods:

Accuracy: It predicted how parts should move just as well as the best existing tools.
Safety: It was much better at ensuring parts didn't crash into each other (collisions) or fall apart (connectivity).
Robustness: Even if they "corrupted" the input (hiding the labels of what the parts were), the system could still figure out how to fix the furniture.

In Summary

Think of this technology as a digital architect and carpenter rolled into one. If you give it a 3D model of a cabinet that looks nice but falls apart when you try to use it, this system will:

Figure out what is missing (hinges, rails, handles).
Build those missing parts and attach them correctly.
Fix any movement errors so the door opens and the drawer slides without crashing.

The goal isn't just to make 3D models look pretty; it's to make them physically usable, which is crucial for things like robotics, video games, and virtual reality where objects need to behave like real life.

Technical Summary: Functionalization via Structure Completion and Motion Rectification

Problem Definition

Existing 3D assets, particularly furniture, are often visually plausible but functionally deficient. They frequently lack necessary structural components (e.g., hinges, rails, handles, shelves) and contain geometric errors such as self-collisions or misaligned parts that prevent intended articulation. Furthermore, human-annotated motion data (e.g., in PartNet-Mobility) often contains errors in motion axes or ranges, leading to physically implausible behavior.

The paper introduces Object Functionalization, a novel task aimed at transforming non-functional 3D models into physically operable ones. The authors focus specifically on structural functional deficiencies, which manifest as missing nodes (parts) or incorrect edges (relations) in the object's assembly graph. The goal is to complete the structure and rectify motion to ensure collision-free, physically grounded articulation.

Methodology

The proposed solution is a two-stage pipeline: Graph Completion followed by Geometric Realization.

1. Functional Graph Representation

The input 3D model is parsed into a functional graph $G=(V, E)$ :

Nodes ( $V$ ): Represent mesh parts with attributes including 3D bounding boxes, geometric representations (point clouds), and semantic labels (e.g., door, drawer, shelf, handle).
Edges ( $E$ ): Encode relations such as contact (static), hinge (revolute), rail (prismatic), and attached (e.g., handle to door).
Motion Attributes: Movable nodes are annotated with motion axes (rotation axis for hinges, translation direction for rails).

2. Neural Graph Functionalizer (GraFu)

GraFu is a graph-to-graph translation network designed to predict missing structural nodes, correct edges, and estimate motion attributes.

Architecture:
- Node Encoder: Encodes part category (one-hot), geometry (PointNet++ variant), and bounding box centroid into a unified latent embedding.
- Graph Encoder: A Graph Transformer operating on a fully-connected topology. It models inter-node relationships using edge features that encode connectivity types and geometric descriptors (distance, orientation, gaps).
- Graph Decoder: A DETR-style decoder using "node slots." It includes anchor slots (corresponding to input nodes) and free query slots (to predict missing nodes). It outputs node validity, category, bounding box, and edge types (hinge, rail, attached, contact, null).
Training: The model is trained on the FurFun-233 dataset, a collection of 233 paired non-functional and functionalized furniture models. Non-functional inputs are synthesized by corrupting ground-truth functional graphs via edge collapse, node removal, and label masking.

3. Geometric Realization

The completed graph drives a geometry realization stage to instantiate physical components and rectify motion:

Hinge Insertion: For predicted hinge edges, the system selects from a gallery of hinge templates (C-hinge, F-hinge, P-hinge) based on surface arrangement. A geometric solver snaps the hinge to the static and dynamic parts, ensuring bilateral surface contact and aligning the rotation axis with the predicted motion. This process naturally rectifies erroneous motion axes.
Rail Insertion: For rail edges, templates are scaled and snapped to the drawer body and cabinet frame. A supporting block bridges gaps if mechanical compatibility is lacking.
Static Completion: New nodes (e.g., top panels, shelves, handles) are instantiated using template meshes or procedural generation (e.g., extruding a top panel based on floor coverage).
Interactive Review: The pipeline is wrapped in a Blender add-on, allowing users to inspect, tune, and accept/reject predicted connectors and new parts.

Key Contributions

Functional Graph Representation: A unified graph schema encompassing part/connector labeling and motion attributes to represent both dynamic and static deficiencies.
GraFu (Neural Graph Functionalizer): A deep learning model for structure completion that predicts missing parts, edges, and motion attributes.
Two-Stage Pipeline: A method that decouples topological completion from geometric realization, using mechanical grounding to rectify motion errors (e.g., fixing collisions caused by incorrect human annotations).
FurFun-233 Dataset: A high-quality dataset of 233 furniture models with paired non-functional and functionalized counterparts, including ground-truth functional graphs and mechanical components.

Experimental Results

The method was evaluated on the PartNet-Mobility (PN-M) Storage Furniture subset and the HSSD dataset.

Motion Prediction: On PN-M, GraFu achieves motion prediction accuracy comparable to state-of-the-art baselines (Particulate, SINGAPO) despite being zero-shot (trained without PN-M data). On HSSD, it outperforms baselines across all metrics.
Physical Plausibility: The geometric realization stage significantly improves physical plausibility. While baselines often suffer from high collision rates or detached parts, the insertion of physical hinges and rails reduces collisions and ensures connectivity.
Robustness: Ablation studies show GraFu remains robust even when input node labels are corrupted up to 100%, maintaining competitive motion prediction and near-perfect connectivity.
Structural Completeness: The method successfully predicts missing top panels in 100% of tested PN-M cases where they were absent.

Significance and Limitations

Significance:
The paper claims to be the first systematic attempt to correct major functional deficiencies in both dynamic and static settings for existing 3D assets. By moving beyond appearance-driven modeling to functional correctness, the work enables the use of 3D assets in robotics, simulation, and fabrication where physical operability is critical. The ability to rectify erroneous human annotations through mechanical grounding is highlighted as a compelling side effect.

Limitations:

Input Dependency: The method requires pre-segmented 3D models; it cannot functionalize unsegmented meshes or add partial structures (e.g., missing drawer panels).
Geometric Constraints: It struggles with highly irregular shapes that violate bounding-box assumptions and cannot handle mesh-level defects (e.g., shell-only models).
Scope: The current implementation is limited to specific motion types (revolute and prismatic) and object categories (furniture), dictated by the training data. It does not yet support chained motions or complex mechanisms like pistons.