Neural Subdivision
Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, Alec Jacobson
NNeural Subdivision
HSUEH-TI DEREK LIU,
University of Toronto
VLADIMIR G. KIM,
Adobe Research
SIDDHARTHA CHAUDHURI,
Adobe Research, IIT Bombay
NOAM AIGERMAN,
Adobe Research
ALEC JACOBSON,
University of Toronto, Adobe Research
Fig. 1. Our neural subdivision framework performs geometry-aware subdivision, reconstructing the reference rocker arm that we decimated to obtain thecoarse input with high accuracy, even though it was only trained on one single model - the Stanford bunny. Neural subdivision does not suffer from theinherent limitations of classic subdivisions, such as volume shrinkage and over-smoothing (Loop [1987]), or amplification of tessellation artifacts (modifiedbutterfly [Zorin et al. 1996]). Throughout this paper, we use green to denote the training shape, and blue for the neural subdivision output.
This paper introduces
Neural Subdivision , a novel framework for data-drivencoarse-to-fine geometry modeling. During inference, our method takes acoarse triangle mesh as input and recursively subdivides it to a finer ge-ometry by applying the fixed topological updates of Loop Subdivision, butpredicting vertex positions using a neural network conditioned on the localgeometry of a patch. This approach enables us to learn complex non-linearsubdivision schemes, beyond simple linear averaging used in classical tech-niques. One of our key contributions is a novel self-supervised trainingsetup that only requires a set of high-resolution meshes for learning net-work weights. For any training shape, we stochastically generate diverselow-resolution discretizations of coarse counterparts, while maintaining abijective mapping that prescribes the exact target position of every newvertex during the subdivision process. This leads to a very efficient andaccurate loss function for conditional mesh generation, and enables us totrain a method that generalizes across discretizations and favors preservingthe manifold structure of the output. During training we optimize for thesame set of network weights across all local mesh patches, thus providing anarchitecture that is not constrained to a specific input mesh, fixed genus, orcategory. Our network encodes patch geometry in a local frame in a rotation-and translation-invariant manner. Jointly, these design choices enable ourmethod to generalize well, and we demonstrate that even when trained on asingle high-resolution mesh our method generates reasonable subdivisionsfor novel shapes.
Authors’ addresses: Hsueh-Ti Derek Liu, University of Toronto, [email protected]; Vladimir G. Kim, Adobe Research, [email protected]; Siddhartha Chaudhuri,Adobe Research, IIT Bombay, [email protected]; Noam Aigerman, Adobe Re-search, [email protected]; Alec Jacobson, University of Toronto, Adobe Research,[email protected] to make digital or hard copies of all or part of this work for personal orclassroom use is granted without fee provided that copies are not made or distributedfor profit or commercial advantage and that copies bear this notice and the full citationon the first page. Copyrights for components of this work owned by others than ACMmust be honored. Abstracting with credit is permitted. To copy otherwise, or republish,to post on servers or to redistribute to lists, requires prior specific permission and/or afee. Request permissions from [email protected].© 2020 Association for Computing Machinery.0730-0301/2020/7-ART1 $15.00https://doi.org/10.1145/3386569.3392418
Fig. 2. Neural subdivision refines different parts of a mesh differently, condi-tioned on the local geometry. Here, the network was trained on the centaurmodel (green) and then evaluated on a coarse gorilla mesh (gray).
ACM Reference Format:
Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aiger-man, and Alec Jacobson. 2020. Neural Subdivision.
ACM Trans. Graph.
39, 4,Article 1 (July 2020), 16 pages. https://doi.org/10.1145/3386569.3392418
Subdivision surfaces are defined by deterministic, recursive up-sampling of a discrete surface mesh. Classic methods work byperforming two steps: each input mesh element is divided intomany elements (e.g., one triangle becomes three) by splitting edgesand adding vertices. The positions of the mesh vertices are thensmoothed by taking a weighted average of their neighbors’ positionsaccording to a weighting scheme based purely on the local meshconnectivity. Subdivision surfaces are well studied and have richtheory connecting their limit surfaces (applying an infinite numberof subdivide-and-smooth iterations) to traditional splines. They area standard paradigm in surface modeling tools, allowing modelersto sculpt shapes in a coarse-to-fine manner. A modeler may startwith a very coarse cage, adjust vertex positions, then subdivide once,adjust the finer mesh vertices, and repeat this process until satisfied.While existing subdivision methods are well-suited for this sortof interactive modeling, they fall short when used to automatically
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. a r X i v : . [ c s . G R ] M a y :2 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson Fig. 3. Neural subdivision can adapt to different input triangulations andoutput a high-resolution surface mesh accordingly. This enables us to use itdirectly in the graphics pipeline such as texture mapping. upsample a low resolution asset. Without a user’s guidance, classicmethods will overly smooth the entire shape (see Fig. 1). Popularmethods based on simple linear averaging do not identify detailsto maintain or accentuate during upsampling. They make no useof the geometric context of a local patch of a surface. Furthermore,classic methods based on fixed one-size-fits-all weighting rules aredetermined for their general convergence and smoothness proper-ties. This ignores an opportunity to leverage the massive amount ofinformation lurking in the wealth of existing 3D models.We propose
Neural Subdivision . We recursively subdivide an inputtriangle mesh by applying the same fixed topological updates ofclassic Loop Subdivision, but move vertices according to a neuralnetwork conditioned on the local patch geometry. We train theshared weights of this network to learn a geometry-dependent non-linear subdivision that goes beyond classic linear averaging (seeFig. 2). The choice of training data tailors the network to a particularclass, type or diversity of geometries.An immediate challenge is how to collect training data pairs.There is an ever-growing number of 3D models available. However,many if not most of them were not created using a subdivisionmodeling tool. Even among those that were, the final model doesnot retain information to replay the modeler’s vertex displacements.In the absence of paired data for a supervised training approach, wepropose a novel method to self-supervise given only high-resolutionsurface meshes of arbitrary origin/connectivity at training time. Westochastically generate candidate low-resolution versions of a train-ing exemplar while maintaining a bijective correspondence betweentheir surfaces. This correspondence enables a novel loss functionthat is more efficient and accurate compared to existing methods.By construction, this training regime ensures generalization acrossdiscretization .In contrast to existing generative models for surfaces, our outputis a surface mesh with deterministic connectivity based on the input,enabling direct use in the standard graphics pipeline such as texturemapping (see Fig. 3). By sharing weights and training across alllocal patches of all the training meshes, we learn a rule based onthe local neighborhood rather than the entire shape. Compared toexisting methods, this frees our network from being constrainedto a fixed genus, relying on a template, or requiring an extremelylarge collection of shapes during training. We demonstrate that evenwhen trained on a single shape, our method can generalize to novelmeshes. We design our network to encode vertex position data in alocal frame ensuring rotation and translation invariances withoutresorting to handcrafted predefined feature descriptors. We demonstrate the effectiveness of our method with a varietyof qualitative and quantitative experiments. Our method generatessubdivided meshes that are closer to the true high-resolution shapesthan traditional interpolatory and non-interpolatory subdivisionmethods, even when trained with a small number of very dissim-ilar exemplars. We introduce a quantitative benchmark and showsignificant gains over classic subdivision methods when measuringupsampling fidelity. Finally, we show prototypical applications ofNeural Subdivision to low-poly mesh upsampling and 3D modeling.
Our work builds directly upon the foundations of classic subdivisionsurfaces and connects to the rapidly advancing field of neural ge-ometry learning. We focus this section on establishing context withpast subdivision schemes and contrasting our geometric learningcontributions with contemporary works.
The basic idea of subdivision is to “define a smooth curve or surfaceas the limit of sequence of successive refinements” [Zorin et al. 2000].This broad definition admits a wide variety or “zoo” of differentsubdivision schemes that would be outside the scope of this paperto cover thoroughly. The history of subdivision surfaces reachesback to the early work on irregular polygon meshes [Doo 1978; Dooand Sabin 1998] and the now ubiquitous Catmull-Clark subdivisionwhich produces quad meshes [Catmull and Clark 1998]. The linearmethod of Loop [1987] for triangle meshes has reached similarpopularity, and is the basis for our non-linear neural subdivision.Classic linear subdivision methods are defined by a combinato-rial update (splitting faces, adding vertices, and/or flipping edges[Kobbelt 2000]) and a vertex smoothing (repositioning step) based onlocal averaging of neighboring vertex positions. Subdivision meth-ods are well studied from a theoretical perspective on the existence,direct evaluation, and continuity of the limit surface [Karciauskasand Peters 2018; Stam 1998; Zorin 2007]. Modelers typically manipu-late a subdivision surface in a coarse to fine fashion. Most modelingtools already visualize the limit surface or some approximation ofit, while the user manipulates the coarse level (cage) (see Fig. 23).Beyond moving vertices, users can control the surface by addingcreases (sharp edges) [DeRose et al. 1998; Hoppe et al. 1994]. Non-interpolating methods such as Catmull-Clark or Loop appear to bethe most popular, but interpolating methods do exist (e.g., [Dyn et al.1990; Kobbelt 1996; Zorin et al. 1996]) and have similar smoothnessguarantees, although fairness is harder to achieve (see Fig. 1). Linearmethods are easier to analyze and design to guarantee smoothness.As a result, capturing details is left to the modeler or a deterministicprocedural routine (e.g., [Tobler et al. 2002a,b; Velho et al. 2002]).Our neural subdivision acts similar to non-linear subdivisionmethods, with the subdivision rule in this case being a non-linearfunction learned by a neural network. Non-linear subdivision hasbeen studied from the mathematical perspective [Floater and Mic-chelli 1997; Schaefer et al. 2008] and also as a mechanism to main-tain certain geometric invariants during each level of subdivision(e.g., circle-preserving [Sabin and Dodgson 2004], quad planarity[Bobenko et al. 2020; Liu et al. 2006], developability [Rabinovich
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:3
Fig. 4. Our subdivision is data-driven. Training on a set of mechaniticalobjects (left, green) or a set of smooth organic objects (right, green) leads todrastically different styles (blue). ©Gyroid Puzzl by eemmett (top left) andHilbert Cube by tbuser (bottom) under CC BY-SA.Fig. 5. One can use existing point upsampling methods to refine coarsemeshes by (1) sampling, (2) upsampling [Wang et al. 2019b], and (3) recon-struction [Kazhdan and Hoppe 2013]. However, this may lead to artifactssince it lacks information about the surface, and requires the use of expen-sive surface reconstruction as a post-process. et al. 2018; Tang et al. 2014], Möbius-regularity [Vaxman et al. 2018],cloth wrinkliness [Kavan et al. 2011]). One general approach is tocombine a linear subdivision with an online geometric optimization,and recursively apply the non-linear rule an arbitrary, if not infi-nite number of times, akin to classic linear rules. Our approach canbe viewed as an extreme form of precomputation, where the opti-mization is the training procedure and the fixed network is appliedgenerally as a non-linear function evaluation. The choice of data inthe training will influence the “style” of our non-linear subdivision(see Fig. 4). Although our method is non-linear, it is trained to workwell for a pre-specified finite number of times.Recently, Preiner et al. [2019] introduced a new non-linear subdi-vision method that treats the coarse shape probabilistically. Theircontributions are orthogonal to ours, and while we base our methodon Loop subdivision, we could in theory extend our network tolearn on top of this more powerful subdivision method.
Recent advances in generative neural networks enabled the use oflearnable components in 3D modeling applications such as shapecompletion [Li et al. 2019], single-view [Tatarchenko et al. 2019]and multi-view [Sitzmann et al. 2019] reconstruction, and modeling-by-parts [Chaudhuri et al. 2020].
Fig. 6. We compare the same model trained using (a) chamfer distance(which only measures error between point sets) and (b) our ℓ loss based onshape correspondences. The model trained using the chamfer distance failsto capture the surface topology (red). In contrast, our loss function leads tomanifold output meshes (blue). ©Gyroid Puzzle by emmett (top) under CCBY-SA. The closest to our neural mesh subdivision application are thedeep point cloud upsampling techniques [Li et al. 2019; Wang et al.2019b; Yu et al. 2018]. The disadvantage of using a point cloudas input is that it lacks connectivity information, and requires theneural network to implicitly estimate the structure of the underlyingmanifold. Meshes can also be more efficient at representing feature-less regions with larger planar elements, providing a wider receptionfield to our mesh-based neural network. Mesh output is preferredfor many standard graphics pipelines, thus, a post process is oftenrequired [Kazhdan and Hoppe 2013] to convert the output of point-based methods to meshes, which prevents building an end-to-endtrainable system. Fig. 5 illustrates the output of a point upsamplingmethod that was pre-trained on a collection of statues [Wang et al.2019b] (see App. A for implementation details).Our work is related to other neural mesh generation techniques.Free-form generation of meshes as a set of vertices and faces isinfeasible with current deep learning methods, due to the lack ofregular structure, uneven discretization, and combinatorial variabil-ity in the possible outputs, limiting such approaches to very coarseoutputs [Dai and Nießner 2019]. A common alternative is to deforma global template either by predicting vertex coordinates [Ranjanet al. 2018; Tan et al. 2018] or by training a deformation networkthat warps the entire 3D domain conditioned on a latent vectorthat encodes the deformation target [Groueix et al. 2018a; Yifanet al. 2020]. While these approaches usually produce meshes withhigher resolution, their output is limited to deformations of a singleshape. Some techniques propose using generic templates such asspheres [Wang et al. 2018; Wen et al. 2019] or 2D atlases [Groueixet al. 2018b], which place limitations on the topology of the out-put. In contrast to these techniques, our method refines the meshlocally, and thus, respects the topology of the input (which could bearbitrary). Another advantage of our local refinement approach isthat we do not require co-aligned training data with a well-definedobject space, the output of our subdivision networks is translationand rotation invariant since it can be described in a local coordinatesystem of the input patch.
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :4 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Fig. 7. Neural subdivision takes a coarse triangle mesh (gray) as input and outputs a sequence of subdivided meshes (blue) with different levels of details.During training, we minimize the ℓ loss from the ground truth (green) to the output meshes (blue) across levels. Our training data consists of pairs of coarseand fine meshes (top left) with a bijective map f between each pair. There are several options for analyzing a mesh patch with a neuralnetwork, such as using a local [Masci et al. 2015; Poulenard andOvsjanikov 2018] or global [Maron et al. 2017] parameterization tounfold a mesh into 2D grid, or apply graph-based techniques adaptedfor meshes [Kostrikov et al. 2018; Wang et al. 2019a] (see [Bronsteinet al. 2017] for a more comprehensive survey). Our approach isinspired by MeshCNN [Hanocka et al. 2019]. Their method directlylearns filters over the local mesh structure via undirected edges, andshows applications in deterministic tasks. In contrast, we focus ongenerative tasks and develop a novel set of features over the half-flaps – an edge along with its two adjacent triangles. Each half-flaphas a canonical orientation which gives us well-defined local frameswhich are crucial for our network’s rigid motion invariance.Geometry generation techniques are typically trained with recon-struction losses that measure how well does the generated surfaceapproximate the known target. Surface-to-surface distances are com-monly employed, with correspondences defined via closest-pointqueries (aka chamfer distance) [Barrow et al. 1977; Fan et al. 2017].However, the closest-point approach matches many points to thesame point, while leaving other points unmatched, resulting inself-overlaps and unrepresented areas (see Fig. 6).Indeed, prior work demonstrates that using higher quality cor-respondence (e.g., ground truth mapping) significantly improvesresults [Groueix et al. 2018a]. While the latter is not available in oursetting, we propose a data generation technique for creating variouscoarse variants of the same high-res mesh with a low-distortionbijective map. Bijectivity is crucial for the quality of our trainingdata, ensuring no self-overlaps exist and that every part of the targetsurface has a pre-image on the coarse mesh.
In the following we overview the main components of our neu-ral subdivision: the test-time inference pipeline, training and loss(Sec. 4), data-generation (Sec. 4), and finally the network architecture(Sec. 5). Later sections will discuss these components in detail.
Inference.
As illustrated in Fig. 7, our method takes a coarse tri-angle mesh (gray) as input and recursively refines it by subdividingeach triangle to create additional vertices and faces. The output is asequence of subdivided meshes (blue) with different levels of details.Our subdivision process follows a simple topological update rule(same as Loop), namely inserting new vertices at the midpoints of all edges. It then uses a neural network to predict new positions forall vertices, at each new level of subdivision.
Training and loss.
The data we generate provides us with corre-spondences between predicted vertices and points inside the triangleon the ground truth shape. We train our network with the simple ℓ loss, by measuring the distance between each predicted vertexposition at every level of subdivision and its corresponding point onthe original shape (green). As there is no existing dataset consistingof pairs of high-quality meshes and subdivision surfaces in corre-spondence, we instead develop a novel technique for generatingtraining data, comprising of coarse and fine meshes with bijectivemappings between them. Data generation.
We first note that each vertex v created from asubdivision step has a well-defined mapping back to the coarse mesh,defined by mapping that vertex to its corresponding midpoint. Thus,each subdivided mesh at any level of subdivision can be mappedback to the initial coarse mesh via a sequence of mid-point-to-vertexor vertex-to-vertex maps. In practice we use barycentric coordinatesto encode this subdivided-to-coarse bijective mapping, д . Hence,if we had a bijective mapping f between the coarse mesh and theoriginal mesh, we could define a unique point on the original meshcorresponding to v , by compositing the two maps: f ( д ( v )) .Thus, the only missing part is to create coarse and fine mesheswith bijective mappings between them. We achieve this by takinga high-resolution training mesh and sequentially coarsening it byapplying random sequences of edge collapses, thereby generating asequence of coarsened meshes. We maintain low-distortion corre-spondences between the coarsened and original mesh by computinga conformal map between the 1-ring edge neighborhood (before thecollapse) and the 1-ring vertex neighborhood (after the collapse).Composition of these maps creates a dense bijective map f betweenthe coarse and original meshes, which is then directly applied tothe training (Fig. 9). Advantages of our training approach.
In comparison to closestpoint losses that are commonly used to train generative neuralnetworks, our correspondence-based loss is aware of the mani-fold structure (Fig. 6) and is orders of magnitude faster to compute(Fig. 17). Bijectivity and continuity of the map ensure that the en-tire ground truth surface is captured by some region of the coarsemesh (Fig. 10). The low distortion encourages uniformity, which in
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:5
Fig. 8. Given a ground truth shape (green), we use random edge collapses to create several coarse meshes (gray). For each coarse mesh, we subdivide the meshand use the bijective map to determine the position on the ground truth for all the vertices across different levels. The blue meshes are the ground truthsubdivisions that exhibit one-to-one vertex correspondences to the network predictions.Fig. 9. Given an edge collapse algorithm of choice, we plug in our succes-sive self-parameterization described in Sec. 4.1 to compute a bijective mapbetween the original mesh (green) and its decimated version (gray). Wevisualize the map by coloring the fine mesh using the triangulation of thecoarse mesh (right). ©Tarbosaurus Skull by gpvillamil under CC BY-SA. turn enables the reproduction of the target surface with just a fewuniform subdivisions, and, more importantly reduces the variancein the signal the network needs to learn. We can further leveragethe low-distortion map to map an additional signal, such as texture(Fig. 3). As our training data contains many pairs with differentrandom decimations of the same ground truth (App. E), our networkis able to learn how to generalize across discretization.
Network architecture.
Similarly to the subdivision process, thelearnable modules of our network are applied recursively. They op-erate over atomic local mesh neighborhoods and predict differentialfeatures (meaning they represent geometry in the local coordinatesof the mesh, and not in world coordinates). These features are thenused to compute vertex coordinates at the new level of subdivision.We define three types of modules applied at three sequential steps.During the Initialization step, we first compute differential per-vertex quantities that are based on the local coordinate frame. Alearnable module I is applied to the 1-ring neighborhood of everyvertex to map these differential quantities to a high-dimensionalfeature vector stored at the vertex. Note that this high-dimensionalfeature vector is a concatenation of a learnable latent space which en-codes local geometry of the patch, and differential quantities which directly represent local geometry and enable us to reconstruct thevertex coordinates.For each subsequent subdivi-sion iteration, we assumes that thetopology is updated following theLoop subdivision scheme, splittingeach edge at midpoint, and conse-quently, subdividing each triangleinto four (see inset). A Vertex step uses the module V to predictvertex features for the next level of subdivision based on its 1-ringneighborhood, where vertices affected by this step only involve cor-ners of triangles at the previous mesh level. Then, an Edge step usesthe module E to compute features of vertices added at midpointsbased on the pair of vertices that were connected by an edge at theprevious mesh level.Our modules share a very simi-lar architecture and heavily relyon a learnable operator definedover a half-flap : a directed edgeand its two adjacent triangles (seethe inset). We use the directed edge to define the local coordinateframe which is used to estimate the differential features of eitherinput or output of learnable modules. Note also that the directededge allows us to order the four adjacent vertices of the flap in acanonical way. We concatenate their features and feed them intoshallow multi-layer perceptrons (MLP). The weights of the MLPs areshared within each module type and across all levels of subdivision.Both modules I and V process all half-flaps defined by an outgoingedge and use average pooling to combine the half-flap features intoper-vertex features. The module E also combines features from twohalf-flaps (both directions of the edge) via average pooling. Sinceour architecture is local, and uses input and output features thatare invariant to rigid motions, it exhibits an impressive ability togeneralize from example, even when trained on a single fine mesh. While our network architecture and invariant layers are crucial forits ability to learn subdivisions, it by its own is only half of thetwo main components that together facilitate high-quality neural
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :6 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Fig. 10. Given a ground truth/coarse mesh pair, naively using “closest-point-on-mesh” to estimate correspondences between the level-6 subdivided meshand the ground truth results in a non-bijective map, causing the loss functionto fail to capture the entire ground truth mesh (third column). Our successiveself-parameterization ensures bijectivity, which implies the entire groundtruth surface will be captured (right)Fig. 11. Different edge-collapse algorithms can be used in a plug-and-playmanner to create, for instance, a uniform-area parameterization (middle)and an appearance-preserving parameterization (right). This flexibility isused to create training data with diverse types of discretizations. subdivisions. The other half consists of the training process, dataand the loss function.Consider a naive approach to the subdivision training: generatepairs of coarse/fine meshes by a decimation algorithm; measurethe distance between the network’s predicted subdivision and theground truth, for instance by the average distance between predictedpoints and their projections on the ground truth mesh; iterate overcoarse/fine pairs while optimizing the loss. This naive approach hasa major caveat. Computing correspondences using the chamfer-likeloss (Fig. 6) or point-to-mesh distance (Fig. 10) is known to lead toincorrect and self-overlapping matches between shapes. This leadsto a badly training set up because the loss itself exhibits artifacts.In lieu of this naive approach, we consider the fact that a pairof coarse and fine meshes both approximate the same underlyingsmooth surface. This motivates us to compute the correspondencesbased on the intrinsic geometry, instead of an ad-hoc correspon-dence. The outcome is a high-quality bijective map between eachpair of coarse and fine meshes, enabling us to obtain one-to-onevertex correspondences. Therefore a simple ℓ loss is sufficient tocorrectly measure the error between every level of neural subdivi-sion and the ground truth shape. One possible solution is to apply general shape matching techniques.But ensuring bijectivity in general shape matching is difficult. For
Fig. 12. We compute a bijective map for each edge collapse. The bijectivemap from the coarsest mesh M to the input mesh M L is then computedby composing all the maps f l − l . instance, it requires the two shapes to have the same number ofvertices [Vestner et al. 2017], or a user-guided common domain[Praun et al. 2001; Schreiner et al. 2004], or user-provided landmarkcorrespondences [Aigerman et al. 2014, 2015; Kraevoy and Sheffer2004] (see [Van Kaick et al. 2011] for a survey). However, our problemis considerably simpler, since we aim to construct a map betweendifferent discretizations of the same shape, and we have full controlon the decimation procedure.The closest solution to our problem is a seminal work – MAPS[Lee et al. 1998] – on self-parameterization. Given an input mesh,MAPS computes the bijective map by successively removing verticesof the maximum independent set. Since then, several improvementshave been proposed [Guskov et al. 2002, 2000; Khodakovsky et al.2003]. Unfortunately, they cannot be directly applied to edge col-lapses for creating training data for our learning task (see App. D).We need an algorithm that has the flexibility to be used with anyedge decimation method, so that we can generate a diverse collec-tion of coarse meshes (see Fig. 11). Fortunately, the idea from [Cohenet al. 1998, 1997, 2003] for minimizing mesh/texture deviation leadsus to generalize the idea of MAPS to any edge collapses.Our method for computing the bijective map, designed specifi-cally for creating data to train neural subdivision, combines the ideaof self-parameterization from MAPS [Lee et al. 1998] and the idea ofsuccessive mapping from [Cohen et al. 1998, 1997, 2003]. Thus, wecall it successive self-parameterization . This combination enables usto compute the parameterization intrinsically to avoid the require-ment of having a given UV map, such as in the method of Liu et al.[2017]. The result of the combination is extremely simple. It is atwo-step module that can be applied to any choice of edge-collapsealgorithm (see Fig. 11) and it will output a bijective map after thedecimation. Hence, the inputs to successive self-parameterizationare a triangle mesh and an edge collapse algorithm of choice, andthe output is a decimated mesh with a corresponding bijective mapbetween the input and the decimated model. For the sake of repro-ducibility, we reiterate the core ideas from [Cohen et al. 1998, 1997;Lee et al. 1998], and describe how to combine both ideas.We denote the input triangle mesh as M L = ( V L , F L ) , where V L , F L are vertex positions and face information respectively at theoriginal level L . The input mesh M L is successively simplified into aseries of meshes M l = ( V l , F l ) with 0 ≤ l ≤ L , where M = ( V , F ) is the coarsest mesh. For each edge collapse M l → M l − , wecompute the bijective map f l − l : M l − → M l (see Fig. 12) on the ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:7
Fig. 13. For each edge collapse, we simultaneously collapse the edge on the3D mesh (top) and the UV domain (bottom). As the boundary vertices ofthe edge’s 1-ring are preserved through the edge collapse, we constrain theflattened boundary in UV space to be at the same position when computingthe conformal parameterization of the post-collapse 1-ring.Fig. 14. Since both the pre-collapse and post-collapse parameterizations ofthe 1-ring map it into the same 2D domain, we can easily use the sharedUV space to map a point back and forth between M l and M l − . fly. The final map f L : M → M L is computed via composition, f L = f L − L ◦ · · · ◦ f . (1)We now focus our discussion on the computation of a bijective mapfor a single edge collapse. In each edge collapse, the triangulation remains the same, exceptfor the neighborhood of the collapsed edge. Let N( i ) be the neigh-boring vertices of a vertex i and let N( j , k ) = N( j ) ∪ N( k ) denotethe neighboring vertices of an edge ( j , k ) . After each collapse, thealgorithm computes the bijective map for the edge’s 1-ring N( j , k ) ,in two stages. It first parameterizes the neighborhood N( j , k ) (priorto the collapse) into 2D. It then performs the edge collapse bothon the 3D mesh, and in UV space, as depicted in Fig. 13. The keyobservation from [Cohen et al. 1998, 1997] is that the boundaryvertices of N( j , k ) before the collapse become the boundary verticesof N( i ) after the collapse. Hence the UV parameterization of the1-ring remains valid and injective after the collapse. Then, for anygiven point p l − ∈ M l − (represented in barycentric coordinates),we can utilize the shared UV parameterization to map p l − to itscorresponding barycentric point p l ∈ M l and vice-versa, as shownin Fig. 14.Following the idea of MAPS [Lee et al. 1998], we use conformalflattening [Mullen et al. 2008] to compute the UV parameterizationof the 1-rings, Fig. 13. After collapsing an edge and inserting the newvertex v ∈ R , we determine this vertex’s UV location by performing Fig. 15. Using a different parameterization technique that does not resultin a conformal flattening leads to a distorted parameterization (left), incontrast to the conformal parameterization we use, that reduces the amountof angle distortion accumulated throughout the edge collapse sequence(right). ©Hilbert Cube by tbuser under CC BY-SA. another conformal flattening with fixed boundary. The conformalityof the map is crucial, as it minimizes angle distortion which wouldotherwise accumulate throughout the successive parameterizations,leading to distorted, skewed correspondences and hindered learningof the network (see Fig. 15).
Successive self-parameterization can be used with any edge collapsealgorithm simply by adding two additional steps (see App. B). Theactual edge collapse algorithm, such as qslim [Garland and Heckbert1997], takes O( N log N ) time, and the flattening is a constant coston top of each collapse (assuming valence is bounded). Thus thecomplexity of the entire algorithm containing both edge collapsesand successive self-parameterization is still O( N log N ) .The robustness of the parameterization algorithm relies heavilyon the robustness of the underlying edge collapse algorithm. Edgecollapses that may lead to self-intersections can result in unusablemaps. In App. C, we summarize our criteria for checking the validityof an edge collapse. This is crucial to ensure that we can generatetraining data using a wide range of shapes (see Fig. 16). Fig. 17. Our loss computation isorders of magnitude faster thanthe chamfer loss on the GPU(Kaolin [J. et al. 2019]) or theCPU (our KD-tree-based imple-mentation).
Our training data is constructedby applying the successive self-parameterization on top of ran-dom edge collapses. In Fig. 8,given a high-resolution shape(green), we use qslim [Garlandand Heckbert 1997] with a ran-dom sequence of edge collapsesto construct several different dec-imated models (gray). During thecollapse, we plug in our self-parameterization to obtain a high-quality bijective map for eachcoarse and fine pair.After the network subdivides the coarse mesh, we use the map toretrieve one-to-one correspondences to the input shape. Specifically,when retrieving the correspondences, we use the Loop topologyupdate to add points in the middle of each edge, e.g., the point withbarycentric coordinates ( . , . , ) in a triangle of the coarse mesh.We use these barycentric coordinates b on the coarse mesh to obtain ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :8 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Fig. 16. Checking the criteria of collapsible edges is crucial for the robustness of the successive self-parameterization. From left to right, ©Psycho by Aeva(2nd, CC BY-SA), Parametric Sculpture by MCompeau (4th, CC BY-NC), Deer Head by TakeshiMurata (5th, CC BY-SA), Brain Slug by Zarquon (6th, CCBY-NC-SA), Spiral Light Bulb by benglish (7th, CC BY-SA), and Metratron by addy (9th, GNU). the barycentric coordinates f ( b ) on the fine mesh, as illustrated inFig. 14 using the bijective map f . During training, suppose E( b ) is the vertex position output by the network E . We measure theper-vertex loss with the ℓ distance ∥ f ( b ) − E( b )∥ . Compared tothe chamfer distance [Barrow et al. 1977], a widely used distance intraining 3D generative models [Fan et al. 2017], our loss computationis orders of magnitude faster (see Fig. 17). Given a mesh at a previous level of subdivision along with a knowntopological update rule (mid-point subdivision as used by Loop),our neural network computes all vertex coordinates for the subdi-vided mesh. Our process involves three main steps illustrated inFig. 18. The Initialization step uses a learnable neural module I to map input per-vertex features to high-dimensional featurevector at each vertex. In each subdivision iteration, the Vertexstep uses a learnable module V to update features at corners oftriangles of the input mesh, and the Edge step uses a learnablemodule E to compute features of vertices that were generated atmid-points of edges of the input mesh. Our network is inspired byclassical subdivision algorithms which have two sets of rules: toupdate (1) even vertices from previous iterations, and (2) the newlyinserted odd vertices. One difference of our approach is that weapply V and E in sequence, instead of in parallel. This allows us toharness neighborhood information from previous steps.We make several design choices that are critical to the abilityof our network to generalize well even from very small amount oftraining data. First, even though all mesh update steps are global(i.e., they affect every vertex of the mesh), our learnable modulesthat are used in these steps operate over local mesh patches andshare weights. Thus, even a single training pair provides many localmesh patches to train our neural modules. Second, our modulesoperate over original discrete elements of the mesh, and do notrequire re-parameterizing or re-sampling the surface. Represent-ing input and output using the mesh discretization enables us topreserve the topology of the input, and generalize to novel mesheswith different topology. Third, we represent our vertices using dif-ferential quantities with respect to a local coordinate frame insteadof using global coordinates. Thus our neural modules operate over representation that is invariant to rigid motion which simplifiestraining and improves their ability to generalize.The key component of our neural module is a learnable operatorthat takes half-flap , a 2-face flap adjacent to a half-edge, inspired bythe edge convolution approach of Hanocka et al. [2019]. We chooseto use half-flap (instead of a flap around an undirected edge) sinceit provides a unique canonical orientation for the four vertices atthe corners of adjacent faces. It also provides a well-defined localcoordinate frame which we will use to define differential vertexquantities for the input and output (see the inset). Each flap operatoris a shallow multi-layer perceptron (MLP) defined over features offour ordered points. We train one operator per module ( I , V , E )across all levels of subdivision and training examples.Equipped with the half-flap operator, we use average pooling toaggregate features from different half-flaps to per-vertex featuresin all our neural subdivision steps. Initialization and Vertexsteps apply the half-flap operator to every outgoing edge in a 1-ringneighborhood of a vertex, and average pooling aggregates per-half-flap outputs into a per-vertex feature. Edge step only considers per-vertex features at two endpoints of a subdivided edge to computethe feature of the inserted vertex. Thus, it simply applies half-flapoperator for each directions of the edge and again uses averagepooling to get the vertex feature.The final critical element of ourarchitecture design is the represen-tation for the input and output. Asmentioned before, we use local dif-ferential quantities to ensure in-variance to rigid transformation. The input features for the half-flaps used in Initialization step by module I consist of three edgevectors (originating at the source vertex of half-flap) and differentialcoordinates of each vertex, as illustrated in Fig. 19, top. The vectorof differential coordinates stores the discrete curvature informationand is defined as the difference between the absolute coordinatesof a vertex and the average of its immediate neighbors in the mesh[Sorkine 2005]. To achieve rotation invariance we represent ourdifferential quantities in the local frame of each half-flap (see theinset), where we treat the half-edge direction as the x-axis, the edgenormal computed via averaging the two adjacent face normals asthe z-axis, and the cross product of the previous two axes becomes ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:9
Fig. 18. Our neural subdivision consists of three sequential steps: Initialization , Vertex , and Edge , with three network modules: I , V , and E for each steprespectively. In both Initialization and Vertex steps, we apply V and E for the half-flaps of all the outgoing edges of a vertex, and use average pooling tocombine the output features back to the center vertex (blue). In the Edge step, we apply E to both half-flaps of an undirected edge and use average pooling tomap the output features to the center vertex (green) of the edge.Fig. 19. The input feature to module I consists of three edge vectors fromthe source vertex (blue) and vectors of the differential coordinates for thefour vertices. The input features to module V and E are three edge vectorswith per-vertex high-dimensional features from the previous steps.Fig. 20. The outputs of modules I and V are the displacement vector fromthe starting vertex and a learned feature vector f v stored at the sourcevertex (blue). The outputs of the module E are the displacement from theedge mid-point (green) and the feature f v stored at the mid-point. Fig. 21. We use differential quantities stored in the local frames as our inputsand outputs. This design makes our network invariant to rigid motions andsignificantly boosts the quality compared to an approach without invariance. our y-axis. The input to half-flap operators used in Vertex andEdge steps is similar (Fig. 19, bottom), where we use edge vectorsand per-vertex high-dimensional learned features (either producedby Initialization step or by previous subdivision iteration). Theoutput of half-flaps used in Vertex and Edge steps includes high-dimensional learned features and differential quantities that can beused to reconstruct the vertex position. For the latter we use thevertex displacement vector from the mid-point subdivided mesh(see Fig. 20) in the local coordinate system of the half-flap. For theInitialization and the Vertex networks, the predicted displace-ments live on the vertices; for the Edge network, the predicteddisplacements live on the edge midpoints. In our experiments, wenotice there is no difference between predicting from the mid-pointsubdivided surface or other subdivision surfaces (see App. H), sowe choose mid-point subdivision for simplicity. We estimate globalcoordinates of vertices after each step to visualize intermediate lev-els of subdivision and compute the loss function, and convert globalcoordinates to local differential per-vertex quantities before eachstep to ensure that each network only observes translation- androtation- invariant representations.Fig. 21 illustrates that invariant representation is critical to thequality of results. We demonstrate that even when trained on anidentical true shape, a slight rigid motion of that shape renderslearned weights completely inapplicable at inference time. We also ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :10 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Table 1. Hyperparameters of our sub-networks. All networks are fully-connected multi-layer perceptrons with two hidden layers. network I network V network E f in · + · · + ·
32 3 · + · fc
32 32 32 fc
32 32 32 f out +
29 3 +
29 3 + V , whether to measure loss acrossall levels, and whether to use input features proposed in [Hanockaet al. 2019] offer small improvements to the convergence (see App. Hfor details).We implemented our network in PyTorch [Paszke et al. 2019].We use ReLu activation [Nair and Hinton 2010], and the ADAMoptimizer [Kingma and Ba 2015] with learning rate 0 . We evaluate our neural subdivision with a range of results of in-creasing complexity. We start by showing that we can generalize toisometric deformations, non-isometric deformations, shapes fromdifferent classes, and shapes from different types of discretizations.We summarize the details of our experiments in App. F.In practice, modelers often manipulate the coarse subdivisioncage of a character into different poses, and then apply the subdi-vision operator. This scenario implies that being able to train onone single pose and generalize to unseen poses is important forcharacter animation. In Fig. 22, we train on a single pose (in green)and show that our network can generalize to unseen poses under(approximately) isometric deformations.In addition to poses, in Fig. 23 we mimic the real scenario to man-ually change the coarse cage and show that the learned subdivisioncan also generalize to non-isometric deformations.Subdivision operators are often used to create novel 3D content,which implies the importance of generalizing to totally differentshapes. In Fig. 24 we show that even when trained on only a singleshape (green), our network is able to generalize to many othershapes (blue). We also show that our network trained on classicLoop subdivision sequences is able to reproduce Loop subdivisionon unseen shapes (App. G).We further evaluate neural subdivision on shape discretizationscreated in a totally independent way. In Fig. 25 we obtain coarseshapes created by artists, instead of from edge collapses, and showthat neural subdivision can still generalize well.The ability to generalize even when trained on a single shapegives us the opportunity to do stylized subdivisions. In Fig. 26 ourneural subdivision operators are aware of the “style” of the trainingshape and are able to create different results from the same coarse
Fig. 22. We train our network on a single pose (green) and the network isable to generalize to unseen poses (blue).Fig. 23. We mimic the modeling scenario by applying non-isometric de-formations to the coarse cage (gray). Our subdivision network is able togeneralize to unseen non-isometric deformations.Fig. 24. Even when trained on only a single shape (green bunny), our networkcan generalize to subdividing different geometries (blue). ©Hilbert Cube bytbuser (right) under CC BY-NC. geometry. In Fig. 27, we show different results when trained on asmooth organic shape vs a man-made object with sharp contours.To quantitatively analyze how our network generalizes to unseenshapes, we take the TOSCA dataset [Bronstein et al. 2009] whichcontains 80 shapes with 9 categories to perform quantitative analysis.For the top table of Table 2, we train on a single category (
Centaur )and test on the remaining categories. Our test shapes are generated
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:11
Fig. 25. In addition to subdividing meshes constructed via decimation, ournetwork can also generalize to subdivide meshes created by artists.Fig. 26. Using different shapes in training leads to stylized subdivisionresults (blue) biased towards the training shapes (green). ©Egg Chair byTeamTeamUSA (left) under CC BY.Fig. 27. Training on a smooth shape leads to a smoother subdivision result(middle). Training on a man-made object can preserve the sharp creases(right). Fig. 28. We train our subdivision network on a mixture of organic andnon-organic shapes. We observe that training on more objects does notsignificantly change visual quality in this case.Table 2. We train on a single category,
Centaur (top table), and three cat-egories,
Centaur, David, Horse (bottom table), separately, and evaluate bysubdividing the rest of the TOSCA shapes. The results indicate that neuralsubdivision outperforms classic Loop subdivision [Loop 1987] and modifiedbutterfly subdivision [Zorin et al. 1996] on two popular metrics: Hausdorffdistance H , and mean surface distance M computed via metro [Cignoniet al. 1998]. Category H loop H m.b. H ours M loop M m.b. M ours Cat 2.75 2.17
David 2.95 2.13
Dog 3.26 2.32
Gorilla 4.53 3.17
Horse 5.87 4.53
Michael 3.88 2.71
Victoria 4.25 3.01
Wolf 2.83 1.74
Category H loop H m.b. H ours M loop M m.b. M ours Cat 2.75 2.17
Dog 3.26 2.32
Gorilla 4.53 3.17
Michael 3.88 2.71
Victoria 4.25 3.01
Wolf 2.83 1.74 by coarsening source meshes with qslim down to 350-450 vertices.We measure the error between the two-level subdivided mesh andthe original shape using Hausdorff distance, as well as mean surfacedistance computed by the metro [Cignoni et al. 1998]. Our methodconsistently produces smaller errors compared to the classic Loop[Loop 1987] and modified butterfly [Zorin et al. 1996] subdivisions.We further evaluate our method when trained on multiple shapesand categories. In Fig. 28, we train the network on a increasingnumber of objects and observe that the results are visually similar.But our quantitative analysis in the bottom table of Table 2 showsthat training on more categories (
Centaur, David, Horse ) can slightlyreduce the error.
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :12 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Fig. 29. Since our method induces a non-linear subdivision, there is noguarantee for the existence of a limit surface (bottom). An alternative isto apply neural subdivision at the trained levels, and continue with classicsubdivision (top) to ensure a smooth limit surface.Fig. 30. Our approach is based on local geometry, and thus fails to halluci-nate semantic features. ©Bratty Dragon by Splotchy Ink under CC BY.
Extending the neural subdivision framework to quadrilateral meshesand surface with boundaries would be closer to real-world modelingscenarios. Making neural subdivision scale-invariant and convergeto a limit surface (see Fig. 29) are also desirable in practice. Incor-porating global information in the training could help the networkhallucinate semantic features (see Fig. 30). Applying architectures(e.g., Recurrent Neural Net) that are more suitable for sequencepredictions could help the network to harness information froma wider neighborhood and to dive to a deeper subdivision level.Training on data that contain a wide range of triangle aspect ratiosand curvature information could further improve the robustness ofthe network. Since our data-generation algorithm is extremely effi-cient, it could be naturally used in an online-learning setting, whereour algorithm constantly draws new randomly-coarsened mesheson-the-fly. This can be extremely useful in, e.g., a GAN setting. As afirst step towards neural subdivision, we showed reconstruction offine meshes from coarse ones. Fully-fledged super-resolution, detailhallucination, and surface stylization are interesting next steps. Allof these questions provide interesting topics for the future researchon neural subdivision.
ACKNOWLEDGMENTS
Our research is funded in part by New Frontiers of Research Fund(NFRFE–201), the Ontario Early Research Award program, NSERCDiscovery (RGPIN2017–05235, RGPAS–2017–507938), the CanadaResearch Chairs Program, the Fields Centre for Quantitative Analy-sis and Modelling and gifts by Adobe Systems, Autodesk and MESHInc. We thank members of Dynamic Graphics Project at the Uni-versity of Toronto; Thomas Davies, Oded Stein, Michael Tao, andJackson Wang for early discussions; Rahul Arora, Seungbae Bang,Jiannan Li, Abhishek Madan, and Silvia Sellán for experiments andgenerating test data; Honglin Chen, Eitan Grinspun, and SarahKushner for proofreading. We thank Mirela Ben-Chen for the en-lightening advice on the experiments and the writing; Yifan Wangfor running comparisons; and Ahmad Nasikun for evaluations. Weobtained our test models from Thingi10K [Zhou and Jacobson 2016]and we thank all the artists for sharing a rich variety of 3D models.We especially thank John Hancock for the IT support which helpedus smoothly conduct this research.
REFERENCES
Noam Aigerman, Roi Poranne, and Yaron Lipman. 2014. Lifted bijections for lowdistortion surface mappings.
ACM Transactions on Graphics (TOG)
33, 4 (2014), 69.Noam Aigerman, Roi Poranne, and Yaron Lipman. 2015. Seamless surface mappings.
ACM Transactions on Graphics (TOG)
34, 4 (2015), 72.Harry G. Barrow, Jay M. Tenenbaum, Robert C. Bolles, and Helen C. Wolf. 1977. Para-metric Correspondence and Chamfer Matching: Two New Techniques for ImageMatching. In
Proceedings of the 5th International Joint Conference on Artificial Intelli-gence. Cambridge, MA, USA, August 22-25, 1977 , Raj Reddy (Ed.). William Kaufmann,659–663.Alexander I. Bobenko, Helmut Pottmann, and Thilo Rörig. 2020. Multi-Nets. Classifica-tion of Discrete and Smooth Surfaces with Characteristic Properties on ArbitraryParameter Rectangles.
Discret. Comput. Geom.
63, 3 (2020), 624–655.Alexander M. Bronstein, Michael M. Bronstein, and Ron Kimmel. 2009.
NumericalGeometry of Non-Rigid Shapes . Springer.Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Van-dergheynst. 2017. Geometric Deep Learning: Going beyond Euclidean data.
IEEESignal Process. Mag.
34, 4 (2017), 18–42.E. Catmull and J. Clark. 1998.
Recursively Generated B-Spline Surfaces on ArbitraryTopological Meshes . Association for Computing Machinery, New York, NY, USA,183–188.Siddhartha Chaudhuri, Daniel Ritchie, Jiajun Wu, Kai Xu, and Hao (Richard) Zhang.2020. Learning to Generate 3D Structures. In
Eurographics State-of-the-Art Report(STAR) .Paolo Cignoni, Claudio Rocchini, and Roberto Scopigno. 1998. Metro: measuring erroron simplified surfaces. In
Computer graphics forum , Vol. 17. Wiley Online Library,167–174.Jonathan Cohen, Marc Olano, and Dinesh Manocha. 1998. Appearance-PreservingSimplification. In
Proceedings of the 25th Annual Conference on Computer Graphicsand Interactive Techniques (SIGGRAPH ’98) . Association for Computing Machinery,New York, NY, USA, 115–122.Jonathan D. Cohen, Dinesh Manocha, and Marc Olano. 1997. Simplifying polygonalmodels using successive mappings. In
IEEE Visualization ’97, Proceedings, Phoenix,AZ, USA, October 19-24, 1997 . IEEE Computer Society and ACM, 395–402.Jonathan D. Cohen, Dinesh Manocha, and Marc Olano. 2003. Successive Mappings: AnApproach to Polygonal Mesh Simplification with Guaranteed Error Bounds.
Int. J.Comput. Geometry Appl.
13, 1 (2003), 61.Angela Dai and Matthias Nießner. 2019. Scan2Mesh: From Unstructured Range Scansto 3D Meshes. In
IEEE Conference on Computer Vision and Pattern Recognition, CVPR2019, Long Beach, CA, USA, June 16-20, 2019 . Computer Vision Foundation / IEEE,5574–5583.Tony DeRose, Michael Kass, and Tien Truong. 1998. Subdivision Surfaces in CharacterAnimation. In
Proceedings of the 25th Annual Conference on Computer Graphics andInteractive Techniques, SIGGRAPH 1998, Orlando, FL, USA, July 19-24, 1998 , SteveCunningham, Walt Bransford, and Michael F. Cohen (Eds.). ACM, 85–94.Tamal K Dey, Herbert Edelsbrunner, Sumanta Guha, and Dmitry V Nekhayev. 1999.Topology preserving edge contraction.
Publ. Inst. Math.(Beograd)(NS)
66, 80 (1999),23–45.Daniel Doo. 1978. A subdivision algorithm for smoothing down irregularly shapedpolyhederons.
Computer Aided Design (1978), 157–165.ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:13
D. Doo and M. Sabin. 1998.
Behaviour of Recursive Division Surfaces near ExtraordinaryPoints . Association for Computing Machinery, New York, NY, USA, 177–181.Nira Dyn, David Levine, and John A. Gregory. 1990. A butterfly subdivision scheme forsurface interpolation with tension control.
ACM Trans. Graph.
9, 2 (1990), 160–169.Haoqiang Fan, Hao Su, and Leonidas J. Guibas. 2017. A Point Set Generation Networkfor 3D Object Reconstruction from a Single Image. In . IEEE Computer Society, 2463–2471.Michael S. Floater and Charles A. Micchelli. 1997. Nonlinear Stationary Subdivision.
Journal of Approximation Theory (1997).Michael Garland and Paul S. Heckbert. 1997. Surface simplification using quadricerror metrics. In
Proceedings of the 24th Annual Conference on Computer Graphicsand Interactive Techniques, SIGGRAPH 1997, Los Angeles, CA, USA, August 3-8, 1997 ,G. Scott Owen, Turner Whitted, and Barbara Mones-Hattal (Eds.). ACM, 209–216.Thibault Groueix, Matthew Fisher, Vladimir G. Kim, Bryan C. Russell, and MathieuAubry. 2018a. 3D-CODED: 3D Correspondences by Deep Deformation. In
ComputerVision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14,2018, Proceedings, Part II (Lecture Notes in Computer Science) , Vittorio Ferrari, MartialHebert, Cristian Sminchisescu, and Yair Weiss (Eds.), Vol. 11206. Springer, 235–251.Thibault Groueix, Matthew Fisher, Vladimir G. Kim, Bryan C. Russell, and MathieuAubry. 2018b. A Papier-Mâché Approach to Learning 3D Surface Generation. In . IEEE Computer Society, 216–224.Igor Guskov, Andrei Khodakovsky, Peter Schröder, and Wim Sweldens. 2002. Hybridmeshes: multiresolution using regular and irregular refinement. In
Proceedings ofthe 18th Annual Symposium on Computational Geometry, Barcelona, Spain, June 5-7,2002 , Ferran Hurtado, Vera Sacristán, Chandrajit Bajaj, and Subhash Suri (Eds.).ACM, 264–272.Igor Guskov, Kiril Vidimce, Wim Sweldens, and Peter Schröder. 2000. Normal meshes.In
Proceedings of the 27th Annual Conference on Computer Graphics and InteractiveTechniques, SIGGRAPH 2000, New Orleans, LA, USA, July 23-28, 2000 , Judith R. Brownand Kurt Akeley (Eds.). ACM, 95–102.Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, and DanielCohen-Or. 2019. MeshCNN: A Network with an Edge.
ACM Transactions on Graphics(TOG)
38, 4 (2019), 90.Hugues Hoppe, Tony DeRose, Tom Duchamp, Mark A. Halstead, Hubert Jin, John AlanMcDonald, Jean Schweitzer, and Werner Stuetzle. 1994. Piecewise smooth surfacereconstruction. In
Proceedings of the 21th Annual Conference on Computer Graphicsand Interactive Techniques, SIGGRAPH 1994, Orlando, FL, USA, July 24-29, 1994 , DinoSchweitzer, Andrew S. Glassner, and Mike Keeler (Eds.). ACM, 295–302.Hugues Hoppe, Tony DeRose, Tom Duchamp, John Alan McDonald, and Werner Stuet-zle. 1993. Mesh optimization. In
Proceedings of the 20th Annual Conference onComputer Graphics and Interactive Techniques, SIGGRAPH 1993, Anaheim, CA, USA,August 2-6, 1993 , Mary C. Whitton (Ed.). ACM, 19–26.Krishna Murthy J., Edward Smith, Jean-Francois Lafleche, Clement Fuji Tsang, ArtemRozantsev, Wenzheng Chen, Tommy Xiang, Rev Lebaredian, and Sanja Fidler.2019. Kaolin: A PyTorch Library for Accelerating 3D Deep Learning Research. arXiv:1911.05063 (2019).Kestutis Karciauskas and Jörg Peters. 2018. A New Class of Guided C2 SubdivisionSurfaces Combining Good Shape with Nested Refinement.
Comput. Graph. Forum
37, 6 (2018), 84–95.Ladislav Kavan, Dan Gerszewski, Adam W. Bargteil, and Peter-Pike Sloan. 2011. Physics-Inspired Upsampling for Cloth Simulation in Games.
ACM Trans. Graph.
30, 4, ArticleArticle 93 (July 2011), 10 pages.Michael M. Kazhdan and Hugues Hoppe. 2013. Screened poisson surface reconstruction.
ACM Trans. Graph.
32, 3 (2013), 29:1–29:13.Andrei Khodakovsky, Nathan Litke, and Peter Schröder. 2003. Globally Smooth Pa-rameterizations with Low Distortion.
ACM Trans. Graph.
22, 3 (July 2003), 350–357.https://doi.org/10.1145/882262.882275Diederik P. Kingma and Jimmy Ba. 2015. Adam: A Method for Stochastic Optimization.In , Yoshua Bengio and YannLeCun (Eds.).Leif Kobbelt. 1996. Interpolatory Subdivision on Open Quadrilateral Nets with ArbitraryTopology.
Comput. Graph. Forum
15, 3 (1996), 409–420.Leif Kobbelt. 2000. 3-subdivision. In
Proceedings of the 27th Annual Conference onComputer Graphics and Interactive Techniques, SIGGRAPH 2000, New Orleans, LA,USA, July 23-28, 2000 , Judith R. Brown and Kurt Akeley (Eds.). ACM, 103–112.Ilya Kostrikov, Zhongshi Jiang, Daniele Panozzo, Denis Zorin, and Joan Bruna. 2018.Surface Networks. In . IEEE Computer Society,2540–2548.Vladislav Kraevoy and Alla Sheffer. 2004. Cross-parameterization and compatibleremeshing of 3D models.
ACM Transactions on Graphics (TOG)
23, 3 (2004), 861–869. Aaron W. F. Lee, Wim Sweldens, Peter Schröder, Lawrence C. Cowsar, and David P.Dobkin. 1998. MAPS: Multiresolution Adaptive Parameterization of Surfaces. In
Proceedings of the 25th Annual Conference on Computer Graphics and InteractiveTechniques, SIGGRAPH 1998, Orlando, FL, USA, July 19-24, 1998 , Steve Cunningham,Walt Bransford, and Michael F. Cohen (Eds.). ACM, 95–104.Ruihui Li, Xianzhi Li, Chi-Wing Fu, Daniel Cohen-Or, and Pheng-Ann Heng. 2019.PU-GAN: A Point Cloud Upsampling Adversarial Network. In . IEEE, 7202–7211.Songrun Liu, Zachary Ferguson, Alec Jacobson, and Yotam I. Gingold. 2017. Seamless:seam erasure and seam-aware decoupling of shape from mesh resolution.
ACMTrans. Graph.
36, 6 (2017), 216:1–216:15.Yang Liu, Helmut Pottmann, Johannes Wallner, Yong-Liang Yang, and Wenping Wang.2006. Geometric modeling with conical meshes and developable surfaces. In
ACMtransactions on graphics (TOG) , Vol. 25. ACM, 681–689.Charles Loop. 1987. Smooth subdivision surfaces based on triangles.
Master’s thesis,University of Utah, Department of Mathematics (1987).Haggai Maron, Meirav Galun, Noam Aigerman, Miri Trope, Nadav Dym, Ersin Yumer,Vladimir G. Kim, and Yaron Lipman. 2017. Convolutional neural networks onsurfaces via seamless toric covers.
ACM Trans. Graph.
36, 4 (2017), 71:1–71:10.Jonathan Masci, Davide Boscaini, Michael M. Bronstein, and Pierre Vandergheynst.2015. Geodesic Convolutional Neural Networks on Riemannian Manifolds. In . IEEE Computer Society, 832–840.Patrick Mullen, Yiying Tong, Pierre Alliez, and Mathieu Desbrun. 2008. SpectralConformal Parameterization.
Comput. Graph. Forum
27, 5 (2008), 1487–1494.Vinod Nair and Geoffrey E. Hinton. 2010. Rectified Linear Units Improve RestrictedBoltzmann Machines. In
Proceedings of the 27th International Conference on MachineLearning (ICML-10), June 21-24, 2010, Haifa, Israel , Johannes Fürnkranz and ThorstenJoachims (Eds.). Omnipress, 807–814.Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, GregoryChanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Des-maison, Andreas Köpf, Edward Yang, Zachary DeVito, Martin Raison, AlykhanTejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and SoumithChintala. 2019. PyTorch: An Imperative Style, High-Performance Deep LearningLibrary. In
Advances in Neural Information Processing Systems 32: Annual Conferenceon Neural Information Processing Systems 2019, NeurIPS 2019, 8-14 December 2019,Vancouver, BC, Canada , Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer,Florence d’Alché-Buc, Emily B. Fox, and Roman Garnett (Eds.). 8024–8035.Adrien Poulenard and Maks Ovsjanikov. 2018. Multi-directional geodesic neural net-works via equivariant convolution.
ACM Trans. Graph.
37, 6 (2018), 236:1–236:14.Emil Praun, Wim Sweldens, and Peter Schröder. 2001. Consistent Mesh Parameter-izations. In
Proceedings of the 28th Annual Conference on Computer Graphics andInteractive Techniques (SIGGRAPH ’01) . Association for Computing Machinery, NewYork, NY, USA, 179–184.Reinhold Preiner, Tamy Boubekeur, and Michael Wimmer. 2019. Gaussian-productsubdivision surfaces.
ACM Trans. Graph.
38, 4 (2019), 35:1–35:11.Michael Rabinovich, Tim Hoffmann, and Olga Sorkine-Hornung. 2018. The shape spaceof discrete orthogonal geodesic nets.
ACM Trans. Graph.
37, 6 (2018), 228:1–228:17.Anurag Ranjan, Timo Bolkart, Soubhik Sanyal, and Michael J. Black. 2018. Generating3D Faces Using Convolutional Mesh Autoencoders. In
Computer Vision - ECCV 2018- 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, PartIII (Lecture Notes in Computer Science) , Vittorio Ferrari, Martial Hebert, CristianSminchisescu, and Yair Weiss (Eds.), Vol. 11207. Springer, 725–741.Malcolm Sabin and Neil Dodgson. 2004. A Circle-Preserving Variant of the Four-PointSubdivision Scheme.
Mathematical Methods for Curves and Surfaces: Tromsø 2004 (01 2004).Scott Schaefer, E. Vouga, and Ron Goldman. 2008. Nonlinear subdivision throughnonlinear averaging.
Comput. Aided Geom. Des.
25, 3 (2008), 162–180.John Schreiner, Arul Asirvatham, Emil Praun, and Hugues Hoppe. 2004. Inter-surfacemapping.
ACM Trans. Graph.
23, 3 (2004), 870–877.Vincent Sitzmann, Justus Thies, Felix Heide, Matthias Nießner, Gordon Wetzstein, andMichael Zollhöfer. 2019. DeepVoxels: Learning Persistent 3D Feature Embeddings.In
IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, LongBeach, CA, USA, June 16-20, 2019 . Computer Vision Foundation / IEEE, 2437–2446.Olga Sorkine. 2005. Laplacian Mesh Processing. In
Eurographics 2005 - State of the ArtReports, Dublin, Ireland, August 29 - September 2, 2005 , Yiorgos Chrysanthou andMarcus A. Magnor (Eds.). Eurographics Association, 53–70.Jos Stam. 1998. Exact Evaluation of Catmull-Clark Subdivision Surfaces at ArbitraryParameter Values. In
Proceedings of the 25th Annual Conference on Computer Graphicsand Interactive Techniques, SIGGRAPH 1998, Orlando, FL, USA, July 19-24, 1998 , SteveCunningham, Walt Bransford, and Michael F. Cohen (Eds.). ACM, 395–404.Qingyang Tan, Lin Gao, Yu-Kun Lai, and Shihong Xia. 2018. Variational Autoencodersfor Deforming 3D Mesh Models. In . IEEEComputer Society, 5841–5850.ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :14 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Chengcheng Tang, Xiang Sun, Alexandra Gomes, Johannes Wallner, and HelmutPottmann. 2014. Form-Finding with Polyhedral Meshes Made Simple.
ACM Trans.Graph.
33, 4, Article Article 70 (July 2014), 9 pages.Maxim Tatarchenko, Stephan R. Richter, René Ranftl, Zhuwen Li, Vladlen Koltun, andThomas Brox. 2019. What Do Single-View 3D Reconstruction Networks Learn?. In
IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach,CA, USA, June 16-20, 2019 . Computer Vision Foundation / IEEE, 3405–3414.Robert F. Tobler, Stefan Maierhofer, and Alexander Wilkie. 2002a. Mesh-BasedParametrized L-Systems and Generalized Subdivision for Generating Complex Ge-ometry.
International Journal of Shape Modeling
8, 2 (2002), 173–191.Robert F. Tobler, Stefan Maierhofer, and Alexander Wilkie. 2002b. A MultiresolutionMesh Generation Approach for Procedural Definition of Complex Geometry. In . IEEE Computer Society, 35–42.Oliver Van Kaick, Hao Zhang, Ghassan Hamarneh, and Daniel Cohen-Or. 2011. A surveyon shape correspondence. In
Computer Graphics Forum , Vol. 30. Wiley Online Library,1681–1707.Amir Vaxman, Christian Müller, and Ofir Weber. 2018. Canonical Möbius subdivision.
ACM Trans. Graph.
37, 6 (2018), 227:1–227:15.Luiz Velho, Ken Perlin, Henning Biermann, and Lexing Ying. 2002. Algorithmic shapemodeling with subdivision surfaces.
Comput. Graph.
26, 6 (2002), 865–875.Matthias Vestner, Roee Litman, Emanuele Rodolà, Alex Bronstein, and Daniel Cremers.2017. Product manifold filter: Non-rigid shape correspondence via kernel densityestimation in the product space. In
Proceedings of the IEEE Conference on ComputerVision and Pattern Recognition . 3327–3336.Nanyang Wang, Yinda Zhang, Zhuwen Li, Yanwei Fu, Wei Liu, and Yu-Gang Jiang. 2018.Pixel2Mesh: Generating 3D Mesh Models from Single RGB Images. In
ComputerVision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part XI (Lecture Notes in Computer Science) , Vittorio Ferrari,Martial Hebert, Cristian Sminchisescu, and Yair Weiss (Eds.), Vol. 11215. Springer,55–71.Yu Wang, Vladimir G. Kim, Michael Bronstein, and Justin Solomon. 2019a. LearningGeometric Operators on Meshes.
ICLR Workshop on Representation Learning onGraphs and Manifolds (2019).Yifan Wang, Shihao Wu, Hui Huang, Daniel Cohen-Or, and Olga Sorkine-Hornung.2019b. Patch-Based Progressive 3D Point Set Upsampling. In
IEEE Conference onComputer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June16-20, 2019 . Computer Vision Foundation / IEEE, 5958–5967.Chao Wen, Yinda Zhang, Zhuwen Li, and Yanwei Fu. 2019. Pixel2Mesh++: Multi-View3D Mesh Generation via Deformation. In .IEEE, 1042–1051.Wang Yifan, Noam Aigerman, Vladimir G. Kim, Siddhartha Chaudhuri, and OlgaSorkine-Hornung. 2020. Neural Cages for Detail-Preserving 3D Deformations. In
CVPR .Lequan Yu, Xianzhi Li, Chi-Wing Fu, Daniel Cohen-Or, and Pheng-Ann Heng. 2018.PU-Net: Point Cloud Upsampling Network. In .IEEE Computer Society, 2790–2799.Qingnan Zhou and Alec Jacobson. 2016. Thingi10K: A Dataset of 10,000 3D-PrintingModels. arXiv preprint arXiv:1605.04797 (2016). https://ten-thousand-models.appspot.comDenis Zorin. 2007. Subdivision on arbitrary meshes: algorithms and theory. In
Math-ematics and Computation in Imaging Science and Information Processing . WorldScientific, 1–46.Denis Zorin, Peter Schröder, T De Rose, L Kobbelt, A Levin, and W Sweldens. 2000.Subdivision for modeling and animation.
SIGGRAPH Course Notes (2000).Denis Zorin, Peter Schröder, and Wim Sweldens. 1996. Interpolating Subdivisionfor Meshes with Arbitrary Topology. In
Proceedings of the 23rd Annual Conferenceon Computer Graphics and Interactive Techniques (SIGGRAPH ’96) . Association forComputing Machinery, New York, NY, USA, 189–192.
A IMPLEMENTATION OF POINT CLOUD UPSAMPLING
An alternative way to upsample a mesh is to first convert the meshinto point cloud via sampling over the surface, run point cloudupsampling algorithms, and then perform a surface reconstructionto convert the upsampled point cloud back to a mesh. However, thisprocedure is expensive to incorporate into the interactive graphicspipeline, fails to produce surfaces with different levels of detail(see Fig. 2), and it fails to preserve textures (see Fig. 3). In addition,many non-trivial design decisions such as the number of samplesto use and how to sample the surface would influence the quality of the results. For example in Fig. 5, we first sample 5000 points withuniform and farthest point sampling, followed by the method ofWang et al. [2019b] pre-trained on statues to upsample the pointcloud by 16 × , and then use the screened poisson reconstruction[Kazhdan and Hoppe 2013] to reconstruct the surface. In the figurewe show that different sampling methods lead to different results.The lack of connectivity information also results in some surfaceartifacts. B IMPLEMENTATION OF SUCCESSIVESELF-PARAMETERIZATION
Incorporating successive self-parameterization only requires addingtwo additional local conformal parameterizations to the edge col-lapse algorithm of choice. Suppose we want to collapse an edge ( j , k ) .We first flatten the edge’s 1-ring N( j , k ) , then we collapse the edge,then we perform another conformal flattening on the 1-ring N( i ) of the newly inserted vertex i after the collapse, with the boundaryheld to place from the previous flattening. This yields a bijectivemap with small computational cost because each flattening onlyinvolves a 1-ring (assuming the vertex valence is bounded). C CRITERIA FOR COLLAPSIBLE EDGES
During edge collapses, many issues such as flipped faces and non-manifold edges may appear. Resolving these issues is crucial tothe robustness of successive self-parameterization (see Fig. 16). Wesummarize our criteria for checking the validity of an edge collapse.If invalid, we simply avoid collapsing the edge at that iteration.
Euclidean face flips.
Certain facesin the Euclidean space may sufferfrom normal flips after an edge col-lapse. To prevent flipped faces, wesimply compare the unit face nor-mal ˆ n of each neighboring face f i before and after the collapseˆ n before f i · ˆ n after f i > δ . (2)Our default δ = . UV face flips.
Flipped faces may also appear in the UV space dueto both the conformal flattening and the edge collapse. We simplycheck whether the signed area of each UV face is positive beforeand after collapses to prevent having UV face flips.
Overlapped UV faces.
Even if allthe UV faces are oriented correctly,some of the faces may still over-lap with each other depending onthe flattening algorithm in use. Wecheck whether the total angle sum of each interior vertex is 2 π todetermine the validity of a collapse. Non-manifold edges.
To preventthe appearance of non-manifoldedges, we must check the link con-dition [Dey et al. 1999; Hoppe et al.1993]. Briefly, the link condition
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. eural Subdivision • 1:15
Fig. 31. We perform qslim with a random sequence of edge collapses to create different coarse discretizations (gray) from a single ground truth mesh (green). says that if an edge e ij connecting vertices i , j is valid, the intersec-tion between the vertex 1-ring of i and the vertex 1-ring of j mustcontain only two vertices, and the two vertices cannot be an edge. Skinny triangles.
To prevent badly shaped triangles from causingnumerical issues, we need to keep track of the triangle quality foreach edge collapse. The quality of a triangle is measured by Q ijk = √ A ijk l ij + l jk + l ki (3)where A is the area of the triangle and l are the lengths of triangleedges. When Q →
1, it approaches an equilateral triangle; when Q → Q for all the neighboring faces in both UV and Euclideandomains after the collapse. By default, a valid edge requires Q > . D COMPARISON TO [Lee et al. 1998]
One possible solution to construct a bijective map between the inputand the decimated model is via MAPS [Lee et al. 1998]. However,MAPS constructs the parameterization via successively removingthe maximum vertex independent sets. The main reason for remov-ing the maximum independent set is to bound the number of levelsof the mesh hierarchy, but it leads to limitations such as sensitivityto the input triangulation.One experiment to verify this is to apply subdivision remeshingpresented in Sec. 4.1 in [Lee et al. 1998]. In Fig. 32 we create a stresstest using a very uneven triangulation, and MAPS suffers fromcreating non-uniform parameterization. In contrast our successiveself-parameterization enjoys the benefits of area-weighted qslim toobtain a more uniform parameterization.
E DATA GENERATION FROM RANDOM COLLAPSES
The training data for neural subdivision is a sequence of subdividedmeshes where the vertex positions are computed using successive
Fig. 32. We decimate the mesh down to the same number of vertices andcompare our method with MAPS on the task of subdivision remeshing. Ourmethod creates a more uniform parameterization (left), but MAPS is moresensitive to the input triangulation (right). self-parameterization (Fig. 8). For each dense input mesh, we per-form semi-random edge collapses in order to generate many dif-ferent coarse meshes. The goal is to help the network to be robustto different discretizations. In Fig. 31 we show input meshes (left)can be decimated differently to get many coarse meshes that havedifferent number of vertices and with different triangulations.Our semi-random edge collapse starts by randomly selecting 100edges and finding the one with the minimum quadric error [Garlandand Heckbert 1997] to collapse. For each edge collapse, we insert thenew vertex the same way as qslim . We terminate the edge collapseswhen a randomly selected target number of vertices between 150and 300 is reached.
F EXPERIMENTAL SETUP
Our experimental setup is consistent throughout the document. Thetraining shape is presented in green in every figure. For each shape,
ACM Trans. Graph., Vol. 39, No. 4, Article 1. Publication date: July 2020. :16 • Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson
Fig. 33. Although most experiments are trained on performing 2-level sub-divisions, our neural subdivision network can still be trained on more levelof the subdivisions.Fig. 34. When trained on meshes created by classic Loop subdivision (green),our network can reproduce the Loop scheme on new meshes, and creates vi-sually indistinguishable results (blue) compared to the ground truth createdby the classic Loop method (right). we use the parameters described in App. E to generate 200 trainingdiscretizations and train for 700 epochs. Our method can learn toproduce several subdivision levels Fig. 33, but we set the numberof training subdivisions to two levels for consistency across theexperiments. If the experiment consists of multiple training shapes,such as the experiments in Fig. 28 and Table 2, we evenly distributethe number of training discretizations so that they still sum up to200 discretizations in total.
G LEARNING CLASSIC LOOP SUBDIVISION
Although we have shown in Sec. 6 that neural subdivision is ableto subdivide a mesh adaptively, one might be interested in seeingwhether neural subdivision can also learn to reproduce classic Loopsubdivision with appropriate training data. In Fig. 34, we trainedour network on a sequence of meshes created with Loop subdivi-sion. Given an original mesh, we create 200 mashes using randomedge collapses, then subdivide each coarsened mesh for two levelsusing Loop to obtain the corresponding ground truth subdividedsequences for measuring the reconstruction loss. We see that whentesting on novel meshes, the network is able to reproduce the Loopscheme to create visually indistinguishable results. The average per-vertex numerical error is just 0 .
3% of the bounding box diagonal.
H ABLATION STUDIES (CONTINUED)