# MSECNet: Accurate and Robust Normal Estimation for 3D Point Clouds by Multi-
Scale Edge Conditioning

Haoyi Xiu  National Institute of Advanced Industrial Science and Technology
(AIST)TokyoJapan<EMAIL_ADDRESS>,  Xin Liu  National Institute of
Advanced Industrial Science and Technology (AIST)TokyoJapan<EMAIL_ADDRESS>,  Weimin Wang  National Institute of Advanced Industrial Science and
Technology (AIST)TokyoJapan<EMAIL_ADDRESS>,  Kyoung-Sook Kim
National Institute of Advanced Industrial Science and Technology
(AIST)TokyoJapan<EMAIL_ADDRESS>and  Masashi Matsuoka  Tokyo Institute of
TechnologyTokyoJapan<EMAIL_ADDRESS>
(2023)

###### Abstract.

Estimating surface normals from 3D point clouds is critical for various
applications, including surface reconstruction and rendering. While existing
methods for normal estimation perform well in regions where normals change
slowly, they tend to fail where normals vary rapidly. To address this issue,
we propose a novel approach called MSECNet, which improves estimation in
normal varying regions by treating normal variation modeling as an edge
detection problem. MSECNet consists of a backbone network and a multi-scale
edge conditioning (MSEC) stream. The MSEC stream achieves robust edge
detection through multi-scale feature fusion and adaptive edge detection. The
detected edges are then combined with the output of the backbone network using
the edge conditioning module to produce edge-aware representations. Extensive
experiments show that MSECNet outperforms existing methods on both synthetic
(PCPNet) and real-world (SceneNN) datasets while running significantly faster.
We also conduct various analyses to investigate the contribution of each
component in the MSEC stream. Finally, we demonstrate the effectiveness of our
approach in surface reconstruction.

normal estimation, edge detection, point cloud, multi-scale fusion

††journalyear: 2023††copyright: acmlicensed††conference: Proceedings of the
31st ACM International Conference on Multimedia; October 29-November 3, 2023;
Ottawa, ON, Canada††booktitle: Proceedings of the 31st ACM International
Conference on Multimedia (MM ’23), October 29-November 3, 2023, Ottawa, ON,
Canada††price: 15.00††doi: 10.1145/3581783.3613762††isbn:
979-8-4007-0108-5/23/10††ccs: Computing methodologies Shape
representations††ccs: Computing methodologies Scene understanding

##  1\. Introduction

3D point clouds can be used for many applications such as surface
reconstruction (Kazhdan et al., 2006), rendering (Gouraud, 1971), and virtual
reality (Garrido et al., 2021). An essential step for many of them is to
estimate normals at each point, which is to infer the local surface
orientation from point samples. Therefore, the quality of normals estimated
has a significant impact on the performance of those applications.

A classical approach for normal estimation is to fit a geometric primitive
such as a plane (Hoppe et al., 1992) or surface (Cazals and Pouget, 2005) to
the local neighborhood/patch of each point. However, a key challenge of these
methods is that various parameters (e.g., the patch size) must be set manually
without knowing the noise level and feature distribution, and their
performance significantly depends on the choice of those parameters. Recently,
data-driven approaches based on deep learning have been proposed to address
this issue. They take a patch as input and estimate the normal of the patch
center using deep neural networks (DNNs). There are two main types of
approaches. The first one directly regresses the normal vector from features
extracted by DNNs (Guerrero et al., 2018). The other one uses DNNs to predict
per-point weights for a weighted least square fitting and obtains the normal
vector by solving it (Lenssen et al., 2020).

A recurrent issue of normal estimation is that the estimation in regions where
normals change rapidly is not reliable. The problem is made even more
challenging in the presence of data corruptions such as noise and density
variations. While some studies attempt to address this issue with hand-crafted
estimators (Zhou et al., 2022), metric learning (Wang et al., 2022), or graph
convolutions (Li et al., 2022b), they often require manual preprocessing or
still rely on surface fitting at the end, which may smooth out details and
requires careful selection of the fitting order.

Figure 1. MSECNet performs accurate and robust normal estimation while running
significantly faster than recent works. The MSEC stream improves estimation at
sharp edges with multi-scale fusion, edge detection, and edge conditioning.

To address this issue, in this work, we propose Multi-Scale Edge Conditioning
Network (MSECNet) for accurate and robust surface normal estimation111Code and
pretrained models is available in https://github.com/martianxiu/MSECNet.. The
overview of our approach is presented in Fig. 1. MSECNet achieves accurate
estimation at normal varying regions by the explicit modeling of normal
variations. We treat the modeling of normal variations as the modeling of
geometric edges. An edge, in essence, describes a variation in certain
properties. A smooth change represents a weak edge while a drastic change
(e.g., a corner) indicates a strong edge. Therefore, explicit modeling of
geometric edges can lead to better modeling of normal variations, which in
turn leads to more accurate estimation.

To model geometric edges, we propose the MSEC stream which consists of multi-
scale fusion, edge detection, and edge conditioning (see Fig. 2). The fusion
step performs multi-scale feature fusion by reusing the multi-scale features
of a backbone network. The fusion is necessary for successful edge detection
as edges are multi-scale structures and the detection needs to be robust
against various data corruption. Unlike previous works (e.g., (Zhu et al.,
2021) and (Li et al., 2022a)) whose fusion aggregates information from larger
scales by pooling, we distribute information from larger scales to the
smallest one by interpolation. This is because we aim to detect edges that are
spatially localized and aggregation destroys such information. The fused
features are then used for adaptive edge detection in which the adaptability
allows for the enhancement of true edges. Lastly, the edge conditioning step
merges the detected edges with the representation learned by the backbone to
produce edge-aware features.

Extensive experiments demonstrate that MSECNet achieves state-of-the-art
performance on the synthetic PCPNet dataset (Guerrero et al., 2018). To
investigate its generalizability, we apply pretrained MSECNet to the real-
world SceneNN dataset (Hua et al., 2016). The results indicate that MSECNet
outperforms all baselines by a large margin. Furthermore, we verify that
MSECNet runs $\sim$61x faster than the previous works during inference.
Moreover, we perform various analyses to show how each step of the MSEC stream
helps. Finally, we demonstrate the utility of MSECNet in surface
reconstruction.

Our main contributions are summarized as follows:

  * •

We propose MSECNet, a new normal estimation approach that models normal
variations by explicit edge modeling. It achieves state-of-the-art performance
on both synthetic and real-world datasets while showing strong robustness
against different noise levels and density variations. Also, it runs
significantly faster than cutting-edge networks.

  * •

We propose the MSEC stream that improves normal estimation at normal varying
regions by the combination of multi-scale fusion, adaptive edge detection, and
edge conditioning. We verify that the MSEC stream significantly advances the
performance of the backbone network.

##  2\. Related Work

###  2.1. Traditional Normal Estimation

The classical methods for normal estimation are based on Principle Component
Analysis (PCA) (Hoppe et al., 1992; Dey and Sun, 2006; Alliez et al., 2007).
They perform a local covariance analysis on a local patch and use the
direction of minimal variance as the normal. On the other hand, methods for
surface reconstruction such as moving least squares (Lancaster and Salkauskas,
1981; Alexa et al., 2001), osculating jets (Cazals and Pouget, 2005), and
spherical fitting (Guennebaud and Gross, 2007) are also used for estimating
normals. While their behavior is theoretically well-understood, they require
careful selection of parameters such as the neighborhood size (Mitra and
Nguyen, 2003) and often need special treatment when data are corrupted.

###  2.2. Normal Estimation with DNNs

One of the earliest approaches first projects a Hough accumulator into an
image and then the normal is estimated by a convolutional neural network (CNN)
(Boulch and Marlet, 2016). Similarly, PointProNets (Roveri et al., 2018) and
Refine-Net (Zhou et al., 2022) convert a local point patch to a 2D height map
that can be fed into CNN. However, they tend to lose fine geometric details
due to the conversion. To address this issue, some methods (Guerrero et al.,
2018; Sharma et al., 2021) leverage PointNet (Qi et al., 2017a), which
directly takes point clouds as input, and aggregates points into a single
vector from which the normal is regressed. This type of approach is further
improved in accuracy and efficiency by introducing multi-scale structures
(Guerrero et al., 2018), a point-voxel architecture (Hashimoto and Saito,
2019), and local plane constraint (Zhou et al., 2020).

On the other hand, some studies leverage intrinsic problem structures to
improve data efficiency. For instance, Lenssen et al. (Lenssen et al., 2020)
use a graph neural network to produce per-point weights and then use them for
a weighted least-square plane fitting. Similarly, DeepFit (Ben-Shabat and
Gould, 2020) adopts PointNet to predict weights for jet fitting. Both of them
try to improve the robustness of estimation and data efficiency with the
fitting techniques. However, the fitting tends to smooth the surfaces.
Besides, the polynomial order of the jet fitting is difficult to determine
because the complexity of the surfaces varies greatly. AdaFit (Zhu et al.,
2021) addresses this issue by predicting an additional offset to adjust point
distributions. Zhang et al. (Zhang et al., 2022) learns the optimal set of
points from which the normal vector is regressed. Zhou et al. (Zhou et al.,
2023) simplifies the surface fitting by focusing on critical points found by
top-K selection. HSurf-Net (Li et al., 2022a) proposes a hypersurface fitting
that frees the user from choosing the polynomial order. NeAF (Li et al.,
2023), on the other hand, learns the angle field by predicting the offset
between the random input vector and the ground truth normal. However, they
tend to be slow in inference because they estimate only a single vector from a
patch.

A recurrent issue of existing approaches is that they produce unreliable
estimations at sharp edges. Hence, a line of research focuses on addressing
this problem. Some approaches aim to accurately predict normal vectors in
areas where the normal varies by separately modeling sharp and non-sharp
patches (Lu et al., 2020; Wang et al., 2022), but these methods require manual
preprocessing. Other approaches use graph convolutions to learn more about
local geometry (Lenssen et al., 2020; Li et al., 2022b), but these techniques
have limited access to multiple scales and may be less robust to data
corruption. Additionally, many of these methods still rely on surface fitting,
which can smooth out details. MESCNet differs from these methods in that it
does not require any preprocessing or surface fitting. Furthermore, it can
directly access features at all scales, allowing for robust and accurate
estimation.

###  2.3. Edge Detection

Computational edge detection is an extremely well-studied topic. Pioneering
works such as Sobel detector (Kittler, 1983), zero-crossing (Marr and
Hildreth, 1980), and Canny method (Canny, 1986) detect edges using gradients.
However, these methods usually cannot cope with the complexity of real-world
applications. To address this issue, learning-based edge detection methods
(e.g., (Martin et al., 2004; Arbelaez et al., 2010; Dollár and Zitnick, 2014))
are proposed. Nevertheless, their performance depends on manual processing and
expert knowledge. Recently, edge detectors based on DNNs have shown impressive
performance. For instance, HED (Xie and Tu, 2015) performs edge detection
using a cascaded architecture in which one layer produces a scale-specific
edge prediction. Edge maps of different scales are then combined to produce
accurate edge predictions. Building on top of HED, RCF (Liu et al., 2017)
makes full use of multi-scale features by using all convolutional layers for
prediction. BDCN (He et al., 2019) further enhances the prediction with scale-
specific supervision. PiDiNet (Su et al., 2021) integrates traditional
operators to convolutions for efficient detection. RINDNet (Pu et al., 2021)
models different types of edges with dedicated decoders. EDTER (Pu et al.,
2022) exploits the full image context with transformers.

A key observation is that multi-scale features are essential for successful
edge detection because edges are multi-scale structures (Marr and Hildreth,
1980). Regarding multi-scale fusion strategies for normal estimation, some
studies use multiple patches with different patch sizes as input and build
separate networks for each scale (Guerrero et al., 2018; Ben-Shabat et al.,
2019). However, creating separate networks for each scale is costly. Another
approach is to aggregate large-scale information through max-pooling and then
copy the resulting vector for all points (Zhu et al., 2021; Li et al., 2022b,
a). Our approach differs from theirs in that we distribute information instead
of aggregating it, since we aim to detect spatially localized edges. Also,
their fusion is limited to adjacent scales, while ours has direct access to
all scales, leading to a more accurate and robust representation.

##  3\. Multi-Scale Edge Conditioning

Figure 2. The architecture of MSECNet. The MSEC stream consists of multi-scale
fusion, edge detection, and edge conditioning steps. LBR stands for a
sequential application of a Linear transformation, a batch normalization, and
a ReLU.

Let $\textbf{P}\in\mathbb{R}^{N\times 3}$ be a patch consisting of $N$ points
and $\textbf{p}_{i}=(x_{i},y_{i},z_{i})\in\mathbb{R}^{3}$ denote the
coordinates of point $i$. A point $i$ can be associated with a feature
$\textbf{f}_{i}\in\mathbb{R}^{d}$. Our task is to estimate the unoriented
normals $\textbf{n}\in\mathbb{R}^{N\times 3}$ of this patch from P. The
overall architecture is illustrated in Fig. 2. Given a patch of point clouds,
a backbone extracts multi-scale features for each point. Then, features from
each stage are fed into the MSEC stream. The motivation for introducing the
MSEC stream is explained in Sec. 3.1. The first step of the stream is feature
fusion (Sec. 3.2) which merges features from different scales. The resulting
multi-scale features are subsequently used for adaptive edge detection (Sec.
3.3). Then, the detected edges are used to condition the output of the
backbone to produce edge-aware representation (Sec. 3.4). Finally, normals are
regressed from the resulting features. Other details are elaborated in Sec.
3.5.

Unlike previous work that estimates only one normal for a patch, we estimate
normals for all points of the patch. This allows for a significant speedup in
inference, which is described in Sec. 3.5.

###  3.1. Motivation

Successful edge modeling must rely on multi-scale analysis for two reasons.
First, edges are naturally multi-scale (Marr and Hildreth, 1980), and thus
combining multiple scales improves edge detection (Ren, 2008). Second, single-
scale edge detection is hardly effective in the presence of data corruption
such as noise and density variations. Combining information from large and
small scales can help to estimate normals accurately while being robust
against data corruption.

To obtain features of different scales, it is natural to use hierarchical DNNs
(e.g., PointNet++ (Qi et al., 2017b)), which perform efficient multi-scale
learning through the use of local aggregation and subsampling. One might think
that the output of such networks could be used for edge detection. However,
from an edge detection perspective, the problem with these networks is that
each layer only has direct access to adjacent scales. Direct access to non-
adjacent scales is hampered by intermediate processing such as transformations
and subsampling, which can severely compromise the rich information contained
in the original features. Therefore, we construct a new stream so that the
edge detector can directly access all scales.

###  3.2. Multi-Scale Fusion

Effectively combining features of different scales is critical for edge
detection. In this work, a feature from one stage of the backbone network
represents a single-scale feature that characterizes a particular scale based
on receptive field size and density.

A common multi-scale fusion strategy for normal estimation aggregates
information from larger scales using max-pooling to extract more information
about the underlying geometry (Zhu et al., 2021; Li et al., 2022b, a).
However, since edges are spatial structures and aggregation destroys spatial
relationships, such fusion methods are not suitable for our purpose.
Therefore, instead of aggregating from larger scales, we distribute
information from larger scales to preserve spatial structures. As shown in
Fig. 2, an output from a stage undergoes a 3-neighbor interpolation before
entering the MSEC stream. The interpolation ensures that the spatial density
of the feature is the same as the input, since we want to detect edges from
the raw point cloud. Unlike the popular gradual interpolation strategy (e.g.,
PointNet++ (Qi et al., 2017b)), our strategy allows a jump across the
hierarchy. This jump results in “blurred” point clouds that efficiently
describe multi-scale structures. As a result, each point has direct access to
rich features learned at different scales.

Let $\textbf{f}^{s}_{i}$ denote the feature of point $i$ whose scale is
$s\in\\{1,2,...,S\\}$. Given $S$ features from different scales, the initial
multi-scale feature is produced by merging all features of different scales
and embedding them into a single vector:

(1)
$\textbf{f}_{i}^{fused}=\phi\left(\left[\textbf{f}_{i}^{1},\textbf{f}_{i}^{2},...,\textbf{f}_{i}^{S}\right]\right),$

where $\phi:\mathbb{R}^{d_{1}+d_{2}+...+d_{S}}\to\mathbb{R}^{d_{fused}}$
denotes an LBR and $[\cdot]$ denotes the concatenation. $\phi$ is shared among
points and nonlinearly maps features of different scales to the fixed
$d_{fused}$-dimensional space. Hence, the resulting features have the accuracy
of small scales and robustness of large scales. However, a point-wise fusion
is not sufficient for edge detection due to various factors: 1) small-scale
features are too sensitive to noise; 2) large-scale features have poor
localization; and 3) interpolation may produce biased multi-scale features due
to biases in sampling density. A key observation is that the above issues can
be addressed by spatial filtering. Therefore, we introduce space
transformation that spatially filters the fused feature. Let $\mathcal{N}(i)$
denote the local neighborhood of point $i$. The space transformation is
defined as:

(2)
$\textbf{f}^{sp}_{i}=\max_{j\in\mathcal{N}(i)}\alpha\left(\left[\textbf{p}_{j}-\textbf{p}_{i},\textbf{f}_{j}^{fused}\right]\right),$

where $\alpha:\mathbb{R}^{3+d_{fused}}\to\mathbb{R}^{d_{fused}}$ is an MLP
consisting of point-wise linear transformations, batch normalizations, and
ReLUs. $\max$ denotes a max-pooling operation within the neighborhood of point
$i$. The relative positions are concatenated to $\textbf{f}^{fused}_{i}$ to
better describe the 3D geometry of points. Consequently, the space
transformation strives to address the above issues by sharpening important
details on the one hand and smoothing harmful signals on the other.
Furthermore, we introduce the channel transformation that performs intra-
channel filtering:

(3) $\textbf{f}_{i}^{spch}=\beta\left(\textbf{f}^{sp}_{i}\right),$

where $\textbf{f}_{i}^{spch}$ indicates features that undergo spatial and
channel transformations and
$\beta:\mathbb{R}^{d_{fused}}\to\mathbb{R}^{d_{fused}}$ represents an MLP,
similar to $\alpha$. With more refined and noise-free features as input, the
channel transformation aims to produce more discriminative features by
nonlinear mapping, in the same sense as a position-wise feed-forward network
in the transformer (Vaswani et al., 2017).

Successive transformations inevitably increase the difficulty of optimization.
Transformations may also result in the loss of useful information contained in
the original features. Therefore, we adopt a residual structure (He et al.,
2016) to ease the optimization while reducing information loss. Specifically,
the output of the fusion is:

(4) $\textbf{f}_{i}^{ms}=\textbf{f}^{fused}_{i}+\textbf{f}_{i}^{spch},$

where $\textbf{f}_{i}^{ms}$ denotes the resulting multi-scale features.

###  3.3. Adaptive Edge Detection

Given a multi-scale feature, the detection step transforms the features so
that the output describes the “edgeness” of the point. For our purposes, the
desired detector should satisfy two requirements. First, the operator should
be computationally efficient, since it must be computed for many training
iterations. Second, the detector should be permutation invariant because the
point clouds can come in any order. To this end, we advocate the use of the
discrete Laplacian (or the umbrella operator (Taubin, 1995)). Unlike
sophisticated edge detectors (e.g., (Dollár and Zitnick, 2014)), the Laplacian
is a linear operator and can be computed by simply taking the differences
between neighbors. In addition, the Laplacian is permutation invariant because
it involves only pairwise differences and a symmetric function (i.e.,
averaging).

However, there are situations where the Laplacian may not be sufficient or
even problematic. For instance, Laplacian is known to be sensitive to noise
and may amplify noisy signals, leading to less reliable edge detection. On the
other hand, there might be weak edges that could be smoothed out easily, which
is undesirable since these edges reflect small changes in surface normals that
should be accurately modeled. To address these concerns, we propose
introducing adaptability into the Laplacian to sharpen useful edges while
suppressing noisy signals. Specifically, edge detection using the adaptive
Laplacian can be expressed as follows:

(5)
$\textbf{e}_{i}=\varphi\left(\frac{1}{|\mathcal{N}(i)|}\sum_{j\in\mathcal{N}(i)}\theta\left(\textbf{f}_{j}^{ms}-\textbf{f}_{i}^{ms}\right)\right),$

where $\textbf{e}_{i}$ denotes the detected edges and
$\theta,\varphi:\mathbb{R}^{d_{fused}}\to\mathbb{R}^{d_{fused}}$ denote point-
wise MLPs. $\theta$ filters the pairwise difference in a local neighborhood to
emphasize significant differences and smooth harmful ones. $\varphi$ is shared
among all points to capture a more complex relationship between detected
edges, making the representation more discriminative. Consequently,
$\textbf{e}_{i}$ can effectively describe the “edgeness” of points. Note that
Eq. (5) degenerates to the raw Laplacian when $\theta$ and $\varphi$ are
removed.

###  3.4. Edge Conditioning

While detected edges are accurate and robust to data corruption, the edges
have limited information about surface orientation as the detector is based on
the isotropic Laplacian. Consider a scenario where two perpendicular planes
intersect. Our edge detector would ideally produce zero vectors for every
point within the planes. However, this would result in the detector being
unable to distinguish between points on the different planes, which in turn
would prevent the differentiation of their normal vectors. To address this
issue, we must supplement the detected edges with global information that
contains surface orientation. This can be achieved by combining the detected
edges and the output of the backbone. As the backbone network essentially
learns the representation of the surface, it naturally contains information
about surface orientations (not necessarily the globally correct one because
our task is to estimate unoriented normals). Specifically, we propose an edge
conditioning operation that conditions edges on the backbone output and
generates an edge-aware surface representation:

(6)
$\textbf{f}_{i}^{cond}=\textbf{f}^{b}_{i}+\gamma\left(\left[\textbf{f}^{b}_{i},\textbf{e}_{i}\right]\right),$

where $\textbf{f}_{i}^{cond}$ denotes the edge-aware surface representation,
$\textbf{f}_{i}^{b}\in\mathbb{R}^{d_{out}}$ is the backbone output, and
$\gamma:\mathbb{R}^{d_{fused}+d_{out}}\to\mathbb{R}^{d_{out}}$ denotes an LBR.
It conditions edges to global information with nonlinear mapping to construct
a feature that can be used for accurate normal estimation. Similar to Eq. (4),
we adopt a residual structure to facilitate optimization while reducing
information loss.

###  3.5. MSECNet

Backbone. As shown in Fig. 2, MSECNet consists of a backbone and an MSEC
stream. We adopt the popular PointNet++ (Qi et al., 2017b) except that each
encoder layer is adapted into a residual structure (He et al., 2016) to save
computation. The network performs subsamplings three times in the encoder, and
each time the number of points is halved while the feature dimension is
doubled. Then, three upsampling layers are used to recover the original point
cloud with nearest-neighbor interpolation. Every interpolation layer adopts a
U-Net (Ronneberger et al., 2015)-like skip connection to help feature
reconstruction. The feature dimension of the first stage is set to 64. Unlike
many prior studies that generate a single normal for a patch center, we
estimate the normals for all points in the patch. In the case of a single-
output network, it is necessary for the network to iterate through all points
to compute normal vectors for the entire point cloud. In contrast, MSECNet
only needs to run until the patches cover the whole cloud, making the
inference dramatically faster (Sec. 4.5).

Loss functions. We adopt two standard loss functions for normal estimation.
The first one is the regression loss (Guerrero et al., 2018; Zhang et al.,
2022):

(7)
$\mathcal{L}^{reg}=\frac{1}{N}\sum_{i=1}^{N}\min(||\widehat{\textbf{n}}_{i}-\textbf{n}_{i}||^{2},||\widehat{\textbf{n}}_{i}+\textbf{n}_{i}||^{2}),$

where $\widehat{\textbf{n}}_{i}$ denotes an estimated normal. The regression
loss is used to penalize the Euclidean distance between estimated and ground
truth normals. Additionally, we adopt a sine loss (Ben-Shabat and Gould, 2020;
Li et al., 2022a) to penalize the angular distance:

(8)
$\mathcal{L}^{sin}=\frac{1}{N}\sum_{i=1}^{N}|\widehat{\textbf{n}}_{i}\times\textbf{n}_{i}|,$

where $\times$ denotes the cross product. Consequently, the total loss is

(9) $\mathcal{L}=\mathcal{L}^{reg}+\mathcal{L}^{sin}.$

We do not include other popular loss functions like the consistency loss (Ben-
Shabat and Gould, 2020; Zhu et al., 2021; Li et al., 2022b) or geometry-
guiding loss (Zhang et al., 2022; Li et al., 2022a) because they are not
applicable or involves manual thresholding.

Figure 3. Examples of point clouds in the PCPNet dataset.  Table 1. Normal angle RMSE results on the PCPNet and SceneNN datasets. The lower the better. Method | Year | PCPNet Dataset | SceneNN Dataset
---|---|---|---
Noise $\sigma$ | Density | Average | Clean | Noise | Average
None | 0.12% | 0.6% | 1.2% | Stripes | Gradient
PCA (Hoppe et al., 1992) | 1992 | 12.29 | 12.87 | 18.38 | 27.52 | 13.66 | 12.81 | 16.25 | 15.93 | 16.32 | 16.12
Jet (Cazals and Pouget, 2005) | 2005 | 12.35 | 12.84 | 18.33 | 27.68 | 13.39 | 13.13 | 16.29 | 15.17 | 15.59 | 15.38
PCPNet (Guerrero et al., 2018) | 2018 | 9.64 | 11.51 | 18.27 | 22.84 | 11.73 | 13.46 | 14.58 | 20.86 | 21.40 | 21.13
Zhou et al. (Zhou et al., 2020) | 2020 | 8.67 | 10.49 | 17.62 | 24.14 | 10.29 | 10.66 | 13.62 | - | - | -
Nesti-Net (Ben-Shabat et al., 2019) | 2019 | 7.06 | 10.24 | 17.77 | 22.31 | 8.64 | 8.95 | 12.49 | 13.01 | 15.19 | 14.10
Lenssen et al. (Lenssen et al., 2020) | 2020 | 6.72 | 9.95 | 17.18 | 21.96 | 7.73 | 7.51 | 11.84 | 10.24 | 13.00 | 11.62
DeepFit (Ben-Shabat and Gould, 2020) | 2020 | 6.51 | 9.21 | 16.73 | 23.12 | 7.92 | 7.31 | 11.80 | 10.33 | 13.07 | 11.70
MTRNet (Cao et al., 2021) | 2021 | 6.43 | 9.69 | 17.08 | 22.23 | 8.39 | 6.89 | 11.78 | - | - | -
Refine-Net (Zhou et al., 2022) | 2022 | 5.92 | 9.04 | 16.52 | 22.19 | 7.70 | 7.20 | 11.43 | 18.09 | 19.73 | 18.91
Zhang et al. (Zhang et al., 2022) | 2022 | 5.65 | 9.19 | 16.78 | 22.93 | 6.68 | 6.29 | 11.25 | 9.31 | 13.11 | 11.21
AdaFit (Zhu et al., 2021) | 2021 | 5.19 | 9.05 | 16.45 | 21.94 | 6.01 | 5.90 | 10.76 | 8.39 | 12.85 | 10.62
GraphFit (Li et al., 2022b) | 2022 | 4.45 | 8.74 | 16.05 | 21.64 | 5.22 | 5.48 | 10.26 | - | - | -
NeAF (Li et al., 2023) | 2023 | 4.20 | 9.25 | 16.35 | 21.74 | 4.89 | 4.88 | 10.22 | - | - | -
HSurf-Net (Li et al., 2022a) | 2022 | 4.17 | 8.78 | 16.25 | 21.61 | 4.98 | 4.86 | 10.11 | 7.55 | 12.23 | 9.89
Ours | - | 3.84 | 8.74 | 16.10 | 21.05 | 4.34 | 4.51 | 9.76 | 6.94 | 11.66 | 9.30

Figure 4. RMSE visualization. Numbers indicate RMSEs. The “Point cloud”
columns show point clouds colored by ground truth normals. (a) Examples from
the PCPNet dataset. From top to bottom: clean, density corrupted, and noisy
point clouds. (b) Examples from SceneNN dataset. The top one is clean and the
others are noisy point clouds.

Angle error visualizations.

##  4\. Experiment

###  4.1. Datasets and Settings

We evaluate MSECNet with the PCPNet dataset (Guerrero et al., 2018) which
consists of several synthetic point clouds. Each clean cloud has corrupted
variants with different noise levels or density variations. Ground truth
normals of corrupted variants are the same as clean ones. Some examples are
shown in Fig. 3. Next, we evaluate the generalizability of MSECNet on the
SceneNN dataset (Hua et al., 2016), a real-world dataset consisting of indoor
scenes. We use the dataset prepared by (Li et al., 2022a), which contains
clean and noisy scenes. All models are pretrained on the PCPNet dataset and
applied to the SceneNN dataset without fine-tuning. For the PCPNet dataset, we
follow the settings in (Guerrero et al., 2018) including the train-test split
and data augmentation. During training, we randomly sample 1000 patches for
each sample. The patch size is set to $N=700$, following previous works (Zhu
et al., 2021; Li et al., 2022a). The patch size (k) of kNN in the backbone is
set to 16 and 9 for the MSEC stream. The AdamW (Loshchilov and Hutter, 2019)
optimizer with an initial learning rate of $2\times 10^{-3}$ is used and the
learning rate is decayed by cosine annealing schedule until it is reduced to
$2\times 10^{-5}$. The model is trained with a batch size of 128 and trained
for 150 epochs on four NVIDIA Tesla V100 GPUs.

For the evaluation metric, we use the common angle Root Mean Squared Error
(RMSE) between the estimated normal and the ground truth to evaluate
performance.

The normal estimation results are reported in Sec. 4.2. Also, we perform
various analyses including the ablation study (Sec. 4.3), visualization of
edge conditioning (Sec. 4.4), efficiency analysis (Sec. 4.5), and the
application to surface reconstruction (Sec. 4.6).

###  4.2. Normal Estimation

As shown in Tab. 1, MSECNet achieves the best scores in terms of average
performance, demonstrating its effectiveness. In addition, MSECNet achieves
the best scores in most categories. Thus, MSECNet consistently performs well
in a variety of situations. Compared to baselines, MSECNet performs
particularly well when data are significantly corrupted (see “1.2%” and
“Stripes”). We speculate that our fusion strategy and adaptability of the
detector lead to a better understanding of the underlying geometry, leading to
improved robustness. MSECNet also achieves the best score in the real-world
scenario, which verifies its good generalizability.

As shown in Fig. 4 (a), the topmost example shows that explicit edge modeling
of MSECNet significantly reduces errors at sharp edges. When the density is
significantly biased (the middle one), MSECNet produces a robust prediction
despite that many points are missing. We believe that the fusion of all scales
leads to more reliable surface descriptions. In the bottom example, strong
noise causes many false edges to appear, turning a smooth surface into a rough
surface. MSECNet produces smooth and accurate predictions, whereas existing
methods produce salt-and-pepper errors. This also proves that MSECNet learns
the underlying geometry well.

###  4.3. Ablation Study

Table 2. Results of ablations. The lower the better. The $\Delta$ column shows the difference of “Average” compared with “Default”. Ablation |  Noise $\sigma$ | Density | Average | $\Delta$
---|---|---|---|---
None | 0.12% | 0.6% | 1.2% | Stripes | Gradient
Default |  |  $S$=4, $d_{fused}=1024$, Direct interpolation,
---
Space + Channel, w/ adaptive Lap., w/ edge cond.
3.84 | 8.74 | 16.10 | 21.05 | 4.34 | 4.51 | 9.76 | -
(a) | w/o MSEC stream | 5.10 | 8.97 | 16.22 | 21.04 | 5.92 | 5.73 | 10.50 | -0.74
$S$=1 | 3.75 | 9.04 | 16.34 | 21.12 | 4.43 | 4.54 | 9.86 | -0.10
$S$=2 | 3.73 | 8.87 | 16.25 | 21.14 | 4.41 | 4.42 | 9.80 | -0.04
$S$=3 | 3.80 | 8.83 | 16.24 | 21.06 | 4.44 | 4.44 | 9.80 | -0.04
(b) |  $d_{fused}$=256 | 3.97 | 8.81 | 16.10 | 20.98 | 4.64 | 4.67 | 9.86 | -0.10
$d_{fused}$=512 | 3.85 | 8.75 | 16.07 | 21.04 | 4.46 | 4.58 | 9.79 | -0.03
(c) | Gradual interpolation | 3.91 | 8.92 | 16.15 | 21.12 | 4.59 | 4.58 | 9.88 | -0.12
(d) | Channel transformation | 4.03 | 8.82 | 16.12 | 21.09 | 4.71 | 4.75 | 9.92 | -0.16
Space transformation | 3.89 | 8.83 | 16.16 | 21.04 | 4.52 | 4.55 | 9.83 | -0.07
(e) | w/o adaptability | 3.86 | 8.85 | 16.17 | 21.05 | 4.44 | 4.52 | 9.82 | -0.06
(f) | edge only | 4.37 | 8.89 | 16.22 | 21.09 | 5.10 | 5.01 | 10.11 | -0.35
w/o conditioning | 3.87 | 8.84 | 16.11 | 21.07 | 4.48 | 4.53 | 9.82 | -0.06

(a) Number of scales. The effectiveness of the MSEC stream is investigated by
varying the number of scales involved, where $S=1$ represents the smallest
scale and each increment of $S$ adds an adjacent larger one. As shown in Tab.
2 (a), the model achieves mediocre performance when the MSEC stream is not
used. However, adding just one scale significantly improves performance,
demonstrating the effectiveness of explicit edge modeling. Also, consistent
improvement for noisy samples as $S$ increases from 1 to 4 suggests that
integrating more scales provides better robustness to noise.

(b) Size of $d_{fused}$. The amount of information retained from different
scales is determined by the size of $d_{fused}$. Tab. 2 (b) shows that
increasing $d_{fused}$ from 256 to 1024 results in a reduction in the average
error, indicating that a larger $d_{fused}$ can preserve more useful
information. The performance of “None” and density variations also improves as
$d_{fused}$ increases. Therefore, a larger $d_{fused}$ can provide a more
comprehensive descriptor and enhance the network’s robustness against sampling
biases.

(c) Interpolation strategy. We investigate the effectiveness of our direct
interpolation strategy by comparing it to the standard gradual interpolation,
i.e., the feature propagation layer (Qi et al., 2017b). Note that no
transformation is applied for a fair comparison. As shown in Tab. 2 (c), our
direct interpolation results in lower errors consistently across all
corruption types.

(d) Space and channel transformations. As shown in Tab. 2 (d), an increase in
average error indicates that a channel transformation cannot make full use of
multi-scale features. The significant decrease in estimation under density
variations indicates that sampling biases cannot be well resolved. As
expected, the situation improves when the space transformation is used instead
of the channel one. The combination of space and channel transformations
achieves the best performance, which fully verifies their necessities.

(e) Effect of the adaptability. To validate the effect of the adaptability in
the adaptive Laplacian, we remove $\theta$ and $\varphi$ from Eq. (5). As
shown in Tab. 2 (e), the adaptability is effective for estimation under low to
medium levels of noise and “Striped” corruption. Thus, the adaptability is
most effective in situations where surface geometry is significantly
distorted. Also, no improvement is seen under the strongest noise level. For
complex point clouds, it is assumed that the noise almost completely destroys
the raw local geometry, making edge detection challenging.

(f) Effect of the edge conditioning. As shown in Tab. 2 (f), the importance of
global information is confirmed by the 0.35 drop in performance when
$\textbf{f}_{i}^{b}$ is removed from Eq. (6). To verify the effect of edge
conditioning, we only remove $\textbf{f}_{i}^{b}$ from $\gamma$, which leads
to a performance drop of 0.06. This result shows that conditioning is useful,
but the degradation is not as severe as when $\textbf{f}_{i}^{b}$ is entirely
removed thanks to the residual connection.

###  4.4. Visualization of Edge Conditioning

Figure 5. Effect of the MESC stream on RMSEs. Figure 6. Visualization of learned features. The sample patches are the same ones as Fig. 5. “Edge” indicates detected edges. “Before” shows the output of the backbone ($\textbf{f}_{i}^{b}$) and “After” shows the features after edge conditioning. Table 3. Number of parameters and inference Time. The average inference time for point clouds with 100k points is reported.  |  Ours ($d_{fused}=256$) |  Ours ($d_{fused}=512$) |  Ours ($d_{fused}=1024$) |  HSurf-Net (Li et al., 2022a) |  AdaFit (Zhu et al., 2021) |  DeepFit (Ben-Shabat and Gould, 2020)
---|---|---|---|---|---|---
Param. (M) | 1.92 | 3.83 | 10.40 | 2.16 | 4.87 | 3.53
Time (s) | 0.45 | 0.45 | 0.93 | 56.70 | 26.54 | 45.12

As shown in Fig. 5, high RMSEs are observed mainly at the edges, where errors
are corrected by the MSEC stream. Thus, the effect of the MSEC stream is most
pronounced in the accurate estimation at the edges. Further, using the same
sample as in Fig. 5, we visualize the detected edges and the effect of edge
conditioning using $l^{2}$-norm. As can be seen from Fig. 6, the edges are
correctly detected, as strong responses are obtained in the edge regions.
After conditioning, the feature distribution changes significantly, confirming
that edge-conditioned representation is obtained. Combining Fig. 5 and 6, we
confirm that the MSEC stream contributes to the improvement.

###  4.5. Number of Parameters and Inference Time

The results are presented in Tab. 3. We use an NVIDIA Tesla V100 with a batch
size of 128. As shown, our default model with $d_{fused}=1024$ is
significantly faster than other methods. Additionally, we can significantly
reduce the model size by decreasing $d_{fused}$ without compromising
performance too much (see Tab. 2 (b)). Therefore, we conclude that MSECNet can
be a practical choice for normal estimation in situations where resources are
limited.

###  4.6. Application to Surface Reconstruction

Figure 7. Result of surface reconstruction.

We use surface reconstruction to demonstrate the utility of MSECNet. Poisson
reconstruction (Kazhdan et al., 2006) is used to reconstruct surfaces. Fig. 7
shows that the reconstructed surfaces using our normals are more precise than
those produced by other methods.

##  5\. Conclusion

We propose MSECNet, a novel method for improving normal estimation at normal
varying regions. The key is that the modeling of normal variations is
converted to the modeling of geometric edges. We design the MSEC stream that
performs multi-scale edge conditioning. MSECNet achieves state-of-the-art
performance on both synthetic and real-world datasets while running
significantly faster than existing methods. We also confirm that the MSEC
stream better models the geometry in the presence of data corruptions.
Therefore, a promising direction for future research is to extend MSECNet to
tasks such as point cloud filtering and generation.

###### Acknowledgements.

This paper is based on the results of a project, JPNP20006, commissioned by
the New Energy and Industrial Technology Development Organization (NEDO). We
would also like to acknowledge the support from JSPS Grant-in-Aid for
Scientific Research (21K12042).

## References

  * (1)
  * Alexa et al. (2001) Marc Alexa, Johannes Behr, Daniel Cohen-Or, Shachar Fleishman, David Levin, and Claudio T Silva. 2001.  Point set surfaces. In _Proceedings Visualization, 2001. VIS’01._ IEEE, 21–29.
  * Alliez et al. (2007) Pierre Alliez, David Cohen-Steiner, Yiying Tong, and Mathieu Desbrun. 2007.  Voronoi-based variational reconstruction of unoriented point sets. In _Symposium on Geometry processing_ , Vol. 7. 39–48.
  * Arbelaez et al. (2010) Pablo Arbelaez, Michael Maire, Charless Fowlkes, and Jitendra Malik. 2010.  Contour detection and hierarchical image segmentation.  _IEEE transactions on pattern analysis and machine intelligence_ 33, 5 (2010), 898–916.
  * Ben-Shabat and Gould (2020) Yizhak Ben-Shabat and Stephen Gould. 2020.  DeepFit: 3D surface fitting via neural network weighted least squares. In _Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part I 16_. Springer, 20–34.
  * Ben-Shabat et al. (2019) Yizhak Ben-Shabat, Michael Lindenbaum, and Anath Fischer. 2019\.  Nesti-net: Normal estimation for unstructured 3d point clouds using convolutional neural networks. In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_. 10112–10120.
  * Boulch and Marlet (2016) Alexandre Boulch and Renaud Marlet. 2016.  Deep learning for robust normal estimation in unstructured point clouds. In _Computer Graphics Forum_ , Vol. 35. Wiley Online Library, 281–290.
  * Canny (1986) John Canny. 1986\.  A computational approach to edge detection.  _IEEE Transactions on pattern analysis and machine intelligence_ 6 (1986), 679–698.
  * Cao et al. (2021) Junjie Cao, Hairui Zhu, Yunpeng Bai, Jun Zhou, Jinshan Pan, and Zhixun Su. 2021\.  Latent tangent space representation for normal estimation.  _IEEE Transactions on Industrial Electronics_ 69, 1 (2021), 921–929.
  * Cazals and Pouget (2005) Frédéric Cazals and Marc Pouget. 2005.  Estimating differential quantities using polynomial fitting of osculating jets.  _Computer Aided Geometric Design_ 22, 2 (2005), 121–146.
  * Dey and Sun (2006) Tamal K Dey and Jian Sun. 2006.  Normal and feature approximations from noisy point clouds. In _FSTTCS 2006: Foundations of Software Technology and Theoretical Computer Science: 26th International Conference, Kolkata, India, December 13-15, 2006. Proceedings 26_. Springer, 21–32.
  * Dollár and Zitnick (2014) Piotr Dollár and C Lawrence Zitnick. 2014.  Fast edge detection using structured forests.  _IEEE transactions on pattern analysis and machine intelligence_ 37, 8 (2014), 1558–1570.
  * Garrido et al. (2021) Daniel Garrido, Rui Rodrigues, A Augusto Sousa, Joao Jacob, and Daniel Castro Silva. 2021\.  Point cloud interaction and manipulation in virtual reality. In _2021 5th Int’l Conf. on Artificial Intelligence and Virtual Reality (AIVR)_. 15–20.
  * Gouraud (1971) Henri Gouraud. 1971\.  Continuous shading of curved surfaces.  _IEEE transactions on computers_ 100, 6 (1971), 623–629.
  * Guennebaud and Gross (2007) Gaël Guennebaud and Markus Gross. 2007.  Algebraic point set surfaces.  In _ACM siggraph 2007 papers_. 23–es.
  * Guerrero et al. (2018) Paul Guerrero, Yanir Kleiman, Maks Ovsjanikov, and Niloy J Mitra. 2018.  Pcpnet learning local shape properties from raw point clouds. In _Computer graphics forum_ , Vol. 37. Wiley Online Library, 75–85.
  * Hashimoto and Saito (2019) Taisuke Hashimoto and Masaki Saito. 2019.  Normal Estimation for Accurate 3D Mesh Reconstruction with Point Cloud Model Incorporating Spatial Structure.. In _CVPR workshops_ , Vol. 1.
  * He et al. (2019) Jianzhong He, Shiliang Zhang, Ming Yang, Yanhu Shan, and Tiejun Huang. 2019.  Bi-directional cascade network for perceptual edge detection. In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_. 3828–3837.
  * He et al. (2016) Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016\.  Deep residual learning for image recognition. In _Proceedings of the IEEE conference on computer vision and pattern recognition_. 770–778.
  * Hoppe et al. (1992) Hugues Hoppe, Tony DeRose, Tom Duchamp, John McDonald, and Werner Stuetzle. 1992.  Surface reconstruction from unorganized points. In _Proceedings of the 19th annual conf. on computer graphics and interactive techniques_. 71–78.
  * Hua et al. (2016) Binh-Son Hua, Quang-Hieu Pham, Duc Thanh Nguyen, Minh-Khoi Tran, Lap-Fai Yu, and Sai-Kit Yeung. 2016\.  Scenenn: A scene meshes dataset with annotations. In _2016 fourth international conference on 3D vision (3DV)_. Ieee, 92–101.
  * Kazhdan et al. (2006) Michael Kazhdan, Matthew Bolitho, and Hugues Hoppe. 2006\.  Poisson surface reconstruction. In _Proceedings of the fourth Eurographics symposium on Geometry processing_ , Vol. 7. 0.
  * Kittler (1983) Josef Kittler. 1983\.  On the accuracy of the Sobel edge detector.  _Image and Vision Computing_ 1, 1 (1983), 37–42.
  * Lancaster and Salkauskas (1981) Peter Lancaster and Kes Salkauskas. 1981.  Surfaces generated by moving least squares methods.  _Mathematics of computation_ 37, 155 (1981), 141–158.
  * Lenssen et al. (2020) Jan Eric Lenssen, Christian Osendorfer, and Jonathan Masci. 2020.  Deep iterative surface normal estimation. In _Proceedings of the ieee/cvf conference on computer vision and pattern recognition_. 11247–11256.
  * Li et al. (2022b) Keqiang Li, Mingyang Zhao, Huaiyu Wu, Dong-Ming Yan, Zhen Shen, Fei-Yue Wang, and Gang Xiong. 2022b.  GraphFit: Learning Multi-scale Graph-Convolutional Representation for Point Cloud Normal Estimation. In _Computer Vision–ECCV 2022: 17th European Conference, Tel Aviv, Israel, October 23–27, 2022, Proceedings, Part XXXII_. Springer, 651–667.
  * Li et al. (2022a) Qing Li, Yu-Shen Liu, Jin-San Cheng, Cheng Wang, Yi Fang, and Zhizhong Han. 2022a.  HSurf-Net: Normal Estimation for 3D Point Clouds by Learning Hyper Surfaces.  _Advances in Neural Information Processing Systems (NeurIPS)_ (2022).
  * Li et al. (2023) Shujuan Li, Junsheng Zhou, Baorui Ma, Yu-Shen Liu, and Zhizhong Han. 2023.  NeAF: Learning Neural Angle Fields for Point Normal Estimation. In _Proceedings of the AAAI Conference on Artificial Intelligence_.
  * Liu et al. (2017) Yun Liu, Ming-Ming Cheng, Xiaowei Hu, Kai Wang, and Xiang Bai. 2017.  Richer convolutional features for edge detection. In _Proceedings of the IEEE conference on computer vision and pattern recognition_. 3000–3009.
  * Loshchilov and Hutter (2019) Ilya Loshchilov and Frank Hutter. 2019.  Decoupled Weight Decay Regularization. In _International Conference on Learning Representations_.  https://openreview.net/forum?id=Bkg6RiCqY7
  * Lu et al. (2020) Dening Lu, Xuequan Lu, Yangxing Sun, and Jun Wang. 2020\.  Deep feature-preserving normal estimation for point cloud filtering.  _Computer-Aided Design_ 125 (2020), 102860.
  * Marr and Hildreth (1980) David Marr and Ellen Hildreth. 1980.  Theory of edge detection.  _Proceedings of the Royal Society of London. Series B. Biological Sciences_ 207, 1167 (1980), 187–217.
  * Martin et al. (2004) David R Martin, Charless C Fowlkes, and Jitendra Malik. 2004\.  Learning to detect natural image boundaries using local brightness, color, and texture cues.  _IEEE transactions on pattern analysis and machine intelligence_ 26, 5 (2004), 530–549.
  * Mitra and Nguyen (2003) Niloy J Mitra and An Nguyen. 2003.  Estimating surface normals in noisy point cloud data. In _Proceedings of the nineteenth annual symposium on Computational geometry_. 322–328.
  * Pu et al. (2021) Mengyang Pu, Yaping Huang, Qingji Guan, and Haibin Ling. 2021\.  Rindnet: Edge detection for discontinuity in reflectance, illumination, normal and depth. In _Proceedings of the IEEE/CVF international conf. on computer vision_. 6879–6888.
  * Pu et al. (2022) Mengyang Pu, Yaping Huang, Yuming Liu, Qingji Guan, and Haibin Ling. 2022.  Edter: Edge detection with transformer. In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_. 1402–1412.
  * Qi et al. (2017a) Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. 2017a.  Pointnet: Deep learning on point sets for 3d classification and segmentation. In _Proceedings of the IEEE conference on computer vision and pattern recognition_. 652–660.
  * Qi et al. (2017b) Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. 2017b.  Pointnet++: Deep hierarchical feature learning on point sets in a metric space.  _Advances in neural information processing systems_ 30 (2017).
  * Ren (2008) Xiaofeng Ren. 2008\.  Multi-scale improves boundary detection in natural images. In _Computer Vision–ECCV 2008: 10th European Conference on Computer Vision, Marseille, France, October 12-18, 2008, Proceedings, Part III 10_. Springer, 533–545.
  * Ronneberger et al. (2015) Olaf Ronneberger, Philipp Fischer, and Thomas Brox. 2015\.  U-Net: Convolutional Networks for Biomedical Image Segmentation. In _Medical Image Computing and Computer-Assisted Intervention – MICCAI 2015_ , Nassir Navab, Joachim Hornegger, William M. Wells, and Alejandro F. Frangi (Eds.). Springer International Publishing, Cham, 234–241.
  * Roveri et al. (2018) Riccardo Roveri, A Cengiz Öztireli, Ioana Pandele, and Markus Gross. 2018.  Pointpronets: Consolidation of point clouds with convolutional neural networks. In _Computer Graphics Forum_ , Vol. 37. Wiley Online Library, 87–99.
  * Sharma et al. (2021) Rajat Sharma, Tobias Schwandt, Christian Kunert, Steffen Urban, and Wolfgang Broll. 2021\.  Point cloud upsampling and normal estimation using deep learning for robust surface reconstruction.  _arXiv preprint arXiv:2102.13391_ (2021).
  * Su et al. (2021) Zhuo Su, Wenzhe Liu, Zitong Yu, Dewen Hu, Qing Liao, Qi Tian, Matti Pietikäinen, and Li Liu. 2021\.  Pixel difference networks for efficient edge detection. In _Proceedings of the IEEE/CVF international conf. on computer vision_. 5117–5127.
  * Taubin (1995) Gabriel Taubin. 1995\.  A signal processing approach to fair surface design. In _Proceedings of the 22nd annual conference on Computer graphics and interactive techniques_. 351–358.
  * Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017.  Attention is all you need.  _Advances in neural information processing systems_ 30 (2017).
  * Wang et al. (2022) Weijia Wang, Xuequan Lu, Dasith De Silva Edirimuni, Xiao Liu, and Antonio Robles-Kelly. 2022\.  Deep point cloud normal estimation via triplet learning. In _2022 IEEE International Conference on Multimedia and Expo (ICME)_. IEEE, 1–6.
  * Xie and Tu (2015) Saining Xie and Zhuowen Tu. 2015.  Holistically-nested edge detection. In _Proceedings of the IEEE international conference on computer vision_. 1395–1403.
  * Zhang et al. (2022) Jie Zhang, Jun-Jie Cao, Hai-Rui Zhu, Dong-Ming Yan, and Xiu-Ping Liu. 2022.  Geometry guided deep surface normal estimation.  _Computer-Aided Design_ 142 (2022), 103119.
  * Zhou et al. (2022) Haoran Zhou, Honghua Chen, Yingkui Zhang, Mingqiang Wei, Haoran Xie, Jun Wang, Tong Lu, Jing Qin, and Xiao-Ping Zhang. 2022.  Refine-net: Normal refinement neural network for noisy point clouds.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ 45, 1 (2022), 946–963.
  * Zhou et al. (2020) Jun Zhou, Hua Huang, Bin Liu, and Xiuping Liu. 2020\.  Normal estimation for 3D point clouds via local plane constraint and multi-scale selection.  _Computer-Aided Design_ 129 (2020), 102916.
  * Zhou et al. (2023) Jun Zhou, Wei Jin, Mingjie Wang, Xiuping Liu, Zhiyang Li, and Zhaobin Liu. 2023\.  Improvement of normal estimation for point clouds via simplifying surface fitting.  _Computer-Aided Design_ 161 (2023), 103533.
  * Zhu et al. (2021) Runsong Zhu, Yuan Liu, Zhen Dong, Yuan Wang, Tengping Jiang, Wenping Wang, and Bisheng Yang. 2021.  AdaFit: rethinking learning-based normal estimation on point clouds. In _Proceedings of the IEEE/CVF international conference on computer vision_. 6118–6127.