# DeltaConv: Anisotropic Point Cloud Learning with Exterior Calculus

Ruben Wiersma Delft University of Technology Ahmad Nasikun Delft University of
Technology Universitas Gadjah Mada  Elmar Eisemann Delft University of
Technology Klaus Hildebrandt Delft University of Technology

###### Abstract

Learning from 3D point-cloud data has rapidly gained momentum, motivated by
the success of deep learning on images and the increased availability of 3D
data. In this paper, we aim to construct anisotropic convolutions that work
directly on the surface derived from a point cloud. This is challenging
because of the lack of a global coordinate system for tangential directions on
surfaces. We introduce a new convolution operator called DeltaConv, which
combines geometric operators from exterior calculus to enable the construction
of anisotropic filters on point clouds. Because these operators are defined on
scalar- and vector-fields, we separate the network into a scalar- and a
vector-stream, which are connected by the operators. The vector stream enables
the network to explicitly represent, evaluate, and process directional
information. Our convolutions are robust and simple to implement and show
improved accuracy compared to state-of-the-art approaches on several
benchmarks, while also speeding up training and inference.

##  1 Introduction

The success of convolutional neural networks (CNNs) on images and the
increasing availability of point-cloud data motivate generalizing CNNs from
images to 3D point clouds [27, 45, 6]. A promising way to achieve this, is to
design convolutions that operate directly on the surface: a non-linear
manifold without a regular grid. Such intrinsic convolutions reduce the kernel
space to tangent spaces, which are 2D on surfaces. This means the convolutions
can be more efficient and the search space for kernels is reduced; they
naturally ignore empty space; and they are robust to rigid- and non-rigid
deformations [3]. Examples of intrinsic convolutions are GCN [35], PointNet++
[60], and EdgeConv [73].

Figure 1: Images have a global coordinate system (left), which makes it
possible to align convolution kernels. Point clouds do not (right),
complicating the design of anisotropic convolutions.

Our focus is on constructing anisotropic intrinsic convolutions, convolutions
that are direction-dependent. This is difficult because of the fundamental
challenge that non-linear manifolds lack a global coordinate system. In
differential geometry, this problem is often approached by designing operators
which are coordinate-free. We will build on this knowledge to improve learning
on point clouds. As an illustration of the problem, consider a CNN on images
(fig. 1, left). Because an image has a globally consistent up-direction, the
network can build anisotropic filters that activate the same way across the
image. For example, one filter can test for vertical edges and the other for
horizontal edges. No matter where the edges are in the image, the filter
response is consistent. In subsequent layers, the output of these filters can
be combined, e.g., to find a corner. Because we do not have a global
coordinate system on surfaces (fig. 1, right), one cannot build and use
anisotropic filters in the same way as on images. This limits current
intrinsic convolutions on point clouds. For example, GCNs [35] filters are
isotropic. PointNet++ [60] uses maximum aggregation and adds relative point
positions, but still applies the same weight matrix to each neighboring point.

We introduce a new way to construct intrinsic anisotropic convolutions on
point clouds. Our convolutions are described in terms of geometric operators
instead of kernels. The operator-based perspective is familiar from GCN [35],
which uses a combinatorial Laplacian on graphs. We allow the network to
combine elemental geometric operators from exterior calculus, more
specifically the de Rham complex: the gradient, co-gradient, divergence, curl,
Laplacian, and Hodge-Laplacian. These operators are defined on scalar fields
and tangential vector fields. Hence, our networks are split in two streams:
one stream contains scalars and the other tangential vectors. The operators
map along and between the two streams (fig. 2). The vector stream encodes
feature activations and directions along the surface, allowing the network to
test and relate directions in subsequent layers. Depending on the task, the
network outputs scalars or vectors. We name our convolutions DeltaConv after
the symbol for the derivative in exterior calculus.

To get an idea of the benefit of these operators, consider the anisotropic
filters proposed by Perona and Malik [56]. The Perona-Malik filter achieves
anisotropic diffusion by combining the gradient, a scaling factor, a non-
linearity, and divergence. Our convolutions have access to all these building
blocks and can thus construct anisotropic filters. Additional benefits of our
approach are the following: by maintaining a stream of vector features
throughout the network, our convolutions can relate directional information
between different points on the surface. Together with the increased
expressiveness of convolutions due to anisotropy, this results in increased
accuracy over isotropic convolutions, as well as state-of-the-art approaches,
as we show in our experiments. Also, each operator is implemented as a sparse
matrix and the combinations of operators are computed per-point, which is
simple and efficient.

Other convolutions on point clouds support anisotropy in the following ways:
Many works extend 2D convolutions to 3D convolutions, instead of building
intrinsic filters. Recent examples of 3D Euclidean convolutions are SSCNs
[26], MinkowskiNets [10], and KPConv [69]. These approaches construct kernels
in three dimensions by learning weights for kernel points on a (pseudo-)grid
and only apply these kernels to points from the point cloud. We go into an
orthogonal direction by building intrinsic convolutions, which operate in
fewer dimensions and naturally generalize to (non-)rigidly deformed shapes.
Another promising solution is to map special 2D kernels to the surface using
charts (local coordinate systems) [24, 12, 16, 75, 76, 57, 52]. By
constraining kernels to a family of rotation- or gauge-equivariant functions,
these networks can relate the output of convolutions at different points by a
rotation or gauge-transformation. We use geometric operators instead of
applying kernels in charts. These operators were designed for non-linear
manifolds and can be applied without additional constructions. This results in
a simple design with many connections to modern theory and machinery in
differential geometry. To the best of our knowledge, the charting-based
approaches have not yet been tested on point clouds.

In our experiments, we demonstrate that a simple architecture with only a few
DeltaConv blocks can match and outperform state-of-the-art results using more
complex architectures. We achieve 93.8% accuracy on ModelNet40, 84.7% on the
most difficult variant of ScanObjectNN, 86.9 mIoU on ShapeNet, and 99.6% on
SHREC11, a dataset of non-rigidly deformed shapes. Our ablation studies show
that adding the vector stream can decrease the error by up to 25% (from 90.4%
to 92.8%) on ModelNet40 and up to 21% for ShapeNet (from 81.1 to 85.1 mIoU),
while speeding up inference by $1.5-2\times$ and the backward pass by
$2.5-30\times$.

Summarizing our main contributions:

  * •

We introduce a new approach for learning from surfaces that explicitly
supports the construction of anisotropic filters and the evaluation and
processing of tangential information. This is achieved by adding a stream of
vector features to the usual stream of scalar features and using discrete
differential operators to communicate in and between the streams.

  * •

We propose a network architecture that realizes our approach using a selected
set of operators from exterior calculus. We also adapt the operators to work
effectively in our networks.

  * •

We implement and evaluate the network for point clouds and propose techniques
to cope with undersampled regions, noise, and missing information prevalent in
point cloud learning.

##  2 Related work

We focus our discussion of related work on the most relevant topics. Please
refer to surveys on geometric deep learning [6] and point cloud learning [27,
45] for a more comprehensive overview of this expanding field.

#### Point cloud networks and anisotropy

A common approach for learning on point-cloud data is to learn features for
each point using a multi-layer perceptron (MLP), followed by local or global
aggregation. Many methods also learn features on local point-pairs before
maximum aggregation. The same MLP is used for each neighbor. Well known
examples are PointNet and its successor PointNet++ [59, 60]. Several follow-up
works improve on speed and accuracy, for example by adding more combinations
of point-pair features [89, 67, 84, 39, 48, 61, 82, 50]. Some of these point-
wise MLPs explicitly encode anisotropy by splitting up the MLP for each 3D
axis [38, 48]. Concepts from transformers have also made their way to point
clouds [90, 86]. These networks learn attention for neighboring points based
on their features. This differs from our approach, as we use spatial
information to influence how neighboring features are aggregated. Nonetheless,
our approach does not exclude the use of attention in the scalar- or vector
stream.

Pseudo-grid convolutions are a more direct translation of image convolutions
to point clouds. Many of these are defined in 3D and thus support anisotropy
in 3D coordinates. Several works learn a continuous kernel and apply it to
local point-cloud regions [47, 4, 46, 69, 78, 29, 1, 23, 81]. Others learn
discrete kernels and map points in local regions to a discrete grid [31, 40,
41, 10, 26]. A group of works studies rotational equivariance in 3D space,
aiming to design networks invariant to rigid point-cloud transformation [19,
70, 11, 58].

Finally, graph-based approaches create a k-nearest neighbor- or radius-graph
from the input set and apply graph convolutions [65, 73, 87, 44, 64, 17, 9,
68, 21, 72, 88, 54]. DGCNN [73] introduces the EdgeConv operator and a dynamic
graph component, which reconnects the k-nearest neighbor graph inside the
network. EdgeConv computes the maximum over feature differences, which allows
the network to represent directions in its channels. Channel-wise directions
can resemble spatial directions if spatial coordinates are provided as input,
which is only the case in the first layer for DGCNN. In contrast, our
convolutions support anisotropy directly in the operator.

#### Two-stream architectures

Architectures with two streams and vector-valued features are also used in
rotation-equivariant approaches for images [77] and surface meshes [16, 76,
12, 57]. These networks constrain kernels to output complex-valued and
rotation- or gauge-equivariant features, which are separated into orders of
equivariance. Instead of equivariant kernels, we work with geometric
operators. These are independent of the choice of coordinate systems by
design. Furthermore, these approaches apply their kernel in local charts,
where geometric operators work directly on the surface. To the best our
knowledge, we are the first to implement and evaluate a two-stream
architecture on point clouds.

#### Geometric operators

Multiple authors use geometric operators to construct convolutions. The graph-
Laplacian is used in GCN [35]. Spectral networks for learning on graphs are
based on the eigenpairs of the graph-Laplacian [7]. Surface networks for
triangle meshes [36] interleave the Laplacian with the extrinsic Dirac
operator. Parametrized Differential Operators (PDOs) [34] use the gradient and
divergence operators to learn from spherical signals on unstructured grids.
Recently, DiffGCN [18] uses finite difference schemes of the gradient and
divergence operators for the construction of graph networks. DiffusionNet [63]
uses the Laplace–Beltrami operator to learn to diffuse signals on the surface.
Alongside learned diffusion, DiffusionNet uses the gradient in combination
with a scalar product to compute directional features. An approach adjacent to
these networks is HodgeNet [66], which learns to build operators using the
structure of differential operators. Our approach extends the available
operators to be used in the network and maintains a stream of vector-valued
features, so that directional information can be processed in deeper layers of
the network. Outside of deep learning, differential operators are widely
applied for the analysis of 3D shapes [13, 15].

##  3 Method

We construct anisotropic convolutions by learning combinations of elemental
operators from exterior calculus. Because these operators are defined on
scalar- and vector-fields, we split our network into scalar and vector
features. In this section, we describe these two streams, the operators and
how they are discretized, and how combinations of the operators are learned. A
schematic overview of our convolutions can be found in Figure 2.

#### Streams

Consider a point cloud $\mathbf{P}\in\mathbb{R}^{N\times 3}$ with $N$ points
arranged in an $N\times 3$ matrix. Each point can be associated with $C$
additional features $\mathbf{X}\in\mathbb{R}^{N\times C}$. Inside the network,
we refer to the features in layer $l$ at point $i$ as
$\mathbf{x}_{i}^{(l)}\in\mathbb{R}^{C_{l}}$. All of these features constitute
the scalar stream.

The vector stream runs alongside the scalar stream. Each feature in the vector
stream is a tangent vector, encoded by coefficients for an orthonormal basis
in the tangent plane:
$\mathbf{v}_{i}=\alpha_{i}^{u}\mathbf{e}_{i}^{u}+\alpha_{i}^{v}\mathbf{e}_{i}^{v}$,
where $\mathbf{e}_{i}^{u},\mathbf{e}_{i}^{v}$ are two basis vectors at point
$p_{i}$, and $\alpha_{i}^{u},\alpha_{i}^{v}$ are the vector coefficients. The
basis vectors can be any set of vectors orthonormal to the normal and each
other and are used to build the operators. The coefficients are interleaved
for each point, forming the tensor of features
$\mathbf{V}^{(l)}\in\mathbb{R}^{2N\times C_{l}}$. One channel in
$\mathbf{V}^{(l)}$ is a column of coefficients:
$[\alpha_{1}^{u},\alpha_{1}^{v},\ldots,\alpha_{i}^{u},\alpha_{i}^{v},\ldots,\alpha_{N}^{u},\alpha_{N}^{v}]^{\intercal}$.
The input for the vector stream is a vector field defined at each point. In
our experiments, we use the gradients of the input to the scalar stream. We
will refer to the continuous counterparts of $\mathbf{X}$ and $\mathbf{V}$ as
$X$ and $V$, respectively.

Figure 2: Schematic of DeltaConv.

###  3.1 Scalar to scalar: maximum aggregation

A simplified version of point-based MLPs is applied inside the scalar stream,
building on PointNet++ [60] and EdgeConv [73]. We apply an MLP per point and
then perform maximum aggregation over a $k$-nn neighborhood. The features in
the scalar stream are computed as

$\mathbf{x}^{(l+1)}_{i}=h_{\mathbf{\Theta_{0}}}(\mathbf{x}^{(l)}_{i})+\max_{j\in\mathcal{N}(i)}h_{\mathbf{\Theta_{1}}}(\mathbf{x}^{(l)}_{j}),$
(1)

where $h_{\mathbf{\Theta}}$ is a multi-layer perceptron (MLP), consisting of
fully connected layers, batch normalization [33], and non-linearities. If
point positions are used as input, they are centralized before maximum
aggregation: $\mathbf{p}_{j}-\mathbf{p}_{i}$.

Comparing our convolutions to EdgeConv and PointNet++, the biggest difference
is that we do not use point-pair or edge-based features inside the network.
Spatial information is provided by the other operators in DeltaConv. The
benefit of this change is that the aggregation step is $k$ times lighter on
the forward and backward pass.

###  3.2 Scalar to vector: Gradient

The gradient and co-gradient connect the scalar stream to the vector stream.
The gradient represents the largest rate of change and the direction of that
change as vectors at each point, which can be used to characterize
(dis)continuities. The co-gradient is a 90-degree rotation of the gradient.
Combined, the gradient and co-gradient span the tangent plane, allowing the
network to scale, skew, and rotate the vector features.

We construct a discrete gradient using a moving least-squares approach on
neighborhoods with $k$ neighbors. This approach is used in modeling and
processing for point clouds and solving differential equations on point clouds
[43]. The gradient operator is represented as a sparse matrix
$\mathbf{G}\in\mathbb{R}^{2N\times N}$. It takes $N$ values representing
features on the points and outputs $2N$ values representing the gradient
expressed in coefficients of the tangent basis of each point. The matrix is
highly sparse as it only has $2k$ elements in each row. The co-gradient
$\mathbf{JG}$ is a composition of the gradient with a block-diagonal sparse
matrix $\mathbf{J}\in\mathbb{R}^{2N\times 2N}$, where each block in
$\mathbf{J}$ is a $2\times 2$ 90-degree rotation matrix.

Figure 3: Gradient of the x-coordinate on a chair without regularization
(left) and with regularization (right).

Point clouds typically contain undersampled regions and noise. This can be
problematic for the moving least-squares procedure. Consider the example in
Figure 3, a chair with thin legs. Only few points lie along the line
constituting the legs of the chair. Hence, the perpendicular direction to the
line is undersampled, resulting in a volatile least-squares fit: a minor
perturbation of one of the points can heavily influence the outcome (left,
circled area). We add a regularization term scaled by $\lambda$ to the least-
squares fitting procedure, which seeks to mitigate this effect (right). This
is a known technique referred to as ridge regression or Tikhonov
regularization. The full procedure and accompanying theory is outlined in the
supplemental material.

We also argue that the gradient operator should be normalized, motivated by
how information is fused in the network. If $\mathbf{G}$ exhibits diverging or
converging behavior, features resulting from $\mathbf{G}$ will also diverge or
converge. This is undesirable when the gradient is applied multiple times in
the network. Features arising from the gradient operation would then have a
different order of magnitude which need to be accounted for by the network
weights. Therefore, we normalize $\mathbf{G}$ by the $\ell_{\infty}$-operator
norm, which provides an upper bound on the scaling behavior of an operator

$\mathbf{\hat{G}}=\mathbf{G}/|\mathbf{G}|_{\infty},\,\quad\text{where}\,\,|\mathbf{G}|_{\infty}=\max_{i}\sum_{j}|\mathbf{G}_{ij}|.$
(2)

###  3.3 Vector to scalar: Divergence, Curl, and Norm

The vector stream connects back to the scalar stream with divergence, curl,
and norm. These operators are commonly used to analyze vector fields and
indicate features such as sinks, sources, vortices, and the strength of the
vector field. The network can use them as building blocks for anisotropic
operators.

The discrete divergence is also constructed with a moving least-squares
approach, which is described in the supplement. Divergence is represented as a
sparse matrix $\mathbf{D}\in\mathbb{R}^{N\times 2N}$, with $2kN$ elements.
Curl is derived as $-\mathbf{DJ}$.

###  3.4 Vector to vector: Hodge Laplacian

Vector features are diffused in the vector stream using a combination of the
identity $\mathbf{I}$ and the Hodge Laplacian $\bm{\Delta}$ of $V$. Applying
the Hodge Laplacian to a vector field $V$ results in another vector field
encoding the difference between the vector at each point and its neighbors.
The Hodge Laplacian can be formulated as a combination of grad, div, curl and
$\mathcal{J}$ [5]

$\bm{\Delta}=-(\text{grad\,}\text{div\,}V+\mathcal{J}\text{\,grad\,}\text{curl\,}).$
(3)

In the discrete setting, we replace each operator with its discrete variant

$\mathbf{L}=-(\mathbf{GD}-\mathbf{JGDJ}).$ (4)

###  3.5 Fusing streams

Each of the operations either outputs scalar-valued or vector-valued features.
We concatenate all the features belonging to each stream and then combine
these features with parametrized functions

$\displaystyle\mathbf{x}_{i}^{\prime}$
$\displaystyle=h_{\mathbf{\Theta_{0}}}(\mathbf{x}_{i},(\mathbf{DV})_{i}\,,(-\mathbf{DJV})_{i}\,,\|\mathbf{v}_{i}\|)+\max_{j\in\mathcal{N}_{i}}\,h_{\mathbf{\Theta_{1}}}(\mathbf{x}_{j})$
$\displaystyle\mathbf{v}_{i}^{\prime}$
$\displaystyle=h^{\mathcal{J}}_{\mathbf{\Theta_{2}}}(\mathbf{v}_{i},\,(\mathbf{GX^{\prime}})_{i}\,,(\mathbf{LV})_{i}).$
(5)

We use the prime to indicate features in layer $l+1$. All other features are
from layer $l$. $h_{\mathbf{\Theta}}$ denotes an MLP.
$h_{\mathbf{\Theta}}^{\mathcal{J}}$ denotes an MLP used for vectors, which
first concatenates the 90-degree rotated vectors to the input features and
then applies a regular MLP. This allows the MLP to rotate, scale, and combine
vector features and enriches the set of operators. For example, the rotated
gradient is the co-gradient. The vector-MLP can learn to combine information
from local neighborhoods (through the gradient and Hodge–Laplacian), as well
as information from different channels (through the identity). Non-linearities
are applied to the vectors’ norms, as these are invariant to the choice of
basis vectors. Other options for vector non-linearities are explored in [74,
16].

###  3.6 Properties of our networks

The proposed structure allows DeltaConv to represent, evaluate, and process
directional information. For example, it can use gradients to detect edges and
their direction and use the vector stream to represent and further evaluate
them. Deeper layers can evaluate patterns formed by these edges both in local
neighborhoods using divergence, curl, and Hodge–Laplace, as well as between
channels at each point, using the vector MLPs.

To represent the vector features and the operators acting on the vector
features, we need to choose a basis in every tangent space. Still, the network
is independent of the choice of tangent basis, as the same vectors are
obtained for any choice of basis. Only their representation changes. DeltaConv
inherits this property from the differential operators that it uses. For the
applications we consider, the last layer of the network always consists of
scalar features. Therefore the bases are only used internally. This means that
a network with DeltaConv is able to learn from directional information, while
being agnostic to the choice of basis vectors in tangent spaces. This is an
alternative to building reference frame fields to compare results of filters
along a surface [3, 53, 32], as well as to methods relying on equivariant
filters to achieve such independence [16, 76].

##  4 Experiments

We validate our approach by comparing DeltaConv to state-of-the-art approaches
for classification and segmentation on data originating from real-world scans
as well as sampled CAD models. In addition, we perform ablation studies to
discern the effect of different connections in the network structure. We also
study the effect of our proposed method on timing and parameter counts and
verify our choice to regularize and normalize the gradient matrix.

###  4.1 Implementation details

The architectures used in these experiments are based on DGCNN [73]. We
replace each EdgeConv block with a DeltaConv block (fig. 2). We do not use the
dynamic graph component, which means the networks operate at a single scale on
local neighborhoods. This rather simple network setup facilitates the
evaluation of the effect of the convolution operators on the performance of
the network. We would like to stress this point, as many previous works
introduce additional architecture changes, like squeeze-excitation blocks,
skip attention, and U-Net architectures. Despite our simple network setup,
DeltaConv achieves state-of-the-art results. To show what architectural
optimizations mean for DeltaConv, we also test the U-ResNet architecture used
in KPFCNN [69] but with the convolution blocks in the encoder replaced by
DeltaConv blocks. In the downsampling blocks used by these networks, we pool
vector features by averaging them with parallel transport [76]. More details
are provided in the supplemental material. Code will be available upon
publication of this paper.

_Data transforms._ A $k$-nn graph is computed for every shape. This graph is
used for maximum aggregation in the scalar stream. It is reused to estimate
normals when necessary and to construct the gradient. For each experiment, we
use xyz-coordinates as input to the network and augment them with a random
scale and translation, similar to previous works. Some datasets require
specific augmentations, which are detailed in their respective sections.

_Training._ The parameters in the networks are optimized with stochastic
gradient descent (SGD) with an initial learning rate of $0.1$, momentum of
$0.9$ and weight decay of $0.0001$. The learning rate is updated using a
cosine annealing scheduler [49], which decreases the learning rate to $0.001$.

###  4.2 Classification

For classification, we study ModelNet40 [79], ScanObjectNN [71], and SHREC11
[42]. With these experiments, we aim to demonstrate that our networks can
achieve state-of-the-art performance on a wide range of challenges: point
clouds sampled from CAD models, real-world scans, and non-rigid, deformable
objects.

Table 1: Classification results on ModelNet40.

| Mean | Overall
---|---|---
| Class Accuracy | Accuracy
PointNet++ [60] | - | 90.7
PointCNN [41] | 88.1 | 92.2
DGCNN [73] | 90.2 | 92.9
KPConv deform [69] | - | 92.7
KPConv rigid [69] | - | 92.9
DensePoint [46] | - | 93.2
RS-CNN [47] | - | 93.6
GBNet [62] | 91.0 | 93.8
PointTransformer [90] | 90.6 | 93.7
PAConv [81] | - | 93.6
Simpleview [25] | - | 93.6
Point Voxel Transformer [86] | - | 93.6
CurveNet [80] | - | 93.8
DeltaNet (ours) | 91.2 | 93.8

Table 2: Classification results on ScanObjectNN. Results in row 1-8 from [71].

| no bg | bg | t25 | t25r | t50r | t50rs
---|---|---|---|---|---|---
3DmFV [2] | 73.8 | 68.2 | 67.1 | 67.4 | 63.5 | 63.0
PointNet [59] | 79.2 | 73.3 | 73.5 | 72.7 | 68.2 | 68.2
SpiderCNN [83] | 79.5 | 77.1 | 78.1 | 77.7 | 73.8 | 73.7
PointNet++ [60] | 84.3 | 82.3 | 82.7 | 81.4 | 79.1 | 77.9
DGCNN [73] | 86.2 | 82.8 | 83.3 | 81.5 | 80.0 | 78.1
PointCNN [41] | 85.5 | 86.1 | 83.6 | 82.5 | 78.5 | 78.5
BGA-PN++ [71] | - | - | - | - | - | 80.2
BGA-DGCNN [71] | - | - | - | - | - | 79.9
GBNet [62] | - | - | - | - | - | 80.5
GDANet [82] | 88.5 | 87.0 | - | - | - | -
DRNet [61] | - | - | - | - | - | 80.3
DeltaNet (ours) | 89.5 | 89.3 | 89.4 | 87.0 | 85.1 | 84.7

#### ModelNet40

The ModelNet40 dataset [79] consists of 12,311 CAD models from 40 categories.
9,843 models are used for training and 2,468 models for testing. Each point
cloud consists of 1,024 points sampled from the surface using a uniform
sampling of 8,192 points from mesh faces and subsequent furthest point
sampling (FPS). We use 20 neighbors for maximum aggregation and to construct
the gradient and divergence. Ground-truth normals are used to define tangent
spaces for these operators and the regularizer is set to $\lambda=0.01$. As
input to the network, we use the xyz-coordinates. The classification
architecture is optimized for 250 epochs. We do not use any voting procedure
and list results without voting.

The results for this experiment can be found in Table 1. DeltaConv improves
significantly on the most related maximum aggregation operators and is on par
with or better than state-of-the-art approaches.

#### ScanObjectNN

ScanObjectNN [71] contains 2,902 unique object instances with 15 object
categories sampled from SceneNN [30] and ScanNet [14]. The dataset is enriched
to $\sim 15,000$ objects by preserving or removing background points and by
perturbing bounding boxes. The variant without background points is tested
without any perturbations (no bg). The variant with background points is both
tested without (bg) and with perturbations. Bounding boxes are translated (t),
rotated (r), and scaled (s) before each shape is extracted. This means that
some shapes are cut off, rotated, or scaled. t25 and t50 denote a translation
by 25% and 50% of the bounding box size, respectively.

We use a modified version of the classification architecture with four
convolution blocks: Conv(64, 64), Conv(64, 64), Conv(64, 64), Conv(64, 128).
This setup matches the architecture used for DGCNN in [71]. Normals are
estimated with 10 neighbors per point and the operators are constructed with
20 neighbors and $\lambda=0.001$. As input, we provide the xyz-positions,
augmented with a random rotation around the up-axis and a random scale
$S\in\mathcal{U}(4/5,5/4)$. The network is trained for 250 epochs.

Our results are compared to those reported by the authors of ScanObjectNN [71]
and other recent approaches in Table 2. We find that our approach outperforms
all networks for every type of perturbation, including networks that
explicitly account for background points.

Table 3:  Classification results on SHREC11 [42]. All networks, except for
GWCNN, are trained and tested on simplified meshes.

Method | Accuracy
---|---
GWCNN [20] | 90.3
MeshCNN [28] | 91.0
HSN [76] | 96.1
MeshWalker [37] | 97.1
PD-MeshNet [51] | 99.1
HodgeNet [66] | 94.7
FC [52] | 99.2
DiffusionNet - hks (no xyz) [63] | 99.5
DeltaNet (ours) | 99.6

Table 4: Part segmentation results on ShapeNet part dataset. Metric is mIoU(%)
on points.

| Mean | aero | bag | cap | car | chair | ear | guitar | knife | lamp | laptop | motor | mug | pistol | rocket | skate | table |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---
| inst. mIoU |  |  |  |  |  | phone |  |  |  |  |  |  |  |  | board |  |
# shapes |  | 2690 | 76 | 55 | 898 | 3758 | 69 | 787 | 392 | 1547 | 451 | 202 | 184 | 283 | 66 | 152 | 5271 |
PointNet++ | 85.1 | 82.4 | 79.0 | 87.7 | 77.3 | 90.8 | 71.8 | 91.0 | 85.9 | 83.7 | 95.3 | 71.6 | 94.1 | 81.3 | 58.7 | 76.4 | 82.6 |
PointCNN | 86.1 | 84.1 | 86.5 | 86.0 | 80.8 | 90.6 | 79.7 | 92.3 | 88.4 | 85.3 | 96.1 | 77.2 | 95.3 | 84.2 | 64.2 | 80.0 | 83.0 |
DGCNN | 85.2 | 84.0 | 83.4 | 86.7 | 77.8 | 90.6 | 74.7 | 91.2 | 87.5 | 82.8 | 95.7 | 66.3 | 94.9 | 81.1 | 63.5 | 74.5 | 82.6 |
KPConv deform | 86.4 | 84.6 | 86.3 | 87.2 | 81.1 | 91.1 | 77.8 | 92.6 | 88.4 | 82.7 | 96.2 | 78.1 | 95.8 | 85.4 | 69.0 | 82.0 | 83.6 |
KPConv rigid | 86.2 | 83.8 | 86.1 | 88.2 | 81.6 | 91.0 | 80.1 | 92.1 | 87.8 | 82.2 | 96.2 | 77.9 | 95.7 | 86.8 | 65.3 | 81.7 | 83.6 |
GDANet | 86.5 | 84.2 | 88.0 | 90.6 | 80.2 | 90.7 | 82.0 | 91.9 | 88.5 | 82.7 | 96.1 | 75.8 | 95.7 | 83.9 | 62.9 | 83.1 | 84.4 |
PointTransformer | 86.6 | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - |
PointVoxelTransformer | 86.5 | 85.1 | 82.8 | 88.3 | 81.5 | 92.2 | 72.5 | 91.0 | 88.9 | 85.6 | 95.4 | 76.2 | 94.7 | 84.2 | 65.0 | 75.3 | 81.7 |
CurveNet | 86.8 | 85.1 | 84.1 | 89.4 | 80.8 | 91.9 | 75.2 | 91.8 | 88.7 | 86.3 | 96.3 | 72.8 | 95.4 | 82.7 | 59.8 | 78.5 | 84.1 |
DeltaNet (ours) | 86.6 | 84.9 | 82.8 | 89.1 | 81.3 | 91.9 | 79.7 | 92.2 | 88.6 | 85.5 | 96.7 | 77.2 | 95.8 | 83.0 | 61.1 | 77.5 | 83.1 |
Delta-U-ResNet (ours) | 86.9 | 85.3 | 88.1 | 88.6 | 81.4 | 91.8 | 78.4 | 92.0 | 89.3 | 85.6 | 96.1 | 76.4 | 95.9 | 82.7 | 65.0 | 76.6 | 84.1 |

#### SHREC11

The SHREC11 dataset [42] consists of 900 non-rigidly deformed shapes, 30 each
from 30 shape classes. This experiment aims to validate the claim that our
approach is well suited for non-rigid deformations. Like previous works [28,
76, 63], we train on 10 randomly selected shapes from each class and report
the average over 10 runs. We sample 2048 points from the simplified meshes
used in MeshCNNs experiments [28] and use 20 neighbors and mesh normals to
construct the operators ($\lambda=0.001$). As input, we provide xyz-
coordinates, which are randomly rotated along each axis. We decrease the
number of parameters in each convolution of the classification architecture to
32, since the dataset is much smaller than other datasets. The network is
trained for 100 epochs. We find that our architecture is able to improve on
state-of-the-art results (table 3), validating the effectiveness of our
intrinsic approach on deformable shapes.

###  4.3 Segmentation

For segmentation, we evaluate our architecture on ShapeNet (part segmentation)
[85]. ShapeNet consists of 16,881 shapes from 16 categories. Each shape is
annotated with up to six parts, totaling 50 parts. We use the point sampling
of 2,048 points provided by the authors of PointNet [59] and the
train/validation/test split follows [8]. The operators are constructed with 30
neighbors and ground-truth normals to define tangent spaces ($\lambda=0.001$).
The xyz-coordinates are provided as input to the network, which is trained for
200 epochs. During testing, we evaluate each shape with ten random
augmentations and aggregate the results with a voting procedure. Such a voting
approach is used in the most recent works that we compare with.

The results are shown in Table 4, where our approach, especially the U-ResNet
variant, improves upon the state-of-the-art approaches on the mean instant IoU
metric and in many of the shape categories. For each category, DeltaConv is
either comparable to or better than other architectures and significantly
better than the most related intrinsic approaches (PointNet++ and DGCNN). We
also visualize the features of our simple architecture in Figure 4 to give an
idea of the features derived by the network.

Figure 4: Feature visualizations of scalar- and vector- features inside the
shape segmentation network on ShapeNet. Each layer shows the same feature.

###  4.4 Ablation Studies

We aim to isolate the effect of the vector stream, validate the choices to
regularize and normalize the gradient and divergence operators, and
investigate the impact of our approach on timing and parameter counts of these
networks.

#### Effectiveness of vector stream

To study the benefit of the vector stream and its effect on different types of
intrinsic scalar convolutions, we set up three different scalar streams: (1) a
Laplace–Beltrami operator, $\Delta=-\text{div}\,\text{grad}$, (2) GCN [35],
and (3) maximum aggregation (eq. 1). We test three variants of each network:
(1) only scalar stream, (2) scalar stream with the number of parameters
adjusted to match a two-stream architecture, and (3) both the scalar and
vector stream.

We test each configuration on ModelNet40 and ShapeNet. For both of these
tasks, we use the DGCNN base-architecture. The model for ShapeNet is trained
for 50 epochs to save on training time and no voting is used, which results in
slightly lower results than listed in Table 4. The results are listed in Table
5. We find that the vector stream improves the network for each scalar stream
for both tasks, reducing the error between $19-25\%$ for classification and
$3-21\%$ for segmentation. For maximum aggregation on ShapeNet, the
improvements are lower, but still considerable, given the rate of progress on
this dataset over the last few years. Simply increasing the number of
parameters in the scalar stream does not yield the same improvement as adding
the vector stream, showing that the vector-valued features are of meaningful
benefit. Maximum aggregation in the scalar stream yields the highest accuracy.

Table 5: Accuracy for ShapeNet (Seg) and ModelNet40 (M40) with different
configurations for the scalar streams.

Scalar | Vector | Match | Seg mIoU | M40 mcA | M40 OA
---|---|---|---|---|---
Convolution | Stream |  $\\#$ params |  |  |
Laplace– | - | - | 82.5 | 86.1 | 90.4
Beltrami | - | ✓ | 82.5 | 87.1 | 90.6
| ✓ | - | 84.9 | 89.4 | 92.2
GCN | - | - | 81.1 | 87.3 | 90.4
| - | ✓ | 81.2 | 87.3 | 90.8
| ✓ | - | 85.1 | 90.6 | 92.8
Max aggregation | - | - | 85.7 | 89.2 | 92.2
| - | ✓ | 85.7 | 89.5 | 92.6
| ✓ | - | 86.1 | 91.2 | 93.8

#### Timing and parameters

In our method section we argue that computating the gradient matrix is
lightweight and that the simplified maximum aggregation operator is
significantly faster than edge-based operators in PointNet++ and DGCNN. The
main bottleneck in these convolutions is maximum aggregation over each edge.
In this experiment we demonstrate this by reporting the time it takes to train
and test the classification network on one batch of 32 shapes with 1,024
points each. This includes computing the k-nearest neighbor graph ($\sim
15$ms) and constructing the gradient and divergence operators ($\sim 30$ms).
All timings are obtained on the same machine with an NVIDIA RTX 2080Ti after
10 iterations. We implemented each method in PyTorch [55] and PyTorch
Geometric [22]. The results are listed in Table 6. We find that our network
only increases the number of parameters by $10\%$. Our network is
significantly faster than the edge-based convolution: $1.5\times$ faster in
training and inference and $2.5\times$ faster in the backward pass. DeltaConv
with a Laplacian in the scalar stream is even faster: $>2\times$ faster in
training and inference and $30\times$ faster in the backward pass.

#### Gradient regularization and normalization

In our method section, we argue that the least-squares fit for constructing
the gradient and divergence should be regularized and the operators should be
normalized. In this experiment we intend to validate these choices. We train a
model that is entirely based on our gradient operator, with a Laplace–Beltrami
operator in the scalar stream. This means that every spatial operator in the
network is influenced by regularization and scaling. The model is trained on
the ModelNet40 for 50 epochs. The results are listed in Table 7. We notice a
considerable difference between our approach with- and without regularization.
There is a $2.8\%$ decrease in mean class accuracy and $1.7\%$ decrease in
overall accuracy when the operator is not normalized.

Table 6: Timing for one batch (32 shapes, including precomputation) and
parameter counts for classification on ModelNet40.

| Data | Training | Backward | Inference |  $\\#$ Params
---|---|---|---|---|---
| Transform |  |  |  |
DeltaConv (Lapl.) | k-nn + grad |  $80$ms |  $5$ms |  $80$ms | 2,036,938
DeltaConv | k-nn + grad |  $130$ms |  $60$ms |  $125$ms | 2,037,962
EdgeConv | k-nn |  $196$ms |  $147$ms |  $186$ms | 1,801,610

Table 7: Ablation on ModelNet40 with different settings, using the
Laplace–Beltrami scalar stream.

$\lambda$ | Normalization | Mean | Overall
---|---|---|---
|  | Class Accuracy | Accuracy
$10^{-32}$ | $\checkmark$ | 85.2 | 90.3
$10^{-2}$ | - | 86.6 | 90.5
$10^{-2}$ | $\checkmark$ | 89.4 | 92.2

##  5 Conclusion

In this paper, we proposed DeltaConv, a new intrinsic convolution operator
that can better capture anisotropy. This is achieved through a combination of
elemental geometric operators from exterior calculus which are weighted by a
neural network. DeltaConv separates features into a scalar- and vector stream
and connects the streams with its operators. We demonstrate improved
performance on a wide range of tasks, showing the potential of using the
operators from exterior calculus in a learning setting on point clouds. We
hope that this work will provide insight into the functionality and operation
of neural networks for point clouds and spark more work that combines learning
approaches with powerful tools from geometry processing.

#### Challenges and future work

We limit our study to regression tasks. While we do not think it is impossible
to adapt our operators for generative tasks, it is unclear if and when the
operators should be recomputed when a surface is generated. We are also
interested in connecting concepts from rotation-invariant approaches and
transformers into our scalar- and vector stream. Finally, it is appealing to
test our approach on other surface discretizations.

## References

  * [1] Matan Atzmon, Haggai Maron, Yaron Lipman, Atzmon Matan, Maron Haggai, and Lipman Yaron.  Point convolutional neural networks by extension operators.  ACM Trans. Graph., 2018.
  * [2] Yizhak Ben-Shabat, Michael Lindenbaum, and Anath Fischer.  3dmfv: Three-dimensional point cloud classification in real-time using convolutional neural networks.  IEEE Robotics and Automation Letters, 2018.
  * [3] Davide Boscaini, Jonathan Masci, Emanuele Rodolà, and Michael Bronstein.  Learning shape correspondence with anisotropic convolutional neural networks.  NeurIPS, 2016.
  * [4] Alexandre Boulch.  Convpoint: Continuous convolutions for point cloud processing.  Comput. Graph. Forum, 2019.
  * [5] Christopher Brandt, Leonardo Scandolo, Elmar Eisemann, and Klaus Hildebrandt.  Spectral processing of tangential vector fields.  Computer Graphics Forum, 2017.
  * [6] Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst.  Geometric deep learning: Going beyond euclidean data.  IEEE Signal Process. Mag., 2017.
  * [7] Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun.  Spectral networks and locally connected networks on graphs.  ICLR, 2014.
  * [8] Angel X. Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu.  ShapeNet: An Information-Rich 3D Model Repository.  Technical Report arXiv:1512.03012, 2015.
  * [9] Jintai Chen, Biwen Lei, Qingyu Song, Haochao Ying, Danny Z Chen, and Jian Wu.  A Hierarchical Graph Network for 3D Object Detection on Point Clouds.  CVPR, 2020.
  * [10] Christopher Choy, JunYoung Gwak, and Silvio Savarese.  4d spatio-temporal convnets: Minkowski convolutional neural networks.  CVPR, 2019.
  * [11] Taco Cohen, Mario Geiger, Jonas Koehler, and Max Welling.  Spherical CNNs.  ICLR, 2018.
  * [12] Taco Cohen, Maurice Weiler, Berkay Kicanaoglu, and Max Welling.  Gauge Equivariant Convolutional Networks and the Icosahedral CNN.  ICML, 2019.
  * [13] Keenan Crane, Fernando de Goes, Mathieu Desbrun, and Peter Schroder.  Digital geometry processing with discrete exterior calculus.  SIGGRAPH Asia 2013 Courses, 2013.
  * [14] Angela Dai, Angel X. Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nießner.  Scannet: Richly-annotated 3d reconstructions of indoor scenes.  CVPR, 2017.
  * [15] Fernando de Goes, Mathieu Desbrun, and Yiying Tong.  Vector field processing on triangle meshes.  SIGGRAPH Asia 2015 Courses, 2015.
  * [16] Pim de Haan, Maurice Weiler, Taco Cohen, and Max Welling.  Gauge Equivariant Mesh CNNs: Anisotropic convolutions on geometric graphs.  ICLR, 2021.
  * [17] Miguel Dominguez, Rohan Dhamdhere, Atir Petkar, Saloni Jain, Shagan Sah, and Raymond Ptucha.  General-Purpose Deep Point Cloud Feature Extractor.  WACV, 2018.
  * [18] Moshe Eliasof and Eran Treister.  DiffGCN: Graph Convolutional Networks via Differential Operators and Algebraic Multigrid Pooling.  NeurIPS, 2020.
  * [19] Carlos Esteves, Christine Allen-Blanchette, Ameesh Makadia, and Kostas Daniilidis.  Learning SO(3) Equivariant Representations with Spherical CNNs.  ECCV, 2017.
  * [20] Danielle Ezuz, Justin Solomon, Vladimir G. Kim, and Mirela Ben-Chen.  Gwcnn: A metric alignment layer for deep shape analysis.  Computer Graphics Forum, 2017.
  * [21] Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao.  Hypergraph neural networks.  AAAI, 2019.
  * [22] Matthias Fey and Jan E. Lenssen.  Fast graph representation learning with PyTorch Geometric.  ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.
  * [23] Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Müller.  SplineCNN: Fast geometric deep learning with continuous B-spline kernels.  CVPR, 2018.
  * [24] Jan E Gerken, Jimmy Aronsson, Oscar Carlsson, Hampus Linander, Fredrik Ohlsson, Christoffer Petersson, and Daniel Persson.  Geometric deep learning and equivariant neural networks.  arXiv preprint arXiv:2105.13926, 2021.
  * [25] Ankit Goyal, Hei Law, Bowei Liu, Alejandro Newell, and Jia Deng.  Revisiting point cloud shape classification with a simple and effective baseline.  ICML, 2021.
  * [26] Benjamin Graham, Martin Engelcke, and Laurens van der Maaten.  3d semantic segmentation with submanifold sparse convolutional networks.  CVPR, 2018.
  * [27] Y Guo, H Wang, Q Hu, H Liu, L Liu, and M Bennamoun.  Deep Learning for 3D Point Clouds: A Survey.  IEEE TPAMI, page 1, 2020.
  * [28] Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, and Daniel Cohen-Or.  Meshcnn: A network with an edge.  ACM Trans. Graph., 2019.
  * [29] Pedro Hermosilla, Tobias Ritschel, Pere-Pau Vázquez, Àlvar Vinacua, and Timo Ropinski.  Monte Carlo Convolution for Learning on Non-Uniformly Sampled Point Clouds.  ACM Trans. Graph., 2018.
  * [30] Binh-Son Hua, Quang-Hieu Pham, Duc Thanh Nguyen, Minh-Khoi Tran, Lap-Fai Yu, and Sai-Kit Yeung.  Scenenn: A scene meshes dataset with annotations.  3DV, 2016.
  * [31] Binh-Son Hua, Minh-Khoi Tran, and Sai-Kit Yeung.  Pointwise Convolutional Neural Networks.  CVPR, 2018.
  * [32] Jingwei Huang, Haotian Zhang, Li Yi, Thomas A. Funkhouser, Matthias Nießner, and Leonidas J. Guibas.  Texturenet: Consistent local parametrizations for learning from high-resolution signals on meshes.  CVPR, 2019.
  * [33] Sergey Ioffe and Christian Szegedy.  Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift.  ICML.
  * [34] Chiyu Max Jiang, Jingwei Huang, Karthik Kashinath, Prabhat, Philip Marcus, and Matthias Nießner.  Spherical CNNs on Unstructured Grids.  ICLR, 2019.
  * [35] Thomas N. Kipf and Max Welling.  Semi-supervised classification with graph convolutional networks.  ICLR, 2017.
  * [36] Ilya Kostrikov, Zhongshi Jiang, Daniele Panozzo, Denis Zorin, and Joan Bruna.  Surface Networks.  CVPR, 2018.
  * [37] Alon Lahav and A. Tal.  Meshwalker.  ACM Trans. Graph., 2020.
  * [38] Shiyi Lan, Ruichi Yu, Gang Yu, and L Davis.  Modeling Local Geometric Structure of 3D Point Clouds Using Geo-CNN.  CVPR, 2019.
  * [39] Eric-Tuan Le, Iasonas Kokkinos, and Niloy J Mitra.  Going Deeper With Lean Point Networks.  CVPR, 2020.
  * [40] Huan Lei, Naveed Akhtar, and Ajmal Mian.  Octree guided CNN with Spherical Kernels for 3D Point Clouds.  CVPR, 2019.
  * [41] Yangyan Li, Bu Rui, Mingchao Sun, Wei Wu, Xinhan Di, Baoquan Chen, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen.  PointCNN: Convolution on x-transformed points.  NeurIPS, 2018.
  * [42] Zhouhui et al. Lian.  Shrec ’11 track: Shape retrieval on non-rigid 3d watertight meshes.  Eurographics Workshop on 3D Object Retrieval, pages 79–88, 01 2011\.
  * [43] Jian Liang and H. Zhao.  Solving partial differential equations on point clouds.  SIAM J. Sci. Comput., 2013.
  * [44] Jinxian Liu, Bingbing Ni, Caiyuan Li, Jiancheng Yang, and Qi Tian.  Dynamic Points Agglomeration for Hierarchical Point Sets Learning.  ICCV, 2019.
  * [45] Weiping Liu, Jia Sun, Wanyi Li, Ting Hu, and Peng Wang.  Deep Learning on Point Clouds and Its Application: A Survey.  Sens, 2019.
  * [46] Yongcheng Liu, Bin Fan, Gaofeng Meng, Jiwen Lu, Shiming Xiang, and Chunhong Pan.  DensePoint: Learning densely contextual representation for efficient point cloud processing.  ICCV, 2019.
  * [47] Yongcheng Liu, Bin Fan, Shiming Xiang, and Chunhong Pan.  Relation-Shape Convolutional Neural Network for Point Cloud Analysis.  CVPR, 2019.
  * [48] Ze Liu, Han Hu, Yue Cao, Zheng Zhang, and Xin Tong.  A closer look at local aggregation operators in point cloud analysis.  ECCV, 2020.
  * [49] Ilya Loshchilov and Frank Hutter.  SGDR: stochastic gradient descent with warm restarts.  ICLR, 2017.
  * [50] Tao Lu, Limin Wang, and Gangshan Wu.  Cga-net: Category guided aggregation for point cloud semantic segmentation.  CVPR, 2021.
  * [51] Francesco Milano, Antonio Loquercio, Antoni Rosinol, Davide Scaramuzza, and Luca Carlone.  Primal-dual mesh convolutional neural networks.  NeurIPS, 2020.
  * [52] Thomas W. Mitchel, Vladimir G. Kim, and Michael Kazhdan.  Field convolutions for surface cnns, 2021.
  * [53] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodolà, Jan Svoboda, and Michael M Bronstein.  Geometric deep learning on graphs and manifolds using mixture model CNNs.  CVPR, 2017.
  * [54] Guanghua Pan, Jun Wang, Rendong Ying, and Peilin Liu.  3DTI-Net: Learn Inner Transform Invariant 3D Geometry Features using Dynamic GCN.  arXiv preprint arXiv:1812.06254, 2018.
  * [55] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala.  Pytorch: An imperative style, high-performance deep learning library.  NeurIPS, 2019.
  * [56] P Perona and J Malik.  Scale-space and edge detection using anisotropic diffusion.  IEEE Transactions on Pattern Analysis and Machine Intelligence, 1990\.
  * [57] Adrien Poulenard and Maks Ovsjanikov.  Multi-directional geodesic neural networks via equivariant convolution.  ACM Trans. Graph., 2018.
  * [58] Adrien Poulenard, Marie-Julie Rakotosaona, Yann Ponty, and Maks Ovsjanikov.  Effective Rotation-invariant Point CNN with Spherical Harmonics kernels.  3DV, 2019.
  * [59] Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas.  PointNet: Deep learning on point sets for 3D classification and segmentation.  CVPR, 2017.
  * [60] Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas.  PointNet++: Deep hierarchical feature learning on point sets in a metric space.  NeurIPS, 2017.
  * [61] Shi Qiu, Saeed Anwar, and Nick Barnes.  Dense-resolution network for point cloud classification and segmentation.  Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), 2021.
  * [62] Shi Qiu, Saeed Anwar, and Nick Barnes.  Geometric back-projection network for point cloud classification.  arXiv preprint arXiv:1911.12885, 2021.
  * [63] Nicholas Sharp, Souhaib Attaiki, Keenan Crane, and Maks Ovsjanikov.  Diffusionnet: Discretization agnostic learning on surfaces.  ACM Trans. Graph., 2021.
  * [64] Yiru Shen, Chen Feng, Yaoqing Yang, and Dong Tian.  Mining point cloud local structures by kernel correlation and graph pooling.  CVPR, 2018.
  * [65] Martin Simonovsky and Nikos Komodakis.  Dynamic edge-conditioned filters in convolutional neural networks on graphs.  CVPR, 2017.
  * [66] Dmitriy Smirnov and Justin Solomon.  HodgeNet: Learning spectral geometry on triangle meshes.  ACM Trans. Graph., 2021.
  * [67] Xiao Sun, Zhouhui Lian, and Jianguo Xiao.  SRINet: Learning Strictly Rotation-Invariant Representations for Point Cloud Classification and Segmentation.  ACM International Conference on Multimedia, 2019.
  * [68] Gusi Te, Wei Hu, Amin Zheng, and Zongming Guo.  RGCNN: Regularized graph CNN for point cloud segmentation.  ACM MM, 2018.
  * [69] Hugues Thomas, Charles R Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, François Goulette, and Leonidas J Guibas.  KPConv: Flexible and Deformable Convolution for Point Clouds.  ICCV, 2019.
  * [70] Nathaniel Thomas, Tess Smidt, Steven Kearnes, Lusann Yang, Li Li, Kai Kohlhoff, and Patrick Riley.  Tensor field networks: Rotation- and translation-equivariant neural networks for 3D point clouds.  CoRR, 2018.
  * [71] Mikaela Angelina Uy, Quang-Hieu Pham, Binh-Son Hua, Duc Thanh Nguyen, and Sai-Kit Yeung.  Revisiting point cloud classification: A new benchmark dataset and classification model on real-world data.  ICCV, 2019.
  * [72] Chu Wang, Babak Samari, and Kaleem Siddiqi.  Local spectral graph convolution for point set feature learning.  ECCV, 2018.
  * [73] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E. Sarma, Michael M. Bronstein, and Justin M. Solomon.  Dynamic graph CNN for learning on point clouds.  ACM Trans. Graph., 2019.
  * [74] Maurice Weiler and Gabriele Cesa.  General e(2)-equivariant steerable cnns.  NeurIPS, 2019.
  * [75] Maurice Weiler, Patrick Forré, Erik Verlinde, and Max Welling.  Coordinate independent convolutional networks – isometry and gauge equivariant convolutions on riemannian manifolds.  arXiv preprint arXiv:2106.06020, 2021.
  * [76] Ruben Wiersma, Elmar Eisemann, and Klaus Hildebrandt.  CNNs on surfaces using rotation-equivariant features.  ACM Trans. Graph., 2020.
  * [77] Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow.  Harmonic networks: Deep translation and rotation equivariance.  CVPR, 2017.
  * [78] Wenxuan Wu, Zhongang Qi, and Li Fuxin.  PointConv: Deep Convolutional Networks on 3D Point Clouds.  CVPR, 2019.
  * [79] Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao.  3D ShapeNets: A deep representation for volumetric shapes.  CVPR, 2015.
  * [80] Tiange Xiang, Chaoyi Zhang, Yang Song, Jianhui Yu, and Weidong Cai.  Walk in the cloud: Learning curves for point clouds shape analysis.  ICCV, 2021.
  * [81] Mutian Xu, Runyu Ding, Hengshuang Zhao, and Xiaojuan Qi.  Paconv: Position adaptive convolution with dynamic kernel assembling on point clouds.  CVPR, 2021.
  * [82] Mutian Xu, Junhao Zhang, Zhipeng Zhou, Mingye Xu, Xiaojuan Qi, and Yu Qiao.  Learning geometry-disentangled representation for complementary understanding of 3d object point cloud.  AAAI, 2021.
  * [83] Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, and Yu Qiao.  Spidercnn: Deep learning on point sets with parameterized convolutional filters.  ECCV, 2018.
  * [84] Jiancheng Yang, Qiang Zhang, B Ni, L Li, J Liu, Mengdie Zhou, and Q Tian.  Modeling Point Clouds With Self-Attention and Gumbel Subset Sampling.  CVPR, 2019.
  * [85] Li Yi, Vladimir G. Kim, Duygu Ceylan, I-Chao Shen, Mengyan Yan, Hao Su, Cewu Lu, Qixing Huang, Alla Sheffer, and Leonidas Guibas.  A scalable active framework for region annotation in 3d shape collections.  ACM Trans. Graph., 2016.
  * [86] Cheng Zhang, Haocheng Wan, Shengqiang Liu, Xinyi Shen, and Zizhao Wu.  Pvt: Point-voxel transformer for 3d deep learning.  arXiv preprint arXiv:2108.06076, 2021.
  * [87] Kuangen Zhang, Ming Hao, Jing Wang, Clarence W de Silva, and Chenglong Fu.  Linked Dynamic Graph CNN: Learning on Point Cloud via Linking Hierarchical Features.  arXiv preprint arXiv:1904.10014, 2019.
  * [88] Yingxue Zhang and Michael Rabbat.  A Graph-CNN for 3D point cloud classification.  ICASSP, 2018.
  * [89] Hengshuang Zhao, Li Jiang, Chi-Wing Fu, and Jiaya Jia.  PointWeb: Enhancing Local Neighborhood Features for Point Cloud Processing.  CVPR, 2019.
  * [90] Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip H.S. Torr, and Vladlen Koltun.  Point transformer.  ICCV, 2021.