SINGAPO: Single Image Controlled Generation of Articulated Parts in Objects

## Abstract

Abstract We address the challenge of creating 3D assets for household articulated objects from a single image.
Prior work on articulated object creation either requires multi-view multi-state input, or only allows coarse control over the generation process.
These limitations hinder the scalability and practicality for articulated object modeling.
In this work, we propose a method to generate articulated objects from a single image.
Observing the object in resting state from an arbitrary view, our method generates an articulated object that is visually consistent with the input image.
To capture the ambiguity in part shape and motion posed by a single view of the object, we design a diffusion model that learns the plausible variations of objects in terms of geometry and kinematics.
To tackle the complexity of generating structured data with attributes in multiple domains, we design a pipeline that produces articulated objects from high-level structure to geometric details in a coarse-to-fine manner, where we use a part connectivity graph and part abstraction as proxies.
Our experiments show that our method outperforms the state-of-the-art in articulated object creation by a large margin in terms of the generated object realism, resemblance to the input image, and reconstruction quality.

## 1 Introduction

Articulated objects are prevalent in our daily environments.
Creating 3D assets that represent articulated objects is becoming increasingly important for building realistic and interactive virtual environments, which is essential for various indoor applications in robotics and embodied AI (Shen et al., ; Li et al., ; Puig et al., ; Li et al., ; Kim et al., ).
The creation of articulated assets typically requires manual labor from experts, which is time-consuming and expensive.
Thus, it is desirable to automate this process to scalably enrich virtual environments.

A line of recent works reconstructs articulated objects from images or videos that capture the object from multi-views or multiple articulated states (Jiang et al., ; Liu et al., ; Heppert et al., ; Song et al., ; Weng et al., ; Mandi et al., ).
These works require careful alignment across views or across states, or recording the object in motion, which is not always feasible in practice.
The challenges in acquisition of input data limit the scalability of these methods to real-world applications.
Another line of work aims to generate articulated objects either unconditionally or guided by high-level constraints (Lei et al., ; Liu et al., ).
One of the primary challenges in content creation is providing users with the flexibility to specify the objects precisely.
However, although object images are widely available and serve as intuitive guidance, their usage to guide generating articulated objects is under-explored.
In this work, we propose a method for generating articulated household objects from a single image to bridge this gap.

Creating articulated assets from an image is challenging when:
1) the object is observed in the closed state where occlusions introduce ambiguity in the part shape and articulation;
2) the part structures are complex and diverse within and between object categories such as cabinets, desks, and refrigerators;
3) the parts are small and thin, making them hard to perceive from a single image.
In this paper, we aim to tackle the task in the challenging setting where the input is an RGB image of an object in the resting state observed from a random view, and the output is the 3D asset of the articulated object.
Our output consists of:
1) a graph specifying the part connectivity and kinematic hierarchy;
2) articulation parameters specifying the type, axis, and range of the joints connecting the parts; and
3) geometry of each articulated part to the level of actionable part (e.g., handles, knobs).

To address these challenges, we propose to create 3D assets of articulated household objects from a single image using a generative model paradigm.
We believe this strategy offers two key advantages.
First, when an input image can be interpreted in various ways, a generative model produces multiple plausible solutions while ensuring consistency with the visual input, effectively capturing any ambiguity in the image as shown in Figure 1.
Second, learning the distribution of articulated objects, a generative model bridges the gap between 2D and 3D by leveraging prior knowledge from the learned data distribution.
This enables the model to more effectively handle input images of objects from arbitrary viewpoints to assemble a coherent 3D object, in contrast to regression-based methods from prior work that treat each part region independently (Chen et al., ).

Addressing this problem necessitates a multi-level understanding of the object image, including recognizing all the articulated parts, inferring how these parts are connected, accurately recovering their 3D arrangement, imagining how each part articulates, and reconstructing the geometry of each part.
To tackle this complexity, we propose a pipeline that decomposes the task into three progressive steps, synthesizing the articulated assets from coarse to fine details (see Figure 1 left).
These steps include:
1) leveraging large vision-language models to infer the part connectivity graph from the image;
2) generating attributes to describe the articulated parts at the abstract level, guided by the graph and the image; and
3) collecting meshes from a part shape library to assemble the final object based on the outputs from previous steps.
This modular design makes our method more efficient and enables easier user interventions to edit and refine the results.
Additionally, this breakdown ensures that core understanding occurs at the appropriate level of abstraction in the second step.
Specifically, we propose a transformer-based diffusion model that learns the spatial layout of the parts through image cross-attention, captures the interplay between part motion and shape via self-attention, and structures the parts using a graph with masked attention.

In summary, our main contributions are as follows:
1) to the best of our knowledge, we are the first to explore the task of generating articulated objects from a single image;
2) we design a pipeline to create articulated objects from coarse to fine details in a modular way, which is more interpretable and editable for users;
3) we propose a diffusion-based model to generate objects that are kinematically plausible and visually consistent with the input image, while allowing for variations to account for any ambiguity in the image;
4) we demonstrate our better reconstruction quality and generalization compared to the prior methods through systematic evaluations on multiple datasets.

Figure: Figure 1: Our work proposes to generate 3D articulated objects from a single image oberving the object in the resting state from a random view. Left: We design a pipeline to synthesize articulated assets progressively from coarse to fine details in a modular way. Right: Our method generates objects with varying part geometry and motion to account for the ambiguity in the input image.
Refer to caption: x1.png

## 2 Related Work

Generation of structured data.
Our task is closely related to the generation of structured data (Chaudhuri et al., ).
The generation of 3D shapes with semantic parts is a widely studied problem with the main goal of modeling objects with geometric details and semantic grouping at the part level.
Prior work either synthesizes objects in voxels with semantic labels (Wang et al., ; Li et al., ; Wu et al., ) or further considers the spatial structure, such as symmetry and support relationship, by jointly learning in the latent space (Wu et al., ) or explicitly modeling a tree structure (Li et al., ; Mo et al., ; Gao et al., ).
3D assembly is a similar problem that aims to place primitives (Gadelha et al., ; Paschalidou et al., ; Jones et al., ; Xu et al., ), joints (Willis et al., ; Li et al., ), or parts (Zhan et al., ; Li et al., ; Narayan et al., ; Xu et al., ; Koo et al., ) to form a shape.
Scene generation work learns to compose scenes from objects by considering the spatial arrangement and relationship between objects (Wang et al., ; Wei et al., ; Tang et al., ).
Similarly, building structure generation focuses on the general layout of the room or house (Nauata et al., ; ; Shabani et al., ; Tang et al., ).
Articulated objects are a type of structured data that considers both part geometry and articulation in 3D.
Thus articulated object generation poses a unique challenge (Liu et al., ).
In this work, we focus on image-conditioned generation of articulated 3D objects.

Conditional generation on 3D structures.
Enabling control over the generation process is crucial for practical applications.
This becomes more challenging for structured data generation, due to the need for fine-grained control and parsing the conditioning into structured components.
Part-based object generation has been studied in settings driven by a partial shape to complete the object part-by-part or guided by an image (Wu et al., ; Niu et al., ).
These methods only work with specific categories of objects that share similar structures.
The recent advances in large-language models and generative models promote conditional generation from 2D (Yang et al., ; Rombach et al., ; Zhang et al., ; Blattmann et al., ) to 3D with structures (Liu et al., ).
Many works on 3D scene generation have explored the control of object arrangements via text for room and object specification (Zhang et al., ; Lin & Mu, ; Aguina-Kang et al., ; Tam et al., ), 2D/3D layout for spatial constraint (Bahmani et al., ; Eldesokey & Wonka, ; Feng et al., ; Po & Wetzstein, ; Maillard et al., ; Yang et al., ), and scene graphs as spatial or semantic priors (Lin & Mu, ; Zhai et al., ; Gao et al., ).
Chen et al. () generate objects from an image by decomposing the subscene into objects to generate separately.
Alam & Ahmed () propose to generate parametric CAD command sequences conditioned on an image.
Our work follows the trend of conditional generation on structured data. To the best of our knowledge, we are the first to explore articulated object generation from a single image.

Articulated object creation.
While more datasets have been introduced for articulated objects recently (Xiang et al., ; Liu et al., ; Geng et al., ), these datasets do not reach the scale and diversity of real-world objects, and still require manual annotation.
To alleviate data scarcity, some works propose the creation of articulated objects from different input modalities.
A-SDF (Mu et al., ) first learns to generate objects that can be deformed to different articulated states from a signed distance field.
Then a line of work reconstructs articulated parts from point clouds collected at multiple states of the object (Jiang et al., ; Liu et al., ), or from stereo-view (Heppert et al., ) or multi-view images observing the object in an open state (Mandi et al., ) or multiple states (Liu et al., ; Weng et al., ), or from a video observing the object in motion (Song et al., ; Kerr et al., ).
Generative models for articulated objects were recently proposed by NAP (Lei et al., ) and extended to a more controllable setting by CAGE (Liu et al., ) to generate objects via specifying the part connectivity graph and object category.
However, these prior works either require a laborious data collection process or lack intuitive control for generation.
Our work aims to take a single image as input to create articulated objects, which is much cheaper and more practical for real-world applications.
The work that shares the most similar setting with us is URDFormer (Chen et al., ), which proposes a regression-based model to predict assets of articulated objects or a scene from an image.
Considering the ambiguity posed by the image of an object in the resting state we propose to address the problem in a generative manner.
This allows us to generate multiple plausible articulated objects from a single image while achieving better consistency to the input.

## 3 Methods

Figure: Figure 2: Our method takes an object image as input and generates attributes of articulated parts, which are used to assemble the object via part mesh retrieval. We design a diffusion-based model for part generation, which is guided by a part connectivity graph and DINO patch features of the input image. Our denoising network is built on layers of attention blocks. The graph constraint is injected into the graph relation module by converting to an adjacency matrix as the attention mask. The image features act as the keys and values in the cross attention to condition the part arrangement.
Refer to caption: x2.png

### 3.1 Overview

Given an image $\mathcal{I}$ of an object in the resting (i.e. unopened) state, our goal is to generate a set of articulated parts $\{p_{i}\}_{i=1}^{N}$ assembling into a 3D object that is geometrically consistent with the input image while being kinematically plausible.
To achieve this goal, we decompose the problem into two subtasks: 1) using the input image to guide the abstract-level generation of each part, and 2) fitting part meshes to the generated part arrangement and constructing them into a 3D articulated object.
To create the 3D object, one can generate each part’s geometry or retrieve it from a predefined part library.
As many parts of household objects are often geometrically simple, we choose to retrieve part geometries from a library.
This works well in practice to assemble coherent objects, as shown in our experiments and also in previous works (Lei et al., ; Liu et al., ).

In this work, we focus on the first subtask and we visualize the pipeline in Figure 2.
We propose a diffusion-based model $\phi$ to learn a distribution of objects with articulated parts that resemble the input image.
This distribution of objects visually matches the input image, but can vary in the part geometry and articulation to capture the ambiguity posed by the single snapshot of the object in the resting state that sometimes can be interpreted in multiple ways.
Examples are illustrated in Figure 1.
For each input image, our model learns to generate a list of attributes to describe each part in shape and motion.
During generation, a part connectivity graph $G$ is also required as a guidance to determine the ordering of the list so that the parts are organized into a coherent articulated object.
Thus, the model is essentially learning a distribution $p_{\phi}\left(\mathbf{x}:\{\mathbf{p}_{i}\}_{i=1}^{N}|\mathcal{I},G\right)$.
We will further explain the details of the data representation in Section 3.2 and the model design in Section 3.3.

### 3.2 Data Representation

We assume objects to be normalized inside a cube of size $2$ centered at the origin and all the parameters are defined in the world coordinate system.
We describe each articulated part with multiple attributes $\mathbf{p}_{i}=\{\mathbf{b}_{i},l_{i},t_{i},\mathbf{a}_{i},\mathbf{r}_{i}\}$ at abstract level, including the part bounding box $\mathbf{b}_{i}\in\mathbb{R}^{6}$, semantic label $l_{i}$, articulation type $t_{i}$, location and direction of joint axis $\mathbf{a}_{i}\in\mathbb{R}^{6}$, and motion range $\mathbf{t}_{i}\in\mathbb{R}^{2}$.
The articulation type considered in this work includes fixed, revolute, prismatic, continuous and screw joints.
The semantic label includes base, door, drawer, handle, knob, tray.
The semantic label will be used to retrieve the part geometry from the dataset.
Spatially, the parts are organized into a connectivity graph, where each node represents a part, and the edge direction indicates the parent-child relationship.
This spatial relationship also defines the kinematic constraints between parts.
During training, the graph is represented as an adjacency matrix $A\in\{0,1\}^{N\times N}$, where $A_{ij}=1$ if part $i$ is in connection with part $j$.
The matrix $A$ will serve as an attention mask to guide the part generation process.
To handle a different number of parts in the denoising diffusion process, we pad the parts to a maximum number $32$ with all part attributes represented in $6$ dimensions.

### 3.3 Denoising Network

#### 3.3.1 Image and Graph Guidance

Image encoding.
To leverage images for generation guidance, we expect to encode the image into a latent feature that
1) is 3D-aware to capture the spatial orientation of the object; 2) is fine-grained to detail the individual part semantically; and
3) contains the spatial information to infer the spatial structure and relationships between parts.
We opt to use DINOv2 (Oquab et al., ), a ViT model pre-trained on a large-scale dataset and that has been shown with rich semantics and strong 3D awareness (El Banani et al., ), to encode our input image into latent patch features.
Practically, we use the ViT-B/14 model with the register version (Darcet et al., ), which results in a total of $256$ patches.
These patch features are fed into our transformer-based denoising network as the conditioning input, where each patch acts as a token to be attended to.
Our model learns to distill essential information from DINO features to understand the part semantic and spatial relationships.

Part connectivity graph.
This graph is required to guide the part generation process.
During training, we use the ground-truth graph provided in the dataset.
For inference, we extract the graph from the input image using large vision-language models, which have been shown advance in visual reasoning tasks, such as image captioning and visual question answering.
We empirically find that the connectivity graph of articulated parts can be effectively predicted from the image by leveraging the GPT-4o models with in-context learning.
We prompt GPT-4o to take an object image as input, recognize all the articulated parts in the object, and then describe the part connectivity.
Along with the instruction, we provide the model with examples of input-response pairs to help the model understand the context of the task.
See the prompt in the appendix for more details.

#### 3.3.2 Model architecture

We design our denoising network as a transformer-based architecture, which is shared for all timesteps.
For each step, the model takes the output from the previous timestep $\mathbf{x}_{t-1}$ with the current timestep $t$ as input and produces a residual noise $\epsilon_{t}$ to be subtracted from $\mathbf{x}_{t-1}$ to construct $\mathbf{x}_{t}$ for the next iteration.
The network consists of $L=8$ layers in total, each of which has a layer normalization followed by attention modules with skip connections.

Figure: Figure 3: Attention maps for two example parts visualized at the $2^{\text{nd}}$ last layer.
Refer to caption: x3.png

Attention modules.
Each part attribute is regarded as a separate token during the attention process.
We select CAGE (Liu et al., ) as our base model that equips each attention block with:
a local attention that harmonizes the attributes within each part;
a global attention that coordinates parts globally to form a coherent object; and
a graph relation attention that incorporates awareness of part connectivity from the graph.
These self-attentions ensure the model to generate parts that adhere to the connectivity graph.
To enforce geometric consistency with the input image, we further introduce an image cross attention at the end of each block; see Figure 2.
Since the bounding-boxes directly reflect the shape and spatial locations of parts in the image, we only let the bounding-box parameters as queries to attend to image patches.
Other attributes are then made compatible with the bounding box during the self-attention process followed.
During cross-attention, we observe from the attention maps (see Figure 3) that each part is learned to focus on its relevant patches, indicating that each part is anchoring a specific region of the image during generation.
This part-patch correspondence is learned without any explicit supervision during training, eliminating the need for taking part detection or segmentation as input.

Classifier-free training for conditioning.
Our denoising network takes image $\mathcal{I}$ as the main control and graph $G$ as auxiliary guidance.
Both of them are critical as the image describes the spatial arrangement of parts and the graph determines the ordering of the parts to be generated so that the parts are organized correctly when articulating.
Inherent from the base model, our network can also take object category $c$ as an additional condition, which is fused with the timestep embeddings via an adaptive norm layer (Xu et al., ) prior to attentions in each block.
We empirically find that the original design of CAGE that takes them as hard constraints will lead the generation to be biased towards a narrow distribution of objects and overfit to the training data.
It causes limited generalization to unseen images.
To alleviate this issue, we propose to train our model in a classifier-free manner by dropping $c$ and $G$ randomly at $50\%$ rate during training.
In this way, the model is forced to generate objects that are visually consistent with the input image without being strictly constrained by them.
Then $c$ can be regarded as an optional condition and $G$ as a condition secondary to the image input.
At the same time, we also apply classifier-free training to $\mathcal{I}$ at $10\%$ dropping rate so that the image guidance can be further enhanced at inference by
$\epsilon_{\phi}(\mathbf{x}_{t};\mathcal{I},G)=(1+\omega)\epsilon_{\phi}(
\mathbf{x}_{t};t,\mathcal{I},G)-\omega\epsilon_{\phi}(\mathbf{x}_{t};t,
\varnothing,G)$
, where $\omega$ is a hyperparameter to balance the influence of the image and the graph, and $\varnothing$ denotes the absence of the image.

#### 3.3.3 Training Objectives

We supervise our model with the loss $\mathcal{L}=\mathcal{L}_{\epsilon}+\lambda\mathcal{L}_{\text{fg}}$, where $\mathcal{L}_{\epsilon}$ is noise residual loss and $\mathcal{L}_{\text{fg}}$ is object foreground loss.
Our model follows the training procedure of the denoising diffusion probabilistic model (Ho et al., ), and $\mathcal{L}_{\epsilon}$ is the standard diffusion loss, which computes the mean squared error between the output $\epsilon_{t}$ and the ground truth residual noise $\hat{\epsilon}_{t}$ that is added to the input $\mathbf{x}_{t-1}$ in the timestep $t$ in the diffusion process.
The loss $\mathcal{L}_{\text{fg}}$ is defined on the cross attention map $\mathcal{A}_{\mathbf{p}_{i}}^{l}$ for each part $\mathbf{p}_{i}$ at layer $l$, which records the attention scores from the part to all the image patches.
$\mathcal{L}_{\text{fg}}$ is designed to encourage the part attention to focus on the foreground patches of the object across all parts and all layers.
We define the loss as $\mathcal{L}_{\text{fg}}=\frac{1}{L}\sum_{l=1}^{L}{\sum_{i=1}^{N}{(1-\mathcal{A
}_{\mathbf{p}_{i}}^{l}\circ\mathcal{M}_{\text{fg}}+\mathcal{A}_{\mathbf{p}_{i}
}^{l}\circ\neg\mathcal{M}_{\text{fg}})}}$, where $\mathcal{M}_{fg}$ is the foreground mask of the object projected onto the patches, and $\circ$ denotes the element-wise product.
We use $\lambda=0.1$ to balance the two losses.

## 4 Experiments

Figure: Figure 4: Qualitative comparison on the PartNet-Mobility test set. For each set of results, the first column shows the predicted part connectivity graph (the wrong ones are denoted in red boxes), the second column shows the part arrangement and joint for each part for the object in the resting state where the part coloring corresponds to the node in the graph, and the third column shows the final assets of the articulated object. Our method outperforms the baselines with better graph prediction, more consistent part arrangement with the input image, and more plausible part articulations.
Refer to caption: x4.png

### 4.1 Dataset

We collect data from PartNet-Mobility dataset (Xiang et al., ) to train our model across 7 categories (i.e., Storage, Table, Refrigerator, Dishwasher,
Oven, Washer, and Microwave).
We render 20 images per object from random viewpoints, sampled within a $90^{\circ}$ horizontal range and a $90^{\circ}$ upwards vertical range relative to the object’s front.
With several augmentation strategies applied, we end up with 3,063 objects paired with 20 images rendered from random views for training, and additional 77 objects paired with 2 random views for testing.
We also use 135 objects from the ACD dataset (Iliash et al., ) for additional evaluation in the zero-shot manner to test the generalization capability.
In total, we have 55K training samples and 424 test samples in the experiments.
Please see the appendix for more details on the data augmentation.

### 4.2 Baselines

We compare our method with two baselines: URDFormer (Chen et al., ) as the state-of-the-art that works in the same setting and NAP (Lei et al., ) as representative prior work that unconditionally generates articulated objects.
For URDFormer, we take their pretrained model for part detection on the input image and re-implement their object-level module to finetune on our training data for articulated object prediction.
For NAP, we re-implement their method by plugging our image cross-attention module to attend with their node attributes after each of their graph attention layer to enable NAP to condition on an image.
This variant of NAP is denoted by NAP-ICA.
We also replace the shape latent originally used in NAP with part semantic label for sharing our retrieval algorithm, which is a lightweight version of NAP that has been shown to perform better in a conditional setting by Liu et al. ().
For comparison, all the methods are trained with or finetuned on the same training set and evaluated on the same test set.
The final geometry of objects are from retrieval across all baseline methods.
Please see the appendix for more implementation details.

### 4.3 Metrics

**Table 1: Evaluation of the reconstruction quality on the PartNet-Mobility test set. We report the results under oracle setting with ground-truth part detection given to URDFormer and ground-truth graph given to NAP-ICA and ours as a highline reference in the upper part of the table. The lower part shows the results on the real setting that only an image is given, and all the methods produce one object per input. Our method outperforms other baselines in both oracle and real settings.**
|  | Reconstruction quality | Collision | Graph |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ | AOR$\downarrow$ | Acc$\%\uparrow$ |
| URDFormer-GTbbox | 1.0861 | 1.0882 | 0.1471 | 0.3225 | 0.3400 | 0.6031 | 0.0616 | 83.55 |
| NAP-ICA-GTgraph | 0.6830 | 0.6915 | 0.0739 | 0.2206 | 0.0282 | 0.2646 | 0.0105 | 44.81 |
| Ours-GTgraph | 0.4381 | 0.4541 | 0.0315 | 0.0751 | 0.0089 | 0.0836 | 0.0014 | 100.0 |
| URDFormer | 1.1868 | 1.1879 | 0.2693 | 0.4535 | 0.5502 | 0.8374 | 0.2341 | 32.03 |
| NAP-ICA | 0.5778 | 0.5854 | 0.0501 | 0.0979 | 0.0173 | 0.0914 | 0.0120 | 75.97 |
| Ours | 0.4841 | 0.4974 | 0.0448 | 0.0955 | 0.0168 | 0.0905 | 0.0043 | 82.47 |

To evaluate the reconstruction accuracy in terms of shape structure and kinematics, we adopt 3 sets of evaluation metrics to measure the similarity between the output and the ground-truth object that correspond to the given image.
For each metric set, the object similarity is measured both in the resting state (RS-) and across the articulated states (AS-) uniformly sampling from resting to the end state.
The overall object scale is normalized to the one of the ground-truth objects to account for scale ambiguity across methods.
Each metric is reported by averaging over the pairwise distance per part per state, and the part pairing is determined by the Hungarian algorithm.

To formalize all the evaluation metrics, we denote $p_{i}$ as the $i$-th part in one object $O_{1}$ and $q_{j}$ as the $j$-th part in the other object $O_{2}$.
The pairwise distance between $p_{i}$ and $q_{j}$ is calculated as $d^{s}(p_{i},q_{j})$ in state $s$ among all sampling states $S$.
The Hungarian matching algorithm $\mathcal{H}_{O_{1}\rightarrow O_{2}}(p_{i})$ takes the centroid distance of the part as the cost matrix to determine the pairing of parts from $O_{1}$ to $O_{2}$ and returns the corresponding part for each part $p_{i}$ in $O_{1}$.
Our metrics $\mathcal{D}$ are computed as follows.

$$ $\mathcal{D}=\frac{1}{|S|}\sum_{s\in S}\left(\frac{1}{2}\left(\frac{1}{N}\sum_{ i=1}^{N}d^{s}\left(p_{i},\mathcal{H}_{O_{1}\rightarrow O_{2}}\left(p_{i}\right )\right)+\frac{1}{M}\sum_{j=1}^{M}d^{s}\left(q_{j},\mathcal{H}_{O_{2} \rightarrow O_{1}}\left(q_{j}\right)\right)\right)\right)$ (1) $$

The three metrics we adopt to compute the pairwise distance $d^{s}(p_{i},q_{j})$ are as follows.

- •
$d_{\text{gIoU}}\downarrow$: At the abstract level of the part description, we report the distance based on generalized intersection over union (gIoU) (Rezatofighi et al., ) of the bounding box volume for each pair of parts as $1-\text{gIoU}$, lower-bounded by 0.
- •
$d_{\text{cDist}}\downarrow$: Since small and thin parts can easily miss the overlapping region, we also report the Euclidean distance between the centroids of two parts, lower bounded by 0. We find it to reflect the part-level similarity in a more fine-grained manner than gIoU.
- •
$d_{\text{CD}}\downarrow$: At the mesh level, we report the Chamfer Distance averaged over the 2,048 points sampled on the mesh surface per part and computed in symmetric, lower-bounded by 0.

Our formulation of $\mathcal{D}$ is built upon the metrics Instantiation Distance (ID) introduced by NAP and Abstract Instantiation Distance (AID) proposed by CAGE.
Initially, ID only accounts for CD over the entire object, minimizing across all possible articulated states while neglecting part-level similarity and state matching.
AID addresses this by incorporating state pairing and part matching to compute IoU, but part pairing is determined using a greedy algorithm, which may not yield optimal results.
In our refined metrics, we employ the Hungarian algorithm for optimal part pairing and extend the pairwise distance to three variations, capturing multiple aspects of part-level similarity more effectively.
Please see the appendix for more details of the prior metrics.

To evaluate the accuracy of the graph inferred from the image, we report the accuracy (Acc$\%\uparrow$) in terms of the percentage of correct graph topology.
We also report the average overlapping ratio (AOR$\downarrow$) introduced by CAGE to detect unrealistic collisions among sibling parts in the graph.

Figure: Figure 5: Qualitative comparison on the ACD dataset in a zero-shot testing. The first four rows show that our method can generate more geometrically accurate objects with plausible motions compared to the baselines. The red boxes denote incorrect part connectivity graphs relative to the ground truth. The first row shows that even when our predicted graph is different from the ground truth due to ambiguity in the image, our method can still generate a realistic and reasonable object. The last two rows show failure cases for two challenging input images. When the texture is complex or the part arrangement is cluttered, our method may not accurately recover some details (e.g., two knobs on drawer merged into one handle in $2^{nd}$ to last example; doors and drawers misplaced in last example).
Refer to caption: x5.png

**Table 2: Evaluation of the reconstruction quality on the ACD testset. We report the results under oracle setting with ground-truth part detection given to URDFormer and ground-truth graph given to NAP-ICA and ours as a highline reference in the upper part of the table. The lower part shows the results in the real setting where only an image is given, and all the methods produce one object per input. Our method outperforms other baselines in better generalization to more complex data.**
|  | Reconstruction quality | Collision | Graph |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ | AOR$\downarrow$ | Acc$\%\uparrow$ |
| URDFormer-GTbbox | 1.1986 | 1.2012 | 0.2292 | 0.2931 | 0.4343 | 0.4965 | 0.1209 | 48.53 |
| NAP-ICA-GTgraph | 1.0585 | 1.0631 | 0.1987 | 0.2810 | 0.1376 | 0.2417 | 0.0193 | 36.67 |
| Ours-GTgraph | 0.9842 | 0.9881 | 0.1620 | 0.2024 | 0.1171 | 0.1784 | 0.0112 | 100.0 |
| URDFormer | 1.2288 | 1.2309 | 0.2914 | 0.4285 | 0.7198 | 0.8995 | 0.2840 | 4.48 |
| NAP-ICA | 1.0233 | 1.0286 | 0.1691 | 0.2331 | 0.1110 | 0.1887 | 0.0133 | 16.67 |
| Ours | 0.9517 | 0.9574 | 0.1526 | 0.1983 | 0.1011 | 0.1679 | 0.0085 | 39.34 |

### 4.4 Results

Reconstruction quality.
We show the quantitative comparison on PartNet-Mobility dataset in Table 1 and qualitative results in Figure 4.
In terms of the topological correctness of the predicted graph, our GPT-4o module achieves the highest accuracy.
The graph prediction of URDFormer is less accurate and we observe that it is largely bottle-necked by their part detection module which often misses parts.
NAP-ICA predicts more accurate graphs when node connectivity is not enforced as a constraint, which is consistent with the observation in CAGE that NAP struggles to adhere to graph conditioning.
In terms of the geometric consistency with the input image, we observe that our method and NAP-ICA handle more variational input views and have better part-level understanding from the image than URDFormer,
which leads to higher reconstruction quality by referring to the “RS-" metrics and qualitative results in Figure 4.
This high performance is largely attributed to the ICA module we proposed that enables us and NAP to efficiently distill part knowledge from the rich DINO features.
Our method further outperforms NAP-ICA, which is benefiting from the efficient graph guidance to better coordinate parts, especially when the number of parts gets larger.
In terms of the plausibility of the part articulation, our method can generate more kinematically plausible objects with less part collisions by referring to the “AS-" and AOR metrics.
It is important to note that the ’AS-’ metrics cannot fully capture motion plausibility, as there are cases where the ground-truth motion is not unique.
From Figure 4, we observe that URDFormer exhibits inaccurate joint axis of doors due to its reliance on a predicted label that conflates semantic and joint categorizations, thereby impairing joint parameter estimation in their post-processing step.
NAP-ICA tends to produce more collisions and less plausible motions which is also reflected in the user study below.

Overall realism evaluated through user study.
To further evaluate the realism of the reconstructed objects, we conduct a user study in terms of how realistic the generated objects refer to the input images.
In our user study, participants were presented with three output objects given the same input image from three methods each time, and 15 pairs of results in total were shown.
The task for each participant was to rank these objects based on their perceived realism, specifically evaluating how closely each object aligned with the input image in terms of visual consistency and how plausible the object articulation is.
We collect responses from 48 participants and report the averaged ranking of each method ranging from 1 as the best to 3 as the worst.
As a result, our method ranks the highest with an average score of 1.20, followed by NAP-ICA with 1.91 and URDFormer with 2.89.

Generalization to unseen dataset.
To further evaluate the generalization capability, we show the comparison results on ACD dataset in a zero-shot manner.
The ACD dataset comprises objects with greater structural complexity, geometric diversity, and appearance variances compared to the PartNet-Mobility dataset.
Figure 5 shows examples from the ACD dataset, where our method generalize better to objects with more challenging textures and more complex part structures that are out-of-distribution.
As shown in Table 2, we outperform other baselines overall by a large margin.

**Table 3: Comparison with Real2Code. The CD $\times 10^{3}$ is reported for the whole object and parts on average.**
| Category | Fridge | Furniture | Furniture |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Number of Parts | 2-3 | 2-4 | 5-15 |  |  |  |
| Metric | whole | part | whole | part | whole | part |
| Real2Code-GTseg | 0.51 | 2.04 | 1.46 | 3.30 | 5.84 | 16.80 |
| Ours-GTgraph | 4.06 | 2.78 | 13.77 | 9.86 | 5.23 | 8.54 |
| Real2Code | 0.60 | 1.28 | 3.47 | 65.79 | 19.70 | 118.58 |
| Ours | 6.67 | 6.35 | 14.29 | 13.69 | 11.81 | 28.67 |

Comparison with multi-view reconstruction.
We compare with Real2Code (Mandi et al., ), a state-of-the-art method for articulated object reconstruction from multi-views.
As their code is not fully open-sourced, we follow the evaluation protocol shown in their paper.
Specifically, Real2Code reconstructs an object from 12 views observing the object in an opening state, which reveals much more geometric and kinematic information than our setting that only observes the object in a resting state from single view.
We retrain our model on their data split with our augmented data and evaluate on their test set to ensure a fair comparison.
From Table 3, we observe that our method achieves a competitive results on simple objects with less parts and can even outperform Real2Code on objects with more parts in complex structures.
Also, our score gap between CD on the whole and its part on average is smaller than Real2Code, indicating that our method reconstructs better part geometry.

Ablation studies.
We ablate the design components of our method as shown in Table 4, where the average of 5 samples per input given GT part connectivity graph is reported on the ACD dataset.
On top of our base model, the ICA module plays the main role in enabling image conditioning by distilling DINO features to part attributes via cross-attention.
Its effectiveness is also demonstrated by adding this module to NAP and achieving performance close to our method.
Removing object category (cCF) as a hard constraint allows the model to share knowledge across categories, which enhances the efficiency of training data utilization and leads to improved generalization.
$\mathcal{L}_{\text{fg}}$ yields a modest improvement in performance by concentrating attention on the object region.
The classifier-free training for the image and graph guidance enhances the model to the best performance by modulating the distribution farther to respect the input image and generalize better to unseen data.
We also ablate on how the augmented data affects the performance in the supplement, where the augmentation strategies are shown to be effective in improving the generalization capability.

**Table 4: The ablation study of the design components of our method on top of the base model, in terms of the image cross-attention (ICA) module, foreground loss $\mathcal{L}_{\text{fg}}$, and the classifier-free training on the object category (cCF), graph constraint (gCF), and image guidance (iCF). The average score of 5 samples per input given GT part connectivity graph is reported on the ACD dataset.**
|  | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| Base | 1.2059 | 1.2094 | 0.2985 | 0.3593 | 0.3469 | 0.4705 |
| Base + ICA | 1.0399 | 1.0433 | 0.1991 | 0.2492 | 0.1459 | 0.2372 |
| Base + ICA + cCF | 1.0102 | 1.0141 | 0.1874 | 0.2312 | 0.1423 | 0.2111 |
| Base + ICA + cCF + $\mathcal{L}_{\text{fg}}$ | 1.0028 | 1.0067 | 0.1857 | 0.2253 | 0.1403 | 0.2009 |
| Base + ICA + cCF + $\mathcal{L}_{\text{fg}}$ + iCF | 0.9887 | 0.9973 | 0.1678 | 0.2109 | 0.1184 | 0.1853 |
| Base + ICA + cCF + $\mathcal{L}_{\text{fg}}$ + gCF + iCF (Ours) | 0.9528 | 0.9565 | 0.1530 | 0.1989 | 0.1014 | 0.1701 |

Failure cases and limitations.
Some failure cases are shown in Figure 5 in the last two rows.
We observe three failure modes in our method: 1) incorrect graph predictions from input images with challenging textures;
2) less accurate part geometry, particularly for small parts (e.g., knobs in the second last example);
and 3) inaccurate part arrangement, often due to missing components in the predicted graph or when the object’s structure is highly cluttered and complex (see the last example).
These failures are due to the low resolution of the input image that provides limited part details for our model to infer accurate part geometry and arrangement, especially for complex objects with large number of parts compacted in a small number of patch features.
The unbalanced training on the data with less complex structure and simple textures also hinder the generalization ability of our model.
Further augmentation to balance the object complexity and increase texture diversity will improve generalization to real settings for future work.

## 5 Conclusion and Future Work

We address the problem of reconstructing household articulated objects from a single image in a generative manner.
We break down this complex task into sub-tasks solving the problem from coarse to fine:
we first infer part connectivity into a graph from the image, and then use the extracted graph and input image as guidance to produce part arrangement and motion parameters to describe the parts abstractly, and we finally retrieve the mesh for each part to assemble the full object.
We develop a diffusion model with attention mechanism to distill DINOv2 features of the image and to leverage graph together to condition the part generation.
We demonstrate the effectiveness and generalizabilty of our method on PartNet-Mobility and ACD datasets, and show that our method outperforms the state-of-the-art methods.

While our work takes important first steps on this challenging task, several aspects remain open for further exploration.
Currently, our method is tailored to specific object categories, primarily those with cuboid shapes.
Extending this approach to handle a wider range of object categories with more complex geometries is interesting for future research.
From a geometric perspective, although our mesh retrieval algorithm performs well for cabinet-like objects, it falls short in capturing finer geometric details of parts as seen in the input image.
A promising avenue for future work lies in developing methods that generate part geometries more faithfully aligned with the input image, enhancing both the accuracy and realism of the reconstruction.
We hope this work encourages the community to explore these directions and push the boundaries of articulated object reconstruction.

#### Acknowledgments

This work was funded in part by CIFAR AI Chair, a
Canada Research Chair, NSERC Discovery, and enabled by
support from WestGrid and the Digital Research Alliance
of Canada. We thank Han-hung
Lee, Hou In Ivan Tam, Qirui Wu, and Yiming Zhang for helpful discussions.

## Appendix A Appendix

### A.1 Implementation details

Our model training.
We empirically find that initializing our base model with the CAGE pretrained weights helps our model converge faster.
The intuition is that the pretrained base model has already learned a good distribution of articulated objects conditioned on the graph, and our model can further modulate the distribution to respect the input image.
We train our model for 200 epochs after initializing CAGE pretrained weights with a batch size of 40 and each with 16 timesteps sampled from the diffusion process for each iteration.
We train 1,000 diffusion steps in total.
We use the AdamW Loshchilov () optimizer with learning rate $5e-4$ for ICA module and $5e-5$ for the base model parameters, and the beta values are set to $(0.9,0.99)$.
We schedule the learning rate with 3 epochs of warm-up from $1e-6$ to the initial learning rate and then consine annealing to $1e-5$.
The network has 6 layers of attention blocks with 4 heads and 128 hidden units.
Our model is trained on 4 NVIDIA A40 GPUs for 23 hours.

Figure: Figure 6: Network architecture of NAP-ICA. We integrate our ICA module into the NAP framework by adding it in between the graph layers and let the node attributes to be conditioned on the image feature distilled from DINOv2.
Refer to caption: x6.png

NAP-ICA training.
In Figure 6, we show how we integrate the ICA module into the NAP (Lei et al., ) framework.
In between each graph layer used in NAP for node and edge feature fusion, we add an ICA module to condition the node attributes on the image patch feature distilled from DINOv2 (Oquab et al., ).
Once updated the node attributes, we concatenate the node and edge features to pass through the next graph layer.
For node attributes, NAP originally uses a shape latent code to encode the part geometry in 128-dimensional vector.
In this work, we replace it with a semantic label, which is shown in CAGE (Liu et al., ) that this lightweight version of NAP performs better in conditional setting as it balances out with other attributes in latent space.
We follow this simplification in our implementation with another benefit of reducing the model’s capacity of cross-attention with image patches.
And we show in the experiments that this light version of NAP works surprisingly well in our task by incorporating our ICA module.
We adopt a similar training strategy for NAP-ICA as above by using a pre-trained NAP to initialize the network parameters except for the ICA module, otherwise the training takes much longer to converge.
We use the AdamW optimizer with learning rate $1e-4$ for all parameters, and other hyperparameters are the same as the original NAP model to train NAP-ICA in 100 epochs on a NVIDIA A40 GPU for 25 hours.

URDFormer training.
As URDFormer (Chen et al., ) has not released the training code, we tried our best to re-implement their object module to match the original implementation by referring to the paper and asking the authors for details.
Additionally, we adapt the architecture to match the correct number of part categories, as originally doorU (door that opens upwards) is missing from the architecture and checkpoint.
We take their pre-trained weights and fine-tune the network on our training data for 100 epochs with learning rate $1e-5$ and batch size 256. We find that the loss weights provided by authors, connectivity loss weighted by 5 and other losses by 1, do not work well in our case.
Therefore, we select the weights that lead to convergence - 20 for connectivity loss and 4 for base part type loss. Additionally, we find that gradient clipping is detrimental and therefore train without it.

Mesh retrieval algorithm.
Our mesh retrieval algorithm is adapted from the implementation of CAGE (Liu et al., ).
They designs to first determine the most similar objects as candidate by computing the Abstract Instantiation Distance (AID) score between the generated object and the objects in the database.
This step helps to find the best base part for the generated object as they assume that the AID score reflects the similarity of articulation of all parts in the object.
We borrow this idea and follow this step with one change that we use our AS-$d_{cDist}$ score to determine the candidate objects.
Then we use the part semantic label to match the part geometry from the candidate object for each part.
If there are multiple parts with the same semantic label, we re-use the mesh for these parts to ensure a style consistency in the generated object.
Our retrieval algorithm is also shared with NAP-ICA model to assemble the final object.

### A.2 Part Connectivity Graph Prediction Using GPT-4o

We empirically find that GPT-4o performs well in understanding articulated part relationships and predicting part connectivity as a graph by taking an object image as input.
We choose the version gpt-4o-2024-08-06 for our experiments.
We provide GPT-4o with step-by-step instructions to teach the model to understand the articulated part in the image and then connect them into a graph.
Here is our instruction:

Figure: Figure 7: Prompt for GPT-4o to predict the part connectivity graph in the object image.
Refer to caption: x7.png

Apart from the instruction, we also provide the model with several examples of conversational dialogues, which is critical for GPT-4o to scope the context and understand what the user is asking for.
We find that the example input as a description of the image outperforms the example input as a real image, and here is an example of the conversation:

Figure: Figure 8: A conversation example to prompt GPT-4o for better context understanding.
Refer to caption: x8.png

### A.3 Dataset details

Data augmentation.
We design several augmentation strategies to enhance the diversity of the training data in terms of part arrangement and articulation:
1) parts randomization by swapping the handles/knobs across objects and perturbing their positions;
2) diversifying part arrangements by rotating the objects upside-down;
3) creating objects with more complex structures by stacking multiple objects together;
4) densifying the data distribution by randomizing the object scale.
We carefully design heuristics to ensure the augmented data is still plausible and realistic, and the above strategies are only applied to Table and StorageFurniture categories.

Ablations on the data augmentation.
We conduct ablation studies to investigate the effectiveness of augmentation strategy in performing our tasks on PartNet-Mobility dataset and generalization to ACD dataset.
We show the quantitative results in Table 5 by reporting the average scores of 5 samples per input given ground-truth part connectivity graph.
Reporting the average score of multiple samples helps to reduce the variance of the results and show consistent trend of the performance.
We observe that our data augmentation significantly improves our performance on both datasets.

**Table 5: The ablation of the effectiveness of our augmented data (aug) by testing on the PartNet-Mobility dataset (PM) and ACD dataset (ACD). The scores in average of 5 samples per input given GT part connectivity graph are reported show consistent trend of the performance.**
|  |  | Reconstruction quality | Collision |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Testing data | Training data | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ | AOR$\downarrow$ |
| PM | w/o aug | 0.5965 | 0.6101 | 0.0827 | 0.1427 | 0.0606 | 0.1725 | 0.0032 |
| w/ aug | 0.4414 | 0.4566 | 0.0309 | 0.0752 | 0.0097 | 0.0841 | 0.0027 |  |
| ACD | w/o aug | 1.1270 | 1.1306 | 0.2260 | 0.2782 | 0.1948 | 0.2783 | 0.0156 |
| w/ aug | 0.9528 | 0.9565 | 0.1530 | 0.1989 | 0.1014 | 0.1701 | 0.0130 |  |

**Table 6: Statistics of the ACD and PartNet-Mobility dataset before (PM-ori) and after data augmentation (PM-aug). We report the number of objects in different shape complexity and in total for each dataset.**
|  | Number of Articulated Parts Per Object |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Dataset | 0-5 | 5-10 | 10-15 | 15-20 | 20-25 | 25-32 | Total |
| ACD | 67 | 32 | 25 | 10 | 1 | 0 | 135 |
| PM-ori | 403 | 135 | 24 | 3 | 1 | 0 | 566 |
| PM-aug | 1,673 | 1,041 | 244 | 150 | 47 | 5 | 3,140 |

Dataset statistics.
We provide the statistics of the data we use in our experiments from ACD dataset and the PartNet-Mobility dataset before (PM-ori) and after our data augmentation (PM-aug).
We filter out the objects with broken part segmentation from the PartNet-Mobility dataset and the L-shaped tables and unrelated categories (e.g., bed, trashcan, barbecue, bench, and safe) from the ACD dataset.

### A.4 Evaluation Metrics

**Table 7: We report the reconstruction quality of our method and other baselines with the evaluation metrics ID proposed in NAP and AID proposed in CAGE.**
| Testing Set | Methods | ID$\downarrow$ | AID$\downarrow$ |
| --- | --- | --- | --- |
| PM | URDFormer | 0.0784 | 0.7565 |
| NAP-ICA | 0.0076 | 0.6224 |  |
|  | Ours | 0.0085 | 0.5628 |
| ACD | URDFormer | 0.0765 | 0.7374 |
| NAP-ICA | 0.0221 | 0.7553 |  |
|  | Ours | 0.0229 | 0.6989 |

We proposed our evaluation metrics $\mathcal{D}$ in the main paper to better capture the part-level reconstruction quality than the existing metrics in the literature: Instantiation Distance (ID) proposed in NAP (Lei et al., ) and Abstract Instantiation Distance (AID) proposed in CAGE (Liu et al., ).
In Figure 9, we use two examples to illustrate the limitation of these metrics.
When evaluating the reconstruction quality of the generated object with respect to the ground-truth object, we observe that the ID and AID metrics may not reflect the quality of the reconstruction well and misalign with the human perception.
The objects in the red box show that there are situations where a lower ID or AID score does not necessarily mean a better reconstruction quality.
The reason is that ID doesn’t consider either part-level matching nor the state-level matching between the objects, and AID matches the parts in a greedy way, which may lead to suboptimal part matching and inaccurate measurement of the reconstruction quality.
While ID and AID have their own limitations in measuring the reconstruction quality, we still report the evaluation results using these metrics here for completeness.
From Table 7, we achieve the best AID score on both datasets, which is consistent with the results reported in the main paper.

Figure: Figure 9: Examples illustrating the limitations of the AID and ID metrics in evaluating reconstruction quality, as they may not capture part-level accuracy and also misalign with human perception. The objects in the red box are examples with worse reconstruction quality but lower AID and ID.
Refer to caption: x9.png

### A.5 More Experiment Results

Reconstruction quality and generalization across multiple outputs.
We provide more quantitative results by reporting the average scores of 5 samples per input for NAP-ICA and our model in comparison with URDFormer on the PartNet-Mobility dataset in Table 8 and generalization on the ACD dataset in Table 9.
The average scores better reflect the consistency of the output quality of the models compared to the single output reported in the main paper.
From Table 8, we observe that our model consistently outperforms other baselines in terms of the reconstruction quality and collision rate between the parts.
From Table 9, we observe that our model consistenly generalizes much better to the ACD dataset compared to other baselines.

More qualitative results.
We provide more qualitative results showing generated objects in animation for our model and other baselines in the supplementary video.
The video shows 6 examples each for the PartNet-Mobility, ACD dataset, and the real images from the internet.
We observe that our model can generalize well to the unseen and real images of objects with variational appearances in terms of part arrangement and object texture.

**Table 8: Evaluation of the reconstruction quality on the PartNet-Mobility testset. For NAP-ICA and ours, we report the average results across 5 outputs per input. Our lowest scores across all metrics indicate that our model can consistently produce high-quality outputs when generating multiple objects with different random seeds.**
|  | Reconstruction quality | Collision | Graph |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ | AOR$\downarrow$ | Acc$\%\uparrow$ |
| URDFormer-GTbbox | 1.0861 | 1.0882 | 0.1471 | 0.3225 | 0.3400 | 0.6031 | 0.0616 | 83.55 |
| NAP-ICA-avg-GTgraph | 0.6834 | 0.6914 | 0.0732 | 0.2214 | 0.0287 | 0.2774 | 0.0134 | 42.59 |
| Ours-avg-GTgraph | 0.4693 | 0.4825 | 0.0316 | 0.0767 | 0.0097 | 0.0879 | 0.0050 | 100.0 |
| URDFormer | 1.1868 | 1.1879 | 0.2693 | 0.4535 | 0.5502 | 0.8374 | 0.2341 | 32.03 |
| NAP-ICA-avg | 0.5753 | 0.5854 | 0.0598 | 0.1072 | 0.0189 | 0.1074 | 0.0224 | 75.84 |
| Ours-avg | 0.5126 | 0.5240 | 0.0459 | 0.0975 | 0.0181 | 0.1032 | 0.0032 | 82.47 |

**Table 9: Evaluation of the reconstruction quality on the ACD testset in a zero-shot manner. For NAP-ICA and ours, we report the average results across 5 outputs per input. Our lowest scores across all metrics indicate that our model can consistently produce high-quality outputs from different random seeds and generalize well to a more complex dataset.**
|  | Reconstruction quality | Collision | Graph |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | RS-$d_{\text{gIoU}}\downarrow$ | AS-$d_{\text{gIoU}}\downarrow$ | RS-$d_{\text{cDist}}\downarrow$ | AS-$d_{\text{cDist}}\downarrow$ | RS-$d_{\text{CD}}\downarrow$ | AS-$d_{\text{CD}}\downarrow$ | AOR$\downarrow$ | Acc$\%\uparrow$ |
| URDFormer-GTbbox | 1.1986 | 1.2012 | 0.2292 | 0.2931 | 0.4343 | 0.4965 | 0.1209 | 48.53 |
| NAP-ICA-avg-GTgraph | 1.0588 | 1.0646 | 0.1996 | 0.2841 | 0.1389 | 0.2542 | 0.0225 | 36.51 |
| Ours-avg-GTgraph | 0.9850 | 0.9891 | 0.1624 | 0.2030 | 0.1183 | 0.1765 | 0.0130 | 100.0 |
| URDFormer | 1.2288 | 1.2309 | 0.2914 | 0.4285 | 0.7128 | 0.8995 | 0.2840 | 4.48 |
| NAP-ICA-avg | 1.0280 | 1.0333 | 0.1771 | 0.2350 | 0.1144 | 0.1991 | 0.0222 | 18.59 |
| Ours-avg | 0.9528 | 0.9565 | 0.1530 | 0.1989 | 0.1040 | 0.1701 | 0.0087 | 39.34 |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. What does `r_i` represent in line 200?

2. I am unclear about the phrase, "the graph determines the ordering of the parts to be generated so that the parts are organized correctly when articulating." Could you explain this in more detail?

3. In line 331, could you clarify why "graph accuracy" for "NAP-ICA-GTgraph" is not 100%?

4. Line 421: The sentence "we report the accuracy (Acc% ↑) in terms of the percentage of correct graph topology" is unclear to me. Could you explain this further?

5. Do you use one token for each part in your transformer?

6. What is the difference between "image guidance (iCF)" and "image cross-attention (ICA)"?
soundness: 3
strengths: 1. The idea of training a diffusion model to generate parts conditioned on a part graph and input image is interesting, as it enables the generation of variations.

2. The authors demonstrate that the proposed method outperforms the baseline and provide extensive ablation studies.

3. Overall, the paper is presented clearly.
summary: This paper proposes a novel method for generating articulated objects from a single image. Given an image of an object in its rest state, it first asks ChatGPT-4o to output the object's connectivity graph. It then trains a diffusion model to generate coarse descriptions of the parts, conditioned on the input image and the connectivity graph. Finally, it retrieves similar parts from a large database to generate the concrete geometry of each part.
weaknesses: 1. The overall coarse-to-fine pipeline for articulated object generation is not uncommon.

2. The proposed method only handles closed-domain objects and relies on ground-truth annotations for training. However, 3D datasets with fine-grained part annotations are extremely challenging to annotate. In the experiments, the authors focus on only six part categories and seven object categories, which may significantly limit the practical applicability of the proposed method in much more diverse and complex real-world scenarios.

3. The inference of the part connectivity graph relies on GPT-4o, which lacks specific designs and may not be considered a major contribution of the paper. It may also be difficult to inject 3D bias or other priors into the pre-trained GPT-4o.

4. The detailed geometry of parts is retrieved from an existing database. There are concerns about the visual quality and consistency of the parts, which may not be effectively captured by current quantitative metrics like IoU and Chamfer distance. Perceptual metrics may provide better ways to evaluate visual quality and consistency. Can the module retrieve complex and fine-grained parts in addition to primitive-like parts?

Additionally, this retrieval component relies heavily on and is adapted from a previous work.

5. According to Table 2, some components bring minimal gains, such as the classifier-free training on the object category (cCF) and the foreground loss \(L_{fg}\).

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: - For the dataset, when rendering the images, what part states are used? (e.g. door open or closed) It would be good to also explain this. As mentioned in the Introduction, "the object is observed in the closed state where occlusions introduce ambiguity in the part shape and articulation". In fact, it would be interesting to see for the same 3D articulated object rendered under different part states (different joint angles), how would the generation results be like (just an interesting bonus, without this I think the experiments are already quite comprehensive).
soundness: 3
strengths: - The paper addresses an important problem of image-conditioned articulated object generation, with detailed explanations of its importance and challenges.
- The experiments are thorough and well-designed. In addition to the main comparisons, the authors also showed a comparison with a multi-view method Real2Code and ablation studies of each module component as well as data augmentation. There is also a clear discussion of failure cases and limitations.
- Both qualitative and quantitative results look good. Compared to the baselines, the part graphs generated by the proposed method seem to have better global coherence.
summary: This paper proposes a framework for single image-conditioned 3D articulated object generation. The framework comprises 3 steps: (i) use a large vision-language models to predict the part connectivity graph from the image; (ii) generate attributes to describe the articulated parts at the abstract level; (iii) retrieve part meshes to assemble the final object.
weaknesses: The overall framework and experiments look good to me. Some minor points:
- If GPT-4o gives a wrong answer to the part graph, there will be no correction to this in the following stages? Intuitively, given an object image, how its part graph can be like should also depend on the prior distribution of part graphs of the object collection.
- As discussed in the introduction, one challenge for the task is that "the parts are small and thin, making them hard to perceive from a single image". The DINOv2 features are on 14x14 image patches, would that be too coarse for the small parts (like handles and knobs)?

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: - Quantitative results show that $L_{fg}$ is effective. Could you also visualize the attention map to show what kind of attention map the model learns if the $L{fg}$ is removed?
- Could you provide some results of real image inputs?
- The paper points out the lack of control over the generation process in previous methods. But I don't understand how / if the method can control the model to switch between multiple states due to the ambiguity in the image (shown in Fig. 1). These states are reasonable and the connectivity graph is the same, how can I control it or change the generation results?
- And are these ambiguities taken into account during evaluation? (For example, generate multiple possible states during quantization?)
soundness: 3
strengths: - Overall, the paper is well-organized and easy to understand. The motivation is clear.
- The paper considers the situation that multiple reasonable articulations of objects may exist when there is only one image input, which is very important for this problem.
- The experimental results show that the proposed method achieves encouraging results on multiple datasets, and the visualization results are reasonable.
summary: In this work, the authors proposed a new framework called SINGAPO to generate articulated objects from a single image. The framework designs a modular way to create objects from coarse to fine, including the connectivity graph, attributes to describe the articulated parts at the abstract level, and 3D mesh. The method uses a diffusion model in the process of generating abstract attributes, which allows for variations to account for any ambiguity in the image. The authors also point out that unlike previous methods that require multi-view or multi-state inputs and methods that only allow coarse control over the generation process, this method is the first to explore the generation of articulated objects from a single image.
weaknesses: - Among the limitations mentioned in the paper, it seems that the method has difficulty handling cases with complex textures and cases with complex arrangements. Does this also mean that the method has difficulty handling inputs of real objects? The paper also does not show results with real pictures as input. This raises some concerns about the generalization ability of the model.
- Since the meshes generated by the model come from retrieval, it will not work if there are some shapes in the input image that are not in the model library.
- This method relies too much on the correct connection graph from the input and can not correct the wrong connection graph. This somewhat weakens its claim of "generating articulated objects from a single image".

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1.The article mentions that the coarse-to-fine generation method gives users more editability, but the article does not explain or experiment on this point. Does this mean that users need to be given more interactive experience in the generation stage, similar to text-guided generation?
soundness: 3
strengths: 1.	The problem tackled in this paper holds substantial practical significance. In contrast to prior approaches that necessitate multi-view or multi-state inputs, this work enables the reconstruction of articulated 3D assets from a single image, thereby significantly enhancing the generalizability and applicability of the method.
2.	This paper effectively deploys various features to guide the generation process, employing a staged architecture that progresses from coarse to fine detail. The experimental results validate the effectiveness of this staged generation approach in producing high-quality articulated objects.
3.	This paper tackles the ambiguity of generating 3D articulated objects from single-view images, addressing challenges like occlusion and limited visual cues for movable parts. A part connectivity graph guides the spatial layout and articulation hierarchy, ensuring coherence even for small, obscured parts. This approach effectively balances realism and structural plausibility, advancing scalable 3D asset creation from minimal input.
summary: This paper presents a method for generating 3D articulated objects from a single image, addressing the limitations of prior work that require multi-view or multi-state inputs. Observing an object in a resting state, the proposed approach leverages a diffusion model to capture plausible variations in geometry and kinematics, effectively handling the ambiguity posed by single-view input. The generation pipeline progresses from coarse structure to fine geometric detail, using a part connectivity graph and part abstraction to guide the process. Experiments show that this method outperforms existing approaches in realism, input-image consistency, and reconstruction quality, marking a significant step towards scalable and practical 3D articulated object creation for applications in virtual environments and robotics.
weaknesses: 1. The proposed method is mainly applied to specific categories of objects (such as cubic furniture and household appliances), and may not be directly applicable to objects with more complex shapes and more diverse categories (such as irregular shapes or soft structures). This limits the versatility of the method.  

2 The use of GPT-4o for part connectivity graph generation faces challenges such as ambiguity handling, prompt sensitivity, and generalization, which are not addressed in the paper. With single-view input, GPT-4o may struggle with occlusion or complex structures, leading to inaccuracies in graph generation. The method's reliance on specific prompts can vary in effectiveness depending on object types and viewpoints, yet the authors do not explore mitigation strategies. Additionally, GPT-4o's performance is limited by its pretraining data, affecting generalization to unseen categories. Addressing these limitations would enhance the method's robustness and applicability in scenarios with high structural variability.

Meta-review: In this paper, the authors have proposed SINGAPO, which aims to generate articulated objects from a single image. The motivation is clear, the problem it gargets at is important, the paper is well-written, and the experiments are comprehensive. The reviewers initially have some concerns but they are well-addressed by the rebuttal. All the reviewers agree to accept the paper. I recommend a decision of acceptance.

Decision: Accept (Poster)