[1]Zexian Huang

These authors contributed equally to this work.

These authors contributed equally to this work.

1]Department of Infrastructure Engineering, The University of Melbourne,
Grattan Street, Melbourne, 3010, Victoria, Australia

# Learning Geometric Invariant Features for Classification of Vector Polygons
with Graph Message-passing Neural Network

<EMAIL_ADDRESS>Kourosh Khoshelham<EMAIL_ADDRESS>Martin Tomko<EMAIL_ADDRESS>[

###### Abstract

Geometric shape classification of vector polygons remains a non-trivial
learning task in spatial analysis. Previous studies mainly focus on devising
deep learning approaches for representation learning of rasterized vector
polygons, whereas the study of discrete representations of polygons and
subsequent deep learning approaches have not been fully investigated. In this
study, we investigate a graph representation of vector polygons and propose a
novel graph message-passing neural network (PolyMP) to learn the geometric-
invariant features for shape classification of polygons. Through extensive
experiments, we show that the graph representation of polygons combined with a
permutation-invariant graph message-passing neural network achieves highly
robust performances on benchmark datasets (i.e., synthetic glyph and real-
world building footprint datasets) as compared to baseline methods. We
demonstrate that the proposed graph-based PolyMP network enables the learning
of expressive geometric features invariant to geometric transformations of
polygons (i.e., translation, rotation, scaling and shearing) and is robust to
trivial vertex removals of polygons. We further show the strong
generalizability of PolyMP, which enables generalizing the learned geometric
features from the synthetic glyph polygons to the real-world building
footprints.

###### keywords:

Spatial Vector Polygons; Geometric Shape Classification; Transformation
Invariance; Permutation Invariance; Deep Neural Networks

##  1 Introduction

Geometric shape classification of spatial objects is a non-trivial task in
spatial analysis. The recognition of spatial objects assisted by automated
shape classification is a major enabler of data intensive tasks, including
cartographic generalisation, building pattern recognition, archaeological
feature analysis, and road geometry identification [1, 2, 3].

One of the main challenges in geometric shape classification is the
identification of object footprints (i.e., outlines) in the geographic
context. A key requirement is the classification of objects invariant to
geometric transformations including rotation, scaling, and shearing. The human
visual system relies on the Gestalt properties of perceived objects [4, 5]
during the classification of shapes. A key property of Gestalt is the
invariance to geometric transformations, assuring that geometric shapes are
recognized regardless of geometric transformations. In contrast to the human
visual perception capabilities, deep learning architectures have been designed
and shown to be mainly translation-invariant (e.g., Convolution Neural
Networks, CNN) or permutation-invariant (e.g., Graph Neural Networks, GNN) on
classification tasks. The ability to reflect Gestalt principles through
transformation invariances thus present a strong motivation for an inductive
bias in the design of learning-based models for geometric shape recognition of
spatial objects.

Spatial objects are often conveniently represented as vector polygons, a data
representation thus far neglected in deep learning research. Learning
geometric-invariant features from vector polygons has the following
requirements: (1) a generic data representation that encodes geometric
features of polygons without information loss; and (2) a learning model built
on this input data representation that enables learning latent geometric-
invariant features robust to geometric transformations. Existing geospatial
applications (i.e., shape coding and retrieval [6], building patter
recognition [2, 1] and building grouping [7]) utilizing polygonal geometries
motivate us to systemically study geometry encoding methods in conjunction
with appropriate and robust learning architectures that enable learning
transformation invariant features of spatial polygon geometries.

Veer et al. [2] proposed VeerCNN, a deep convolution model to learn
convolutional features on fixed-size 1D vertex sequences of polygon vertices
for building attribute recognition. The architectural limitations of CNNs
attributable to shared-weights convolutional kernels followed by non-linear
activation and fixed-size pooling layers (e.g, $mean$, $sum$ or $max$) only
enable learning intermediate hierarchical features invariant to translation,
with poor handling of rotation, scaling and shearing. Mai et al. [8] noted
that CNN models learning on 1D sequences are also sensitive to (1)
permutations of the feed-in order of polygon vertices (i.e., sensitive to
_loop origin invariance_); and (2) the impact of trivial vertices on the
exterior and interiors of polygons, defined by Mai et al. [8] as _“[vertices]
…where the addition or removal of the vertex have no effect on the geometric
shape and topological properties of the outlines of the polygons”_. In this
study, we treat the addition or removal of trivial vertices of polygons as
changes that do not alter the semantic information of the shape (captured by
the human-assigned label), thus closely reflecting the relationship with the
Gestalt principles.

Learning models tailored for discrete (i.e., not grid-like), permutation
invariant data representations are predicated on data domains where entries
hold no explicit neighborhood information (e.g., point sets [9, 10, 11, 12]).
Polygons can then be encoded into point sets of vertices on the exterior and
interior rings of the polygons with arbitrary ordering. In contrast to the 1D
sequence encoding of polygons, point set encoding assumes input data to have
varying input sizes and feed-in order. Models learning on point sets are
designed to map input points with permuted order to task-specific outputs
(i.e., _permutation invariance_ [13]). Here, we argue that such point set
representations do not sufficiently capture the connectivity information
between vertices of polygons, leading to information loss and performance
degradation in geometric shape classification.

Graph data structures present a suitable data encoding for polygons. Recent
studies [6, 14, 15] convert vector polygons into un-directed graphs where the
vertices on the exteriors and interiors of polygons are captured as graph
nodes linked by un-directed graph edges. Compared to fixed-size 1D sequences
and varying-size point-set encoding of polygons, graph encoding effectively
encapsulates both the geometric and connectivity information of the vertices
along the exterior and interior linear rings defining the polygons. Graph-
based representations also enable the feed-in order of polygon vertices to be
independent of the model outcomes, while the connectivity (topology) between
parts of polygon representations remains invariant to geometric
transformations.

Graph convolutional autoencoders (GCAE) [6] extend graph convolution neural
networks [16] by learning spectral convolution embeddings from polygon graphs
and demonstrate the effectiveness of latent embedding. Bronstein et al. [13]
discussed that the graph convolution layers aggregate node features from
neighboring nodes with constant weights, largely limited by the topological
structure of the input graphs. In vector polygons vertices on the linear rings
have constant neighbours (i.e., left and right neighbour vertices on linear
rings), leading to a reduction in the expressivity of graph convolution
features learned from polygon graphs. In this study, we propose to leverage
graph message-passing mechanisms [17] in graph-based learning models to learn
highly expressive and robust latent features of polygons.

Our hypothesis is that graph representations of polygons enable the learning
of robust latent features of polygons invariant to geometric transformations
(i.e., rotation, scaling and shearing) when combined with graph message-
passing models, thus supporting generalizability on data with domain shifts.

If the hypothesis holds, we suggest that the downstream tasks performed on the
learned features of vector polygons lead to robust performance on shapes with
varying amounts of trivial vertices. We present the results of a series of
experiments designed to evaluate model robustness on polygons altered by
geometric transformations, and investigate the generalizability of the
findings on combinations of polygon representations and model architectures
(permutation-invariant vs. translation-invariant models) for the
classification of vector polygons with and without holes (inner linear rings).

After a literature review of related literature (Section 2) we present a
synthetic dataset of polygonal shapes of high shape variability with known,
robust human labels, based on latin alphabet character glyphs (Section 3.1.1).
Despite a broad range of shape variations between fonts (in particular with
respect to trivial vertices), characters must maintain strong recognisability
attributable to the shapes’ Gestalt. We then experimentally benchmark the
performance of learning models operating on three distinct data
representations (1D sequence, set and graph) and varying amounts of geometric
transformations (i.e., rotation, scaling and shearing). Our results (Section
4) document the models’ robustness to geometric transformations by
benchmarking their performance on the synthetic glyph dataset. Building on
these results, we further evaluate the generalizability of the models on a
real-world building footprint dataset collected from the Open Street Map (OSM)
[6].

Our main contributions are:

  1. 1.

a thorough investigation of the impact of distinct combinations of graph
representation of polygons and message-passing learning architectures for the
learning of geometric features robust to geometric transformations of shapes
and removals of trivial vertices, grounded in a theoretically grounded set of
desiderata;

  2. 2.

the contribution of an open synthetic dataset of vector polygon shapes based
on glyphs, enabling the benchmarking of geometric learning models; and

  3. 3.

the experimental demonstration that graph representations of vector polygons
in conjunction with message-passing neural networks achieve the most robust
performance and generalization to real-world shape datasets.

##  2 Background

###  2.1 Machine Learning with Vector Geometries

In a straightforward extension of computer vision approaches devised for image
classification, current research on polygonal shape classification typically
learns salient geometric features of shapes based on rasterized 2D vector
geometries and traditional deep CNN architectures [18, 19].

The geospatial community has adopted these approaches for a variety of remote
sensing tasks, including vector shape generation. The Microsoft open building
footprints dataset [20] was generated by segmenting and subsequently
vectorizing building polygons based on satellite and aerial imagery using deep
semantic segmentation networks [21].

Such expertise in image classification naturally influenced approaches to
learning tasks on vector shapes. Xu et al. [22] trained a deep convolution
autoencoder to assess the quality of geographic information of rasterized
building footprints collected from OpenStreetMap (OSM) [23]. Veer et al. [2]
evaluated the classification performance of deep neural networks on spatial
vector geometries with geometry vertices encoded as 1D sequences directly feed
into deep learning models. While this shows the ability of CNNs and RNNs to
achieve performances comparable to machine learning methods with hand-crafted
features, these approaches neglect the desirable property of learning
transformation invariant features of shapes.

Beyond the geospatial community, the typography and computer graphics
communities also significantly handle vector shapes. Lopes et al. [24]
developed a generative model with convolution layers as encoders, to generate
vector text glyphs. Yet, this model is optimized to learn only scale-invariant
features of font styles. Mino and Spanakis [25] and Sage et al. [26] generated
vector icons and logos from rasterized images using deep generative
autoencoders proposed by Radford et al. [27] and Odena et al. [28].
Furthermore, Ha and Eck [29] proposed a recurrent neural network (RNN),
_sketch-rnn_ , to generate stroke-based vector drawings of common objects,
while later Carlier et al. [30] introduced a hierarchical generative network
(DeepSVG) which uses Transformer blocks [31] as the encoder and decoder of a
backbone architecture for scalable vector graphics (SVG) generation.

###  2.2 Vector Geometry as Discrete Data Representation

Recently, the progress of graph representation learning [32, 33, 16, 34],
enabled studies re-formalized learning tasks of vector polygons as graph or
set representation learning problems. Previous work by Yan et al. [1]
investigated the building pattern classification problem utilizing graph
convolution networks. They processed buildings into building clusters, based
on geometric patterns of individual buildings. They discovered the relational
representations between buildings in graphs built using clusters based on
Delaunay triangulation and Minimun Spanning Tree. They then trained a graph
convolution model [16] for a binary classification of regular and irregular
building clusters. Similarly, Bei et al. [15] devised a spatial adaptive model
that makes use of graph encoding, but applied to entire building clusters
(i.e., buildings as graph nodes) and applied a graph convolution neural
network [16] for group pattern recognition (i.e., inner-state, edge-state and
free state building patterns).

Most recently, Yan et al. [6] presented a graph convolutional autoencoder,
based on the graph convolution model [16], to analyze the shape of building
polygons. Different from previous works, they proposed to represent building
polygons as graphs with the vertices of boundary geometries of buildings as
graph nodes and their neighbour vertices as description features. However,
this method did not consider the relational structures between connected
vertices in graphs. Hence, their experiments on building shape coding and
empirical results of building shape similarity measurement suggest that the
proposed method is sensitive to rotation of building polygons.

Liu et al. [35] proposed a deep point convolutional network (DPCN), a
modification of a DGCNN [36], to recognize the geometric shapes of buildings
in map space, with the convolution operator `TriangleConv`. Their method
operates on the coordinates of vertices of the exterior boundaries of building
polygons and the convolution operator `TriangleConv` extracts local geometric
features from triangle features, where triangle features are given by
$f_{\verb+TriangleConv+}(x_{i-1},x_{i},x_{i+1})=\\{(x_{i}-x_{i-1}),(x_{i}-x_{i+1}),(x_{i-1}-x_{i+1})\\}$,
and $(x_{i-1},x_{i},x_{i+1})$ are adjacent coordinate features of a building
polygon. This method, trained and evaluated on a building footprint dataset
[6], achieves fair classification performances (i.e., accuracy) on geometric
shapes of buildings. However, their method requires a pre-definition of local
triangles constructed by the graph nodes and adjacency points, and attempts to
aggregate the local triangle features (i.e., angles and areas) for updating
node features. We argue that learning additional local triangle features of
polygons repeatedly is redundant and increase computing overhead in model
training, as pointed out by Tailor et al. [37]. Further, they do not evaluate
the robustness and generalizability of permutation-invariant data
representations and learning architectures to geometric transformations of
spatial geometries.

Mai et al. [8] recently proposed a general-purpose polygon encoding model for
single and multi-part polygonal geometries. Their polygon encoding method,
ResNet1D is a 1D CNN-based polygon encoder that captures local geometric
features of spatial polygons and is deemed suitable for shape classification.
ResNet1D encodes a polygon coordinate vertex $i$ as relative offset vectors
from $k$ neighbouring vertices:
$\\{x_{i},x_{i-1}-x_{i},x_{i+1}-x_{i},\cdots,x_{i+k}-x_{i},x_{i-k}-x_{i}\\}$.
They contrast this encoding with a Non-Uniform Fourier Transformation (NUFT)
method NUFTspec, based on the shape spectral domain. The NUFTspec aggregates
global features of polygons as a NUFT representation and is a better encoding
method for geometry topological relation predictions. Their work is thus
parallel to our study. Here, we focus on the ability to support specific
transformation invariant properties of combinations of learning architectures
(permutation-variant CNN, set-based, graph-based and attention-based
permutation-invariant models) and data representations (1D grid, set, graph
and complete graph).

While some of the above studies leverage graph representations and local
geometric encoding of vector polygons and state-of-art graph representation
learning models to solve tasks on vector shapes, they do not yet provide a
grounded, principled justification for graph-based learning methods on vector
polygons. We attempt to fill this gap here by providing experimental results
grounded in a sound theoretical motivation, and demonstrate why discrete data
representations in combination with permutation-invariant learning models
provide desired robustness to vector shape learning tasks.

###  2.3 Graph Representation of Polygon

Polygons are point sets connected by lines, constituting a collection of
clock-wise or counter clock-wise linear rings [38]. According to the Gestalt
principles of invariance, the compact embedding of linear rings should ideally
be invariant to geometric transformations (rotation, scale and shear). We
define a graph $\mathcal{G}=(X,E)$, where $X$ is a node matrix that contains
the point coordinates of geometry vertices and $E$ is an edge matrix that
captures the connectivity of these vertices along the linear rings (boundaries
of the outside and of any holes of polygons), hence encoding the node
connectivity of the graph. The binary adjacency value $a_{ij}=1\in A$ is used
to indicate the connectivity between nodes $i$ and $j$, with $A$ being a
square adjacency matrix.

###  2.4 Graph Representation Learning

Graph representation learning model leverages the property of data
permutations and learns a whole graph embedding $\mathcal{G}^{\star}$ from the
input graph $\mathcal{G}$ with differentiable permutation-invariant function
$\mathcal{F}$. The learned embedding $\mathcal{G}^{\star}$ can be applied to
graph-wise and node-wise classifications, or even edge predictions.

By representing polygon linear rings as graphs, we can define a differentiable
permutation-invariant function $\mathcal{F}$, which takes the graph
representations as inputs and returns a corresponding compact graph embedding
$\mathcal{F}(\mathcal{G};\theta):=\mathcal{F}(X,A;\theta)\rightarrow\mathcal{G^{\star}}\in\mathcal{R}$.

Considering a permutation matrix $\mathcal{P}$ operating on graph
$\mathcal{G}$, the permutation matrix $\mathcal{P}$ alters the order of node
feature matrix $X$ in $\mathcal{G}$ along with the adjacency matrix $A$,
producing a perturbed graph
$\mathcal{G}^{\prime}=(PX,PAP^{\intercal})=(X^{\prime},A^{\prime})$. The ideal
permutation-invariant function $\mathcal{F}$ should satisfy
$\mathcal{F}(X^{\prime},A^{\prime};\theta)=\mathcal{F}(X,A;\theta)$. We relate
the idea of permutation matrix $\mathcal{P}$ to the aforementioned geometric
transformations.

In the view of invariant feature learning, the permutation invariance of
$\mathcal{F}$ outputs are guaranteed through the local aggregations of node
features of $x\in X$ and the linear transformations of aggregated node
features:

$\displaystyle\mathcal{F}(X;\theta)=\rho(\sum_{x\in X}\phi(x,\theta)).$

The local differentiable function $\phi$ linearly transforms each node feature
individually $x$ to latent space and the aggregation function sums over latent
node features 111The basic aggregation in this setting can also be averaging
or max pooling., and $\rho$ is a global differentiable function applied on the
summed node features followed by a non-linear activation function. In this
simple setting, the outputs of $\mathcal{F}$ are invariant to the permutation
of node features since the aggregation sum returns the same outputs for any
input permutation:
$Aggr_{sum}(x_{1},x_{2},....,x_{n})=Aggr_{sum}(x_{n},...,x_{2},x_{1})$.

This learning setting [9] makes a simple assumption on the permutations acting
on input data, which can affect only individual node features without taking
into account the connectivity within data (i.e., boundaries of polygon
geometries). Graph convolution neural networks (GCN) by Kipf and Welling [16]
learn convolutional features of node matrix $X$ with the normalized graph
Laplacian matrix $\hat{A}=\tilde{D}^{-1/2}\tilde{A}\tilde{D}^{-1/2}$, where
$\tilde{A}=A+I$ is the adjacency matrix with a identity matrix (i.e., self-
connections of nodes), and $\tilde{D}$ is the diagonal degree matrix.
Intuitively, the graph Laplacian matrix describes the divergence of energy
flowing from one place (source nodes) to another (target nodes) in a graph.
Linking this back to the linear rings of polygons and graph representation,
the graph Laplacian conceptually shows similar energy divergence for nodes on
the same rings(i.e., polygons with holes) and for nodes that are close to each
other (i.e, polygons without holes).

Thus, GCN can learn graph Laplacian embedding of node feature with a
differentiable neural network layer as follows:

$\begin{array}[]{c}\mathcal{F}_{conv}(X,A;\theta)=\tilde{D}^{-1/2}\tilde{A}\tilde{D}^{-1/2}X\theta\\\
=\hat{A}X\theta.\end{array}$ (1)

We can express Eq.1 from a vector-wise view:

$f(x_{i};a_{ij},\theta)=\sum_{\begin{subarray}{c}a_{ij}\in A,\\\ x\in
X\end{subarray}}\phi(x_{i},x^{\prime}_{j},\theta),\text{where}\;x^{\prime}_{j}=\frac{\tilde{a}_{ij}}{\sqrt{\tilde{d}_{i}\times\tilde{d}_{j}}}x_{j},$
(2)

$\frac{\tilde{a}_{ij}}{\sqrt{\tilde{d}_{i}\times\tilde{d}_{j}}}$ corresponds
to the edge weight between nodes $x_{i}$ and $x_{j}$ in the normalized graph
Laplacian matrix $\hat{A}$. From Eq.2, the latent feature of target node
$x_{i}$ depends on the relation with its neighbour node $x_{j}$ and constant
edge weight $\frac{\tilde{a}_{ij}}{\sqrt{\tilde{d}_{i}\times\tilde{d}_{j}}}$.
However, the constant edge weight between nodes $x_{i}$ and $x_{j}$ largely
limits the expressivity of latent node features of polygonal graph since every
node has a constant node degree ($d=2$).

As discussed in Yan et al. [6], graph autoencoders GCAE based on GCN are
sensitive to orientation and rotation of polygons, and therefore current
graph-based learning methods are not optimized for geospatial settings with
polygonal geometries of arbitrary orientation, or conversely, arbitrary
observer orientation. Here we propose to leverage the message-passing
mechanism [17, 39] with the permutation-invariant function $\mathcal{F}$ to
learn expressive and robust latent features of polygons.

###  2.5 Message-passing Neural Network

The principle of the message-passing mechanism is the aggregation of neighbour
node features in graphs based on the “message” computed between the source and
target nodes. We define the message-passing function operating on a single
node as:

$\begin{array}[]{c}h_{i}=\phi(x_{i},msg(x_{i},x_{j}),\theta),\end{array}$ (3)

where $\\{x_{i},x_{j}\\}\in A=1$ and $msg(\cdot)$ is a message function with
the source and target nodes as inputs. From Eq.3, the node feature of $x_{i}$
is updated with the computed message $(x_{i},x_{j})$, and together linearly
transformed into latent space, producing the latent feature
$h_{i}\in\mathcal{H}$.

Eq. 4 present the message-passing neural network in vector view as follow:

$\begin{array}[]{c}\mathcal{F}_{msg}(X,A;\theta)=\rho_{\theta}(readout(h_{i}|h_{i}\in\mathcal{H})).\end{array}$
(4)

A global readout function (i.e., mean or max pooling) summarizes the latent
node-wise features ($\mathcal{H}$) and computes a global graph embedding for
the input graph by non-linearly transforming the pooled feature.

Hence, we propose a Messpage-passing neural network for Polygon geometries,
PolyMP, as shown in Fig. 1. The PolyMP considers the point coordinates of
polygons as input node features and the exterior connectivity of polygons as
input edges. The message-passing layers of PolyMP then compute the “message”
for each node according to the graph adjacency. Following existing works on
point clouds [36, 11] and polygons Liu et al. [35], we compute the message of
relative positions of two connected nodes: $msg(x_{i},x_{j})=|x_{j}-x_{i}|$,
which enable aggregating the local geometric features of polygons for updating
node features. After message-passing layers, a global pooling layer is applied
over the polygons with aggregated node features to generate a whole graph
embedding, which is then used for the downstream shape classification of
polygons.

Figure 1: Model architecture of PolyMP. PolyMP consists of two message-passing
layer and a classification layer (Multi-layer perceptron).

##  3 Experiment

###  3.1 Datasets

####  3.1.1 Glyph Dataset

We introduce a synthetic dataset of highly variable geometric shapes for
benchmarking the classification performance of learning models on vector
polygons. The dataset consists of 26 Latin alphabet character glyph geometries
(here also equal to semantic classes A to Z) of fonts gathered from an online
source [40]. An equivalent approach to construct a rich dataset of geometric
shapes has been used to test algorithms in computational geometry before [41].

We extract the boundaries of glyphs ( i.e., contour lines, as called in
typography) for 1,413 sans serif and 1,002 serif fonts, to produce 2D simple
polygon geometries compliant with OpenGeospatialConsortium [38]. Serif and
sans serif fonts are the two main typographic font families. Serif glyphs have
salient decorative strokes ending the main character strokes increasing
legibility of body text, whereas sans serif glyphs have clean strokes suitable
e.g., for the display of headers. Importantly, these minor variations do not
alter the Gestalt of the shapes (as proven by reader’s ability to consistently
read the symbols). Thus, the labels assigned to the symbols are stable and
robust. We encode each polygon geometry into a fixed-size feature matrix $\in
R^{n\times 3}$ where each feature vector $\in R^{3}$ includes the 2D
coordinates of vertices $(x,y)$ as geometric feature and a binary feature
$(0,1)$ to indicate the positions of 2D coordinates, whether on outer rings or
holes of polygons. Examples of glyph geometry are displayed in Figure 2.

Figure 2: Glyph dataset samples. Left to right columns: A-shape to J-shape
glyphs.

####  3.1.2 OSM Dataset

Latin alphabet glyph geometries share geometric similarity with building
footprints. We use a building geometry dataset designed to test the
generalizability of learning models on spatial objects proposed by Yan et al.
[6]. The dataset contains 10,000 real-world building footprints extracted from
OSM [23], labelled by 10 categories based on a template matching to letters
[42]. The building footprints are randomly rotated and reflected from the
original canonical samples (Figure 3). This is currently the most
comprehensive real-world dataset of vector geometries with purely shape-based
labels (as opposed to, e.g., building use, which should not be used for shape
classification). We note that the assignment of labels in this dataset is
somewhat subjective and likely less robust than in the glyph-based dataset.
Note, in particular, that shape reflection is problematic for label stability,
e.g., for asymmetric letters ($R$), or mirror shapes of distinct labels
($S$,$Z$).

Figure 3: OSM dataset samples. Top row: building geometries of standard
shapes. Bottom row: geometric transformation counterparts. Left to right
columns: E, F, H, I, L, O, T, U, Y and Z-shape buildings. [6]

####  3.1.3 Pre-processing

##### Label-preserving transformations

To examine the invariances of geometric transformations of polygon
representations and corresponding learning models with respects to data
transformations, we consider four training datasets under data
transformations, each consisting of 20%, 40%, 60% and 80% of glyph polygons
that have undergone label-preserving geometric transformations. The details of
transformations are presented in Table 1. The original and transformed data
samples are visualised in Fig. 4. We thus obtain five training datasets,
including the original dataset: dataset 0%, 20%, 40%, 60% and 80% for the
experiment. The test set consists of data randomly sampled from the five
datasets.

Table 1: Label-preserving transformations applied to samples of Glyph dataset maintains the semantic information (label) of original polygons (i.e., 180 degrees rotation of letter M alter its semantic label, converting to letter W). Transformation | Operation
---|---
Rotation | Rotate data around its centroid by a random angle $\in$ $\left[-75^{\circ},75^{\circ}\right]$.
Scaling | Scale data by random distinct factors $\in$ $\left[0.1,2\right]$ on the $x$ and $y$ axes.
Shearing | Shear data in a random angle $\in$ $\left[-45^{\circ},45^{\circ}\right]$ on the $x$ and $y$ axes.
Figure 4: Data samples of Glyph dataset under label-preserving
transformations.

##### Polygon Simplifications

To test the invariances to trivial vertices of polygon, we apply the
Douglas–Peucker algorithm [43] (tolerance = 1.0) on the original size of glyph
polygon (in the order of 50 $\times$ 50 units) to generate simplified samples
for glyph dataset. The resulting polygon linestrings are defined by fewer
vertices (in particular, excluding all co-linear or close to co-linear
vertices). Notice that the simplification occurs before the normalisation to
the range of (-1,1) and any augmentation of polygons, ensuring that the
simplified geometries preserve the topology and essence of the shape of the
original glyph (see Fig. 5).

Figure 5: Visualisation of original and simplified polygon examples generated
with Douglas–Peucker algorithm [43]. The simplified polygons, compared to
original polygons, contain a subset of the vertices that defined the original
curve.

###  3.2 Training Configuration

We evaluate the performances of learning models from previous studies, in
particular: the VeerCNN in Veer et al. [2], based on 1D sequences converted
from polygons as inputs; the DeepSet from Zaheer et al. [9] and SetTransformer
Lee et al. [12], based on polygon vertices as input point clouds; and the GCAE
in Yan et al. [6], representing polygons as input graphs. We then compare
their performances with the proposed message-passing model for polygons
(PolyMP).

The model configurations used in our experiments are in Table 2.
Correspondingly, we depict the data representations of polygons and baseline
models in Figure 6. The proposed PolyMP is demonstrated in Figure 1. For
experimental control, every model tested was constrained to a comparable model
depth and latent space of feature embedding.

For model training on Glyph dataset and fine-tuning on OSM dataset, we compute
the cross entropy loss [44] to determine training gradients for fast training
convergence and good model generalizability. We use the Adam optimization [45]
with an initial learning rate of $0.01$. For better model generalization, we
adopt a learning rate decay strategy that reduces the learning rate by a
factor of $10$ once the model training reaches a performance plateau over $25$
epochs. An early-stopping mechanism halts the training once the loss ceases to
decrease for $50$ epochs, to mitigate overfitting. We set the batch size to
$64$ and the total training epochs to $100$. Thus, importantly, the models
here are not designed to individually outperform current state-of-the-art for
each architecture, but to maintain comparability across architectures and to
enable evaluation of the effects of data representations on the results.

Table 2: Model configuration. Each model is configured to have the same number of convolution layers and dimensions of latent embedding, to keep the model size (i.e., number of training parameters) comparable. Model |  Conv.
depth |  Latent
dim. | #Param. | Pooling
---|---|---|---|---
VeerCNN [2] | 2 | {2, 32, 64} | 13,853 | Global avg.
DeepSet [9] | 2 | {2, 64, 64} | 11,837 | Global avg.
SetTransformer [12] | 2 | {2, 64, 64} | 113,531 | Attention
GCAE [6] | 2 | {2, 64, 64} | 7,613 | Global avg.
PolyMP (Ours) | 2 | {2, 64, 64} | 11,837 | Global avg.
Figure 6: Data representations of polygons (as 1D sequence, Point Set, Graph
and Complete Graph) and the corresponding learning models (Baselines: VeerCNN,
DeepSet, GCAE and SetTransformer).

##  4 Result

We report model performances for all experiments as the overall accuracy
(O.A.), calculated as the ratio of true positives over the total number of
samples.

###  4.1 Results on Glyph Dataset

Table 3 and 4 demonstrates the model performances testing on Glyph dataset and
the simplified polygons, respectively.

At $0\%$ transformation ratio in Table 3, we observe that the PolyMP achieves
$99.41\%$, $42.91\%$ and $80.03\%$ acc. on the original, rotated and scaled
test samples, whereas VeerCNN achieves $59.07\%$ acc. on sheared samples.
While deepset, set transformer and GCAE maintain comparable performances
($94.62\%$, $65.01\%$; and $96.25\%$, $67.91\%$; and $95.16\%$, $64.54\%$,
respectively) on original and scaled test samples, the models suffer large
performance deterioration, achieving only $23.67\%$, $26.00\%$ and $25.23\%$,
$27.79\%$ and $31.38\%$ and $38.84\%$ test acc. on rotated and sheared
samples, respectively. From the overall accuracy, the VeerCNN outperforms the
PolyPM by a slight margin ($69.43\%$ and $69.01\%$).

At 20% transformation ratio, the PolyMP improves model test acc. on rotated,
scaled and sheared samples rapidly, achieving 83.17% (+40.26%), 91.29%
(+11.26%) and 86.86% (+33.54%) respectively. In overall acc., the PolyMP
achieves 90.12% O.A. (+21.11%) and outperforms VeerCNN. In comparison, the
other models can not match with PolyMP and achieve comparable performances
from increasing data diversity of training set.

At 40% and 60% transformation ratio, we notice that the accuracy improvements
gained from increasing the ratio of geometric transformed samples in training
set have converged. In this case, the PolyMP maintains its leading
performances among models (91.91% and 93.06% O.A.), and VeerCNN (83.30% and
84.88% O.A.), deepset (80.12% and 81.49% O.A.), set transformer (80.33% and
81.94% O.A.) and GCAE (72.72% and 75.50% O.A.) fall behind.

At 80% transformation ratio, the PolyMP achieves the optimal test performances
at rotated and sheared samples, giving 90.35% and 91.52% test accuracy. This
empirical results suggest that compared to the sequence encoding of polygons
and CNN as well as the set representation and set-based learning models, the
graph representation together with message-passing neural network (i.e.,
PolyMP) are robust to the permutations of feed-in order of polygon vertices,
which occurs in geometric transmutations of polygons, in particular rotation
and shearing.

From a different perspective, the ratio of original samples is decreasing in
the training set progressively from the 0% to 80% transformation ratios
datasets. The PolyMP only encounters 1.46% test performance deterioration
along this progression (99.41% to 97.95% acc.), while the VeerCNN (-4.13%
acc.), deepset (-3.96% acc.), set transformer (-5.08% acc.) and GCAE (-5.58%
acc.) suffer larger performance drops on the test accuracy of original
samples.

Table 3: Test performances on Glyph dataset. Transformation ratios 0%, 20%, 40%, 60% and 80% refer to training datasets consisting of 0%, 20%, 40%, 60% and 80% geometric transformed samples. Glyph-O, Glyph-R, Glyph-SC and Glyph-SH Acc. indicate the classification accuracy of models tested on original, rotated, scaled and sheared data. Overall accuracy is reported as Glyph O.A.. Trans. Ratio | Model |  Glyph-O Acc. |  Glyph-R Acc. |  Glyph-SC Acc. |  Glyph-SH Acc. |  Glyph O.A.
---|---|---|---|---|---|---
0% |  VeerCNN | 97.64 | 41.51 | 79.15 | 59.07 | 69.43
DeepSet | 94.62 | 23.67 | 65.01 | 26.00 | 52.56
SetTransformer | 96.25 | 25.23 | 67.91 | 27.79 | 54.42
GCAE | 95.16 | 31.38 | 64.54 | 38.84 | 57.83
PolyMP | 99.41 | 42.91 | 80.03 | 53.32 | 69.01
20% |  VeerCNN | 95.12 | 67.63 | 83.53 | 77.78 | 81.05
DeepSet | 93.88 | 67.95 | 77.31 | 64.72 | 76.25
SetTransformer | 93.87 | 71.72 | 82.43 | 72.56 | 80.18
GCAE | 93.31 | 47.31 | 71.47 | 57.11 | 67.61
PolyMP | 98.92 | 83.17 | 91.29 | 86.86 | 90.12
40% |  VeerCNN | 94.75 | 73.26 | 84.77 | 80.29 | 83.30
DeepSet | 92.57 | 74.24 | 79.24 | 72.08 | 80.12
SetTransformer | 91.97 | 72.73 | 83.25 | 73.25 | 80.33
GCAE | 91.70 | 59.55 | 74.35 | 64.42 | 72.72
PolyMP | 98.48 | 87.06 | 92.49 | 89.25 | 91.91
60% |  VeerCNN | 94.50 | 77.16 | 85.38 | 82.36 | 84.88
DeepSet | 91.72 | 76.89 | 81.46 | 73.97 | 81.49
SetTransformer | 90.93 | 77.04 | 82.39 | 77.31 | 81.94
GCAE | 90.46 | 65.02 | 76.38 | 68.78 | 75.50
PolyMP | 98.30 | 89.40 | 93.43 | 91.11 | 93.06
80% |  VeerCNN | 93.51 | 78.97 | 85.25 | 83.17 | 85.25
DeepSet | 90.66 | 78.68 | 82.14 | 76.55 | 82.47
SetTransformer | 91.17 | 79.94 | 83.69 | 79.78 | 83.67
GCAE | 89.58 | 67.95 | 77.99 | 70.55 | 76.83
PolyMP | 97.95 | 90.35 | 93.30 | 91.52 | 93.42

In Table 4, the test performances of models trained and evaluated on the
simplified polygons of Glyph dataset are presented. In this experiment
setting, we focus on models’ test performances on simplified polygons
containing fewer numbers of vertices, and compare them with the test
performances showed in Table 3.

We observe similar test performance trends to those of models evaluated on the
simplified polygons. Noticeably, there is a significant performance
deterioration in VeerCNN compared with the test performances in Table 3 on
simplified polygons. Specifically, at 0% transformation ratio, the test
performances of VeerCNN drops from 69.43% O.A. (Table 3) to 66.56% O.A. (Table
4), i.e., a 2.87% performance deterioration. As the data diversity increases,
the performance deterioration in VeerCNN increases, too, from 5.2%,
progressively through to 5.56% O.A. deterioration respectively from 20% to 80%
transformation ratios.

The performance deterioration of VeerCNN strongly indicates that CNN models
are not robust to varying the numbers of vertices in polygons. This can be
attributed to a number of factors, incl. the data encoding of polygons in
VeerCNN as as fixed-length 1D sequences with zero padding. Simplifying
polygons and removing trivial vertices from polygons alters the length of 1D
sequences, and hence the geometric information of simplified polygons are not
only diluted by the zero padding in the 1D sequences, but also by alteration
of vertex adjacency explicitly encoded in the 1D sequence.

In comparison, we notice only small performance drops occur in general set-
based and graph-based learning models. We credit this to set and graph
representation of polygons and the corresponding learning models as both set
and graph-based models accept input polygons of varying lengths. In
particular, the graph-based message-passing network (i.e., PolyMP) learns
salient local node features from connected neighbours in the message-passing
function with permutation-invariant pooling operations (i.e., Max-pooling), as
shown in E.q. 4. A similar pooling operation is also adopted in set-based
learning models [9, 12].

Table 4: Test performances on Glyph dataset, consisting of simplified polygons generated by Douglas–Peucker algorithm (tolerant=1.0) with the removal of trivial vertices. Trans. Ratio | Model |  Glyph-O Acc. |  Glyph-R Acc. |  Glyph-SC Acc. |  Glyph-SH Acc. |  Glyph O.A.
---|---|---|---|---|---|---
0% |  VeerCNN | 94.72 | 39.65 | 75.42 | 56.12 | 66.56
DeepSet | 94.01 | 23.75 | 65.11 | 25.53 | 52.30
SetTransformer | 94.57 | 23.67 | 65.72 | 26.61 | 52.76
GCAE | 94.83 | 31.64 | 64.21 | 39.90 | 58.08
PolyMP | 98.89 | 43.71 | 79.15 | 52.70 | 68.63
20% |  VeerCNN | 90.55 | 62.58 | 77.80 | 72.31 | 75.85
DeepSet | 93.81 | 68.26 | 77.83 | 64.93 | 76.47
SetTransformer | 92.31 | 70.51 | 80.54 | 70.65 | 78.54
GCAE | 92.26 | 47.29 | 71.28 | 57.33 | 67.39
PolyMP | 97.61 | 82.45 | 88.42 | 84.84 | 88.22
40% |  VeerCNN | 89.63 | 67.82 | 78.72 | 74.61 | 77.73
DeepSet | 92.66 | 74.81 | 79.60 | 71.62 | 80.46
SetTransformer | 89.86 | 70.91 | 80.70 | 70.97 | 78.14
GCAE | 91.65 | 59.30 | 74.95 | 64.79 | 72.94
PolyMP | 97.55 | 86.14 | 89.99 | 87.29 | 90.21
60% |  VeerCNN | 89.29 | 71.91 | 79.42 | 77.29 | 79.50
DeepSet | 91.58 | 77.44 | 81.62 | 73.84 | 81.57
SetTransformer | 89.70 | 75.03 | 80.26 | 75.53 | 80.15
GCAE | 90.06 | 63.61 | 76.64 | 68.05 | 74.79
PolyMP | 97.35 | 88.73 | 91.04 | 89.31 | 91.47
80% |  VeerCNN | 88.05 | 73.89 | 79.55 | 77.17 | 79.69
DeepSet | 91.04 | 79.21 | 82.44 | 76.45 | 82.67
SetTransformer | 89.99 | 79.14 | 82.70 | 78.60 | 82.63
GCAE | 88.22 | 66.55 | 78.01 | 70.44 | 76.06
PolyMP | 97.01 | 90.19 | 91.53 | 90.31 | 92.22

###  4.2 Results on OSM Dataset

We fine-tune models pre-trained on the glyph 80% dataset with the OSM dataset,
and report the classification test accuracy of fine-tuned models in Table 5
for building footprints with original and normalised coordinates respectively.

PolyMP achieves optimal test performance on normalised footprints with
$91.92\%$ O.A. on the OSM dataset, and performs better than all other methods.
Both set-based methods (i.e., DeepSet: $95.71\%$ and SetTransformer:
$94.99\%$) and graph-based GCAE ($94.79\%$) achieve comparable performance on
OSM-O dataset with building footprints without geometric transformations.
Conversely, the convolutional VeerCNN shows lower performance of $90.54\%$.
When testing on OSM-R with randomly rotated and reflected footprints, PolyMP
maintains a robust performance of $85.62\%$ and the baseline methods suffer
performance deterioration at various levels (VeerCNN: $90.54\%\rightarrow
78.51\%$, DeepSet: $95.71\%\rightarrow 84.86\%$, SetTransformer:
$94.99\%\rightarrow 83.87\%$, GCAE: $94.79\%\rightarrow 80.19\%$).

Performances of models fine-tuned on OSM footprints with original spatial
coordinates drop for all models except for PolyMP, which maintains a
performance of $81.58\%$ O.A.. This robust performance of PolyMP against the
translation of spatial coordinates can be accounted for by the message-passing
network of PolyMP where the local geometric features of polygons are computed
(i.e., the relative positions of polygons $msg(x_{i},x_{j})=|x_{j}-x_{i}|$).
This relative positional features reduce the impact of absolute positioning
and effectively normalise the spatial coordinates of polygons while preserving
the geometric properties of polygons. VeerCNN outperforms DeepSet ($24.34\%$
O.A) and CGAE ($23.18\%$ O.A) and achieves a test performance of $42.68\%$
O.A. when fine-tuned on the original OSM footprints. We account for VeerCNN’s
performance by the built-in translation invariant priors in conventional
convolution neural networks. Similarly, SetTransformer shows comparable
performance as VeerCNN ($44.72\%$ O.A), which can be attributed to the self-
attention features based on the fully connected graph of point sets.

In Fig. 7, we visualise the classification results of PolyMP evaluated on
spatial building footprints in OSM-O (Fig. 7 (a)) and OSM-R (Fig. 7 (b)).
Predictions indicate that the fine-tuned PolyMP can robustly classify building
footprints on a map in varying sizes and geometric shapes based on the
geometric invariant features learnt by message-passing networks, taking the
graph-based representation of polygons as inputs.

Table 5: Fine-tune test performances on OSM dataset. OSM-O and OSM-R acc. suggest the the classification accuracy of models tested on original and rotated & reflected samples. Overall accuracy is reported for OSM O.A..  Model | OSM-O Acc. | OSM-R Acc. | OSM O.A. |
---|---|---|---|---
VeerCNN | 90.54 | 78.51 | 84.52 |  Normalised coordinates $\in(-1,1)$
DeepSet | 95.71 | 84.86 | 90.56
SetTransformer | 94.99 | 83.87 | 89.42
GCAE | 94.79 | 80.19 | 88.02
PolyMP | 98.04 | 85.62 | 91.92
VeerCNN | 42.35 | 43.01 | 42.68 |  Original coordinates
DeepSet | 24.12 | 24.08 | 24.34
SetTransformer | 44.67 | 44.77 | 44.72
GCAE | 23.44 | 23.04 | 23.18
PolyMP | 89.86 | 73.56 | 81.58

(a) OSM-O

(b) OSM-R

Figure 7: Shape classification of building footprints by PolyMP on the
selected region in OSM dataset (downtown areas of Shanghai, China [6]). Model
predictions are colored in red.

##  5 Discussion

(a) Glyph dataset.

(b) OSM dataset.

Figure 8: Failure cases of PolyMP on Glyph and OSM datasets.

(a) Sheared M glyph.

(b) Rotated M glyph.

(c) Scaled W glyph.

(d) Rotated W glyph.

(e) Sheared R glyph.

(f) Original Q glyph.

Figure 9: Feature maps to visualize salient features learned by individual
models to classify input geometries to output categories. The darker the
color, the more salient are the features learned. Feature values are
normalised $\in[0,1]$.

###  5.1 Model Expressivity

For the interpretation of model expressivity with respect to various polygon
encodings and learning models, we visualize the feature maps of models tested
on original and geometric transformed samples in glyph dataset in Figure 9.

Figs. 9a and 9b depict the salient feature maps and class predictions of four
models (Deepset, Set Transformer, GCAE and PolyMP) on geometric transformed
samples (sheared and rotated glyph M). In this case, the PolyMP correctly
predicts the class label of glyph $M$, whereas DeepSet, Set Transformer and
GCAE have made incorrect predictions on the geometric transformed samples. By
comparing the feature maps in Figures 9c and 9d, the PolyMP learns to identify
the global structures or the “skeleton” of polygons via non-trivial vertices
on the boundary. The message-passing network and local pooling function (i.e.,
max-pooling) can capture the salient vertices from local neighbours (i.e.,
non-trivial vertices (dark color) in the clusters of trivial vertices (light
color), which enable a robust embedding of polygons under geometric
transformations. Set-based models and GCAE learn sparser geometric features
for input polygons, capturing salient features regionally in node clusters and
ignoring geometric features of more distant nodes. This can be attributed to
the set representation where any relational information between nodes is
neglected.

Figures 9e and 9f demonstrate the feature maps on polygons with holes. Both
Deepset and Set Transformer only capture geometric features from non-trivial
vertices located at the exterior boundary of polygons. While set-based models
accept point set encoding of polygons in varying length and the output
features are invariant to the feed-in order of vertices, such methods largely
ignore the connectives and interactions between points. Such a learning
setting inherently hinders the model’s capability to learn geometric
information from polygons with holes. The graph convolution model, GCAE, lacks
learning flexibility in learning local geometric features as discussed in the
previous sections. On the other hand, PolyMP can capture geometric features
from salient points located at the exterior and interiors of polygons. In the
message-passing network, the exterior and interior of polygons are considered
to be two distinct elements as there is no direct connection between points
located at the two boundaries. In other words, the geometric features (i.e.,
the “message”) are only passed between points that are connected in a
connected component of a graph, in this case defined by the linear rings of
polygon boundaries.

###  5.2 Limitations

Of course, PolyMP still encounters limitations in terms of misclassification.
Fig. 8. demonstrates failures of PolyMP classifications on the Glyph and OSM
datasets. On synthetic data, misclassifications occur predominantly on samples
where excessive geometric transformations (e.g., heavy shearing and
anisotropic scaling) destroy the gestalt of the shape to the extent it is no
longer label preserving (Fig. 8(a): letter V, Z and R). A special case are
shapes with different labels dependent on orientation – M and W, where
depending on the extent of rotation and shearing, misclassifications occur.
For instance in row two of Fig. 8(a), we observe that rotated letters W can be
misclassified into letter M, or even Z; heavily sheared W can be misclassified
as H and V. Similarly for building polygons (OSM), PolyMP may misclassify
polygons sharing similar geometric shapes (E, vs L or U) (Fig. 8).

Considering the characteristics of the two datasets (Sec. 3.1), PolyMP trained
Glyph dataset learns locally salient geometric features via message-passing
layers from serif glyphs, which contain salient decorative strokes ending.
Letters sharing similar geometric shapes are misclassified when the geometric
shapes of classified polygons are destroyed by excessive geometric
transformations.

##  6 Conclusion

Based on extensive empirical evidence given by the analysis of invariances to
geometric transformations, trivial vertices and model generalizability, we
demonstrate that discrete, non-grid like data representations in combination
with graph-based message-passing neural networks (PolyMP) are optimal for deep
learning models on 2D vector geometries. We demonstrate a robust ability to
learn shapes of polygonal geometries, and demonstrate the ability to
generalize to a real-world building footprint dataset.

We find that a learning model based on graph data representation that
explicitly encodes both node and explicit edge structures leads to a robust
approach enabling highly accurate feature learning on geometric shapes –
conveniently, these structures are readily available from the 2D simple
feature representations of geometries implemented in current GIS libraries.
Our results indicate that representations play an important part providing a
strong inference bias for geometric shape learning, and tasks such as the
classification of polygons and boosting model performance. We believe that our
approach to learning geometric-invariant features of polygons is not limited
to simple geometric shape classification. This approach can benefit suitable
geospatial tasks where the geometric-invariant features of polygons matches
the learning objectives (i.e., geospatial regression tasks involving spatial
relation predictions of polygon map [8]).

We also discuss the limitations of PolyMP through misclassification examples
on datasets. Through the failure cases of classification, we observe that the
message-passing network for graph data representation of polygons has limited
capability of transferring locally salient geometric features from one domain
to another. The simple message-passing network has limited control on
learning/not learning geometric invariant features as need.

The geometric invariant feature learning of vector geometries is currently an
area of intense investigation in spatial deep learning [2, 1, 6, 35, 8].
Unlike in learning based on raster datasets or point clouds, the segmentation
problem is partially solved by the explicit encoding of structured vector
geometries. Here, we show results that allow us to undertake the
classification of spatial geometric shapes efficiently, based on decisions
that can be grounded in theory and are experimentally validated. In future
work, we will further examine how richer graph encoding of the structure of
geometries, as well as of the relationships between proximal geometries could
further boost model performance, or enable the segmentation of complex spatial
object arrangements.

## Statements and Declarations

Data availability. The data and codes that support the findings of this study
are available with the identifier(s) at the private link:
https://figshare.com/s/b781d7724d3220e24c7c.

Conflicts of interest. This paper has been approved by all co-authors. The
authors have no competing interests to declare that are relevant to the
content of this article.

## References

  *   * Yan et al. [2019] Yan, X., Ai, T., Yang, M., Yin, H.: A graph convolutional neural network for classification of building patterns using spatial vector data. ISPRS journal of photogrammetry and remote sensing 150, 259–273 (2019)
  * Veer et al. [2018] Veer, R.v., Bloem, P., Folmer, E.: Deep learning for classification tasks on geospatial vector polygons. arXiv preprint arXiv:1806.03857 (2018)
  * Andrášik and Bíl [2016] Andrášik, R., Bíl, M.: Efficient road geometry identification from digital vector data. Journal of Geographical Systems 18(3), 249–264 (2016)
  * Lehar [2003a] Lehar, S.: The World in Your Head: A Gestalt View of the Mechanism of Conscious Experience. Lawrence Erlbaum, Mahwah, N.J. (2003)
  * Lehar [2003b] Lehar, S.: Gestalt isomorphism and the primacy of subjective conscious experience: A gestalt bubble model. Behavioral and Brain Sciences 26(4), 375–408 (2003)
  * Yan et al. [2021] Yan, X., Ai, T., Yang, M., Tong, X.: Graph convolutional autoencoder model for the shape coding and cognition of buildings in maps. International Journal of Geographical Information Science 35(3), 490–512 (2021)
  * Yan et al. [2022] Yan, X., Ai, T., Yang, M., Tong, X., Liu, Q.: A graph deep learning approach for urban building grouping. Geocarto International 37(10), 2944–2966 (2022)
  * Mai et al. [2022] Mai, G., Jiang, C., Sun, W., Zhu, R., Xuan, Y., Cai, L., Janowicz, K., Ermon, S., Lao, N.: Towards general-purpose representation learning of polygonal geometries. GeoInformatica, 1–52 (2022)
  * Zaheer et al. [2017] Zaheer, M., Kottur, S., Ravanbakhsh, S., Poczos, B., Salakhutdinov, R.R., Smola, A.J.: Deep sets. Advances in neural information processing systems 30 (2017)
  * Qi et al. [2017a] Qi, C.R., Su, H., Mo, K., Guibas, L.J.: Pointnet: Deep learning on point sets for 3d classification and segmentation. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 652–660 (2017)
  * Qi et al. [2017b] Qi, C.R., Yi, L., Su, H., Guibas, L.J.: Pointnet++: Deep hierarchical feature learning on point sets in a metric space. Advances in neural information processing systems 30 (2017)
  * Lee et al. [2019] Lee, J., Lee, Y., Kim, J., Kosiorek, A., Choi, S., Teh, Y.W.: Set transformer: A framework for attention-based permutation-invariant neural networks. In: International Conference on Machine Learning, pp. 3744–3753 (2019). PMLR
  * Bronstein et al. [2021] Bronstein, M.M., Bruna, J., Cohen, T., Veličković, P.: Geometric deep learning: Grids, groups, graphs, geodesics, and gauges. arXiv preprint arXiv:2104.13478 (2021)
  * He et al. [2018] He, X., Zhang, X., Xin, Q.: Recognition of building group patterns in topographic maps based on graph partitioning and random forest. ISPRS Journal of Photogrammetry and Remote Sensing 136, 26–40 (2018)
  * Bei et al. [2019] Bei, W., Guo, M., Huang, Y.: A spatial adaptive algorithm framework for building pattern recognition using graph convolutional networks. Sensors 19(24), 5518 (2019)
  * Kipf and Welling [2017] Kipf, T.N., Welling, M.: Semi-supervised classification with graph convolutional networks. In: International Conference on Learning Representations (ICLR) (2017)
  * Gilmer et al. [2017] Gilmer, J., Schoenholz, S.S., Riley, P.F., Vinyals, O., Dahl, G.E.: Neural message passing for quantum chemistry. In: International Conference on Machine Learning, pp. 1263–1272 (2017). PMLR
  * He et al. [2016] He, K., Zhang, X., Ren, S., Sun, J.: Deep residual learning for image recognition. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778 (2016)
  * Wu et al. [2016] Wu, Q., Diao, W., Dou, F., Sun, X., Zheng, X., Fu, K., Zhao, F.: Shape-based object extraction in high-resolution remote-sensing images using deep boltzmann machine. International Journal of Remote Sensing 37(24), 6012–6022 (2016)
  * Microsoft [2018] Microsoft: Microsoft/USBUILDINGFOOTPRINTS: Computer generated building footprints for the United States (2018). https://github.com/microsoft/USBuildingFootprints
  * Lin et al. [2017] Lin, G., Milan, A., Shen, C., Reid, I.: Refinenet: Multi-path refinement networks for high-resolution semantic segmentation. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1925–1934 (2017)
  * Xu et al. [2017] Xu, Y., Chen, Z., Xie, Z., Wu, L.: Quality assessment of building footprint data using a deep autoencoder network. International Journal of Geographical Information Science 31(10), 1929–1951 (2017)
  * OpenStreetMap contributors [2017] OpenStreetMap contributors: Planet dump retrieved from https://planet.osm.org . https://www.openstreetmap.org (2017)
  * Lopes et al. [2019] Lopes, R.G., Ha, D., Eck, D., Shlens, J.: A learned representation for scalable vector graphics. In: Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 7930–7939 (2019)
  * Mino and Spanakis [2018] Mino, A., Spanakis, G.: Logan: Generating logos with a generative adversarial neural network conditioned on color. In: 2018 17th IEEE International Conference on Machine Learning and Applications (ICMLA), pp. 965–970 (2018). IEEE
  * Sage et al. [2018] Sage, A., Agustsson, E., Timofte, R., Van Gool, L.: Logo synthesis and manipulation with clustered generative adversarial networks. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5879–5888 (2018)
  * Radford et al. [2016] Radford, A., Metz, L., Chintala, S.: Unsupervised representation learning with deep convolutional generative adversarial networks. In: Bengio, Y., LeCun, Y. (eds.) 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings (2016). http://arxiv.org/abs/1511.06434
  * Odena et al. [2017] Odena, A., Olah, C., Shlens, J.: Conditional image synthesis with auxiliary classifier gans. In: International Conference on Machine Learning, pp. 2642–2651 (2017). PMLR
  * Ha and Eck [2018] Ha, D., Eck, D.: A neural representation of sketch drawings. In: International Conference on Learning Representations (2018)
  * Carlier et al. [2020] Carlier, A., Danelljan, M., Alahi, A., Timofte, R.: Deepsvg: A hierarchical generative network for vector graphics animation. Advances in Neural Information Processing Systems 33, 16351–16361 (2020)
  * Vaswani et al. [2017] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A.N., Kaiser, Ł., Polosukhin, I.: Attention is all you need. Advances in neural information processing systems 30 (2017)
  * Bruna et al. [2014] Bruna, J., Zaremba, W., Szlam, A., LeCun, Y.: Spectral networks and locally connected networks on graphs. In: ICLR (2014)
  * Defferrard et al. [2016] Defferrard, M., Bresson, X., Vandergheynst, P.: Convolutional neural networks on graphs with fast localized spectral filtering. Advances in neural information processing systems 29 (2016)
  * Velickovic et al. [2017] Velickovic, P., Cucurull, G., Casanova, A., Romero, A., Lio, P., Bengio, Y., et al.: Graph attention networks. stat 1050(20), 10–48550 (2017)
  * Liu et al. [2021] Liu, C., Hu, Y., Li, Z., Xu, J., Han, Z., Guo, J.: Triangleconv: A deep point convolutional network for recognizing building shapes in map space. ISPRS International Journal of Geo-Information 10(10), 687 (2021)
  * Wang et al. [2019] Wang, Y., Sun, Y., Liu, Z., Sarma, S.E., Bronstein, M.M., Solomon, J.M.: Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog) 38(5), 1–12 (2019)
  * Tailor et al. [2021] Tailor, S.A., Jong, R., Azevedo, T., Mattina, M., Maji, P.: Towards efficient point cloud graph neural networks through architectural simplification. In: Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 2095–2104 (2021)
  * OpenGeospatialConsortium [2003] OpenGeospatialConsortium: OpenGIS Simple Features Specification For SQL. OpenGeospatialConsortium (2003). http://www.opengis.org/
  * Battaglia et al. [2018] Battaglia, P.W., Hamrick, J.B., Bapst, V., Sanchez-Gonzalez, A., Zambaldi, V., Malinowski, M., Tacchetti, A., Raposo, D., Santoro, A., Faulkner, R., et al.: Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261 (2018)
  * Google [2010] Google Google (2010). https://fonts.google.com/
  * Duckham et al. [2008] Duckham, M., Kulik, L., Worboys, M., Galton, A.: Efficient generation of simple polygons for characterizing the shape of a set of points in the plane. Pattern recognition 41(10), 3224–3236 (2008)
  * Yan et al. [2017] Yan, X., Ai, T., Zhang, X.: Template matching and simplification method for building features based on shape cognition. ISPRS International Journal of Geo-Information 6(8), 250 (2017)
  * Douglas and Peucker [1973] Douglas, D.H., Peucker, T.K.: Algorithms for the reduction of the number of points required to represent a digitized line or its caricature. Cartographica: the international journal for geographic information and geovisualization 10(2), 112–122 (1973)
  * Zhang and Sabuncu [2018] Zhang, Z., Sabuncu, M.: Generalized cross entropy loss for training deep neural networks with noisy labels. Advances in neural information processing systems 31 (2018)
  * Kingma and Ba [2015] Kingma, D.P., Ba, J.: Adam: A method for stochastic optimization. In: ICLR (Poster) (2015)