{'fraction_non_alphanumeric': 0.026584762827211787, 'fraction_numerical': 0.009277903805469886, 'mean_word_length': 4.817615658362989, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
NeuralMeshing: Differentiable Meshing of Implicit Neural Representations

The generation of triangle meshes from point clouds, i.e. meshing, is a core task in computer graphics and computer vision. Traditional techniques directly construct a surface mesh using local decision heuristics, while some recent methods based on neural implicit representations try to leverage data-driven approaches for this meshing process. However, it is challenging to define a learnable representation for triangle meshes of unknown topology and size and for this reason, neural implicit representations rely on non-differentiable post-processing in order to extract the final triangle mesh. In this work, we propose a novel differentiable meshing algorithm for extracting surface meshes from neural implicit representations. Our method produces the mesh in an iterative fashion, which makes it applicable to shapes of various scales and adaptive to the local curvature of the shape. Furthermore, our method produces meshes with regular tessellation patterns and fewer triangle faces compared to existing methods. Experiments demonstrate the comparable reconstruction performance and favorable mesh properties over baselines.

In recent years, neural implicit representations (NIRs) [47,42,44,15] have been used to improve upon traditional implicit-based representations by storing the implicit function within a deep neural network. Follow-up approaches based on these have addressed various issues, e.g., concerning scalability [49, 12,30], quality [20,54,53] or processing of raw data [5,6,24]. However, such methods still rely on an isosurface extraction method like marching cubes [37,40] in order to generate the final triangle mesh, usually resulting in unnecessarily high-resolution

Initialization
Iterative Meshing Procedure Fig. 1: NeuralMeshing. We propose a novel meshing algorithm specifically designed for neural implicit representations (NIRs). Starting from an initial set of randomly placed seed triangles on the zero level set of the implicit neural representation, NeuralMeshing iteratively expands the triangles into all directions until the full zero level set is covered triangle meshes. Furthermore, those post-processing steps are often not differentiable, prohibiting end-to-end training of networks.
In this paper, we propose NeuralMeshing ( Figure 1), a novel data-driven approach for directly predicting a triangle-mesh from a NIR. NeuralMeshing aims to close the gap of a differentiable meshing approach specifically designed for the usage with NIRs. Starting from a seed of initially placed triangles, Neu-ralMeshing iteratively extends triangles at boundary edges by predicting new vertex locations given local geometry information like curvature, SDF and surface normals through queries on the underlying implicit representation. This allows to adaptively place bigger triangles at surface areas with lower curvature, i.e. flat surface patches, and smaller triangles at areas with high curvature. The main contributions of this paper can be summarized as follows: (1) We propose NeuralMeshing, a novel data-driven meshing approach for NIRs. Our method iteratively predicts new triangles based on local surface information from the implicit representation. (2) Extensive experiments show that NeuralMeshing better approximates the surface of NIRs while using considerably fewer triangles than commonly used iso-surface extraction methods [37].

Related Work
Traditional Deterministic Reconstruction Methods. Early works on shape reconstruction from points have proposed deterministic approaches using alpha shapes [21,22], Delaunay triangulation [9] or ball-pivoting [7]. Such methods make local decisions to directly triangulate the given input point cloud. Later works focused on extracting the surface as the crust of a Voronoi diagram [2,3,4,1]. However, these methods do not well handle noise or outliers and thus perform poorly on real-world data, creating noisy and incomplete output meshes. Traditional Implicit Reconstruction Approaches. In contrast to triangulation methods, implicit-based approaches try to represent the surface as an implicit function. The pioneering work of Hoppe et al .
[28] introduced a method for creating a piecewise smooth surface through implicit modeling of a distance field. An alternative approach relies on radial basis function methods [11] which try to fit implicit functions to a surface. Another line of work focuses on extracting the iso-surface from signed distance function values (SDF) of a volumetric grid, the most prominent known as the marching cubes algorithm [40,37]. There has been a plethora of follow-up work [31,55,51], improving upon marching cubes. Moving least-squares (MLS) [23,35,45] based techniques locally reconstruct the surface with local functions approximating the SDF in the local neighborhood. Poisson surface reconstruction [32,33] reconstructs surfaces from oriented points via energy optimization. While these methods are able to close larger surface holes they come with high computational demands.
Neural Implicit Representations. Recently, neural implicit representations are used as an alternative representation for surface reconstruction. Pioneering works [15,42,44,47] use coordinate-based deep networks in order to learn a continuous SDF or occupancy function. While the early works have been limited to objects and low levels of details, follow-up approaches have extended the representations to scenes of larger scale [12,17,30,39,43,49], proposed learning on raw data [5,6,18,24], improved details [54] or improved upon the training scheme [20,53]. In order to obtain the final mesh, all these methods rely on extracting the surface via an iso-surface extraction approach like marching cubes [40].
Data-driven Direct Meshing Approaches. Recent works have started to adopt deep learning-based approaches for triangulation and meshing of shapes. Early approaches used deep networks in order to warp 2D patches onto the point cloud [25,60]. Such parametric approaches often lead to undesirable holes and overlapping patches. Some works proposed to utilize grids, e.g. to predict a signed distance field using random forests [36], to deform and fit a shape [61] or to extract the surface via a differentiable marching cubes algorithms [38]. However, they come with high computational resource demands. BSP-Net [14] and CvxNet [19] both build upon the idea of predicting a set of hyperplanes for creating convex shapes as building blocks of the final shape. The triangulation is extracted through a non-differentiable post-processing step involving convex hull computations in the dual domain. However, the number of planes is fixed which limits the reconstruction to objects of smaller scale. Another line of work deforms and fits a template mesh to the input point cloud [27,46,58,59]. However, the topology of the reconstructed shape is usually fixed to the topology of the provided template mesh. Recently, PointTriNet [52] proposed to directly predict the connectivity of the given input point cloud. In an iterative procedure, triangle candidates are first proposed and then classified for their suitability to be part of the final mesh. While the method is local and differentiable, the resulting meshes often include holes. Similarly, Rakotosaona et al . [50] model the problem of triangulation locally by predicting a logarithmic map which allows triangulation in 2D using non-differentiable Delaunay triangulation. Finally, some recent work focus on using the neural implicit representation as the core representation for differentiable meshing or learning [16,48,26]. Neural Marching Cubes [16] implements a data-driven approach to improve the mesh quality at sharp edges by defining a learnable representation to differentiate between the topological configurations of marching cubes. They introduce additional vertices inside cells of  Fig. 2: Overview. Given an input point cloud P (left), we use a neural implicit representation with added curvature head S (middle) to extract a continuous SDF field. After placing a set of random triangles on the zero level set of S, NeuralMeshing then queries S in order to predict a triangular mesh M (right) in an iterative fashion. Red blocks denote trainable MLPs the underlying grid and predict the offset of these vertices. However, they use a 3D ResNet and rely on discretized inputs, limiting the resolution and making it less memory efficient. In contrast, our method operates in continuous space and therefore on arbitrary resolutions. DeepMesh [26] uses a trick, i.e., an additional forward pass on all mesh vertex locations for computing gradients with respect to an underlying implicit representation without the need to make the meshing differentiable. They use a non-differentiable marching cubes algorithm to generate the output and define loss functions directly on the obtained mesh. The recent work by Peng et al . [48] instead proposes a new shape representation based on a differentiable Poisson solver. Contrary to those two works, we aim to directly create a triangle mesh from the underlying neural implicit representation.

Method
NeuralMeshing takes as input an oriented point cloud Our goal is to compute a surface mesh M = (V, F) defined as a set of vertices V = {v i ∈ R 3 } and a set of triangular faces F in order to approximate the surface of a shape. In a first step, we employ a modified neural implicit representation S in order to learn a continuous SDF field approximating the shape's surface. In a second step, we use the neural representation as input for our meshing algorithm in order to extract an explicit representation M of the surface. In order to effectively predict new triangles, our neural representation S uses an extra branch in addition to the existing SDF branch, which outputs curvature information. Please refer to Figure 2 for an overview of our method.

Modified Neural Implicit Representation
Ideally, we aim for small triangles where the curvature is high and larger triangles at low curvature. To account for this, we extend the neural implicit representation S with curvature information. In order to learn a NIR, we follow Gropp et al .
[24] and use implicit geometric regularization (IGR) for network training.  Curvature Information. Our method grows the mesh seeds by generating new triangles in orthogonal direction of unprocessed boundary edges. For generating new vertices close to the implicit surface, we are interested in the curvature only along that particular direction, i.e., normal curvature, which we found to provide more meaningful information than aggregated curvature measures, e.g., mean or gauss curvature. The problem of measuring normal curvature on a surface in 3D can be reduced to a line on a 2D-plane, defined by a query point p 1 , its corresponding surface normal n 1 and a query direction vector q. To this end, we employ the turning angle for approximating the curvature, i.e., the signed angle between the tangential lines, defined by query point p 1 and the target point p 2 , respectively. For our case, p 2 is computed by following the geodesic path on the discrete mesh along q until a fixed distance l has been covered, as illustrated in Figure 3a. We define φ 1 = π 2 as the angle between the tangential line and the surface normal at p 1 , and φ 2 as the angle between the tangential line at p 2 and the surface normal n 1 at p 1 . The turning angle is then computed as κ p1,q = φ 2 − φ 1 = φ 2 − π/2 . The resulting value is positive for surfaces bending away from the surface normal n 1 , negative for surfaces bending towards the surface normal n 1 and zero for flat surfaces. Furthermore, the distance l determines the scale of detected curvatures and is fixed to 0.005 for all of our experiments. Although just an approximation of curvature, we found the turning angle to be a good indicator for predicting the amount of surface bending.
Directed Curvature Head. We extend the neural implicit representation of IGR [24] with an additional directed curvature head in order to predict the curvature κ p,q of a surface point p along the tangential direction q. The extended signed distance function (s p , κ p,q ) = f κ ((p, q); θ; z) returns a tuple of signed distance and normal curvature at point p. We make the curvature query optional, such that the extended decoder can be queried for signed distance val-ues only. We use the same training losses as in IGR [24]. We train the curvature head with a supervised L 2 loss on top of the existing IGR losses L IGR : where κ p,q is the curvature prediction and κ GT the ground truth curvature, based on the turning angle approximation. During training, we sample a surfacetangential direction q uniformly at random for every element in the batch. We refer to the supplementary material for architectural details.

Iterative Meshing Procedure
The input to our iterative meshing module are the predictions of our modified implicit representation S. The resolution of the output mesh M = (V, F) is defined by the default equilateral triangle with circumradius r d which is provided as an input parameter. In an initial step, random faces are placed along the surface defined by S. Further processing then iteratively extends existing triangles by inserting new faces along boundary edges until completion of the mesh, as shown in Figure 3c. In order to keep track of boundary edges, we employ a halfedge data structure, which provides efficient operations for boundary edge access, vertex insertion and face insertion. To find vertices in a local region quickly, we use an additional k-d tree to keep track of mesh vertices. Initialization. As visualized in Figure 3b, the set of initial triangles {T i } I is computed by first sampling a set of I points uniformly at random within the bounding box of the point cloud P. This set of points is then projected onto the surface using the gradient ∇ p f (p; z) of the SDF prediction. For each projected point, we construct an equilateral triangle on the tangential plane with circumradius r d and random location of vertices. We enforce a minimum euclidean distances d min = 3r d to be present between all projected points in order to avoid overlapping triangles. We use a k-d tree data structure to query candidates within a radius d min efficiently and filter out overlapping triangles. As the underlying implicit representation S might exhibit inaccuracies, e.g., far from the surface, we employ a simple heuristic in order to accurately place the initialization triangles. We perform the surface projection P times for k × I points, each time bringing the initial random samples closer to the surface, similar to Chibane et al . [18]. Finally, we choose random I non-overlapping points as initialization locations for the triangles. Iterative Face Insertion. Given the initial set of triangles {T i } I , our iterative meshing module proceeds to iteratively select boundary edges, i.e., edges of existing triangles which only have one connected face, and predict new vertices until no boundary edges are left. The process can be accelerated by computing batches of vertex insertions. To this end, the vertex predictions are computed batchwise on the GPU. As batch processing introduces the risk of inserting overlapping triangles, we employ two simple strategies: (1) Only boundary edges with distances between their mid-points greater than a certain threshold are processed  (2) we filter overlapping face insertion candidates before adding the faces to the mesh. This procedure ensures that no overlapping triangles are inserted, given a reasonable threshold. Since the sampling of nonoverlapping boundary edges reduces the number of available boundary edges, we use a simplified procedure in practice where we apply a minimum threshold of 3r d between the boundary edge centers. Although this reduces the number of collisions, the absence of overlaps is not guaranteed. We apply a final overlap check in order to reject candidates with small distances between triangle centers.

Merging Surface Patches
Naively inserting new faces for every boundary edge leads to overlapping surface patches. Therefore, we employ a deterministic procedure for merging such faces. Prior to creating the triangle proposed by the vertex prediction, we replace it by the existing vertex closest to the center m of the boundary edge, provided the vertical distance is below a threshold t v = r d 2 and the prospective new triangle does not overlap with an existing triangle. In order to decide whether two triangles overlap, we distinguish between several scenarios illustrated in Figure 4. For the most frequent case 4a where no overlap occurs, the prediction is not replaced. Case 4b handles geometric intersections between the predicted vertex and the existing triangle, while 4c addresses the case where an existing triangle is completely contained in the prospective new triangle. In both cases, the predicted vertex is projected onto the triangle plane followed by a simple inside-outside test. Since vertex projection is not sufficient in all cases, we additionally perform edge intersection tests (4d) and compare the vertical distance between triangle planes (4e). Finally, we consider vertices in close proximity to the prediction to be overlapping, as shown in Figure 4f. Please refer to the supplementary material for more details.

Vertex Prediction
We introduce a novel vertex prediction module which takes a boundary edge and a feature vector as input and predicts the location of the next vertex based on local geometry information. The output of the predictor is a 2-dimensional vector r = r LS r ER . As demonstrated in Figure 5, both target a separate degree of freedom for transforming the default prediction v d at the center of the boundary edge m. Note that we define v d such that it is orthogonal to the boundary edge and the face normal n F and incidentally defines the height of the predicted triangle. The first component denotes the boundary edge rotation, i.e. the angle r ER ∈ − π 2 , π 2 defining the rotation around the boundary edge ( Figure 5b). The length scaling factor r LS ∈ [−1, 1] scales the length of the default vector v d . Negative values decrease the vector length whereas positive values increase its length. Note that we intentionally only predict two out of 3 DoF, i.e., we omit the rotation around the face normal n F belonging to the face of the boundary edge, since we found no performance improvement in incorporating the 3 rd DoF. Feature Embedding. To effectively predict accurate vertex locations, we provide the predictor with a feature embedding containing information about the local geometry. Figure 5e depicts the used feature vector. We consider the 3 points defined by the default triangle, i.e., the vertex at the default location v d and the two boundary edge end points, a and b. For each of these 3 points, we query the implicit representation S for SDF values (s p d , s a and s b ), SDF gradients or normals (n p d , n a and n b ) and directional curvature values (κ p d , κ a and κ b ) (Figure 5d). In practice, we use multiple directional curvature queries for each query point. Additionally, we feed the length of the boundary edge e length = a − b 2 into the feature vector. Note that the feature embedding can be made invariant to rotation and translation. Prior to inference, we therefore transform the normals into a local coordinate system with the boundary edge center m as its origin. The network predictions can be readily applied within the world coordinate system to obtain the new vertex p d . In order to reduce prediction errors, we apply surface projection once as a post-processing step in the same way as performed during the initialization phase. Loss Functions. We introduce a surface distance loss L SD = |s p d |, in order to penalize any deviation from the zero value for the SDF s p d of the predicted vertex p d . To encourage the network to predict triangles with default size r d , we additionally define a length regularization loss L LR = |r LS | which prevents prediction of degenerate triangles close to the boundary edge and competes with the surface distance loss. Based on the surface mapping procedure, applied as a post-processing step, we can compute the ground truth turning angle φ GT , located at the boundary edge. Therefore, the boundary edge rotation loss L ER = |r ER − φ GT | encourages the network to predict vertices close to the surface and penalize the predicted boundary angle r ER . The final loss then consists of a weighted sum of those loss terms, i.e., L Total = λ SD L SD + λ ER L ER + λ LR L LR .

Evaluation
For the experiments, we use a subset of the D-Faust [8] dataset, containing highresolution scans of humans in different poses and corresponding triangle meshes, which we use as ground truth (GT) reference. We train, validate and test on 512, 64 and 32 poses respectively, sampled randomly from the subset used in IGR [24]. To further evaluate our capability of dealing with sharp corners and edges, we evaluate on a selected subset of shapes, belonging to the file cabinet category of the ShapeNet [13] dataset. We use 147 models for training, 32 for validation and 32 for testing and preprocess the models with ManifoldPlus [29].

Reconstruction Quality
Reconstruction Error. We evaluate the reconstruction error of the produced triangle meshes with the Chamfer-L1 distance in Table 1. The Chamfer distance is reported in two directions, i.e., from the prediction to the ground truth and the implicit representation, respectively, and vice versa. We report both, the distance to the ground truth mesh and the distance to the respective implicit representation, since there is a discrepancy between both, introducing an additional error in the reported numbers. We compare our method to the SotA method PointTriNet [52], however, since PointTriNet directly operates on point clouds sampled from the ground truth mesh, the reported error appears lower than methods working directly on implicit representations. We therefore evaluate PointTriNet on both, points sampled on the ground truth mesh, and points generated from the implicit representation by first sampling surface points on the ground truth mesh and projecting them to the zero level set of the implicit representation. We further compare our method to a version of marching cubes  Table 1: Reconstruction error on D-Faust [8]. We report the distances of closest point pairs between the generated meshes and the ground truth (GT) or the implicit representation (IGR) respectively. The distances are evaluated at 20k randomly sampled surface points. For the implicit representation the sampled GT points are projected to the zero level set of the implicit representation resolutions. In the same manner, we evaluate our method for three different triangle sizes r d . Finally, we compare to PSR [32] from Open3D (depth=10), and DSE [50], with the author-provided model. On the highest resolution, our method outperforms all baselines, when measured on the implicit representation, while yielding comparable results on the medium resolution. Compared to marching cubes, our method improves on every comparable level of resolution. For evaluations on the ground truth mesh, NeuralMeshing also outperforms marching cubes. PointTriNet evaluated on the ground truth sampled points shows comparatively better numbers, which is expected because of the error introduced by the underlying implicit representation. Reconstruction Accuracy and Completeness. We report further quantitative results in Table 2. Specifically, we report the accuracy, completeness and the F-score for 3 different inlier thresholds, evaluated on both implicit surface representation and ground truth mesh. The accuracy is computed as the ratio of inlier points, i.e. sampled points on the predicted mesh which are within inlier distance of the ground truth mesh, and total number of sampled points. The completeness is computed similarly in the opposite direction. Our method again outperforms marching cubes on implicit surface evaluations while PointTriNet performs better when evaluated on the ground truth mesh, presumably because of reconstruction errors inherent in the implicit surface representation.
Qualitative Results. Figure 6 shows the meshes of all methods on one example. NeuralMeshing yields well behaved triangle meshes with regularly shaped and sized triangles, reconstructing high-level details in accordance to the chosen triangle size r d . While marching cubes on comparable resolution levels reconstructs a similar level of detail, their generated triangle sizes cannot become bigger than    the underlying voxel size. PointTriNet reconstructs the full shape with some level of detail but introduces many visible holes and overlapping faces.

Triangle Mesh Properties
In this section, we evaluate several mesh properties and triangle metrics. Mesh Metrics. To demonstrate the capability of producing detail-preserving, low-memory triangle meshes, we report typical mesh metrics in Table 3, i.e., number of triangles, number of vertices and the average triangle area. We also list the inference time for speed comparisons. Our method produces less but bigger triangles than marching cubes for comparable levels of detail. Distribution of Face Area, Triangle Angles and Holes. To demonstrate the regularity of the generated faces, Figure 7a shows the angle distribution observed in generated meshes of each method. Compared to marching cubes and Point-TriNet, our method produces triangle angles closer to the equilateral triangle, containing very few triangles with tiny angles. Figure 7b provides similar insights by comparing the triangle area distribution. It can be observed that our method produces more similarly sized faces while still allowing some variation in order to adapt to more complex surface patches. In Figure 7c, we plot the number of holes vs. the hole size and compare it with both baselines, illustrating that the vast majority of holes produced by NeuralMeshing are very small. We refer to the supplementary material for more quantitative metrics and ablation studies.
Limitations. NeuralMeshing does not guarantee watertightness, but typically produces meshes with fewer holes than comparable methods. Sharp edges are sometimes problematic which we attribute to the performance of the prediction network. Like marching cubes, NeuralMeshing does not provide a manifoldness guarantee. However, our mesh growing strategy can effectively avoid the insertion of non-manifold edges, while marching cubes requires expensive post-processing.

Conclusion
We introduced NeuralMeshing, a novel meshing algorithm for neural implicit representations. We exploit curvature information learned as part of the neural implicit representation in order to guide the predictions of new triangles. Our iterative, curvature-based processing of boundary edges allows us to generate triangle sizes in accordance to the underlying curvature, yielding preferable mesh properties. Experiments demonstrate that NeuralMeshing outperforms existing meshing algorithms, producing meshes with lower triangle counts. In this supplementary material, we provide more details on overlap checks (Sec. A), the curvature head of the modified neural implicit representation (Sec. B) and the vertex prediction module (Sec. C). The data preprocessing used for the experiments is explained in Sec. D. In Sec. E and Sec. F, we provide additional quantitative and qualitative results, respectively. We provide ablation studies in Sec. G and further quantitative results regarding the watertightness property in Sec H. Finally, we discuss sharp features and highlight a few more limitations in Sec. I.

A Details on Overlap Checks
The size of the triangles inserted into the mesh is controlled by the circumradius r d of the default triangle while the height of a triangle is upper bounded by two times the height of the default triangle. It is therefore sufficient to apply the overlap check only on a local subset of nearby mesh faces. For a triangle candidate f c , we define this set of relevant local faces as where c(f c ) is the centroid of the triangle and d(f, c(f c )) denotes the smallest euclidean distance among the face vertices in f and the triangle center of f c . F fc can be efficiently constructed by first collecting all relevant vertices through a radius search on the centroid c(f c ) with radius 2r d using the vertex k-d-tree. The half-edge data structure allows us to access all the triangles involved with these vertices. Vertex Proximity Test. Vertex insertions very close to existing vertices are undesirable (Figure 4f) since it requires the insertion of very small faces at subsequent prediction steps. We therefore consider triangle candidates close to an existing triangle as overlapping. The threshold t v = r d 2 is applied along the axis defined by the face normal and on the distance to the triangle edges on the triangle plane. More formally, we define the test for whether point p overlaps with triangle f as where d vertical is the smallest distance between p and the triangle plane and s e denotes the signed distance of p projected onto the triangle plane, to the lines defined by the triangle edges. Note that these values are positive if the point lies on the same site of the line as the triangle and negative otherwise. Segment Intersection Test. Consider two edges e 1 and e 2 , both belonging to different triangles. Let v e1,a and v e1,b denote the vertices of e 1 and v e2,a and v e2,b denote the vertices belonging to e 2 . Furthermore, let p 1 and p 2 be the points on edge e 1 and edge e 2 , respectively, belonging to the shortest line segment which connects these two lines. The points can be expressed as with p 1 and p 2 being on the triangle edge if d 1 ∈ [0, 1] and d 2 ∈ [0, 1], respectively. Therefore, we consider two edges intersecting, if the two points p 1 and p 2 are located on the respective edges and the euclidean distance between the points is within a defined threshold, i.e. d 1 , d 2 ∈ [0, 1] and p 2 − p 1 ≤ t near .
To compute the scalars d 1 and d 2 , we make use of the constraint that the line segment is perpendicular to the edges. Hence, the dot product must be zero, i.e. (v ei,b − v ei,a ) (p 2 − p 1 ) = 0 for i ∈ {0, 1}. By rewriting the vector p 2 − p 1 with Eq. 4, we are able to solve for the scalars d 1 and d 2 .
Existing Vertex Selection. If one of the above tests indicates that the predicted vertex overlaps with existing triangles, the predicted vertex is replaced with an existing vertex v A . Only vertices returned from the radius search used to build the triangle set F fc (Sec. A) are considered as candidates. Among the available candidate vertices, we choose the candidate with the smallest euclidean distance to the center of the boundary edge, provided the triangle defined by the vertex candidate does not overlap with the existing mesh. We therefore perform an additional overlap check for all candidate vertices. Note that vertex proximity test must not be applied to faces containing the vertex candidate, since the two faces always intersect at the vertex candidate.

B Curvature Head Details
As shown in Figure 8, we attach the curvature head at the layer after the skip connection. The head consists of three fully connected layers of width 512 with ReLU activations, except for the output layer where we use tanh as the activation function. The directional curvature query q is exclusively provided to the curvature head and doesn't get used for standard SDF queries. The decoupled curvature head allows us to use pretrained decoder weights from models trained without a curvature head. During training, the query direction q is randomly sampled on the tangential plane of each query point, defined by the surface normal.

C Vertex Prediction Details
Architecture. The MLP in the vertex prediction module, shown in Figure 9, consists of five fully connected layers of width 512. We use ReLU as activation function and tanh for the output layer. The angular value in the result vector is scaled by π 2 . Training. We use the Adam optimizer [34] with an initial learning rate of 0.001 without any learning rate scheduling. The MLP is trained iteratively with new batches (of 32 shapes) of triangle insertions. Each shape is initialized with 1024 initialization triangles. A training step consists of a mini batch containing 512 boundary edges per shape. For every batch of 32 shapes, 50 training steps are computed. Currently, we train a model for every mesh resolution, defined by r d . Artifact Removal. The implicit neural representation (IGR) used by marching cubes and our method introduces several shape artifacts. An example of such artifacts is visualized in Figure 10. Furthermore, as the implicit representation is an approximation of the ground-truth mesh, it might differ slightly in some surface areas, smoothing sharp features or providing explanations for parts of the shape where no input data was provided. In order to compare our method with approaches which do not use an implicit representation, e.g. PointTriNet [52], we remove such artifacts automatically. The removal process first discards all triangles in the lowest five percent of the bounding box, i.e. we cut of the feet of humans in the DFaust dataset since the artifacts often are connected with the scans through the ground and the feet. We then split the mesh into connected components and keep only the component closest to the center of the bounding box. The distance from a mesh component to the center of the bounding box is computed by measuring the euclidean distance between the center of the bounding box and the mean of all mesh-vertices.   Table 4: Normal consistency. The normal consistency of generated meshes is measured against the implicit representation (IGR) and the ground-truth (GT)

E More Quantitative Results
Impact of Inlier Threshold on F1-score. To provide a better picture on the impact of the threshold on the F1-score, Figure 11 visualizes the change of the F1-score with growing t inlier . Compared to marching cubes, our method achieves a better F1 score for similar resolutions with tight inlier thresholds. PointTriNet meshes are closer to the ground truth mesh, which we attribute to the artifacts and differences in the implicit representation. Normal Consistency. To further evaluate the consistency of the orientation of the generated faces, we employ the normal consistency metric (NC). The corresponding results are reported in Table 4. The quality of the face orientation are within the same range for marching cubes and our method when evaluated on the implicit representation.
Interaction with Implicit Representation. Marching cubes and NeuralMeshing rely on querying the underlying implicit representation. In Table 5 we report the average number of queries performed in the evaluated meshing procedures on the D-Faust dataset. We can observe that the extensive querying performed

F More Qualitative Results
In Figure 12 and Figure 13, we provide additional qualitative results. We can observe that our meshes are more complete than those from PointTriNet, while still providing the same level of detail as marching cubes.

G Ablation Study
To understand the impact of different elements of our meshing algorithm on the reconstruction quality, we perform an ablation study and report the results in Table 6. For a given triangle size of r d = 0.005, we retrain the vertex predictor   Table 5: Number of SDF queries. We report the number of SDF queries used by marching cubes [37] and our method. NeuralMeshing uses significantly less SDF queries than marching cubes with different components disabled, while using a similar experiment setup as before. We run all ablations with a disabled surface projection post-processing step, as it otherwise skews the results, as differences between the ablations get tiny. For the no length scaling experiment, we use the default triangle size r d instead of the predicted length, while for the no edge rotation experiment, we use a predicted angle of zero, corresponding to an extension of the mesh along the plane defined by the existing triangle adjacent to the boundary edge. For the no prediction experiment, we do not use either prediction. The next 4 experiments test the effectiveness of each embedded feature. We alternatingly either omit the features at the default vertex (no p-queries) or at the boundary edge end points (p-queries only), use only 1 directional curvature feature queries instead of the original 3 (1 direction) or use no curvature features at all (no curvature).

H Watertightness
We report the boundary edge to total edge ratio in Table 7 as a metric for watertightness. Since some shapes intersect the bounding box, marching cubes also introduces boundary edges at these locations. NeuralMeshing exhibits fewer and smaller holes than PointTriNet while marching cubes does not generate any.

I Limitations
Sharp features The subset of the ShapeNet dataset used for evaluation contains features such as corners and sharp edges. NeuralMeshing naturally extends to sharp edges and corners, as visible in Figure 14. However, due to the limited information provided to the vertex prediction module and the smoothing effects of the underlying implicit representation, the meshing procedure reconstructs smoother corners and can lead to irregularities along sharp edges. Holes. Holes occur mostly at surface locations with high curvature, illustrated in Figure 15a, 15b and 15c. In such cases, the edge rotation prediction does not bend the triangle sufficiently towards the real surface, leading to a scenario where no existing vertices are found, and the mesh therefore remains unclosed. Holes in flat surfaces can occur, but are rare and almost unnoticeable, as shown Figure 15d. Supervision. The current method requires an explicit mesh for computation of the supervision signal of the curvature head. Future work would address this by incorporating self-supervision in order to preserve training on raw scans only. Initialization Triangles. A single initialization triangle is sufficient for reconstructing a single connected component, but will fail for shapes containing mul- tiple disconnected surface components. The procedure must therefore sample enough points in order to catch all surface components with high probability. Such cases can easily be reduced by using the grid points of an initialisation grid instead of random points in space.
Furthermore, initialization triangles placed on a surface region with high curvature might introduce inaccurate faces in the mesh. Future work could improve upon this by adapting the size of the initialization triangle to the curvature.   Table 7: Quantitative metrics of observed holes. We report the ratio of boundary edges to total edges, the average number of holes per shape, the average radius of the minimum enclosing sphere of holes and the average number of edges involved in a hole