GSDiff: Synthesizing Vector Floorplans via
Geometry-enhanced Structural Graph Generation

Our forward process incrementally adds noise to an original data sample $V_{0}$ over $T$ steps, resulting in a sample resembling Gaussian noise. Our reverse process is a Transformer (Vaswani et al. 2017) based neural network, which takes the noisy node set at time $t$ and outputs the predicted noise $\epsilon_{\theta}$ at time $t-1$ ($\theta$ represents the parameters of Transformer), therefore inferring the noisy node set at time $t-1$. When the time step reaches 0, the node generation process terminates. Given a noisy node set $V_{t}$ at time $t$. We initialize the node embedding of node $f_{i}$ as

$$f_{i}=f^{\text{c}}_{i}+f^{(r,b)}_{i}+f^{t}_{i}$$

(1)

$f^{\text{c}}_{i}=[\gamma(x_{i}),\gamma(y_{i})]\in\mathbb{R}^{d}$ is the coordinate embedding, where $\gamma(\cdot)$ is the positional encoding (Vaswani et al. 2017). $f^{(r,b)}_{i}\in\mathbb{R}^{d}$ is the embedding of $(r_{i},b_{i})$ using a fully connected layer. $f^{t}_{i}\in\mathbb{R}^{d}$ is the time embedding using a feed-forward neural network (FFN).

The reconstruction loss is typically defined as the Mean Squared Error (MSE) for training:

$$MSE(\epsilon,\epsilon_{\theta})=\mathbb{E}\left[\|\epsilon-\epsilon_{\theta}(V_{t},t)\|^{2}_{2}\right]$$

(2)

Due to the probabilistic nature of neural networks, the generated nodes may not be perfectly aligned. We propose a new alignment loss that optimizes alignment errors. Unlike natural language or images, structural graphs have precise geometric relationships, like perfectly horizontal or vertical walls. Directly regressing real-valued coordinates often fails to capture this precision. Thus, we convert real values into binary representations for regression, which discretizes the continuous coordinate space for more precise learning. However, learning discrete representations accurately is challenging, as errors in higher-order bits can cause significant real-value errors. To address this, we propose mixing multiple radix representations. Real-valued representations can heavily penalize large errors but are lenient on small misalignments. Binary representations, though overly discrete and causing significant penalties for small misalignments, are ineffective for large errors. By “interpolating” various radix representations, we aim for a smooth transition that penalizes large errors appropriately while remaining sensitive to small misalignments, balancing both advantages for better performance. We aim to enhance node alignment by applying the above concepts to propose a novel alignment loss across multiple bases, including real, binary, quaternary, octal, and hexadecimal:

$$MixAlg(\hat{V}_{0})=Alg(\hat{V}_{0})+\sum_{k\in{2,4,8,16}}Alg^{k}(\hat{V}_{0})$$

(3)

$$\text{Alg}(\hat{V}_{0})=\sum_{i=1}^{n}g(\min\left(\Delta b_{i}^{X},\Delta b_{i}^{Y}\right))$$

(4)

$$Alg^{2}(\hat{V}_{0})=\sum_{i=1}^{n}g^{2}(\sum_{j=1}^{s}\left(Base^{2}\left(\min\left(\Delta b^{X}_{i},\Delta b^{Y}_{i}\right)\right)\right)_{j})$$

(5)

where $Base^{k}(\cdot)$ is the $k$-base representation, $\Delta b^{*}_{i}=\min_{j\neq i}|b^{*}_{i}-b^{*}_{j}|$, $*\in\{X,Y\}$, $g(x)=-2*\log\left(1-\frac{x}{2}\right)$, $g^{k}(x)=-d^{k}\log\left(1-\frac{x}{d^{k}}\right)$, with $d^{k}$ indicating the maximum allowable distance under $k$-base. $n$ is the node number, $s$ is the bit size. With $k=2,4,8,16$, $s=12,6,5,3$ and $d^{k}=12,18,35,45$. $(\cdot)_{i}$ denotes the $i$-th bit.

We combine the reconstruction loss and alignment loss:

$$\mathcal{L}=MSE(\epsilon,\epsilon_{\theta})+\omega(t)MixAlg(\hat{V}_{0})$$

(6)

We adopt time-related weighting scheme $\omega(t)$ (Chen et al. 2024), assigning higher weights at smaller time step $t$. More details can be found in the supplementary material.

For each candidate edge $(v_{i},v_{j})$, the input embedding is obtained by fusing the embeddings of $v_{i}$ and $v_{j}$:

$$f_{i,j}=f_{i}+f_{j}$$

(7)

The coordinate embedding $f^{c}_{i}\in\mathbb{R}^{\frac{d}{2}}$ and the semantic-background embedding $f^{(r,b)}_{i}\in\mathbb{R}^{\frac{d}{2}}$ are concatenated as the node embedding $f_{i}=f^{c}_{i}\oplus f^{(r,b)}_{i}$.

To enhance the model’s robustness, we introduce noise to the node features during the training phase. Specifically, for the normalized 2D coordinate of each node, we add truncated Gaussian noise $\epsilon^{\prime}\sim Truncate\left(\mathcal{N}(0,\sigma_{c}^{2}),-3\sigma_{c},3\sigma_{c}\right)$, which sampled from Gaussian noise but is bounded at both ends. For the semantic attributes of the nodes, we randomly flip each bit in the multi-hot representation with a probability $p_{flip}$, simulating label noise. We set $\sigma_{c}=1$ and $p_{flip}=0.01$.

Edge prediction is essentially geometric inference, rich geometric information will be more helpful. However, the geometric information of an edge includes more than just its endpoints. To improve edge perception, we propose an edge perception enhancement strategy. Specifically, we add a random interpolation point and require the model to predict its interpolation coefficient, enhancing the model’s ability to infer intermediate edge structures. For each edge $(v_{i},v_{j})$, the interpolation point’s coordinates and attributes are defined as:

$$c_{\lambda}=\lambda c_{i}+(1-\lambda)c_{j}\in[-1,1)^{2}$$

(8)

where $r_{\lambda}=\textbf{0}\in\mathbb{R}^{7}$, $\lambda\sim U(0,1)$ is a random interpolation coefficient. The supervised loss for interpolation is:

$$\mathcal{L}_{\lambda}=\mathbb{E}\left[\left|\tilde{\lambda}-\hat{\lambda}_{\theta}(e_{ij})\right|\right]$$

(9)

where $\hat{\lambda}_{\theta}$ represents the model’s predicted interpolation coefficient. $\tilde{\lambda}=1-\lambda$, if $\lambda>0.5$; $\tilde{\lambda}=\lambda$, if $\lambda\leq 0.5$.

The enhanced edge feature includes the features of the two endpoints of an edge, as well as the random interpolation point. The final edge prediction loss for training is:

$$\mathcal{L}_{edge}=\mathcal{L}_{cls}+\mathcal{L}_{\lambda}$$

(10)

where $\mathcal{L}_{cls}$ is the Cross-entropy classification loss. More details are provided in the supplementary material.

So far, we have obtained the structural graph $G=(V,E)$. We can simply extract all minimal polygonal loops as rooms. Considering that the prediction based on neural networks might contain errors, leading to the absence of a category shared by all nodes, we select the most frequently occurring category as the room type. If multiple categories have the highest frequency, we consider factors such as the rarity of the category and determine the room type based on the following priority: Storage $>$ Bathroom $>$ Kitchen $>$ Bedroom $>$ Balcony $>$ Living room. An illustration is provided in the supplementary material.

A boundary refers to the outer contour of a floorplan, typically represented as a polygon. To encode a boundary, we draw the boundary polygon on an image with a resolution of $256\times 256$, converting the boundary polygon into an image. We then use a CNN-based encoder for encoding. Specifically, we modify U-Net (Ronneberger, Fischer, and Brox 2015) by removing skip connections and adding residual connections, as our boundary encoder. The encoder outputs a feature map of $16\times 16$ with $1024$ channels. During the pre-training phase, we generate random polygons on the image and learn their encodings with a CNN-based autoencoder. In the fine-tuning phase, we train with real boundary data from the dataset. The boundary embeddings are fed to node and edge Transformers, ensuring that the boundary of the generated structural graph adheres to the given constraint of the boundary.

Floorplan topology is used to describe the connectivity between rooms. It is an undirected graph where each node represents a room, and each edge represents a connectivity between two rooms. We encode the topological graph with a Transformer, which outputs 256D embeddings of all rooms, constituting topological embeddings. During the pre-training phase, we randomly generate topological graphs and learn their embeddings using a Transformer-based autoencoder. During the fine-tuning phase, we train with real topological graph data. The topology embeddings are fed to node and edge Transformers, ensuring that the topology of the generated structural graph adheres to the given constraint of the topology.

Unconstrained generation means that diverse floorplans can be generated without any inputs. The unconstrained generation allows users to explore freely, potentially inspiring more creative and innovative designs. It is worth noting that less research work is currently focused on unconstrained floorplan generation. By tilting balcony walls in the dataset, our method can also generate floorplans with slanted walls. Thanks to our robust structural graph representation, alignment error optimization strategy, and edge perception enhancement strategy, we can generate diverse, high-quality, vector floorplans without any inputs (Figure 4). For more results, please refer to the supplementary materials.

Both Graph2Plan and WallPlan can generate floorplans from boundaries, thus we compare our method against them. Figure 5 shows a comparison of floorplans generated by different methods. Graph2Plan is prone to generating issues such as unreasonable space divisions and areas, making these defects particularly noticeable as almost every sample exhibits significant flaws. Specifically, the second column features a huge balcony and tiny bedrooms, kitchen, and bathroom; the third column lacks a balcony; the fourth column has a bedroom accessible only through another bedroom on the right, and the fifth column includes an overly narrow balcony. WallPlan, although it produces fewer unreasonable shapes than Graph2Plan, some defects still persist. In the first column, the storage cabinet next to the bathroom should be against a wall, but it is located in the middle of the room; the second column has an unreasonable bathroom division, the third column has overly simplistic divisions, a huge bathroom, and a missing balcony; the fourth column has a super small, impractical bedroom, and the fifth column has a bathroom blocked by storage. The limitations of Graph2Plan and WallPlan are that they can only generate a single result for a specific input, and CNNs struggle to model long-range semantic relationships that involve the reasonableness of room layouts. In contrast, our model, benefiting from structural representation and attention mechanisms, can produce a variety of results that are closer to the fundamental facts of actual buildings.

We compare our method with House-GAN++ and HouseDiffusion, which can generate floorplans based on topology graph constraints. It’s noteworthy that HouseDiffusion requires the number of vertices for each room polygon to be pre-specified, hence we retrieve samples from the dataset as its input. Figure 6 shows a comparison of different methods. The principal issue with House-GAN++ lies in the peculiar room shapes, and jagged room boundaries are prevalent, leading to weaker visual aesthetics. Specifically, the overly small balcony at the top of the first column, the unreasonable arrangement between balconies and bedrooms in the second, third, and fourth columns, and the bedroom obstructed by the bathroom in the fifth column. And nearly every sample fails to meet the constraints. HouseDiffusion generates better quality compared to House-GAN++, yet it requires the number of vertices for each room polygon to be pre-specified as an extra “constraint”, limiting the diversity of room shapes. Moreover, limited by their binary coordinate optimization, there are issues with boundaries not aligning well, preventing the acquisition of a good wall structure. Many of their generated results fail to satisfy the room’s topological constraints. Specifically, the poorly shaped balconies in the first, third, and fourth columns, the bathroom in the middle of the house in the second column, and the kitchen in the fourth column that can only be entered from a bedroom. In contrast, our method can generate high-quality and diverse room boundaries, making the generated results more natural, aesthetically pleasing, and compliant with constraints.

The distribution comparison is used to analyze the overall generation capability of a generative model by comparing the differences between the distributions of generated data and real data. We consider the following representative metrics: (1) FID (Fr’echet Inception Distance)(Heusel et al. 2017) is used to measure the quality and diversity of generated images by calculating the distribution distance between real and generated data in feature space; (2) KID (Kernel Inception Distance)(Bińkowski et al. 2018) uses kernel methods to calculate the maximum mean discrepancy in feature space and is generally considered to be more robust than FID. Table 1 shows the results of the distribution comparison. It’s worth mentioning that we found that the image metrics FID and KID are influenced by a combination of factors such as room type, area, room layout, wall shape, and alignment, which can measure the generation results on the whole, making them excellent indicators for floorplan generation. In the evaluation of boundary-constrained generation, we selected the intersection of the test sets of our model, Graph2Plan, and WallPlan (378 boundaries in total) as input constraints, generating one sample per boundary for each method (as Graph2Plan and WallPlan can only produce a single output). Table 1 shows that the visual, geometric, and other features of our generation results outperform Graph2Plan and WallPlan. For the evaluation of topology graph-constrained generation, we selected the intersection of the test sets of our model, House-GAN++, and HouseDiffusion (a total of 757 topology graphs) as input constraints, generating 757 * 5 samples for each method, calculating the results five times and taking the average. Table 1 indicates that our generation results maintain better geometric consistency, visual appeal, and better practicality. Additionally, for topology-constrained generation, we reference HouseDiffusion (Shabani, Hosseini, and Furukawa 2023), and introduce Graph Edit Distance (GED) (Abu-Aisheh et al. 2015) as an additional metric for evaluation. GED is a graph-matching approach that calculates the distance between the input bubble diagram and the one reconstructed from the generated floorplan. For GED of House-GAN++, we directly use the reported GED in their paper. Table 1 indicates that our generation results maintain better constraint satisfaction, which benefits from our structural representation. For the unconstrained generation of floorplans with slanted walls, FID=12.02, KID=9.98.

We also conducted a statistical analysis of the generated vector results to evaluate the quality of the generated floorplans in terms of practicality. We ran the test set five times for each method. For each method’s generated results, we calculated the amount of each type of room. We calculated the average values of these statistics and compared them with the corresponding statistics of the ground truth in the real dataset (the closer to 1, the better). The results, as shown in Table 1, indicate that our method has a clear advantage in practicality compared to state-of-the-art techniques. For most types of rooms (living room, kitchen, bedroom), the amount generated by our method is closer to the real dataset. Only the balcony, storage, and bathroom are closer to the dataset by House-GAN++ and HouseDiffusion, but the difference in closeness with ours is not significant. Moreover, for boundary constraints, our method also shows an advantage in bathrooms.

Our original model for topology-constrained generation has approximately 125 million parameters, while House-GAN++ and HouseDiffusion have about 2 million and 27 million parameters, respectively. To assess the impact of model size, we reduced our model’s parameter count to 27 million to match that of HouseDiffusion, retraining it with all other configurations unchanged. As shown in Figure 6 and Table 1, even with the same parameter size, our method still achieves superior performance. This indicates that the effectiveness of our method stems from its inherent advantages rather than a larger parameter count. Regarding House-GAN++, we could not adjust our model to match their 2 million parameters. However, House-GAN++ has inherent problems. See the supplementary material for details.

Our model has about 137 million parameters. In comparison, WallPlan has about 106 million parameters and Graph2Plan has about 8 million parameters. To evaluate the impact of model size, we reduce the number of parameters of our model to 106 million to match WallPlan and retrain it. As shown in Fig. 5 and Table 1, our method still achieves superior performance, which also shows that our method has its inherent advantages. Regarding Graph2Plan, we were unable to adjust the model to match their 8 million parameters. However, Graph2Plan has inherent problems. See the supplementary material for details.