Chems-Eddine Himeur
email: himeur@irit.fr

Thibault Lejemble
email: lejemble@irit.fr

Thomas Pellegrini
email: thomas.pellegrini@irit.fr

Mathias Paulin
email: mathias.paulin@irit.fr

Loic Barthe
email: loic.barthe@irit.fr

Nicolas Mellado
email: nicolas.mellado@irit.fr

PCEDNet : A Lightweight Neural Network for Fast and Interactive Edge Detection in 3D Point Clouds

Keywords: Point clouds processing, neural networks, edge detection, datasets, energy efficiency, low resource computing

In recent years, Convolutional Neural Networks (CNN) have proven to be efficient analysis tools for processing point clouds, e.g., for reconstruction, segmentation and classification. In this paper, we focus on the classification of edges in point clouds, where both edges and their surrounding are described. We propose a new parameterization adding to each point a set of differential information on its surrounding shape reconstructed at different scales. These parameters, stored in a Scale-Space Matrix (SSM), provide a well suited information from which an adequate neural network can learn the description of edges and use it to efficiently detect them in acquired point clouds. After successfully applying a multi-scale CNN on SSMs for the efficient classification of edges and their neighborhood, we propose a new lightweight neural network architecture outperforming the CNN in learning time, processing time and classification capabilities. Our architecture is compact, requires small learning sets, is very fast to train and classifies millions of points in seconds.

CCS Concepts: • Computing methodologies → Point-based models; Shape Analysis; Neural networks.

INTRODUCTION

Nowadays, acquired point clouds is a very common and widespread representation. The large range of acquisition devices and Computer Vision techniques massively generate clouds with tens or hundreds of millions of points. The shapes sampled by these large unstructured data are arbitrarily complex, and their processing remains extremely tedious. Edges are fundamental features for processing point clouds and their automatic detection is thus useful in a wide range of applications in the fields of computer vision (e.g. feature extraction), computer graphics (e.g. contour line reconstruction) and others. Despite regular advances over the years, it remains an open, very challenging problem.

In general, edges are defined strictly as sharp edges, e.g. for manufactured objects [START_REF] Koch | ABC: A Big CAD Model Dataset for Geometric Deep Learning[END_REF], or as feature lines for objects. When asked to draw feature lines, users tend to follow more complex rules that may vary from people to people [START_REF] Cole | Where Do People Draw Lines?[END_REF]. This leads to a lack of clear theoretical definition of an edge, especially on 3D surfaces acquired from models including features of different scales and more or less damaged/clean edges (e.g. stone or plastered buildings, progressively smoothed edges, polished mechanical parts, etc). In addition, an edge can be considered as sharp or smooth depending on the observation scale. This generates contextualized and potentially ambiguous interpretation of what edges are. For instance, different persons produced different annotations on the models provided for the recent feature curve detection contest [START_REF] Moscoso Thompson | Feature Curve Extraction on Triangle Meshes[END_REF]]. These models include a large variety of different edges, from sharp to smooth and rounded. This underlines that the frontier between an edge and a smooth surface (i.e. a feature boundary and a feature continuity) remains subjective, especially in the case of real world models.

Machine Learning (ML) approaches have gain a lot of interest for their ability to efficiently reproduce theoretically łfuzzyž or complicated classifications for which we are able to provide a sufficiently large set of annotated data. At first glance, they thus seem particularly attractive to create efficient edge detectors. However, in the context of point cloud processing, ML remains very challenging to use as there is neither natural ordering [START_REF] Zaheer | Deep Sets[END_REF] nor intrinsic parameterization of the input data. In the past years, patches of points have been used by several approaches to apply Convolution Neural Networks (CNN) for classification [Qi et al. 2017], local shape property estimation [START_REF] Guerrero | PCPNet: Learning Local Shape Properties from Raw Point Clouds[END_REF], and continuous sharp edges classification/ reconstruction [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF].

For edge detection, geometric approaches avoid using patches by considering geometric descriptors parameterizing each individual point [START_REF] Demarsin | Detection of closed sharp edges in point clouds using normal estimation and graph theory[END_REF][START_REF] Weinmann | Feature relevance assessment for the semantic interpretation of 3D point cloud data[END_REF]. Following this idea, [START_REF] Hackel | Contour Detection in Unstructured 3D Point Clouds[END_REF] propose to train a random forest classifier taking as input geometric quantities obtained at multiple scales by linear regression in order to classify points belonging to edges.

In this paper, we introduce both a new way to individually parameterize points, together with a dedicated edge detection lightweight neural network classifier called Point Cloud Edge Detection Network (PCEDNet). Points are parameterized with a so-called Scale-Space Matrix (SSM) (Section 3.2) encoding extrinsic geometric properties of a locally reconstructed surface surrounding each point of the input point cloud at multiple scales. The use of this multi-scale parameterization allows us to propose a compact architecture (Section 3.3) based on a simple neural network enabling both its training in seconds or few minutes on small data sets, and the processing of 500 thousands of points per second on average with our current CPU implementation (Table 10). This fast training and the limited requirement on annotated data allow to easily specialize our network to specific edge definitions, as illustrated in Figures 1-a and1-b. It is fast enough to allow a user to interactively label small sub-parts of a point cloud and let our network annotate millions of points in seconds (Figure 1-c, Section 5.7).

The choice of our SSM values is validated by an ablation study (Section 5.1), and we evaluate the effectiveness of our network by comparing its speed and accuracy with existing geometric edge detection approaches, point-based processing networks, and two baselines: a Convolutional Neural Network (CNN) and a Fully Connected neural network (FC) (Section 3.4). Our results (Section 5) demonstrate the superiority of our PCEDNet over previous works, and illustrate its efficiency on a large variety of data, from CAD models to real world examples with tens of millions of points (Figures 1-a and25).

Current networks processing point clouds rely on very deep architectures in an end-to-end strategy. While the way our point parameterization is computed is not novel in geometry processing, the use of these parameters structured in our SSM as input of a network is new. Our proposition illustrates how a simple network exploiting these multi-scale geometric surface descriptors overpasses current approaches. We believe that its superiority in training and evaluation speed, scalability and resource requirements (computation, memory) makes it an example for the creation of lightweight point cloud processing solutions opening new perspectives regarding the system interactivity and adaptation to user's wishes. This is also a step forward to reach real-time point cloud processing with limited resources and low energy consumption (Section 5.8), which are both becoming very important challenges when also considering embedded systems and environmental impact.

RELATED WORK

In this section, we first present the way unorganized point clouds are parameterized before being processed for geometric learning (Section 2.1). We introduce the different existing architectures for point-based machine learning and we discuss methods for edge detection from point clouds (Section 2.2). We then review geometric approaches (Section 2.3) dedicated to this topic.

Point cloud parameterization

Point clouds are most of the time defined as unordered and unstructured set of points sampling an unknown surface. When using neural networks on point clouds, a first challenge is to define a regular structure of the cloud that fits a network architecture, i.e. to parameterize the point cloud according to the network architecture. Several approaches have been proposed to tackle this challenge. A first class of approaches parameterizes unstructured point clouds in regular grids, e.g. using series of images taken from different viewpoints [START_REF] Boulch | SnapNet: 3D point cloud semantic labeling with 2D deep segmentation networks[END_REF][START_REF] Boulch | Unstructured Point Cloud Semantic Labeling Using Deep Segmentation Networks[END_REF][START_REF] Kalogerakis | 3D Shape Segmentation with Projective Convolutional Networks[END_REF][START_REF] Su | Multi-view convolutional neural networks for 3d shape recognition[END_REF], or using voxel grids [START_REF] Maturana | VoxNet: A 3D Convolutional Neural Network for Real-Time Object Recognition[END_REF][START_REF] Ruizhongtai | Frustum PointNets for 3D Object Detection from RGB-D Data[END_REF][START_REF] Ruizhongtai | Volumetric and Multi-View CNNs for Object Classification on 3D Data[END_REF]Wu et al. 2015;[START_REF] Zhou | VoxelNet: End-to-End Learning for Point Cloud Based 3D Object Detection[END_REF]. The main limitation of these approaches is the cells memory requirement that limits their scalability to very large models especially when detecting thin structures and details, as edges.

A second class of approaches processes each point and its neighborhood, so that the point coordinates are directly processed by the network. PointNet and its variants [START_REF] Guerrero | PCPNet: Learning Local Shape Properties from Raw Point Clouds[END_REF]Qi et al. 2017;Qi et al. 2017] use multi-layer perceptron (MLP) to consecutively sample and group point coordinates and build geometric features around a point. Several approaches have been proposed to extend convolution to 3D point clouds, using local spectral convolution [START_REF] Wang | Local Spectral Graph Convolution for Point Set Feature Learning[END_REF], parameterized convolutional filters [START_REF] Xu | Spidercnn: Deep learning on point sets with parameterized convolutional filters[END_REF], transformed points [START_REF] Li | PointCNN: Convolution On X-Transformed Points[END_REF], sparse lattices [START_REF] Su | SPLATNet: Sparse Lattice Networks for Point Cloud Processing[END_REF], adaptive kernels [START_REF] Boulch | Generalizing Discrete Convolutions for Unstructured Point Clouds[END_REF]] and kernel point convolution [START_REF] Thomas | KPConv: Flexible and Deformable Convolution for Point Clouds[END_REF].

The strong benefit of point-based convolutions is to allow the design of networks whose first layers learn features at multiple scales directly from the point locations. On the other hand, the characterization of geometric structures relies on the way convolution layers capture those features, only based on the local spatial organization of points. On real data, point sets also include sampling variation, noise, outliers and missing data that also have to be learned.

Network architectures

Most of the point-based geometry analysis neural networks are tailored for point cloud segmentation [START_REF] Dai | ScanNet: Richly-annotated 3D Reconstructions of Indoor Scenes[END_REF]] and classification [START_REF] Hackel | SEMANTIC3D.NET: A new large-scale point cloud classification benchmark[END_REF]Zhirong Wu et al. 2015]. They follow the rational introduced by PointNet, where point coordinates are abstracted by successive layers, then reduced using max pooling for feature extraction and finally processed with MLP for the final decision. Such architectures aim at abstracting the input point cloud and estimating high level or semantic properties.

Some approaches also aim at processing point clouds according to their local geometric properties, e.g. normal estimation [START_REF] Boulch | Deep Learning for Robust Normal Estimation in Unstructured Point Clouds[END_REF]. PCPNet [START_REF] Guerrero | PCPNet: Learning Local Shape Properties from Raw Point Clouds[END_REF]] learns local shape properties (e.g. normal vectors) directly from raw point clouds. Interestingly, this work suggests a multi-scale architecture where several networks process the surrounding of the analyzed point at increasing neighborhood size (one network per size). The features learned by the different networks are stacked to form a feature vector, and processed by a fully connected network to produce the final decision. Recently, the deep Learning Point Network architecture [START_REF] Lê | Going Deeper with Lean Point Networks[END_REF] improves the implementation of convolution-based point cloud processing networks such as PointNet, DGCNN [START_REF] Wang | Dynamic Graph CNN for Learning on Point Clouds[END_REF] and SpiderNet [START_REF] Zhao | SpiderNet: A spiderweb graph neural network for multi-view gait recognition[END_REF].

Overall, all these networks have been designed to extract semantic information from point clouds, which justify their both deep and large architectures. In our more geometric and specialized context, these architectures become unnecessarily complex while requiring long training and processing times.

Edge detection

Detecting edges in unstructured point clouds is usually cast as a sharp feature, a feature contour or a curve detection problem. It is often the first step of constrained surface reconstruction algorithms and over the years, many approaches have been proposed in this context. We refer the interested reader to the survey by [START_REF] Berger | A Survey of Surface Reconstruction from Point Clouds[END_REF]. A standard approach is to compute at each point a geometric descriptor using the eigenstructure of the covariance matrix [START_REF] Gumhold | Feature extraction from point clouds[END_REF]. It can be a ratio between the eigenvalues, taking into account their evaluation at different scales [START_REF] Pauly | Multi-scale Feature Extraction on Point-Sampled Surfaces[END_REF] or not [START_REF] Xia | A Fast Edge Extraction Method for Mobile Lidar Point Clouds[END_REF], or directly a curvature estimation [START_REF] Lin | Line segment extraction for large scale unorganized point clouds[END_REF][START_REF] Wei Liang Nguyen | Edge detection from point cloud of worn parts[END_REF]]. The ratio between eigenvalues is considered as a more reliable parameter and it is, for instance, used in the CGAL Library [START_REF] Alliez | Point Set Processing[END_REF]] with a Delaunay-based feature estimation [START_REF] Mérigot | Voronoi-Based Curvature and Feature Estimation from Point Clouds[END_REF]]. While well established, all these approaches suffer from a sensibility to noise and they perform at a given scale with a strong dependence to a decision threshold. The methods introduced by [START_REF] Pauly | Multi-scale Feature Extraction on Point-Sampled Surfaces[END_REF] and [START_REF] Pkgpointsetprocessing | Fast and Robust Edge Extraction in Unorganized Point Clouds[END_REF] consider curvature ratio at different scales that reduces the dependence to the scale of analysis and the sensibility to noise, but they remain subject to a decision threshold.

Another family of methods relies on Moving Least Squares surface reconstruction [START_REF] Demarsin | Detection of closed sharp edges in point clouds using normal estimation and graph theory[END_REF][START_REF] Ni | Edge detection and feature line tracing in 3d-point clouds by analyzing geometric properties of neighborhoods[END_REF][START_REF] Weber | Sharp feature preserving MLS surface reconstruction based on local feature line approximations[END_REF]. Using this reconstruction, edge detection can be performed on a Gaussian map clustering computed in a local neighborhood [START_REF] Weber | Sharp Feature Detection in Point Clouds[END_REF]. Adaptive reconstruction kernels [START_REF] Fleishman | Robust Moving Least-Squares Fitting with Sharp Features[END_REF] can also be combined with polynomial fit [START_REF] Daniels | Spline-based feature curves from point-sampled geometry[END_REF]. Other approaches rely either on subspace detection and feature intersection computation [START_REF] Leandro | A general framework for subspace detection in unordered multidimensional data[END_REF], on the mean-shift algorithm to select the farthest points from the centroid of their neighborhood [START_REF] Syeda | Edge and Corner Detection for Unorganized 3D Point Clouds with Application to Robotic Welding[END_REF], on the average of neighbors altitude over a local tangent plane [START_REF] Li | Curve Set Feature-Based Robust and Fast Pose Estimation Algorithm[END_REF], or on the intersection of planes detected using RANSAC [START_REF] Mitropoulou | An Automated Process to Detect Edges in Unorganized Point Clouds[END_REF]. In other contexts, edges are defined as a specific type of lines on the surface. [START_REF] Lin | Line segment extraction for large scale unorganized point clouds[END_REF] use RANSAC to spatially regularize the response of a sharp feature detector. Recently, [START_REF] Hackel | Contour Detection in Unstructured 3D Point Clouds[END_REF] proposed a data-driven method where the points are classified and then structured using a graph-based approach. Extending local sharp feature detectors by a global analysis improves the robustness of the detection but limits the scalability, a critical aspect when processing large sets of point clouds defined by tens of millions of points or more.

With an architecture extending PU-Net [Yu et al. 2018], ECNet [Yu et al. 2018] is a network consolidating edges after up-sampling the point cloud and detecting its edges. ECNet is thus a very deep network requiring important resources for training and processing points at inference time, while being limited in scalability by its upsampling. Finally, the recent PIENet [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]] first trains two networks based on PointNet++ [Qi et al. 2017] for respectively classifying edge points and corner points. The classified points are filtered with a non-maximal suppression, and clustered by feature using the third variant of PointNet++. A resulting set of curves is then generated by a two-headed PointNet network [Qi et al. 2017]. Even if it is closely related to our proposal, the Pie-Net edge classification is based on a concatenation of several networks with deep architecture, and it is thus also prone to high resource requirements.

In this work, as suggested by [START_REF] Hackel | Contour Detection in Unstructured 3D Point Clouds[END_REF], we propose to take advantage of the discrimination offered by geometric descriptors in a machine learning approach. We increase the robustness to noise and the adaptation to the different feature size and shape by the use of stable multi-scale descriptors including derivatives over scales. We then use these parameters together with a specifically designed neural network. By relying on this set of descriptive parameters, our network avoids the deep design of existing approaches by only requiring a very compact architecture that recursively combines the features learned at different analysis scales.

METHOD 3.1 Problem statement

Given a surface sampled by a point cloud, a sharp edge is commonly defined as a tangential discontinuity. [START_REF] Weber | Sharp Feature Detection in Point Clouds[END_REF] define edges as sharp features (crests and valleys) between two meeting planes, as well as corners at the point of intersection between three or more planes. [START_REF] Hackel | Contour Detection in Unstructured 3D Point Clouds[END_REF] call them "wire-frame contours", and define edges as linear features along which the orientation (normals) of the underlying surface exhibits an unusual discontinuity.

There are at least two main reasons why these definitions are restrictive and not really practical for the analysis of point clouds: sampling real-world objects, on which edges are always more or less rounded (Figure 16)/damaged (Figure 25). For instance, two facades of a building might be locally connected by a continuous curved surface considered as an edge at the scale of the building, which may be unlikely to be detected at finer scales such as the one of the bricks. In order to handle these situations, we propose to classify points as sharp-edge when they lie on a sharp edge, and as smooth-edge when they are (1) near a sharp edge or (2) on a rounded edge. Other points are then labeled as non-edge. Depending on the application context and the artifacts found in the data, one might consider either one or the two edge classes in the results (we experimentally validate this proposition of two edge classes in Section 5.1). In this paper, we denote our network as PCEDNet when it is used with three classes and as PCEDNet-2C when it is used with two classes. Considering that we do not have a universal and practical definition of an edge, we propose to learn the point-based classification of this feature from examples. For instance, when edges have similar geometries and discretization over all models, PCEDNet-2C may be preferred while PCEDNet is suggested when the edge definition is more fuzzy. In that case, the sharp-edge class is to be used to annotate what is considered as an edge (whatever sharp or smooth/rounded) and the smooth-edge class is rather to annotate points at proximity of the points tagged as sharp-edges or on features that are close to what is considered to be an edge. We do not suggest any automatic or threshold-based annotation approach as, so far, they are not robust enough and they do not enable the flexibility of letting the user defining his definition of edges through annotations.

In order to be robust to acquisition artifacts, sampling issues and edge roundness, we first reconstruct the surface described by the input points using a robust reconstruction algorithm at multiple scales. We then compute geometric descriptors of the reconstructed surfaces, which are parameters to be processed by a machine learning algorithm (see Section 3.2). We show how this parameterization can be used with a common CNN and a fully connected neural network (Section 3.4), and we propose a dedicated architecture (Section 3.3) that outperforms these networks as well as previous edge classification approaches.

Scale-Space Matrix

Our approach is inspired by the Growing Least Squares (GLS) approach [START_REF] Mellado | Growing Least Squares for the Analysis of Manifolds in Scale-Space[END_REF], where the geometry surrounding a point is described by the differential properties of the surfaces reconstructed from neighborhoods of increasing size. We first present the basics of GLS, and then introduce the Scale-Space Matrix (SSM), which wraps in a regular structure the differential properties of the surfaces reconstructed at different scales.

The GLS extends the concept of Scale-Space analysis [START_REF] Lindeberg | Scale-Space Theory in Computer Vision[END_REF][START_REF] Witkin | Scale-space filtering[END_REF] to point-based shape analysis. The key idea is to detect pertinent geometric structures and scales as stabilities in scalespace. Stabilities are found when the magnitude of the derivatives of the surface is minimized when the scale varies. Due to its multi-scale nature, this approach disambiguates between noise and features, and detects geometric features defined at arbitrary scales. As such, points on a rounded and a sharp edge have discriminative descriptors and can be disambiguated during classification.

We denote S 𝑡 the continuous surface reconstructed at scale 𝑡, defined as the 0-isosurface of a scalar field 𝑆 𝑡 (x) : R 3 → R. We use the Algebraic Point Set Surfaces (APSS) [START_REF] Guennebaud | Algebraic Point Set Surfaces[END_REF] to reconstruct continuous surfaces from raw point clouds. This approach has been proven to be fast and stable at large scales [START_REF] Guennebaud | Dynamic Sampling and Rendering of Algebraic Point Set Surfaces[END_REF]. As many other previous work, the scale is controlled by varying the size of a neighborhood ball centered around the evaluation point.

In its original formulation, the pertinent scale extraction introduced by [START_REF] Mellado | Growing Least Squares for the Analysis of Manifolds in Scale-Space[END_REF] combines several descriptors measuring the variation of local relief (i.e. the algebraic distance from the point to the locally reconstructed surface) 𝛿𝑡 , where 𝜏 (x, 𝑡) : R 4 → R, 𝜂 (x, 𝑡) : R 4 → R 3 and 𝜅 (x, 𝑡) : R 4 → R are scale-invariant properties of the surfaces S 𝑡 (x) (mathematical formulations are presented in Appendix A). They also use 𝜙 (S 𝑡 (x)), the residuals of the fitting process, as confidence value.

In this work we propose to extend this idea further by measuring the surface variation in scale and space around each sample p 𝑖 of the input point cloud. We do not seek at defining an hand-crafted descriptor, but rather providing differential properties of the surface that are discriminative for edge detection. According to the GLS formalism, the parameters 𝜏, 𝜂 and 𝜅 are differentiable both in scale and space, which leads to a Jacobian matrix of 5 × 4 entries (see the description in Appendix A). By keeping only the quantities that are invariant by rigid transformations and not linearly dependent, we obtain the following feature vector 𝑋 𝑡 𝑖 :

𝑋 𝑡 𝑖 = 𝜏 𝑡 𝑖 𝜅 𝑡 𝑖 𝑘1 𝑡 𝑖 𝛿𝜏 𝑡 𝑖 𝛿𝑡 𝛿𝜅 𝑡 𝑖 𝛿𝑡 𝜙 (𝑆 𝑡 p 𝑖 ) (1)
where 𝜏 𝑡 𝑖 = 𝜏 (p 𝑖 , 𝑡) and 𝜅 𝑡 𝑖 = 𝜅 (p 𝑖 , 𝑡). 𝑘1 𝑡 𝑖 measures the magnitude of the first principal curvature of the surface, and is computed from The Scale-Space Matrix (SSM) defines a structured parameterization of the surfaces S 𝑡 described by the feature vectors 𝑋 𝑡 𝑖 computed at 𝑁 scales on each of the 𝑀 points of the cloud. It is thus defined as follows:

𝑆𝑆𝑀 =          𝑋 1 1 𝑋 1 2 𝑋 1 3 . . . 𝑋 1 𝑀 𝑋 2 1 𝑋 2 2 𝑋 2 3 . . . 𝑋 2 𝑀 . . . . . . . . . . . . . . . 𝑋 𝑁 1 𝑋 𝑁 2 𝑋 𝑁 3 . . . 𝑋 𝑁 𝑀 .          . ( 2
)
The minimum scale 𝑠 min is defined as the mean distance between points computed using the k nearest neighbors of each point (k=10), and the maximum scale 𝑠 max is 10% of the diagonal of the point cloud axis aligned bounding box (the effect of the variation of these values is presented in Section 5.9). According to previous work [START_REF] Bronstein | Scale-invariant heat kernel signatures for nonrigid shape recognition[END_REF][START_REF] Mellado | Relative scale estimation and 3D registration of multi-modal geometry using Growing Least Squares[END_REF], we use a logarithmic scale sampling to obtain scale-invariant feature vectors, such that:

𝑠 𝑖 = 𝑠 max 𝑠 min 𝑖-1 𝑁 -1 * 𝑠 min , 𝑖 = 1..𝑁 . (3)
For all our experiments we use 16 scales distributed according to Equation 3 (the use of different number of input scales is discussed in Section 5.2). Even though we carefully selected the set of descriptors defining our SSM for their geometric meaning with respect to edge detection, we validate the optimality of this choice when parameterizing our neural network by an ablation study presented in Section 5.1.

Our network: PCEDNet

The architecture of our Point Cloud Edge Detection Network, denoted PCEDNet, is depicted in Figure 3. The input data is provided to the network as sixteen 6-dimensional vectors 𝑋 𝑡 𝑖 per point, each vector corresponding to a scale (Figure 3-left column). The sixteen scale vectors are concatenated by groups of two in order to form eight 12-dimensional vectors. More precisely, the first scale is grouped with the second one, the third one with the fourth one, and so on. The idea is to halve the number of scales iteratively until obtaining a single 12-dimensional vector as a final feature representation (four left columns of black circles in Figure 3).

All the layers are fully-connected layers, also called dense layers (linear layer with biases, depicted in Figure 3-green box), followed by a sigmoid activation function. For the first layer, each vector of size 12 is given to a dense layer comprised of 6 neurons. There are eight input vectors and each vector is fed to its own 6-neuron layer. The weights are not shared between these small layers, allowing to process the scales differently, as would do a convolution layer, but here, we combine scales by groups of two. The subsequent three layers perform similarly, but with 48, 24, 12 neurons, respectively.

The final 12-dimensional feature vector is given to a multi-layer perceptron (MLP) responsible for the classification (MLP architecture is presented in Figure 3-blue/purple/red boxes). This MLP is composed of two 16-neurons dense+sigmoid layers followed by the output layer with 3 neurons and a softmax activation function. The

6×12 12×1 6×1 6×1 W In B Out 16×12 12×1 16×1 16×1 W In B Out 16×16 16×1 16×1 16×1 W In B Out 3×16 16×1 3×1 3×1 W In B Out
Fig. 3. Our PCEDNet architecture. The left column of circles represents the input sixteen 6-dimensional vectors 𝑋 𝑡 𝑖 . They are successively pairwise concatenated and processed by dense layers coupled with 6 neurons as depicted in the green box (W: weights, In: input and B: bias). The output vector of size 12 is then processed by a multi-layer perceptron (boxes blue, purple and red) for providing the output classification.

total number of weights is about 2.1k, which makes our architecture very compact.

The goal of grouping different scales together is to observe the input shape at different scales in a simultaneous and more intricate way than without grouping them. We expect that this eases the simultaneous detection of higher-scale and sharp geometric properties of the input point clouds. Another reason is that such a representation helps the model to cope with noise in the point clouds.

The "tree structure" merging scales two by two iteratively can be seen as a variant of a grouped convolution operation. It preserves the high computing speed of keeping the scales separate while also mixing the scales layer after layer. It is expected to reduce the chance of being biased by a specific scale and the sensitivity to scale-dependent noise.

Baseline models

The use of this new architecture is justified only if it performs better than more common choice of networks. We thus incorporate as baselines two networks in our evaluation:

• FC: A Fully Connected variant of PCEDNet where all scales are connected (Figure 4).

• CNN: A 1-d Convolutional Neural
Network with a number of layers similar to our PCEDNet architecture (Figure 5).

FC. This architecture presented in Figure 4 allows us to measure the impact of the pairwise scale connection introduced in PCEDNet. FC and PCEDNet architectures differ by the four first layers: instead of consecutively combining scales by pairs, the FC baseline combines all the scales in unique dense layers while keeping the same reduction rate, i.e. 16-8-4-2 scales. We use the same number of neurons than PCEDNet to get comparable architectures. In total, the FC baseline is comprised of about 6663 weights (three times more than PCEDNet). The input data is provided to the network by concatenating the sixteen 6-dimensional vectors used by PCEDNet in a single 96-dimensional vector.

CNN. We chose a standard convolutional neural network architecture presented in Figure 5, composed of two blocks: a first block for representation learning with two 1D convolution layers, each followed by a ReLU activation function, and a second block dedicated to classification with three fully-connected layers and one 3D output layer. We tried a large number of variants and the one we present is the best we obtained by trials and errors. The two convolution layers are composed of 15 filters, with a kernel size of 6 and 5, respectively. Zero padding of size 2 was used to get outputs of shape 15 × 5. The three dense layers are composed of 75, 15 and 15 neurons, respectively, followed by the output layer with 3 neurons. A sigmoid activation function is used after all the dense layers, except the output layer that uses a softmax non-linearity function. In total, CNN is composed of about 8.7k weights. The input data is also provided to the network as sixteen 6-dimensional vectors. Using the different scales as channels enables a potentially larger expressivity power to the model since each convolution filter uses different weights to combine the scales.

EXPERIMENTAL SETUP 4.1 Point cloud dataset

We measure the efficiency and adaptability of our network on three different datasets with ground truth for learning and evaluation: edges on point clouds with acquisition artifacts (Default), sharp edges on CAD models (ABC) and annotated curves on challenging shapes (SHREC). Each dataset is split in three sets: training set (denoted T, used for training), validation set (denoted V, used for learning to monitor accuracy) and evaluation set (denoted E). Visual evaluations are also conducted on a set of acquired models. Point clouds with classification results are shown in the website accompanying the submission.

In addition to annotated learning sets, we also show in Section 5.7 how PCEDNet can learn from small set of data annotated interactively by a user and classify point clouds without requiring additional predefined training data.

Default dataset. We design this dataset to emulate geometric structures regularly found in acquired point clouds. It is as small as possible, in order to demonstrate that a few annotated data used for training our network in a short time are enough for an effective detection (see timings in Table 2). The Default dataset is composed of 8 synthetic models containing edges of different shapes illustrated in Figure 6 and 7, and detailed in Table 1. We also included some of our models characterized by varying densities and shapes (i.e. Cube, Cone, Fandisk and 2-cube), with different levels of noise generated by a random motion on the points following a Gaussian distribution with standard deviation denoted 𝜎 (the different values of 𝜎 per model are given in Table 1-Noise). We defined the validation set by selecting a random subset within the training set with an equal number of points across the three classes (1k per class, 3k in total). We also created an evaluation set with specific features to better evaluate the networks against noise and sharp angles. ABC dataset. We use the ABC dataset [START_REF] Koch | ABC: A Big CAD Model Dataset for Geometric Deep Learning[END_REF] to evaluate the performance of our network on the detection of sharp edges in CAD models. We use the chunk 000, which contains 7167 models represented as OBJ files. We generate the point clouds by exporting the vertices and the normal vectors of the meshes. The ground truth classification is produced using the vertices associated to a sharp feature in the feature files. A notable difference with the Default dataset is that no ground truth information is provided for the smooth-edge label. Only sharp edges are considered and other smoother features are thus labeled as non-edge. We define the training and evaluation sets by randomly selecting 200 and 50 models respectively (see the model list in the joined website). SHREC dataset. We use the dataset produced for feature curve extraction by [START_REF] Moscoso Thompson | Feature Curve Extraction on Triangle Meshes[END_REF] in order to evaluate the performance of our network on challenging data annotated by humans. As for ABC, we consider the vertices and normal vectors of the given meshes, and mark the annotated vertices as edge vertices. Similarly, we define the training and evaluation sets by randomly selecting models, e.g., (M5, M6 and M14) and (M2, M11) respectively. This procedure is not ideal as these models exhibit very heterogeneous edge shapes, but we found it fairer than randomly sampling the point clouds.

Acquired point clouds. We also perform visual evaluations on 9 acquired point clouds whose number of vertices are reported in Table 10. Normal estimation. The normals used for the GLS computation are either directly those estimated with the acquisition technique (e.g. photogrammetry, laser scanner), which are actually provided for most current acquisition devices, or those computed automatically from the point samples (we used Meshlab [START_REF] Cignoni | MeshLab: an Open-Source Mesh Processing Tool[END_REF] to estimate normals on Default dataset and on Euler, Lans, Church and Train Station). We did not encounter any difficulty related to normal estimation. Eventually, oriented normals may be avoided and replaced by unoriented normals [Chen et al. 2013a], which could be easily estimated using local fitting.

Networks training

Implementation details. We implemented PCEDNet in C++ and ran our experiments on a 10-cores Intel Xeon(R) CPU E5-2640 v4 (20 threads), with 128GB RAM. We use the Ponca library [START_REF] Mellado | Ponca: a Point Cloud Analysis Library[END_REF] for surface fitting and derivative computation. These surface fitting computations (GLS) are performed on two 10-cores Intel Xeon(R) CPU E5. The network modeling and evaluation for PCEDNet and FC is implemented in our own prototype using Eigen [START_REF] Guennebaud | Eigen v[END_REF]] for linear algebra. The baseline CNN is implemented, trained and evaluated using Pytorch.

Categorical cross-entropy is used as objective function for both the baseline architectures and PCEDNet. On each dataset, CNN, FC and PCEDNet are trained for 200, 200 and 40 epochs respectively, all reaching 98% accuracy on the validation sets. Weights are initialized randomly using the [START_REF] Glorot | Understanding the difficulty of training deep feedforward neural networks[END_REF] method. For the three architectures, learning rate is set to 0.01, momentum to 0.9, with batch size of 100 points.

Training. As illustrated in Table 1, the three training sets contain mostly non-edge surfaces. The small number of sharp and smooth edge samples (4-14% of the points) implies that we are in presence of a highly unbalanced training set biased towards the non-edge class. We handle this issue by generating balanced batches of points during training and validation. Batches are balanced by replicating sharp and smooth edge points until the number of points in each class is equal. We recorded training curves for PCEDNet on Default and ABC datasets (see Figure 8 and Table 6). As we can see in Figure 8-bottomleft, the behavior of the validation loss may appear unusual, even though in practice, it is sometimes observed in machine learning.

During the first epochs, starting from a random initialization, the network does not generalize yet on the validation set, which may result in an increase of the loss. Then, during the following epochs, even though decreasing, the loss may remain higher than its value at the random initialization, which may be due to the strong impact of wrong predictions on the loss value.

RESULTS

In this Section, we first validate our choice of input parameters with an ablation study (Section 5.1) and discuss the number of input scales (Section 5.2). We then compare our network with our baseline (i.e. CNN and FC), with ECNet [Yu et al. 2018] and PCPNet [START_REF] Guerrero | PCPNet: Learning Local Shape Properties from Raw Point Clouds[END_REF]] and two geometric feature detection methods, i.e. the covariance analysis method proposed by Bazazian et al. [2015] (CA) and the Feature Edge Estimation (FEE) implemented in the CGAL Library [START_REF] Alliez | Point Set Processing[END_REF][START_REF] Mérigot | Voronoi-Based Curvature and Feature Estimation from Point Clouds[END_REF]]. We also report the evaluation of PIENet and ECNet performed on the ABC dataset by [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]. For clarity, we denote A(D) the approach A trained on dataset D, e.g., PCEDNet trained on Default is denoted PCEDNet (Default). We present training and classification times (Section 5.3), quantitative comparisons (Section 5.4), visual comparisons (Section 5.5), networks behavior on noisy data (Section 5.6), the way our PCEDNet can be used for interactive learning (Section 5.7) and some complementary experiments (sensibility to variation in sampling, choice of the maximum scale and choice of the surface reconstruction method -Section 5.9). All of the Figures of the next sections are available in full resolution on the joined website homepage, with left/right interactive comparisons between the methods.

Results of the quantitative experiments on each dataset are documented in dedicated webpages presenting interactive distribution plots, histograms, tables, and a 3D point cloud viewer.

Comparison metrics. We compare positive and negative matches of the classifications w.r.t. ground truth by measuring True Positives (TP), True Negatives (TN), False Positives (FP) and False Negatives (FN). To do so, we consider the following metrics: Precision, Recall, F1-Score, Intersection over Union (IoU), Matthews Correlation Coefficient (MCC), and Accuracy, whose formulations are given in Appendix B. Note that F1 and IoU scores ignore the True Negatives and thus may be misleading for unbalanced classes, which is our case in general, i.e. the number of TP edge points is in general very small in comparison to the TN non-edge points. It is however reported for comparison as F1 and IoU are commonly used in similar contexts and it still provides a score aggregating Precision and Recall. Also note that the IoU metric is known to be very correlated to the F1 score (see their Equations in Appendix B) and they differ as the IoU is more sensitive to high errors (i.e. it is more affected by worst cases) while the F1 score tends to measure an average performance. In our case (i.e. with a low number of highly unbalanced classes), the number of TP significantly influences the result evaluation and [START_REF] Chicco | The advantages of the Matthews correlation coefficient (MCC) over F1 score and accuracy in binary classification evaluation[END_REF] explain in details how a measure of the correlation between observation and prediction relying on all TP, TN, FP, FN, as the MCC, better represent the quality of the network classification.

Comparison of classifications with two and three classes. As previously stated, PCEDNet outputs three classes corresponding to sharpedges, smooth-edges and non-edges. However if edges are defined as sharp features only (e.g. the ABC dataset), results from the smoothedge class does not bring significant quantitative information and only the sharp-edge class is of interest. In that case, we consider the sharp-edge as the unique positive class, and merge the smooth-edge and non-edge classes as the negative class. When a fuzzier definition is used for edges, as for the SHREC dataset where both rounded and sharp edges co-exists, we present additional results where the positive class is defined either as sharp edge only, or, as the union of sharp-edges and smooth-edges classes. Accordingly, three-classes approaches are trained on two-classes datasets as if no vertex is labelled as smooth-edge, but only has sharp-edge or non-edge.

Ablation study

In this Section, we validate both the choice of input parameters and the number of output classes (i.e two or three) of PCEDNet. Quantitative results are given respectively in Tables 3 and4. SSM. Our Scale-Space Matrix is composed of 6 parameters computed by differentiating the GLS implicit surface both in scale and space. In order to measure the relevance of our parameterization, we tested four alternative sets of parameters, ranging from 28 to 3 parameters per scale. For each scenario, the PCEDNet architecture is modified as follows: the number of weights of the four first layers is set according to the number of input parameters, as well as the connection between the fourth and fifth layers. We define the different parameter sets as follows:

• 28 parameters: taking all the derivatives of the GLS descriptor in scale and space, • 7 parameters: keeping only the derivatives that are invariant to rigid transformations (rotation, translation and scale), 𝜙 (𝑆 𝑡 p 𝑖 ) . We trained these five parameter configurations on Default and reported in Table 3 the Precision, Recall and F1 scores when applied on the evaluation set. As we compare 3-classes approaches on a 3classes dataset in this experiment, we sum-up TP and FP for both the sharp-edge and smooth-edge labels, and use non-edge for negatives. Our choice of 6 parameters is validated as it always has the higher Recall, F1 and MCC, while providing a good precision in comparison with the other sets of parameters. 1) for PCEDNet and its two-classes implementation PCEDNet-2C. As we can see, the addition of the third class improves the classification quality of the sharp-edge class.

leading
Number of output classes. We measure the impact of the smoothedge class on the quality of the sharp-edge classification by implementing a version, denoted PCEDNet-2C, in which the decision layers return scores for 2 classes instead of 3. We trained PCEDNet-2C on the Default dataset by considering points labelled as sharpedge for one class and as the union of non-edge and smooth-edge for the other class. We report in Table 4 the scores obtained by PCEDNet and PCEDNet-2C on the evaluation set. We can see that the addition of the third class allows PCEDNet to obtain higher scores than PCEDNet-2C, for all the metrics. Note that one class could have been the union of sharp and smooth edges and the other the nonedges. This increases the false positive rate and leads to the same best parameterization, with overall lower performance. This gain in performance can be due to the unequal sampling of point clouds and the lack of robustness of geometric thresholding, that makes the accurate labeling of edges very tedious. The addition of the smooth-edge class enables a more conservative labeling of points.

Different number of input scales

We now discuss the performances in training and processing times, and edge detection capabilities of our PCEDNet for 4, 8, 16, 32, 64 and 128 input scales. We modify our architecture by changing the number of pairwise concatenation/processing layers (respectively 1, 2, 3, 4, 5, 6) in its first stage (Figure 3-left, green dense layers). For all configurations, the training curves of our network on Default and ABC are similar to those presented in Figure 8. We report the timings obtained with the different number of input scales in Table 5 and we illustrate the results in Figure 9 on the Pisa Cathedral and on a model of the ABC dataset. In Figure 10 we also show the distribution of precision/recall scores for each number of input scales. Not surprisingly, computation times increase with the number of input scales. Depending on the number of different scales representing important features in a model, 8 to 32 scales may be used. For instance, as illustrated in Figures 9-bottom and 10, on the ABC dataset where edges are of similar scale and sharpness, 8 scales may be enough while Figure 9-top shows on the Pisa Cathedral model that 32 scales would improve the results on large models with several scales of interest. As a default architecture, we present PCEDNet with 16 scales as a good compromise between speed and detection rate. It provides both accurate detection on all the models we tested while enabling interactive training sessions (as presented in Section 5.7), however, if less emphasis is put on computation times, the input configuration with 32 scales may be considered. In our experiments, 64 and 128 input scales did not improve over 32 scales while being significantly slower.

Training and classification times

In this section we compare the learning and evaluation speed of our specialized approach to more versatile networks based on Point-Net [Qi et al. 2017], the state of the art solution for point-based learning and semantic shape analysis. Among the different possibilities, we selected ECNet [Yu et al. 2018] , PCPNet [START_REF] Guerrero | PCPNet: Learning Local Shape Properties from Raw Point Clouds[END_REF]] as they can be easily adapted to our more geometric and focused problem. We also include the evaluation of the edge classification presented on PIENet on the ABC dataset by [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF].

Experimental setup for compared approaches. For PCPNet, we ran a specialization training in order to adapt its original output from point normals estimation to point classification. We removed the output normalization from their architecture, and trained the last layers of the network (using the default hyperparameters provided by the authors) using our data (400 epochs on Default, and 50 epochs on ABC). This allows us to take advantage of PCPNet original training for the first layers. For ECNet, we use the pre-trained version provided by the authors (denoted ECNet (EC)), and we report the evaluation provided in [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF] for ECNet (ABC) and PIENet (ABC), respectively the ECNet network and PIENet trained on ABC, when applied on the ABC dataset. Note that ECNet oversamples the input point cloud, and label each generated point as edge or non-edge. We retrieve the classification of the input point cloud by assigning to each input point the label of the closest output sample. PCPNet, ECNet and PIENet approaches require more computation power and memory than provided by our 10-cores Intel Xeon-E5 to handle large data sets as ABC. For training PCPNet, and evaluating both PCPNet and ECNet, we thus used an NVIDIA Quadro RTX 6000 with 24GB of G-RAM and PIENet was trained on an NVIDIA TITAN X GPU in [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]. This is reminded by a * in the text and in tables when we report timings.

Training. We trained PCPNet with three classes on our Default dataset (denoted PCPNet (Default)) and with two classes on ABC (denoted PCPNet-2C (ABC)). As shown by the loss plot in Figure 11-left 5. Timings for training (first row) and processing (second and third) point clouds using PCEDNet for the different number of input scales (from 4 to 128). We report the network training/classification time followed in brackets by the total_time with total_time = GLS_precomputation+processing_time. For the ABC dataset (second row) we provide the times for processing the 7167 models. loss plot in Figure 11-right) is better adapted and enables the convergence of PCPNet training with low loss. Regarding the timings, PCPNet and PIENet require significantly longer training than our approach (more than 500 times slower on ABC), as reported in Table 6.

Classification. In addition to PCPNet, ECNet and PIENet, we compare our approach with CA [Bazazian et al. 2015] (for all our experiments, we used 10 neighbors and threshold=0.65, except for Munich for which we used 20 neighbors to handle sparse sampling), FEE [START_REF] Mérigot | Voronoi-Based Curvature and Feature Estimation from Point Clouds[END_REF]] (we specifically adjusted parameters for each dataset), our baselines CNN and FC. We report in Figure 12 the evolution of the classification timings (in logarithmic scale) when increasing the point cloud size. We observe for PCEDNet, FC and CNN that scale-space calculation (which can be done in pre-process) requires more time than the classification itself. It also illustrates how fast our compact network architecture is, compared to more complex and computationally intensive architectures as PCPNet, ECNet, and PIENet. Finally, PCPNet and ECNet require more than 24 GB G-RAM to handle large point clouds and we thus could not provide the timings for the classification of our larger models by these networks.

Quantitative evaluation

We now compare the classification produced by the aforementioned approaches with ground truth classification on datasets Default, ABC and SHREC. are strong baselines getting significantly higher MCC scores than most methods from previous work. PCPNet (Default) shows a very limited detection of sharp edges. ECNet (EC) produces very precise classifications, but overall misses to classify 50% of the points labeled as edges in ground truth (high precision and low recall). This classification by ECNet (EC) of a small subset of the edge points is emphasized by the low F1 and MCC scores that aggregate precision and recall. Regarding single-scale fitting-based approaches (i.e. CA and FEE), both approaches fail at handling outliers (for FEE, we used the following parameters: r= 0.025, R= 0.05 and th= 0.16). PCEDNet (Default) produces the best results on this dataset, getting significantly higher indicators than other approaches. Overall, PCEDNet trained on the Default dataset provides the best balance between precision and recall with the highest F1 and, more importantly, MCC scores.

Finally, we observe that PCEDNet-2C (EC) provides a better recall and a lower precision than ECNet (EC), with a lower MCC on Default. The same behavior is observed on the SHREC (Table 9) and ABC (Table 8) datasets, with a higher MCC for PCEDNet-2C on the ABC dataset. It illustrates the more conservative behavior of PCEDNet-2C (EC) while ECNet (EC) tends to detect subsets of correct edges.

ABC dataset. Due to the large size of ABC (7167 models) we present in Figure 13 (and in the accompanying website) the results as a precision/recall scatter plots, which provide a more readable overall view of the performance of the different approaches. For each approach, we plot each 3D model as a point sample, and display the resulting density maps as 2D-contour maps. We use the Hot colormap, with density values ranging from 50 (light yellow) to 1000 (dark red). A perfect classification result would lead to a Dirac distribution centered at location (1,1) and with magnitude 7167. Most of the analysed approaches are producing classifications with high recall, but differ by their capacity to reach high precision. Table 8 shows the median statistical scores obtained by each method on the whole dataset. Single-scale fitting-based approaches, e.g., CA and FEE (we use r= 0.4, R= 0.8 and th= 0.16 for this dataset) exhibit very high recall but low precision (lower than 0.4) with the classification of a lot of FP. As shown in supplementary materials, these approaches produce good results for very clean and simple geometries, but fail at analyzing thin objects (i.e. neighborhood might include two pieces of opposite surfaces, see in Figure 15) and other intricate shapes. CNN follows a similar pattern, but is able to produce better classifications with high precision (MCC ≈ 0.65). FC produces results with lower quality (MCC < 0.55) and higher dependency to the training set. Both FC (Default) and FC-2C (ABC) are however competitive compared to state of the art methods.

Overall, the evaluation of ECNet (EC) (in terms of MCC, F1 and Accuracy) is better than fitting-based approaches. ECNet (ABC) exhibits a higher precision and a lower recall than ECNet (EC), resulting in better general behavior. It remains however less efficient than our baselines trained on ABC, which, in terms of F1 score, are also less effective than PIENet (ABC). All the variants of our PCEDNet produce varying precision and recall but similar F1 scores above 0.7, and PCEDNet-2C (ABC) shows the best results with an MCC and F1 scores above 0.8. Despite the large difference between the training sets of Default and ABC, our approach PCEDNet (Default) produces classifications with better MCC than competitors (MCC = 0.688), but at the cost of a recall loss. As shown in the joined website, the classifications produced by both PCEDNet (Default) and PCEDNet-2C (ABC) remain visually convincing despite quantitative differences against the ground truth. A notable exception to the global trend highrecall/variable-precision is PCPNet-2C (ABC), which exhibits higher precision/lower recall than any other approach. It also reaches comparable scores as our approach (e.g. MCC, F1, Accuracy), but visual inspection reveals that PCPNet-2C (ABC) tends to miss some edges entirely (lower recall), while our approach finds relatively thicker edges (lower precision). Also, PCPNet-2C (ABC) requires 3 days to process the entire dataset (instead of 3 hours for PCEDNet-2C (ABC)).

SHREC dataset. This dataset has been originally designed to evaluate curve detection algorithms on organic and relatively smooth objects with a comparison to human labelling. In addition, some objects have strong semantics (e.g. human face), and we observe that the ground-truth classification seems to take into account this semantic rather than strictly respecting geometric features. This makes this SHREC dataset very challenging to classify, as illustrated in Table 9 by the lower scores obtain by all approaches, in comparison to the other datasets. In particular, PCPNet (Default) fails at classifying edge points (MCC = 0). On this dataset, ECNet tends to

Visual evaluation

In this section we present visual results on acquired datasets without ground truth labelling. All these scenes are presented in more details in the accompanying video and in the joined website. For all the results presented in this section, we compare PCPNet (Default), PCPNet (ABC) and ECNet (EC) (on smallest scenes only), FC (Default), CNN (Default), PCEDNet (Default), CA and FEE. Table 10 shows precomputation (GLS) and classification times for all approaches. We see that processing time for PCEDNet (including precomputation) remains of the same order of magnitude than less robust approaches as CA and FEE, and outperforms PCPNet and ECNet (up to two orders of magnitude). Once trained, our approach also avoids the tedious parameter tuning of geometric methods.

Figure 17 10. Timing comparison for classification, where (s) stands for seconds, (m) for minutes, (h) for hours, and (d) for days. For datasets (e.g., Default, SHREC and ABC) we report the time needed to process all the models. The column GLS corresponds to the precomputation of the GLS descriptors. For columns CNN, FC and PCED, we report first the classification time, followed in brackets by the total_time = GLS+classification_time. Timings marked with * have been obtained using dedicated hardware (NVIDIA RTX 6000). Figure 18 presents the behavior of each method when processing models with important noise and a lot of outliers. As observed on synthetic datasets, ECNet is strongly penalized by the outliers, and most of the flat areas are misclassified as edges. CA detects all the edge points on the synthetic models but also considers the outliers as edges. PCPNet classification is weakened by the outliers and does not provide any positive results. FC shows results similar to CA, the network is capable of extracting different edges, yet it is still very sensitive to outliers. CNN and PCEDNet both obtain a high recall on edges, with PCEDNet being the least sensitive to noise. Figure 21 shows how our approach performs on a large point cloud (6M points) in comparison with CA and FEE (other approaches require too much memory/time). Munich exhibits common irregularities of acquired data, i.e. variable point densities, large gaps, scan noise, and volumetric objects (e.g., trees). PCEDNet (Default) produces cleaner detection and is less affected by acquisition artefacts than the other approaches. 11. Quantitative evaluation on ABC dataset altered with a Gaussian noise of deviation 𝜎 = 0.04 (median scores). For PCEDNet trained on the Default dataset (with three classes), we show the results when considering the points of both the sharp and smooth edge classes as edges (4 𝑡ℎ row, denoted with + ), and when considering only the sharp-edge class as edges (3 𝑟𝑑 row).

Behavior on noisy data

We compare the classification produced by PCPNet-2C, ECNet, PCEDNet and PCEDNet-2C on the ABC dataset altered in the normal direction by a Gaussian noise of deviation 𝜎 = 0.04. See Figure 20bottom for classification results on model 0133 (other models are included in joined website), and Figure 22 for scatter plots illustrating the distribution of the (Precision, Recall) scores on the entire dataset. As illustrated on Figure 20-bottom, the two approaches trained on ABC (PCPNet-2C and PCEDNet-2C) cannot disambiguate between noise and edges. This is due to the lack of noise in the ABC training set. Trained on more versatile data, both ECNet and PCEDNet (EC) are more robust to noise and still exhibit high recall, despite a loss in precision. In presence of noise, PCEDNet tends to classify inaccurate edge points as smooth edges. We thus propose to also evaluate the classification results considering the edge and smooth edge classes as positive matches (denoted with + in Table 11 and Figure 22). With this setting, PCEDNet (Default) + produces the best quantitative scores in Recall, MCC and F1, slightly overpassing ECNet, while being trained on smaller dataset and requiring 3 hours of computation instead of 20 days. PCEDNet (Default) + , however, detects smoother edges, as on chamfers, that are avoided by ECNet, as illustrated in Figure 20 1 𝑠𝑡 , 3 𝑟𝑑 and 4 𝑡ℎ columns.

Figure 23 shows the capability of PCEDNet to classify edges on an acquired noisy model Paris rue Madame (we could not process this 12M-points dataset with PCPNet-2C and ECNet because of their hardware requirements). Figure 14-bottom provides a qualitative evaluation of the different classification methods on the model 2-cube of the Default dataset with a severe Gaussian noise (deviation 𝜎 = 0.14). In this case also, ECNet and PCEDNet exhibit a more convincing behavior.

Interactive learning

As shown in Table 6, PCEDNet requires very low training time, and is stable for very small training sets as our Default. We illustrate how such a flexible network can be trained interactively to better adapt to user wishes and data specificity.

Our interactive training system performs as follows: the user loads a point cloud on which GLS descriptors are precomputed. This is done in less than 20 seconds for 1M points. Then, the user manually labels some points of the two classes (sharp edge and non-edge) or the three classes (sharp edge, smooth edge and nonedge). We observed that the non-edge class should contain more points than the two others. This training sets are provided to the PCEDNet network initialized with random values, which learns for 5k epochs in around 10 seconds for approximately 10k input points. As for any other dataset, the number of points per class is automatically balanced during training. Once trained, the network classifies the whole point cloud in around 2 seconds per 1M points. Upon classification, the user can refine the training set according to the network output. If he does so, the network is trained again from a random initialization with the updated learning sets (as training is fast enough and modifying the previous training is less efficient).

We illustrate in Figures 1-c and 24, and in the accompanying video how a user can generate a high-quality classification corresponding to a specific edge definition defined by the annotations he provides during an interactive training session. For instance, in Figure 1-ctop, edges are defined sharp, while in Figure 1-c-bottom, edges are defined as a large scale feature including chamfers.

Energy efficiency

Energy consumption is a critical aspect of processing methods when considering their application in embedded systems or their environmental impact on global warming. In addition to evaluating the results in terms of classification and timings, we present an empirical study of the energy consumption of the different approaches for training and classification, based on their hardware requirement and processing time.

Methodology. Ideally, energy consumption should be measured during processing in order to account for the modulation of processor charge. Since we do not have such measuring device yet, we propose to roughly estimate the energy consumption based on the Thermal Design Power (TDP) of the processing unit (CPU or GPU), which measures the energy consumption under high workload. This thus provides over-estimations of the energy consumption that remain useful for the comparison of approaches with significant differences (in our case, up to several orders of magnitude, as can be seen in Tables 12 and13). The TDP is expressed in Watts and it is provided by manufacturers. We denote 𝐸 K the energy, expressed in Joule (1J = 1Ws), used for processing 1K points, and we define it as follows:

𝐸 K = 𝑇 𝐷𝑃 .𝑡 K and 𝑡 K = 𝑃𝑡 .1000 𝑁 ,
where 𝑡 K is the time required for processing 1K points, 𝑃𝑡 is the processing time and 𝑁 is the number of processed points in the time 𝑃𝑡. The TDP of our 10 cores Intel Xeon E5-2640 v4 @2.4 GHz is 90W, the one of an NVIDIA TITAN X GPU is 250W and for an NVIDIA Quadro RTX 6000 it is 260W. Based on Tables 1, 2, 6, 10, and the statistics provided by [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF] and Yu et al. [2018] for training and classification times and number of points, we show in Tables 12 and13 the mean processing unit energy consumption 𝐸 K of each approach for respectively training and classifying 1K points.

When training (see Table 12), our approach requires significantly less energy than our baselines (one order of magnitude) and than very deep neural networks running on the GPU, e.g. PCPNet, ECNet and PIENet (up to two orders of magnitude). The low efficiency of CNN can be explained by its higher number of weights (about 4 times higher than PCEDNet) and by its implementation based on Tensorflow.

Similar trends can be observed during classification (see Table 13). We report the performance of PIENet provided by [START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF] on models composed of around 8 thousand points. Other approaches are evaluated on larger models, up to several millions of points. Complementary experiments would be required to better evaluate PIENet classification efficiency on larger point clouds. CA requires a very little energy while PCEDNet and its baselines remains more efficient than FEE.

Complementary experiments

Variation of sampling (minimum scale). The features computed in the SSM are influenced by the minimum scale 𝑠 min , estimated from the density of the point cloud. We show in Figure 25 how our approach behaves when changing the point cloud density by subsampling, while keeping the automatic estimation of 𝑠 min . This is illustrated on the Loudun tower, initially composed of 35 millions points, and subsampled down to 15, 5 and 1 million points. Unsurprisingly, decreasing the resolution reduces the quantity of details and leads to thicker edges. However, our classification remains stable and PCEDNet still finds the position of edges, even for low densities, and without requiring the user to set any parameter value. An open question is whether the SSM could be efficiently used to provide additional parameters to the points used as input in patchbased point cloud deep processing architectures such as PointNet. This may be investigated, but we point out two issues that should be considered. The first is the significant memory overhead that will be generated on architectures that are already resource-demanding. The second is more conceptual: the goal of using the SSM is to capture local multi-scale shape descriptors at each point without having to explicitly handle their neighborhood in the network. This makes a lot of sense for a point cloud processed by point individually in the network, as we do for edges. This is less clear for a processing relying on point patches (e.g. for style or large features recognition). The first layers of these networks learn features from the spatial organisation of neighbor points and it is not easy to predict which additional parameter would be redundant (i.e. the information it brings is already captured by the network first layers) and which parameter would increase the network efficiency.

Need of local surface reconstruction. The need for locally reconstructing an approximating surface at different scales may be seen as a drawback of our method. In fact, this reconstruction does not allow to explicitly reconstruct or detect edges, and once the surface reconstructed, the problem remains unsolved. However, it enables the computation of the SSM shape descriptors that, used as input in our network, allow us to efficiently label edge points.

LIMITATIONS AND CONCLUSION

We introduced a new parameterization together with its dedicated neural network architecture (PCEDNet) specially designed for the classification of edges in point clouds. PCEDNet outperforms both state of the art methods such as CA, FEE, ECNet, PCPNet and PIENet, and baselines as CNN and FC. PCEDNet is also remarkably compact by being only composed of about 2100 weights. Given this small size, it is faster than the other approaches tested in this work. Both CNN and PCEDNet achieve similar very good results on synthetic point clouds, which shows that our parameterization based on GLS descriptors is very efficient to encode the point clouds features required for edge classification. Coupled with PCEDNet, it provides a very compact multi-scale representation that captures local geometric properties with reduced sensitivity with respect to noise, as can be seen on the various tests performed on real point cloud scans. The training and classification of our approach is also sufficiently fast to enable interactive training and classification from direct user inputs.

Limitations. APSS requires oriented normals, which may be tedious to compute accurately in some cases. For all our experiments with point clouds without normals, we obtained good classification results by estimating consistent normal vectors using Meshlab [START_REF] Cignoni | MeshLab: an Open-Source Mesh Processing Tool[END_REF], without requiring human intervention. An interesting future work would be to consider alternative fitting techniques that do not require oriented normals [Chen et al. 2013b]. Regarding performance, SSM precomputation is currently the bottleneck of the approach, however we believe that a GPU implementation would enable near real-time classification, the most computationally intensive task being the neighborhood queries. Theoretically, SSM is by nature limited to surfaces only, alternative representations [START_REF] Digne | Sparse Geometric Representation Through Local Shape Probing[END_REF]] might be considered in future work to handle lines and volumes.

Perspectives. Other experiments may be conducted to improve the network layout, for instance n by n scales concatenation. An interesting direction for future work could be the study of the extension of this architecture to other geometrical labelling tasks, but also to semantic analysis.

Fig. 1 .

 1 Fig. 1. Three examples of edge detection in point clouds by our PCEDNet neural network. It handles both: (a) the imperfect edges of large scale scans (here 12 million vertices) subject to irregular sampling and noise while detecting both sharp (in red) and smoother (in yellow) edges in few minutes (here less than 6)and -(b) accurate CAD data on which it can focus on sharp edges if desired, in a few seconds for this model. (c) Our network can also be trained in a few seconds to detect edges following the edge definition provided by a user in an interactive model annotation. We show two annotations corresponding to different user expectations. Most of the processing is precomputed and at runtime edges of this model are classified in less than a second.

Fig. 2 .

 2 Fig. 2. Synthetic point cloud sampling a cube with sharp edges (red lines).Due to the sparse sampling and noise, only a few points lie on edges (red points). Detecting the edge surrounding (yellow points) improves the robustness to noise and sampling variation.

( 1 )

 1 Sparsity: Points of acquired point clouds are unequally distributed over the object surfaces. Sharp edges are by nature very sparse, and it is very unlikely that the points of a point cloud actually sample the exact edge of the underlying surface as illustrated by the red points in Figure 2. (2) Rounding: Acquired point clouds are composed by points

  𝛿𝜂 𝑡 𝑖 𝛿x . According to our experiments, high values of 𝜏, which measure the local relief, helps to disambiguate between rounded and sharp edges. The scale derivatives 𝛿𝜏 𝑡 𝑖 𝛿𝑡 and 𝛿𝜅 𝑡 𝑖 𝛿𝑡 denote the stability of the reconstruction scale 𝑠 𝑗 .

Fig. 4 .

 4 Fig. 4. Architecture of the FC baseline

Fig. 6 .

 6 Fig. 6. Training set of the dataset Default, with sharp edges points in red, and smooth edges points in yellow.

Fig. 7 .

 7 Fig. 7. Evaluation set of the dataset Default. Left: 2-cube, with increasing Gaussian noise (𝜎 ranging between 0 and 0.14 units, cube edge length 1). Right: Angle (90 degrees).

  Loudun 1 and Loudun 35 are down-sampled versions (of respectively 1 and 35 million vertices) of a photogrammetric acquisition of the Square Tower of Loudun (France). We used Euler, Empire and Lans as provided by Monszpart et al. [2015], Pisa Cathedral as provided by Mellado et al. [2015], Munich as provided by Hackel et al. [2016], Paris rue Madame as provided by Serna et al. [2014], and we downloaded Church and Train Station from Sketchfab 1 .

Fig. 8 .

 8 Fig. 8. PCEDNet: learning curves measured on Training (T) and Validation (V) sets on the (left) Default and (right) ABC. For the latter, learning stops automatically at epoch 10, when loss and accuracy stop to be improved.

Fig. 9 .

 9 Fig. 9. Different classifications produced by PCEDNet with, from left to right, 4, 8, 16, 32, 64 and 128 input scales, on the Pisa Cathedral model (two top rows) and model 7024 of the ABC dataset (bottom row).

  Table6. Timings for training PCPNet on the Default dataset with three classes and on the ABC dataset with two classes. For PCEDNet, we report first the training time, followed in brackets by the total_time = GLS+training _time. We also remind the PCEDNet training times with the same number of classes for comparisons. The training time of PIENet is reported from[START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]. Timings with a * have been performed on recent high performance GPUs (e.g., NVIDIA TITAN X).

Fig. 11 .

 11 Fig. 11. PCPNet: learning curves measured on Training (T) and Validation (V) sets on the (left) Default and (right) ABC datasets.

Fig. 12 .

 12 Fig. 12. Time (in seconds) required by the approaches presented in Table10to classify different models.

Fig. 13 .Fig. 14 .

 1314 Fig. 13. Distribution of the Precision (abscissa)/Recall (ordinate) scores displayed as a scatter plot (each point cloud is a sample) and its associated density function for the ABC dataset. Interactive plots are provided in the joined website. All maps share the same color scale.

Fig. 15 .

 15 Fig. 15. Model 7029 of the ABC dataset.

Fig. 16 .

 16 Fig. 16. Model 7 of the SHREC dataset. Results for CNN and FC can be found in the joined website. produce noisy and thick edges, getting lower score than CA. CA and FEE (we use r= 2, R= 4 and th= 0.16 for this dataset) produce more convincing results, with CA reaching MCC= 0.39. CNN (Default) get the best scores on this dataset (both MCC and F1), but the same architecture trained on SHREC gets lower detection rate. Both FC and PCEDNet show better stability w.r.t. the training set (MCC ≈ 0.4 for all variants), but lower score than CNN. Regardless to the quantitative analysis, the results produced by PCEDNet (Default) are very interesting on this dataset. By enforcing the detection of both smooth and sharp edges, it better adapts to the smooth nature of the analysed objects and it provides very pertinent results as illustrated in Figure 16.

  00 h 1:25:00 (4:00:00) h 0:25:40 (3:00:40) h 0:25:30 (3:00:30) h Table

Fig. 17 .Fig. 18 .

 1718 Fig. 17. Lans model. Results for CNN and FC can be found in the joined website.FC extracts large scale edges leaving out finer details, which highlights the importance of scale separation layers in PCEDNet network architecture. Both CNN and PCEDNet produce visually convincing results, but CNN does not detect some fine details that are adequately detected by PCEDNet. ECNet also produces good results on this example, detecting most of the edges and some of the thin details.

Fig. 19 .

 19 Fig. 19. Church. Results for FEE, FC and PCPNet can be found in the joined website. CNN, FC and PCEDNet rely on the same parameterization. We thus provide in Figures 19 a closer comparison of the results produced by these architectures. In Figures 19, even though all networks

Fig. 20 .

 20 Fig. 20. Top: Classification produced by the different networks on model 0133 of the ABC dataset. Bottom: Same model altered with a random Gaussian noise of deviation 𝜎 = 0.04.

Fig. 21 .

 21 Fig. 21. Munich model (see Results for CNN and FC in the joined website).

Fig. 27 .

 27 Fig. 27. Impact of the surface reconstruction algorithm on the classification. From left to right: covariance plane fitting (used by Bazazian et al. [2015]), point set surfaces [Alexa et al. 2001], algebraic sphere fitting, algebraic point set surfaces [Guennebaud and Gross 2007] (used in this work).

Table 2 .

 2 The validation accuracy keeps increasing during training, probably because it is less sensitive to wrong predictions than the loss. Overall, training usually takes a couple of minutes for PCEDNet, a dozen for the baseline FC, and more than one hour for CNN. Training times of our networks on the different datasets.

		GLS	Training	Total
	PCEDNet (Default)	19.32 s	2:52 m	3:11 m
	FC (Default)	19.32 s 13:58 m	14:17 m
	CNN (Default)	19.32 s 1:19:08 h 1:19:27 h
	PCEDNet-2C (ABC)	2:11 m	20:00 m	22:11 m
	FC-2C (ABC)	2:11 m 2:01:05 h 2:03:16 h
	CNN-2C (ABC)	2:11 m 9:00:00 h 9:02:11 h
	PCEDNet-2C (SHREC)	4 s	28.09 s	32.09 s
	FC-2C (SHREC)	4 s	10:03 m	10:07 m
	CNN-2C (SHREC)	4 s	26:01 m	26:05 m

Table 3 .

 3 Precision, recall, F1 and MCC computed on the 2-cube (with a Gaussian noise generated with different value of 𝜎) and Angle models of the Default evaluation set (see Table1) for the different parameterization of PCEDNet.

			0	0.01	2-cube (𝜎) 0.02 0.03	0.12	0.14	Angle
	All GLS	P	0.529 0.305 0.348 0.413 0.310 0.340 0.327
	derivatives	R	0.415 0.424 0.454 0.481 0.427 0.45	0.5
	(28 parameters)	F1	0.465 0.355 0.394 0.445 0.360 0.387 0.396
		MCC 0.435 0.310 0.353 0.407 0.315 0.345 0.400
	Invariant to rigid	P	0.983 0.839 0.866 0.882 0.845 0.853 0.871
	transformations	R	0.823 0.904 0.921 0.912 0.904 0.919 0.984
	(7 parameters)	F1	0.897 0.871 0.893 0.897 0.874 0.885 0.925
		MCC 0.870 0.828 0.858 0.864 0.832 0.848 0.924
	Our	P	0.966 0.807 0.832 0.868 0.817 0.826 0.724
	configuration	R	0.897 0.960 0.970 0.934 0.961 0.964 0.984
	(6 parameters)	F1	0.931 0.877 0.896 0.901 0.884 0.890 0.835
		MCC 0.908 0.839 0.864 0.869 0.847 0.856 0.840
	Remove	P	0.360 0.217 0.250 0.265 0.217 0.233 0.428
	scale	R	0.340 0.489 0.513 0.696 0.475 0.495 0.416
	(4 parameters)	F1	0.350 0.301 0.337 0.385 0.298 0.317 0.423
		MCC 0.305 0.260 0.299 0.373 0.256 0.277 0.419
	Remove	P	0.173 0.103 0.115 0.355 0.105 0.109 0.242
	curvature	R	0.292 0.290 0.277 0.783 0.290 0.286 0.222
	(3 parameters)	F1	0.217 0.152 0.163 0.489 0.155 0.158 0.232
		MCC 0.152 0.079 0.094 0.484 0.084 0.087 0.227

Table 4 .

 4 Precision, Recall, F1 and MCC computed on the 2-cube (with different Gaussian noise) and Angle models of the Default evaluation set (presented in Table

			0	0.01	2-cube (𝜎) 0.02 0.03	0.12	0.14	Angle
	PCEDNet-2C	P	0.576 0.298 0.366 0.364 0.308 0.330	0.435
	(Default)	R	0.564 0.610 0.652 0.689 0.611 0.614	0.278
		F1	0.570 0.400 0.469 0.477 0.410 0.430	0.339
		MCC 0.539 0.374 0.445 0.458 0.383 0.402	0.344
	PCEDNet	P	0.966 0.807 0.832 0.868 0.817 0.826 0.724
	(Default)	R	0.897 0.960 0.970 0.934 0.961 0.964 0.984
	(Ours)	F1	0.931 0.877 0.896 0.901 0.884 0.890 0.835
		MCC 0.908 0.839 0.864 0.869 0.847 0.856 0.840

  , training of the deep architecture of PCPNet converge to relatively high loss on our Default training set. Also, despite several attempts, PCPNet couldn't stabilise on SHREC due to the high variability of the annotations. Training on a larger dataset such as ABC (see the

		4	8	16	32	64	128
	Training on Default	4.32 (47.17) s	0:06 (1:30) m	0:19 (3:11) m	3:59 (9:44) m	4:10 (15:37) m	6:18 (29:23) m
	ABC	6:50 (44:38) m	0:11:20 (1:30:12) h	0:25:30 (3:00:30) h	0:51:02 (6:01:02) h	1:40:00 (12:00:00) h	3:20:00 (20:40:00) h
	Pisa Cathedral	1.34 (13.80) s	2.23 (27.65) s	4.12 (58.61) s	0:07 (1:55) m	0:15 (3:44) m	0:31 (7:19) m
	Table

Table 7 .

 7 Table 10 to classify different models.Default dataset. Results are reported in Table7and illustrated in both Figure14and the accompanying website. Both CNN and FC Quantitative evaluation on Default: median scores (see scores of the other approaches in the accompanying website).

	Method	Precision Recall MCC	F1	Accuracy	IoU
	CA	0.490	0.880	0.506 0.628	0.752	0.457
	FEE	0.341	0.814	0.471 0.480	0.879	0.316
	FC (Default)	0.618	0.958. 0.682 0.753	0.849	0.604
	CNN (Default)	0.546	0.955	0.623 0.694	0.807	0.532
	PCPNet (Default)	0.722	0.198	0.301 0.310	0.789	0.183
	PCEDNet (Default)	0.826	0.952 0.857 0.890	0.946	0.802
	PCEDNet-2C (Default)	0.364	0.611	0.402 0.430	0.908	0.274
	ECNet (EC)	1.000	0.457	0.656 0.620	0.960	0.450
	PCEDNet-2C (EC)	0.201	0.991 0.383 0.334	0.759	0.200
	Method	Precision Recall MCC	F1	Accuracy	IoU
	CA	0.348	0.944	0.520 0.504	0.881	0.338
	FEE	0.135	1.000 0.062 0.235	0.278	0.132
	FC (Default)	0.452	0.679	0.469 0.513	0.921	0.327
	CNN (Default)	0.530	0.995	0.648 0.689	0.922	0.519
	PCEDNet (Default)	0.746	0.745	0.688 0.713	0.966	0.548
	PCEDNet-2C (Default)	0.662	0.936	0.708 0.730	0.958	0.574
	ECNet (EC)	0.425	0.648	0.423 0.460	0.910	0.294
	PCEDNet-2C (EC)	0.378	0.849	0.480 0.503	0.888	0.334
	ECNet (ABC)	0.487	0.573	-	0.526	-	0.356
	PIENet (ABC)	0.692	0.858	-	0.766	-	0.622
	FC-2C (ABC)	0.470	0.871	0.555 0.581	0.920	0.408
	CNN-2C (ABC)	0.507	0.983	0.646 0.662	0.928	0.491
	PCPNet-2C (ABC)	0.954	0.756	0.797 0.807	0.979	0.668
	PCEDNet-2C (ABC)	0.735	0.984 0.808 0.822	0.970	0.597

Table 8 .

 8 Quantitative evaluation on ABC: median scores (see scores of the other approaches in the accompanying website). ECNet (ABC) and PIENet (ABC) are reported from[START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021.

Table 9 .

 9 Quantitative evaluation on SHREC: median scores. For 3-classes methods marked with + , we compare both the smooth and sharp edges classes with the ground truth, i.e. Positives=Sharp+Smooth.

	Method	Prec.	Recall MCC	F1	Accuracy	IoU
	CA	0.434	0.449	0.390	0.442	0.876	0.284
	FEE	0.191	0.527	0.151	0.278	0.727	0.160
	PCPNet (Default)	0.000	0.000	0.000	0.009	0.893	0.000
	FC (Default)	0.392	0.538	0.391	0.455	0.880	0.294
	FC (Default) +	0.313	0.909	0.428	0.461	0.793	0.300
	CNN (Default)	0.468	0.928	0.570 0.611	0.911	0.440
	CNN (Default) +	0.299	0.945	0.429	0.446	0.802	0.287
	PCEDNet-2C (Default)	0.462	0.623	0.455	0.510	0.868	0.342
	PCEDNet (Default)	0.495	0.377	0.344	0.437	0.916	0.280
	PCEDNet (Default) +	0.349	0.898	0.444	0.489	0.814	0.323
	ECNet (EC)	0.365	0.503	0.341	0.397	0.845	0.248
	PCEDNet-2C (EC)	0.254	0.747	0.285	0.365	0.676	0.223
	FC-2C (SHREC)	0.406	0.715	0.392	0.480	0.849	0.316
	CNN-2C (SHREC)	0.207	0.881	0.202	0.248	0.622	0.142
	PCEDNet-2C (SHREC)	0.441	0.872	0.426	0.522	0.874	0.353

  represents a part of Lans without outliers and with very few noise. In this example, FEE detects larger scale edges cleanly, yet it misses fine details. CA detects edges, but it still struggles with surface noise and irregularities. PCPNet has an improved behavior over the noisy model and is able to detect smooth-edges. However, it still fails at classifying sharp-edges. Similar to FEE and PCPNet,

	Dataset	#obj #vert.	CA	FEE	PCPNet	ECNet	GLS	CNN (total)	FC (total)	PCEDNet (total)
	Loudun 1	1	1M	14.30 s	1:30 m	35:00 m *	-	19.30 s	0:54 (1:13) m	1.80 (21.10) s	2.10 (21.40) s
	Empire	1	1.2M	15.70 s	2:55 m	54:22 m * 5:43 m *	36.40 s	0:53 (1:29) m	1.80 (38.20) s	2.10 (38.50) s
	Lans	1	1.23M	16.40 s	3:46 m	1:00:08 h * 6:13 m *	21.00 s	0:55 (1:16) m	1.80 (22.80) s	2.10 (23.10) s
	Church	1	1.9M	23.40 s	5:53 m	1:46:40 h *	-	58.40 s	1:26 (2:24) m	0:02 (1:01) m	0:03 (1:01) m
	Pisa Cathedral	1	2.5M	31.80 s	6:03 m	2:56:40 h *	-	53.60 s	1:57 (2:50) m	3.90 (57.50) s	4.70 (58.30) s
	Euler	1	3.9M	51.20 s	13:22 m	-	-	1:55 m	3:00 (4:55) m	0:06 (2:01) m	0:07 (2:02) m
	Munich	1	6M	1:31 m	26:33 m	-	-	1:59 m	4:41 (6:41) m	0:09 (2:09) m	0:11 (2:10) m
	Train St.	1 12.45M	2:35 m	50:44 m	-	-	5:31 m	9:17 (14:49) m	0:19 (5:50) m	0:25 (5:57) m
	Loudun 35	1	35M	7:29 m	1:30:25 h	-	-	9:52 m	26:38 (36:30) m	1:06 (10:59) m	1:09 (11:02) m
	Paris rue Madame	1	XX	-	-	-	-	XX	-	-	XX
	Default	8	55k	0.53 s	4.41 s	22.11 s*	2.09 s*	1.08 s	2.03 (3.11) s	0.30 (1.38) s	0.25 (1.33) s
	SHREC	15	654k	9.70 s	41.47 s	5:54 m * 2:48 m *	14 s	28.58 (42.58) s	3.10 (17.10) s	3.10 (17.10) s
	ABC	7167 312.

Table 12 .

 12 Times 𝑡 K (2 𝑛𝑑 row) and processing unit energy consumption 𝐸 K (3 𝑟𝑑 row) required for processing 1K points when training the different networks (1 𝑠𝑡 row) denoted as name(training dataset). (average) represents the average of the times obtained when training on the different datasets Default, ABC and SHREC. PCPNet is trained on an NVIDIA TITAN Quadro RTX 6000 GPU, and ECNet and PIENet are trained on an NVIDIA TITAN X GPU. The times and energy consumption for ECNet and PIENet are computed respectively from the statistics provided in[Yu et al. 2018] and[START_REF] Wang | PIE-NET: Parametric Inference of Point Cloud Edges[END_REF]].

	Classification	CA	FEE	PCPNet	ECNet	PIENet (8K pts)	GLS	CNN	FC	PCEDNet
	Time 𝑡 K	0.015	0.16	2.28*	1.32*	0.062*	0.023 0.043 (0.066) 0.0024 (0.0254) 0.0026 (0.0256)
	Energy 𝐸 K	1.36	14.79	592.87*	345.77*	15.63*	4.24	3.87 (8.11)	0.22 (4.46)	0.23 (4.47)

Table 13 .

 13 Times 𝑡 K (2 𝑛𝑑

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021.

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021. PCEDNet : A Lightweight Neural Network for Fast and Interactive Edge Detection in 3D Point Clouds • 1:5

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021. PCEDNet : A Lightweight Neural Network for Fast and Interactive Edge Detection in 3D Point Clouds • 1:7

Church: https://sketchfab.com/3d-models/christ-church-and-dublin-city-council-b5f6bcce8ebc44a3b4bbb6b0fef067b3. Train Station: https://sketchfab.com/3d-models/ station-rer-6c636ca4793345e8ae12beb97b7d6359 ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January

2021.

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021. PCEDNet : A Lightweight Neural Network for Fast and Interactive Edge Detection in 3D Point Clouds • 1:11

ACM Trans. Graph., Vol. 1, No. 1, Article 1. Publication date: January 2021. PCEDNet : A Lightweight Neural Network for Fast and Interactive Edge Detection in 3D Point Clouds • 1:15

ACKNOWLEDGEMENTS

We would like to thank Archeovision for the courtesy of the Loudun dataset. This work has been partially funded by the ANR CaLiTrOp project (ANR-11-BS02-0006). Point clouds processing and visualization have been implemented in the Radium Engine [Mourglia et al. 2021]. Paris rue Madame is part of the Paris-rue-Madame database: MINES ParisTech 3D mobile laser scanner dataset from Madame street in Paris. MINES ParisTech created this special set of 3D MLS data for the purpose of detection-segmentation-classification research activities, but does not endorse the way they are used in this project or the conclusions put forward.

 7) and PCEDNet-2C trained on ABC. Variation of maximum scale. We also show in Figure 26 how our classification behaves when changing the maximum scale. Thanks to the logarithmic scale sampling and the scale invariance property of the SSM entries, our approach provides stable results even though the maximum scale is divided by 10 or multiplied by 2.5.

Surface reconstruction algorithm. Our network is parameterized using the Algebraic Point Set Surfaces (APSS) [START_REF] Guennebaud | Algebraic Point Set Surfaces[END_REF], which are known to be stable and reliable even at large scales. We illustrate in Figure 27 the performance of our classifier when computing the parameterization with different approaches: covariance plane fitting (also used in Bazazian et al. [2015]), planebased point set surfaces [START_REF] Alexa | Point Set Surfaces[END_REF]] and algebraic sphere fitting (same fitting as APSS but without the Moving Least Squares -MLS-projection). For each variant we compute similar values as our GLS descriptor, with derivatives estimated using finite differences. We clearly observe that the use of sphere fitting rather than plane fitting improves the classification, and the best results are always obtained using MLS projection. Eventually, recent more stable derivative evaluations of the APSS may also be experimented [START_REF] Thibault Lejemble | Stable and efficient differential estimators on oriented point clouds[END_REF]].

APPENDICES A GLS DESCRIPTORS AND DERIVATIVES

The APSS [START_REF] Guennebaud | Algebraic Point Set Surfaces[END_REF] The Scale-Space Jacobian of the GLS parameters if defined as a 5 × 4 matrix:

, where 𝛿x and 𝛿𝑡 are the derivatives in scale and space respectively. 𝑘1 is computed by projecting 𝛿𝜂 𝛿x on the surface tangent plane, which provides an estimate of the second fundamental form.

B SCORES USED FOR QUANTITATIVE COMPARISON

The scores used in Section 5 are defined as follows:

Precision (also denoted positive predictive value ś PPV) measures the proportion of positive identifications that are actually correct (the higher, the better). It is defined as: precision = 𝑇 𝑃 𝑇 𝑃 + 𝐹 𝑃 .

Recall (also denoted sensitivity, hit rate, or true positive rate ś TPR) measures the proportion of actual positives that are correctly identified (the higher, the better). It is defined as: recall = 𝑇 𝑃 𝑇 𝑃 + 𝐹 𝑁 .

The Matthews Correlation Coefficient (MCC) is a correlation coefficient between the observed and predicted binary classifications; it returns a value in [-1 : 1]. A coefficient of 1 represents a perfect prediction, 0 no better than random prediction and -1 indicates a disagreement between prediction and observation. It is defined

F1 score is a measure of a test accuracy. For binary classification, F1 is defined as follows:

Accuracy measures is the fraction of predictions our model got right. For binary classification, accuracy is defined as: accuracy = 𝑇 𝑃 + 𝑇 𝑁 𝑇 𝑃 + 𝑇 𝑁 + 𝐹 𝑃 + 𝐹 𝑁 .

The Intersection over Union score (IoU) is a value between 0 and 1 specifying the overlap between the prediction and the observation. A value of 1 means that the union of the predicted and the reference sets is the same as their overlap (intersection) while a value of 0 means that there is no overlap between the predicted and the reference sets. It is defined as follows: IoU = 𝑇 𝑃 𝑇 𝑃 + 𝐹 𝑃 + 𝐹 𝑁 .


Clarisse Bourdelle

Clemente Angioni

Jean-Francois Artaud

Yann Camenen

Francis J Casson

Jonathan Citrin

E Fable

F Felici

A Ho

F Kochl

Physics model development and extensive validation of predictive integrated modelling within the new EU framework programme 2021-2027 (TSVV11 activity)

ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

"a strong theory and modelling programme is essential because empirically based predictions are uncertain in unexplored environments like ITER and particularly DEMO, and this will be a stronger focus than foreseen earlier" [Statement from the 2018 Fusion Roadmap] In the EUROfusion Work Package Advanced Computing, among the 14 'Theory, Simulation, Verification and Validation ' activities one is devoted to such effort. The TSVV11 team plan to significantly extend the state-of-the-art in predictive integrated tokamak simulation, and validation methodologies thereof, combining both technical framework and physics-module advances.

All the physics that we master in 2021 has to be available from ITER control room in 2027. AAPPS 2020]. This High Fidelity Pulse Simulator (HFPS) presently allows core-edge-SOL coupled simulations for multichannel transport, including multiple ions and radiation (from low Z to W). We will further develop this framework under the name of HFPSeu. The HFPSeu will use EUROfusion software standards, it will couple all previously developed under EUROfusion IMAS-adapted modules as well as new modules provided by this TSVV and other TSVVVs activities, and will use run management tools for efficient validation pipelines and simulation workflows.

Physics module development involves:

development and validation of reduced turbulence models in L-mode up to LCFS, and including isotope effects and all ions; reduced neoclassical models, including poloidal asymmetries most relevant for W impurities; MHD modules adequate for ramp-up and ramp-down; reduced pedestal and SOL models accounting for the fueling impact; breakdown and burn-through modules with self-consistent equilibrium and plasma evolution.

Automated validation means :

Focus is placed on systematic and automated validation, verification, and uncertainty quantification (VVUQ) pipelines. Integrated modelling advanced preparation pipelines including automated fitting procedures will be generated. Automated simulation execution, validation workflows including UQ, and database storage, will be developed. Consistency checks in 0D, 1D, and 2D synthetic diagnostics will be implemented for a hierarchy of modelling use-cases.

The HFPSeu framework will also be demonstrated for ITER First Plasma scenarios and the pre-fusion-power-operation (PFPO) phase. Updated info here https://wiki.euro-fusion.org/wiki/TSVV-11 Do not hesitate to contact clarisse.bourdelle@cea.fr for any questions/suggestions.

  The physics-based full pulse predictive capability validated within TSVV11 will be an input to the plasma model needed in the flight (or pulse design) simulator which is developed in parallel to design DEMO. Some very nice success stories Using JINTRAC on JET for multi channel prediction incl. multiple impurities [Casson et al NF 2020] [Citrin @ IAEA] [Manas @IAEA] on AUG And much more… C. Bourdelle 1 , C. Angioni 2 , J-F Artaud 1 , Y. Camenen 3 , F.J. Casson 4 , J. Citrin 5 , E. Fable 2 , F. Felici 6 , A. Ho 5 , F. Köchl 4 , P. Maget 1 , P. Manas 1 , J. Morales 1 , O. Sauter 6 , J. Simpson 4 , G. Tardini 2 , K. VanDePlassche 5 1 CEA, IRFM, Saint Paul Lez Durance, France 2 Max Planck Institute for Plasma Physics, Garching, Germany, 3 CNRS, Aix-Marseille University, Marseille, France, 4 CCFE, Abingdon, United Kingdom 5 DIFFER -Dutch Institute for Fundamental Energy Research, Eindhoven, The Netherlands, 6 Ecole Polytechnique Fédérale de Lausanne, Swiss Plasma Cente, CH-1015 Lausanne, Switzerland Physics model development and extensive validation of predictive integrated modelling within the new EU framework programme 2021-2027 (TSVV11 activity) 2021 integrated modelling state-of-the-art Also very successfull SOL-core integration on: 50 AUG H modes: better than empirical scaling laws, qualitatively of course but also quantitatively! [Luda NF 2020 and this conference] 28 JET-ILW H modes [Saarelma PPCF2018] And much more… State-of-the-art extended to prepare ITER operation within the TSVV11 project, supported by the Advanced Computing Hub @Poznan TSVV11 project structure (PI C. Bourdelle) WP1: HFPSeu Workflow orchestration and module coupling framework (coordinator: F.J. Casson, 2.5 ppy incl. 1.5 ACH) WP2: HFPSeu key physics modules validation (3.5 ppy incl. 1 from ACH) WP2-D1 Turbulent transport reduced models targeted validation (coordinator: Y. Camenen) WP2-D2 Core-edge-SOL coupling targeted validation (coordinator : C. Bourdelle) WP2-D3: Impurity transport, development of reduced models, verification and targeted validation (coordinator: C. Angioni) WP2-D4: MHD modules targeted validation (coordinator: P. Maget) WP2-D5: Plasma initiation (Breakdown and burn-through and MHD equilibrium) integration and validation (coordinator: J-F Artaud) WP3-HFPSeu full pulse modelling capability demonstration (coordinator: E. Fable, 2 ppy) WP4-HFPSeu systematic validation (coordinator: A. Ho, 1ppy incl. 0.5 from ACH) WP5-HFPSeu initial ITER phase modelling (coordinator: J. Citrin, total effort 0.5 ppy)

Therefore the TSVV11 guiding principles are:

• Align with ITER technical choices in terms of integrated modelling workflow and database management (WP1) • Improve and validate advanced physics modules focusing on high priority modelling extensions that will be needed for multi-physics full predictive modelling, with the help of other TSVV activities (WP2) •

Demonstrate validation of full pulse predictive modelling from

		breakdown to termination, including a realistic assessment of operational
		limits (WP3)
	•	Support extended validation against EU operating tokamaks by providing to
		users outside this TSVV yearly training on the integrated modelling
		workflow, a detailed and clear documentation on the workflow and the
		embedded physics modules, a user friendly interface and automated
		validation tools. (WP4)

Aligning with ITER choices for Integrated modelling means: Start

from a Python-based integrated modelling framework building on principles developed in past EUROfusion programmes: ITM and subsequently WPCD, namely independent and heterogeneous modules communicating physical data only via IMAS Data Structure arguments. A functional template for this framework has been developed and demonstrated by ITER and the CCFE team (under contract to ITER) with modules developed by WPCD for the HCD workflow, and with the JETTO and Edge2D-EIRENE transport modules [Pinches