Nested Cages

Leonardo Sacht1 Etienne Vouga2 Alec Jacobson3

1Universidade Federal de Santa Catarina 2University of Texas at Austin 3Columbia University

Figure 1 Given an input shape (yellow on bottom right) our method constructs nested cages each subsequent mesh is coarser than the lastand fully encloses it without intersections A slice through all layers (left) shows a tightly encaged Bunny

AbstractMany tasks in geometry processing and physical simulation bene-fit from multiresolution hierarchies One important characteristicacross a variety of applications is that coarser layers strictly encagefiner layers nesting one another Existing techniques such as surfacemesh decimation voxelization or contouring distance level sets donot provide sufficient control over the quality of the output surfaceswhile maintaining strict nesting We propose a solution that enablesuse of application-specific decimation and quality metrics Themethod constructs each next-coarsest level of the hierarchy using asequence of decimation flow and contact-aware optimization stepsFrom coarse to fine each layer then fully encages the next whileretaining a snug fit The method is applicable to a wide variety ofshapes of complex geometry and topology We demonstrate theeffectiveness of our nested cages not only for multigrid solvers butalso for conservative collision detection domain discretization forelastic simulation and cage-based geometric modeling

CR Category I30 [Computer Graphics]

Keywords Mesh decimation geometric flow multigrid

1 IntroductionAs the complexity and size of computational objects continue togrow acceleration algorithms become increasingly important Onepowerful technique is to decompose a high-resolution mesh into ahierarchy of increasingly coarse approximations or cages (see Fig-ure 1) For example multigrid FEM techniques efficiently solve

Eulerian PDEs on very fine meshes by moving up and down thehierarchy low frequency residual error disappears quickly on thecoarsest levels while fine levels smooth away high frequency er-ror Coarse enclosing cages also find use in physical simulationwhere deformations of the cage are interpolated onto embeddedhigh-resolution geometries in interactive animation where artistsspecify large-scale deformations by adjusting the low-dimensionalcage and in collision detection where conservative culling reducescomputation time For all these applications the key to high perfor-mance is the ability to generate a quality multiresolution hierarchy

The straightforward approach to building a hierarchy around an ob-ject F is to use an application-specific decimation algorithm to builda coarse approximation C to F C itself can be further coarsenedto build the next level of the hierarchy etc (see Figure 2) Unfortu-nately C will typically intersect F which is often undesirable mostalgorithms for transferring the pose of a deformation cage to a de-tailed object only guarantee small distortion of the object and lack ofelement-inversion artifacts if the object is entirely contained withinthe cage [Joshi et al 2007 Ben-Chen et al 2009b] strict nestingis essential for accelerating collision detection conservatively andwhile nesting is not a necessary condition for multigrid convergence[Chan et al 1996] the ability to use simple linear interpolationfor prolongation is known to be more robust more efficient andeasier to implement [Chan amp Wan 2000 Dickopf 2010] This isparticularly important for enforcing Neumann boundary conditionscommon to simulation and geometry processing [Chan et al 1999]

Figure 2 25 increasingly coarse cages nested around a Horse Ourtight nesting property is robust even for a large number of cages

Squiggly torus Csaacuteszaacuter torus Invalid cage

Figure 3 Some coarse-fine mesh combinations are impossible TheCsaacuteszaacuter torus is too coarse to nested around the Squiggly torusrsquoscomplex handle While embedding the Squiggly torus inside theCsaacuteszaacuter torus is possible (right) this is not a validly nesting cage

For these reasons one would like a cage C that is nested around F that surrounds F without intersecting it More formally given twowatertight (connected closed self-intersection-free and oriented)meshes C and F (later we generalize our method to build cagesfor polygon soups) we say that C nests F if (i) F is contained inthe interior of C and (ii) for every loop on C there is a homotopyfrom that loop to a loop on F that remains at all times inside Crsquosenclosed volume In other words for every handle of C there is acorresponding one on F but not necessarily the other way aroundThis definition extends naturally to when F is a polyhedron withvoids or multiple connected components

The inset figure shows examples of cagesthat do (top) and do not (bottom) nesta 2D example (black outline) Givena pC that does not nest F we look forthe best perturbation C of pC that doesnest F where ldquobestrdquo is measured byan application-dependent fitness energyEpF pCCq penalizing for example to-tal volume for tight fitting cages for effi-cient multigrid distortion for simulationor collisions or violations of symmetryand quad-planarity for interactive defor-mation cages Finding C entails solvingthe nested cage problem

Given an embedded polyhedron F a polyhedron pC and a fitnessfunctionE the goal is to minimizeEpF pCCq over all embeddingsC of pC that nest F

This problem in its full generality is intractable For single polygonsin 2D and simply-connected meshes in 3D at least one nestedembedding C always exists but once F is allowed to have nontrivialtopology counterexamples exist where it is impossible to embedpC in a way that nests F (see Figure 3) The decision problem ofwhether any nesting of pC around F exists can be shown to be NP-complete [Vouga et al 2015] Fortunately in practice pC and F arenot completely arbitrary any reasonable decimation scheme willkeep pC morphologically similar and roughly aligned to F andthese favorable initial conditions can be leveraged by heuristics

Contribution We present a practical algorithm for solving thenested cage problem on meshes typically used in applications suchas physical simulation and geometric modeling Our method remainscompletely agnostic to the decimation scheme used to create pC andfitness function E Briefly the method first flows F inside pC alongpCrsquos signed distance field once inside we rewind the flow whiledeforming pC to minimizeE contact forces guarantee that the coarsecage always encloses F at each reverse-flow time step This processcan be generalized to building an entire multiresolution hierarchyaround F Although our method is not guaranteed to always find

a solution C especially for very coarse or nearly-self-intersectingF (see Section 5 for discussion of failure cases) we tested ouralgorithm on an extensive zoo of example meshes (see Section 4)

2 Related methods and special cases

Our method solves the nested cage problem for the large variety ofinput meshes shown in Section 4 while interoperating with arbitraryproblem-specific decimation algorithms and fitness functions Manyrelated approaches have been proposed that work for special casesor relax requirements imposed above

If the algorithm is free to generate the coarse cage pC rather than ac-cepting it as input from the user the problem becomes substantiallyeasier and has been extensively studied

Bounding polytopes Most naively one can simply take pC to bea canonical bounding polytope (eg box KDOP convex hull) Anextension would be to ldquoshrink-wraprdquo the bounding polytope aroundpF to minimize E This idea has been explored before [Peterhans2012 Wang et al 2013] but no full solution has been developedThis is presumably becausemdashwhile this approach works well forconvex pFmdashit will not give a good fit for meshes with nooks orconcavities It is also not clear how to find a bounding polytope formeshes of nontrivial topology Another approach might be to stitchoverlapping convex volumes [Xian et al 2012] using mesh booleanoperations but cage topology and quality become difficult to controlwithout sacrificing control of resolution

Offset surfaces for simulation meshes Representing pF as animplicit surface and contouring level sets is a popular method ofcreating offset surfaces that nest pF particularly in the context ofsimulations that use a ldquosimulation meshrdquo as a proxy for very finerendered geometry [Campen amp Kobbelt 2010] The challenge isnot just defining a scalar function with an isosurface envelopingthe object but also contouring it with a piecewise-linear trianglemesh without (i) cutting corners too harshly and intersecting pF or(ii) resorting to fine resolution nullifying any performance gainsof using the cage Xu et al [2014] define a robust signed distancefield but pass the field to an off-the-shelf contour mesher withoutany attempt to guarantee non-intersection with the input SimilarlyShen at al [2004] iteratively refine a moving least squares iso-surfaceto enclose an existing model tightly via a global scaling parameter

Our nested layers

Original

Tightest fitting distance field contours

Figure 4 Contouring requires aggressive spacing between distance-field isolevels to produce valid nesting Semantically distant partsfuse together destroying shape-awareness visualized by a pseudo-coloring of a Poisson solution computed on each level

Input [Ben-Chen et al 09] Our tight cages[Sander et al 00]

Figure 5 Methods like [Ben-Chen et al 2009a] use coarse cagesas computational workhorses to reduce complexity Their iterativeoffset heuristic does not allow control of the cage topology Mean-while [Sander et al 2000] attempt to maintain nestedness duringgreedy decimation with local constraints Cages are loosely-fittingbut more importantly self-intersections (orange) and intersectionswith the input model (yellow) eventually accumulate

Some applications such as collision detection can make use ofimplicit representations without intermediary meshes but when amesh is needed it is not enough that the continuous isosurface doesnot intersect the input model since generic contouring will invalidatethis A large enough iso-value or small-enough resolution tolerancemust always be chosen to ensure non-intersection after contouringFor large iso-values topological control is lost and close featuresare quickly merged (see Figure 4) violating the nestedness of thecage A similar approach [Ben-Chen et al 2009a] has been usedfor building deformation cages around input shapes where an offsetsurface is created via Poisson surface reconstruction [Kazhdan et al2006] (we compare against this approach in Figure 5) While thetightness of these cages could be controlled with post-hoc shrinkingof the cage the method can introduce topology changes that are noteasily remedied For meshes with well defined feature curves itmay be possible to merge coarse on-surface triangulations of patches[Xian et al 2013] though strict nesting is not sought or guaranteed

Progressive decimation of pF using edge collapses taking careto place new vertices on the exterior of the current volume by solvinga system of inequality constraints [Sander et al 2000] has foundsome success in real-time rendering and collision detection [Platisamp Theoharis 2003] Although the vertices of these ldquoprogressivehullsrdquo are guaranteed to lie outside of pF edges and faces of pC

might still intersect pF (and pC might globally self-intersect) seeFigure 5 We tested this method on the entire ldquozoordquo of examplesshown in Figure 11 and the supplementary material and of the 26examples there in only one case was the entire hierarchy free ofsuch intersections We also observe that for coarse cages these hullstend to be more loose-fitting than cages produced by methods thatoptimize the cage shape globally (see Figure 5) Self-intersectionsresulting from edge collapses can be corrected with post-hoc meshrepair [Deng et al 2011] but this technique relies on temperamental3D tetrahedral meshing in tight regions near overlaps and does notconsider face- or edge-intersections with the input model

Voxelization of pF will create a nested cage provided that theresolution is chosen fine enough to avoid topological artifacts (as inthe case of contouring implicit functions) Naive voxelization yieldsdense inefficient cages [Mehra et al 2009] possibly improved byprogressive decimation [Xian et al 2009] or mesh booleans [Xianet al 2015] though also inheriting their respective drawbacks

Mesh untangling All of the above methods require relinquishingsome degree of control over decimation to the nested cage algorithm

Input Shrinking fine mesh overlaps resolved

Expanding coarse mesh overlaps persist forever

10 iters 40 iters 70 iters 100 iters

10 iters 20 iters 30 iters 40 iters

Figure 6 Shrinking the fine mesh inside the coarse quickly removesoverlaps (yellow) Expanding the coarse mesh requires self-contacthandling (eg between arms and body) blocking progress

algorithms that accept an arbitrary pre-decimated cage pC are lesswell-developed History-free cloth collision response methods (eg[Baraff et al 2003 Volino amp Magnenat-Thalmann 2006 Wickeret al 2006 Ye amp Zhao 2012]) could be used to separate pC from pFif intersections are not too severe otherwise such methods quicklyget stuck in local minima

Outward Flow Before settling on an inward flow of pF we ex-perimented with an outward flow of pC away from pF along itssigned distance field For convex meshes this works well Howeverextensive testing revealed that this approach suffers from severaldifficulties on more complex geometries 1) Flowing vertices alongthe signed distance field of pF is not guaranteed to resolve all face-face collisions between the fine and coarse meshes the flow is mostrobust when the flowing elements are small and the signed distancefield does not have too many fine features Flowing the coarse meshoutward is more fragile than flowing the fine mesh in as both ofthese factors are less favorable 2) when flowing the fine mesh insidethe coarse mesh we do not need to handle self-collisions within thefine mesh whereas if inflating the coarse mesh we do Addingcollision constraints aggravates the fragility of the outward flow theconstraints can prevent a flowing face from ever leaving the volumeof the fine mesh (see Figure 6)

Multigrid Methods based on regular grids or lattices naturallysupport multiresolution numerical methods McAdams et al [2011]successfully employ multigrid on voxelized shapes to animate volu-metric elastic characters The main downside of grid-based methodsis their traditionally poor handling of irregular boundaries Special-ized multigrid methods using adaptive octrees to handle complexboundaries for fractures [Dick et al 2011] and fluids [Ferstl et al2014] exist but are not immune to troubles of regular grids bound-aries must be represented at fine grid levels to avoid aliasing andretain the inputrsquos topology To avoid fusing together geodesicallydistant parts the shape must be modeled in an accommodating poseIf remodeling is not possible the grid size must be chosen smallerthan not just the smallest features but also the smallest void betweenfeatures One solution is to replicate cells in close areas and man-

age adjacencies when two or more replicated patches merge andsplit [Teran et al 2005 Nesme et al 2009 Syacutekora et al 2009]Cell replication is not only difficult to realize robustly but also rid-dles multigrid numerical methods with expensive SIMD-breakingboundary handling code detracting from the performance gains ofmemory-efficient regular grids [Demmel 2004]

Multigrid on unstructured grids or tetrahedral meshes is more tem-peramental and constructing each level requires care [Fish et al1995] Geometric multigrid schemes typically coarsen an inputtetrahedral mesh by removing vertices attempting to connect thoseremaining in a reasonable way [Guillard 1993 Adams amp Demmel1999] Special care is required to maintain any semblance of theoriginal boundary [Brune et al 2011] essentially devolving into con-strained Delaunay tessellation with no guarantee that the coarseningwill not eat away large portions of the domain In many scenariosthe boundary of the domain is assumed to be only as irregular as thecoarsest layer simplifying level design [Feng et al 1997]

A second group of methods generates a multiresolution hierarchyusing decimation Unmodified mesh decimations [Garland amp Heck-bert 1997] have been used for adaptive simulations for visco-elasticsolids [Debunne et al 2001] Such non-nested cages require ex-trapolation or one-to-many mappings to prolongate solutions on thecoarse levels to finer levels We show cases where this fails to con-verge for common linear systems on irregular domains and we showbetter convergence for strictly nesting cages where prolongation is apurely linear interpolation

Algebraic alternatives also exist [Ruge amp Stuumlben 1987] but are rec-ommended only when geometric information is not available [Fal-gout 2006] Recently [Krishnan et al 2013] proposed a multigridpreconditioner for Laplace-based systems on images and surfacesThis method combines the elegance of algebraic techniques withsome geometric information derived from the characteristics of theLaplacian matrix but is limited to special problems

Simplification The majority of surface mesh decimation tech-niques aim to preserve outward appearance with lower and lowermesh resolution [Hoppe 1996 Garland amp Heckbert 1997 Melax1998] Along these lines [Gumhold et al 2003] output decimationsfree of self-intersections ensuring for example that a characterrsquosclothing stays outside its body In contrast our method assumesself-intersection free input decimations and transforms them intonested layers with no intersections across hierarchy layers Recentwork has considered more elaborate decimation goals than appear-ance such as preserving haptic sensations [Otaduy amp Lin 2003b]Otdauy and Lin [2003a] also demonstrate how to combine meshdecimations and bounding volume hierarchies to achieve faster colli-sion detection without affecting visual appearance Our nested cagesare hierarchical decimations strictly containing the input shape en-suring strictly conservative collision detection Rather than workagainst the sophistication of existing shape decimation techniqueswe complement them Our method takes arbitrary decimations asinput and nests them as a post process

Interference-aware processing We credit [Harmon et al 2011]for their ground-breaking introduction of contact handling to main-stream geometry processing Their work inspires us to consider thecontact and collisions tool-set familiar to physically based simula-tion in our geometry processing task In this task our novel flow isessential for finding a feasible starting state

3 Method

The input to our method is a sequence of k ` 1 potentially over-lapping triangle meshes xM0 xM1 xMk Each mesh xMi has a

Input overlapping decimations Output nested cages

M0M1M2M3M4 M0 M1 M2 M3 M4

Figure 7 We deform a set of input overlapping decimations so thateach contains all finer layers (2D illustration)

corresponding list of initial vertex positions xMi P Rniˆ3 and list oftriangle indices Ti P t1 niu

miˆ3 In a typical scenario xM0 isa high-resolution original mesh and xM1 xMk are decimationsof decreasing resolution the method of decimation is unimportant solong as the input meshes all approximate xM0 and are all watertightDepending on the application troublesome input meshes can becleaned as a pre-process using available tools (eg [Attene 2010Jacobson et al 2013])

The output of our method is a new sequence of k lists of vertex posi-tions M1 Mk such that for i ldquo 1 k each Mi ldquo pMiTiq

is a deformed mesh whose surface nests Miacute1 (with M0 ldquo xM0)Recursively this ensures that each Mi lies strictly outside Mj forj ldquo iacute 1 0 We call such meshes nested (see Figure 7)

We preserve the original combinatorics of xM0 xM1 xMk (Ti

are unchanged) respecting the output of whichever problem-specificdecimation routine produced them The nesting property of theoutput meshes is easily verified by testing that at least one vertex(per connected component in the general case) of Miacute1 lies insideMi (eg has positive winding number) and that no intersectionsexist between Miacute1 and Mi

We now describe a general method that produces this nesting prop-erty while also optimizing any problem-specific energy E (seeAlgorithm 1 with additional subroutines in Appendix B)

Algorithm 1 nested_cages(M0 LDecEnergy) NtildeM1 Mk

InputsM0 Initial high-res mesh vertices M0 faces T0

L k-long list of desired mesh resolutionsDec Function object for black-box decimatorEnergy Function object for re-inflation energy and gradient

OutputsM1Mk k-long list of nested cages

beginfor i P t1 ku do

Decimate from previous layer or input mesh xMi ETH Dec

acute

Miacute1 xMiacute1 Lpiqmacr

F ETHMiacute1 pC ETH xMi Rename coarse and fine meshesH ETH Shrinkp pCF q history of shrinking fine mesh Reverse history then Mi will nest Miacute1 Mi ETH ReInflatepH pCEnergyq

Our method operates recursively on two meshes of the sequence at atime we compute Mi by considering only its original embedding

Re-inflate F to F pushing C to C

Flow F to F until inside C

Overlapping pairand CF C

F F

C

FF

C

Figure 8 Our pipeline has two stages for each pair of neighboringcoarse C and fine F layers

xMi and the solution to the previous level Miacute1 In this way wecompute M1M2 Mk in order ensuring nesting between eachsubsequent pair Breaking the problem of nesting many cages intoindividual subproblems is key to our success as it greatly reducesthe complexity of the collision and optimization subproblems

To simplify notation from now on we only consider computingthe new positions of a coarse mesh C from its original mesh pC andthe next finer output mesh F Computing new coarse mesh vertexpositions C involves two phases flow of the fine mesh until it isfully inside the coarse mesh and re-inflation of the fine mesh to itsoriginal embedding while pushing the coarse mesh out of the way(see Figure 8) During the flow we do not care about the fine meshrsquosaesthetic surface quality or even whether it self-intersects becausewe will re-inflate it back to its original positions in the next step

31 Flow

The first step of our pipeline is to move vertices sF of the fine meshalong a flow that minimizes total signed distance to pC integratedover all deforming surface points sp P sF (see Figure 9 top left)

ΦpsFq ldquo

ż

F

spspqdpspq dA (1)

where dpspq is the unsigned distance from sp to the coarse meshand spspq modulates by the appropriate sign (negative inside) Weminimize Φ by taking small steps opposite its gradient direction foreach vertex position sf in sFptq as a function of a fictitious time t

F

C

invalidBsf

Btldquo acutenabla

sfΦpsFq (2)

By following this gradient we flow thefine mesh vertices sFptq until all of sF(not just vertices see inset) is fully insidethe coarse mesh (determined by check-ing for intersections at each time step)

While Φ is similar to data terms found in iterative closest point(ICP) methods for non-rigid registration [Chang et al 2010] thesign modulator spspq is an important difference Minimizing un-signed (positive) distances would flow points toward the surface ofthe coarse mesh Instead by allowing and encouraging negativedistances points flow to the medial axis within the coarse mesh

Since Φ is nonlinear and intractable to compute exactly we approxi-mate the gradient using numerical quadrature For each triangle Ti

incident on vertices a b c we sample s and d at quadrature points

spj with corresponding weights wj j ldquo 1 h

ΦpsFq ldquo

mFyuml

ildquo1

ż

spPTi

spspqdpspq dA laquo

mFyuml

ildquo1

hyuml

jldquo1

wjspspjqdpspjq

spj ldquo λasfa ` λb

sfb ` λcsfc

where λa λb λc are the barycentric coordinates of spj in Ti andmF

is the number of fine mesh triangles We use second-order quadraturerules and see diminishing returns with more exact schemes

The difficulty of differentiating the unsigned distance function dpspjq

remains To tackle this we adapt the successful ICP approach of non-rigid registration techniques Namely we assume that the closestpoint pq˚j to each spj and sign spspjq ldquo s˚j remain constant duringeach small time step (one could consider modifications common toICP eg point-to-plane distance but our goal is not to align the twosurfaces rather to flow one inside the other)

We may now push the gradient through the summation to the termsinvolving each vertex position sf

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j nablasf spj acute pq˚j (3)

where Npsfq gathers all triangles incident on vertex sf Applying thechain rule and handling the special case where spj laquo pq˚j (ie whenour assumption that spspjq ldquo s˚j is invalid) we arrive at

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j pnablasf spjq

Tnablaspj spj acute pq˚j (4)

ldquo acuteyuml

iPNpsfq

hyuml

jldquo1

wjλfgi (5)

where gi ldquo

s˚jppiacuteq˚

i

ppiacuteq˚i

if ppi acute q˚i ą ε

npq˚i q otherwise(6)

where λf is the barycentric coordinate of spi corresponding to sf andnpq˚i q is the unit normal at q˚i For q˚i near edges and vertices weuse an angle-weighted normal [Baerentzen amp Aanaes 2005]

We use a step size ∆t laquo 10acute3 (after scaling inputs to unit diameter)After each step we update signs s˚i and closest points q˚i for allquadrature points We terminate if all signs are negative and nointersection exists between sF and pC

inputs failed flow

Our signed distance flow is not guaran-teed to always succeed Indeed in diffi-cult cases (eg very coarse meshes withvery thin features or highly concave ver-tices) the flow converges without mov-ing the fine mesh fully inside the coarsemesh (see inset) It is possible for allquadrature points on the fine mesh toflow toward the medial axis of the coarse mesh while stretchingtriangles through corners leaving intersections (yellow cage facets)

In particularly difficult cases we propose an additional step wereverse the picture and expand the coarse mesh flowing it away fromthe current fine mesh along its signed distance field Contact forcesmust also be included in this case to ensure the coarse mesh doesnot flow into a configuration where it self-intersects Fortunately inthese hard cases only a few expansion steps are typically necessary

We experimented with an alternative formulation where we onlyconsider expansion of the coarse mesh but this proved problematic

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Squiggly torus Csaacuteszaacuter torus Invalid cage

Figure 3 Some coarse-fine mesh combinations are impossible TheCsaacuteszaacuter torus is too coarse to nested around the Squiggly torusrsquoscomplex handle While embedding the Squiggly torus inside theCsaacuteszaacuter torus is possible (right) this is not a validly nesting cage

For these reasons one would like a cage C that is nested around F that surrounds F without intersecting it More formally given twowatertight (connected closed self-intersection-free and oriented)meshes C and F (later we generalize our method to build cagesfor polygon soups) we say that C nests F if (i) F is contained inthe interior of C and (ii) for every loop on C there is a homotopyfrom that loop to a loop on F that remains at all times inside Crsquosenclosed volume In other words for every handle of C there is acorresponding one on F but not necessarily the other way aroundThis definition extends naturally to when F is a polyhedron withvoids or multiple connected components

The inset figure shows examples of cagesthat do (top) and do not (bottom) nesta 2D example (black outline) Givena pC that does not nest F we look forthe best perturbation C of pC that doesnest F where ldquobestrdquo is measured byan application-dependent fitness energyEpF pCCq penalizing for example to-tal volume for tight fitting cages for effi-cient multigrid distortion for simulationor collisions or violations of symmetryand quad-planarity for interactive defor-mation cages Finding C entails solvingthe nested cage problem

Given an embedded polyhedron F a polyhedron pC and a fitnessfunctionE the goal is to minimizeEpF pCCq over all embeddingsC of pC that nest F

This problem in its full generality is intractable For single polygonsin 2D and simply-connected meshes in 3D at least one nestedembedding C always exists but once F is allowed to have nontrivialtopology counterexamples exist where it is impossible to embedpC in a way that nests F (see Figure 3) The decision problem ofwhether any nesting of pC around F exists can be shown to be NP-complete [Vouga et al 2015] Fortunately in practice pC and F arenot completely arbitrary any reasonable decimation scheme willkeep pC morphologically similar and roughly aligned to F andthese favorable initial conditions can be leveraged by heuristics

Contribution We present a practical algorithm for solving thenested cage problem on meshes typically used in applications suchas physical simulation and geometric modeling Our method remainscompletely agnostic to the decimation scheme used to create pC andfitness function E Briefly the method first flows F inside pC alongpCrsquos signed distance field once inside we rewind the flow whiledeforming pC to minimizeE contact forces guarantee that the coarsecage always encloses F at each reverse-flow time step This processcan be generalized to building an entire multiresolution hierarchyaround F Although our method is not guaranteed to always find

a solution C especially for very coarse or nearly-self-intersectingF (see Section 5 for discussion of failure cases) we tested ouralgorithm on an extensive zoo of example meshes (see Section 4)

2 Related methods and special cases

Our method solves the nested cage problem for the large variety ofinput meshes shown in Section 4 while interoperating with arbitraryproblem-specific decimation algorithms and fitness functions Manyrelated approaches have been proposed that work for special casesor relax requirements imposed above

If the algorithm is free to generate the coarse cage pC rather than ac-cepting it as input from the user the problem becomes substantiallyeasier and has been extensively studied

Bounding polytopes Most naively one can simply take pC to bea canonical bounding polytope (eg box KDOP convex hull) Anextension would be to ldquoshrink-wraprdquo the bounding polytope aroundpF to minimize E This idea has been explored before [Peterhans2012 Wang et al 2013] but no full solution has been developedThis is presumably becausemdashwhile this approach works well forconvex pFmdashit will not give a good fit for meshes with nooks orconcavities It is also not clear how to find a bounding polytope formeshes of nontrivial topology Another approach might be to stitchoverlapping convex volumes [Xian et al 2012] using mesh booleanoperations but cage topology and quality become difficult to controlwithout sacrificing control of resolution

Offset surfaces for simulation meshes Representing pF as animplicit surface and contouring level sets is a popular method ofcreating offset surfaces that nest pF particularly in the context ofsimulations that use a ldquosimulation meshrdquo as a proxy for very finerendered geometry [Campen amp Kobbelt 2010] The challenge isnot just defining a scalar function with an isosurface envelopingthe object but also contouring it with a piecewise-linear trianglemesh without (i) cutting corners too harshly and intersecting pF or(ii) resorting to fine resolution nullifying any performance gainsof using the cage Xu et al [2014] define a robust signed distancefield but pass the field to an off-the-shelf contour mesher withoutany attempt to guarantee non-intersection with the input SimilarlyShen at al [2004] iteratively refine a moving least squares iso-surfaceto enclose an existing model tightly via a global scaling parameter

Our nested layers

Original

Tightest fitting distance field contours

Figure 4 Contouring requires aggressive spacing between distance-field isolevels to produce valid nesting Semantically distant partsfuse together destroying shape-awareness visualized by a pseudo-coloring of a Poisson solution computed on each level

Input [Ben-Chen et al 09] Our tight cages[Sander et al 00]

Figure 5 Methods like [Ben-Chen et al 2009a] use coarse cagesas computational workhorses to reduce complexity Their iterativeoffset heuristic does not allow control of the cage topology Mean-while [Sander et al 2000] attempt to maintain nestedness duringgreedy decimation with local constraints Cages are loosely-fittingbut more importantly self-intersections (orange) and intersectionswith the input model (yellow) eventually accumulate

Some applications such as collision detection can make use ofimplicit representations without intermediary meshes but when amesh is needed it is not enough that the continuous isosurface doesnot intersect the input model since generic contouring will invalidatethis A large enough iso-value or small-enough resolution tolerancemust always be chosen to ensure non-intersection after contouringFor large iso-values topological control is lost and close featuresare quickly merged (see Figure 4) violating the nestedness of thecage A similar approach [Ben-Chen et al 2009a] has been usedfor building deformation cages around input shapes where an offsetsurface is created via Poisson surface reconstruction [Kazhdan et al2006] (we compare against this approach in Figure 5) While thetightness of these cages could be controlled with post-hoc shrinkingof the cage the method can introduce topology changes that are noteasily remedied For meshes with well defined feature curves itmay be possible to merge coarse on-surface triangulations of patches[Xian et al 2013] though strict nesting is not sought or guaranteed

Progressive decimation of pF using edge collapses taking careto place new vertices on the exterior of the current volume by solvinga system of inequality constraints [Sander et al 2000] has foundsome success in real-time rendering and collision detection [Platisamp Theoharis 2003] Although the vertices of these ldquoprogressivehullsrdquo are guaranteed to lie outside of pF edges and faces of pC

might still intersect pF (and pC might globally self-intersect) seeFigure 5 We tested this method on the entire ldquozoordquo of examplesshown in Figure 11 and the supplementary material and of the 26examples there in only one case was the entire hierarchy free ofsuch intersections We also observe that for coarse cages these hullstend to be more loose-fitting than cages produced by methods thatoptimize the cage shape globally (see Figure 5) Self-intersectionsresulting from edge collapses can be corrected with post-hoc meshrepair [Deng et al 2011] but this technique relies on temperamental3D tetrahedral meshing in tight regions near overlaps and does notconsider face- or edge-intersections with the input model

Voxelization of pF will create a nested cage provided that theresolution is chosen fine enough to avoid topological artifacts (as inthe case of contouring implicit functions) Naive voxelization yieldsdense inefficient cages [Mehra et al 2009] possibly improved byprogressive decimation [Xian et al 2009] or mesh booleans [Xianet al 2015] though also inheriting their respective drawbacks

Mesh untangling All of the above methods require relinquishingsome degree of control over decimation to the nested cage algorithm

Input Shrinking fine mesh overlaps resolved

Expanding coarse mesh overlaps persist forever

10 iters 40 iters 70 iters 100 iters

10 iters 20 iters 30 iters 40 iters

Figure 6 Shrinking the fine mesh inside the coarse quickly removesoverlaps (yellow) Expanding the coarse mesh requires self-contacthandling (eg between arms and body) blocking progress

algorithms that accept an arbitrary pre-decimated cage pC are lesswell-developed History-free cloth collision response methods (eg[Baraff et al 2003 Volino amp Magnenat-Thalmann 2006 Wickeret al 2006 Ye amp Zhao 2012]) could be used to separate pC from pFif intersections are not too severe otherwise such methods quicklyget stuck in local minima

Outward Flow Before settling on an inward flow of pF we ex-perimented with an outward flow of pC away from pF along itssigned distance field For convex meshes this works well Howeverextensive testing revealed that this approach suffers from severaldifficulties on more complex geometries 1) Flowing vertices alongthe signed distance field of pF is not guaranteed to resolve all face-face collisions between the fine and coarse meshes the flow is mostrobust when the flowing elements are small and the signed distancefield does not have too many fine features Flowing the coarse meshoutward is more fragile than flowing the fine mesh in as both ofthese factors are less favorable 2) when flowing the fine mesh insidethe coarse mesh we do not need to handle self-collisions within thefine mesh whereas if inflating the coarse mesh we do Addingcollision constraints aggravates the fragility of the outward flow theconstraints can prevent a flowing face from ever leaving the volumeof the fine mesh (see Figure 6)

Multigrid Methods based on regular grids or lattices naturallysupport multiresolution numerical methods McAdams et al [2011]successfully employ multigrid on voxelized shapes to animate volu-metric elastic characters The main downside of grid-based methodsis their traditionally poor handling of irregular boundaries Special-ized multigrid methods using adaptive octrees to handle complexboundaries for fractures [Dick et al 2011] and fluids [Ferstl et al2014] exist but are not immune to troubles of regular grids bound-aries must be represented at fine grid levels to avoid aliasing andretain the inputrsquos topology To avoid fusing together geodesicallydistant parts the shape must be modeled in an accommodating poseIf remodeling is not possible the grid size must be chosen smallerthan not just the smallest features but also the smallest void betweenfeatures One solution is to replicate cells in close areas and man-

age adjacencies when two or more replicated patches merge andsplit [Teran et al 2005 Nesme et al 2009 Syacutekora et al 2009]Cell replication is not only difficult to realize robustly but also rid-dles multigrid numerical methods with expensive SIMD-breakingboundary handling code detracting from the performance gains ofmemory-efficient regular grids [Demmel 2004]

Multigrid on unstructured grids or tetrahedral meshes is more tem-peramental and constructing each level requires care [Fish et al1995] Geometric multigrid schemes typically coarsen an inputtetrahedral mesh by removing vertices attempting to connect thoseremaining in a reasonable way [Guillard 1993 Adams amp Demmel1999] Special care is required to maintain any semblance of theoriginal boundary [Brune et al 2011] essentially devolving into con-strained Delaunay tessellation with no guarantee that the coarseningwill not eat away large portions of the domain In many scenariosthe boundary of the domain is assumed to be only as irregular as thecoarsest layer simplifying level design [Feng et al 1997]

A second group of methods generates a multiresolution hierarchyusing decimation Unmodified mesh decimations [Garland amp Heck-bert 1997] have been used for adaptive simulations for visco-elasticsolids [Debunne et al 2001] Such non-nested cages require ex-trapolation or one-to-many mappings to prolongate solutions on thecoarse levels to finer levels We show cases where this fails to con-verge for common linear systems on irregular domains and we showbetter convergence for strictly nesting cages where prolongation is apurely linear interpolation

Algebraic alternatives also exist [Ruge amp Stuumlben 1987] but are rec-ommended only when geometric information is not available [Fal-gout 2006] Recently [Krishnan et al 2013] proposed a multigridpreconditioner for Laplace-based systems on images and surfacesThis method combines the elegance of algebraic techniques withsome geometric information derived from the characteristics of theLaplacian matrix but is limited to special problems

Simplification The majority of surface mesh decimation tech-niques aim to preserve outward appearance with lower and lowermesh resolution [Hoppe 1996 Garland amp Heckbert 1997 Melax1998] Along these lines [Gumhold et al 2003] output decimationsfree of self-intersections ensuring for example that a characterrsquosclothing stays outside its body In contrast our method assumesself-intersection free input decimations and transforms them intonested layers with no intersections across hierarchy layers Recentwork has considered more elaborate decimation goals than appear-ance such as preserving haptic sensations [Otaduy amp Lin 2003b]Otdauy and Lin [2003a] also demonstrate how to combine meshdecimations and bounding volume hierarchies to achieve faster colli-sion detection without affecting visual appearance Our nested cagesare hierarchical decimations strictly containing the input shape en-suring strictly conservative collision detection Rather than workagainst the sophistication of existing shape decimation techniqueswe complement them Our method takes arbitrary decimations asinput and nests them as a post process

Interference-aware processing We credit [Harmon et al 2011]for their ground-breaking introduction of contact handling to main-stream geometry processing Their work inspires us to consider thecontact and collisions tool-set familiar to physically based simula-tion in our geometry processing task In this task our novel flow isessential for finding a feasible starting state

3 Method

The input to our method is a sequence of k ` 1 potentially over-lapping triangle meshes xM0 xM1 xMk Each mesh xMi has a

Input overlapping decimations Output nested cages

M0M1M2M3M4 M0 M1 M2 M3 M4

Figure 7 We deform a set of input overlapping decimations so thateach contains all finer layers (2D illustration)

corresponding list of initial vertex positions xMi P Rniˆ3 and list oftriangle indices Ti P t1 niu

miˆ3 In a typical scenario xM0 isa high-resolution original mesh and xM1 xMk are decimationsof decreasing resolution the method of decimation is unimportant solong as the input meshes all approximate xM0 and are all watertightDepending on the application troublesome input meshes can becleaned as a pre-process using available tools (eg [Attene 2010Jacobson et al 2013])

The output of our method is a new sequence of k lists of vertex posi-tions M1 Mk such that for i ldquo 1 k each Mi ldquo pMiTiq

is a deformed mesh whose surface nests Miacute1 (with M0 ldquo xM0)Recursively this ensures that each Mi lies strictly outside Mj forj ldquo iacute 1 0 We call such meshes nested (see Figure 7)

We preserve the original combinatorics of xM0 xM1 xMk (Ti

are unchanged) respecting the output of whichever problem-specificdecimation routine produced them The nesting property of theoutput meshes is easily verified by testing that at least one vertex(per connected component in the general case) of Miacute1 lies insideMi (eg has positive winding number) and that no intersectionsexist between Miacute1 and Mi

We now describe a general method that produces this nesting prop-erty while also optimizing any problem-specific energy E (seeAlgorithm 1 with additional subroutines in Appendix B)

Algorithm 1 nested_cages(M0 LDecEnergy) NtildeM1 Mk

InputsM0 Initial high-res mesh vertices M0 faces T0

L k-long list of desired mesh resolutionsDec Function object for black-box decimatorEnergy Function object for re-inflation energy and gradient

OutputsM1Mk k-long list of nested cages

beginfor i P t1 ku do

Decimate from previous layer or input mesh xMi ETH Dec

acute

Miacute1 xMiacute1 Lpiqmacr

F ETHMiacute1 pC ETH xMi Rename coarse and fine meshesH ETH Shrinkp pCF q history of shrinking fine mesh Reverse history then Mi will nest Miacute1 Mi ETH ReInflatepH pCEnergyq

Our method operates recursively on two meshes of the sequence at atime we compute Mi by considering only its original embedding

Re-inflate F to F pushing C to C

Flow F to F until inside C

Overlapping pairand CF C

F F

C

FF

C

Figure 8 Our pipeline has two stages for each pair of neighboringcoarse C and fine F layers

xMi and the solution to the previous level Miacute1 In this way wecompute M1M2 Mk in order ensuring nesting between eachsubsequent pair Breaking the problem of nesting many cages intoindividual subproblems is key to our success as it greatly reducesthe complexity of the collision and optimization subproblems

To simplify notation from now on we only consider computingthe new positions of a coarse mesh C from its original mesh pC andthe next finer output mesh F Computing new coarse mesh vertexpositions C involves two phases flow of the fine mesh until it isfully inside the coarse mesh and re-inflation of the fine mesh to itsoriginal embedding while pushing the coarse mesh out of the way(see Figure 8) During the flow we do not care about the fine meshrsquosaesthetic surface quality or even whether it self-intersects becausewe will re-inflate it back to its original positions in the next step

31 Flow

The first step of our pipeline is to move vertices sF of the fine meshalong a flow that minimizes total signed distance to pC integratedover all deforming surface points sp P sF (see Figure 9 top left)

ΦpsFq ldquo

ż

F

spspqdpspq dA (1)

where dpspq is the unsigned distance from sp to the coarse meshand spspq modulates by the appropriate sign (negative inside) Weminimize Φ by taking small steps opposite its gradient direction foreach vertex position sf in sFptq as a function of a fictitious time t

F

C

invalidBsf

Btldquo acutenabla

sfΦpsFq (2)

By following this gradient we flow thefine mesh vertices sFptq until all of sF(not just vertices see inset) is fully insidethe coarse mesh (determined by check-ing for intersections at each time step)

While Φ is similar to data terms found in iterative closest point(ICP) methods for non-rigid registration [Chang et al 2010] thesign modulator spspq is an important difference Minimizing un-signed (positive) distances would flow points toward the surface ofthe coarse mesh Instead by allowing and encouraging negativedistances points flow to the medial axis within the coarse mesh

Since Φ is nonlinear and intractable to compute exactly we approxi-mate the gradient using numerical quadrature For each triangle Ti

incident on vertices a b c we sample s and d at quadrature points

spj with corresponding weights wj j ldquo 1 h

ΦpsFq ldquo

mFyuml

ildquo1

ż

spPTi

spspqdpspq dA laquo

mFyuml

ildquo1

hyuml

jldquo1

wjspspjqdpspjq

spj ldquo λasfa ` λb

sfb ` λcsfc

where λa λb λc are the barycentric coordinates of spj in Ti andmF

is the number of fine mesh triangles We use second-order quadraturerules and see diminishing returns with more exact schemes

The difficulty of differentiating the unsigned distance function dpspjq

remains To tackle this we adapt the successful ICP approach of non-rigid registration techniques Namely we assume that the closestpoint pq˚j to each spj and sign spspjq ldquo s˚j remain constant duringeach small time step (one could consider modifications common toICP eg point-to-plane distance but our goal is not to align the twosurfaces rather to flow one inside the other)

We may now push the gradient through the summation to the termsinvolving each vertex position sf

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j nablasf spj acute pq˚j (3)

where Npsfq gathers all triangles incident on vertex sf Applying thechain rule and handling the special case where spj laquo pq˚j (ie whenour assumption that spspjq ldquo s˚j is invalid) we arrive at

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j pnablasf spjq

Tnablaspj spj acute pq˚j (4)

ldquo acuteyuml

iPNpsfq

hyuml

jldquo1

wjλfgi (5)

where gi ldquo

s˚jppiacuteq˚

i

ppiacuteq˚i

if ppi acute q˚i ą ε

npq˚i q otherwise(6)

where λf is the barycentric coordinate of spi corresponding to sf andnpq˚i q is the unit normal at q˚i For q˚i near edges and vertices weuse an angle-weighted normal [Baerentzen amp Aanaes 2005]

We use a step size ∆t laquo 10acute3 (after scaling inputs to unit diameter)After each step we update signs s˚i and closest points q˚i for allquadrature points We terminate if all signs are negative and nointersection exists between sF and pC

inputs failed flow

Our signed distance flow is not guaran-teed to always succeed Indeed in diffi-cult cases (eg very coarse meshes withvery thin features or highly concave ver-tices) the flow converges without mov-ing the fine mesh fully inside the coarsemesh (see inset) It is possible for allquadrature points on the fine mesh toflow toward the medial axis of the coarse mesh while stretchingtriangles through corners leaving intersections (yellow cage facets)

In particularly difficult cases we propose an additional step wereverse the picture and expand the coarse mesh flowing it away fromthe current fine mesh along its signed distance field Contact forcesmust also be included in this case to ensure the coarse mesh doesnot flow into a configuration where it self-intersects Fortunately inthese hard cases only a few expansion steps are typically necessary

We experimented with an alternative formulation where we onlyconsider expansion of the coarse mesh but this proved problematic

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Input [Ben-Chen et al 09] Our tight cages[Sander et al 00]

Figure 5 Methods like [Ben-Chen et al 2009a] use coarse cagesas computational workhorses to reduce complexity Their iterativeoffset heuristic does not allow control of the cage topology Mean-while [Sander et al 2000] attempt to maintain nestedness duringgreedy decimation with local constraints Cages are loosely-fittingbut more importantly self-intersections (orange) and intersectionswith the input model (yellow) eventually accumulate

Some applications such as collision detection can make use ofimplicit representations without intermediary meshes but when amesh is needed it is not enough that the continuous isosurface doesnot intersect the input model since generic contouring will invalidatethis A large enough iso-value or small-enough resolution tolerancemust always be chosen to ensure non-intersection after contouringFor large iso-values topological control is lost and close featuresare quickly merged (see Figure 4) violating the nestedness of thecage A similar approach [Ben-Chen et al 2009a] has been usedfor building deformation cages around input shapes where an offsetsurface is created via Poisson surface reconstruction [Kazhdan et al2006] (we compare against this approach in Figure 5) While thetightness of these cages could be controlled with post-hoc shrinkingof the cage the method can introduce topology changes that are noteasily remedied For meshes with well defined feature curves itmay be possible to merge coarse on-surface triangulations of patches[Xian et al 2013] though strict nesting is not sought or guaranteed

Progressive decimation of pF using edge collapses taking careto place new vertices on the exterior of the current volume by solvinga system of inequality constraints [Sander et al 2000] has foundsome success in real-time rendering and collision detection [Platisamp Theoharis 2003] Although the vertices of these ldquoprogressivehullsrdquo are guaranteed to lie outside of pF edges and faces of pC

might still intersect pF (and pC might globally self-intersect) seeFigure 5 We tested this method on the entire ldquozoordquo of examplesshown in Figure 11 and the supplementary material and of the 26examples there in only one case was the entire hierarchy free ofsuch intersections We also observe that for coarse cages these hullstend to be more loose-fitting than cages produced by methods thatoptimize the cage shape globally (see Figure 5) Self-intersectionsresulting from edge collapses can be corrected with post-hoc meshrepair [Deng et al 2011] but this technique relies on temperamental3D tetrahedral meshing in tight regions near overlaps and does notconsider face- or edge-intersections with the input model

Voxelization of pF will create a nested cage provided that theresolution is chosen fine enough to avoid topological artifacts (as inthe case of contouring implicit functions) Naive voxelization yieldsdense inefficient cages [Mehra et al 2009] possibly improved byprogressive decimation [Xian et al 2009] or mesh booleans [Xianet al 2015] though also inheriting their respective drawbacks

Mesh untangling All of the above methods require relinquishingsome degree of control over decimation to the nested cage algorithm

Input Shrinking fine mesh overlaps resolved

Expanding coarse mesh overlaps persist forever

10 iters 40 iters 70 iters 100 iters

10 iters 20 iters 30 iters 40 iters

Figure 6 Shrinking the fine mesh inside the coarse quickly removesoverlaps (yellow) Expanding the coarse mesh requires self-contacthandling (eg between arms and body) blocking progress

algorithms that accept an arbitrary pre-decimated cage pC are lesswell-developed History-free cloth collision response methods (eg[Baraff et al 2003 Volino amp Magnenat-Thalmann 2006 Wickeret al 2006 Ye amp Zhao 2012]) could be used to separate pC from pFif intersections are not too severe otherwise such methods quicklyget stuck in local minima

Outward Flow Before settling on an inward flow of pF we ex-perimented with an outward flow of pC away from pF along itssigned distance field For convex meshes this works well Howeverextensive testing revealed that this approach suffers from severaldifficulties on more complex geometries 1) Flowing vertices alongthe signed distance field of pF is not guaranteed to resolve all face-face collisions between the fine and coarse meshes the flow is mostrobust when the flowing elements are small and the signed distancefield does not have too many fine features Flowing the coarse meshoutward is more fragile than flowing the fine mesh in as both ofthese factors are less favorable 2) when flowing the fine mesh insidethe coarse mesh we do not need to handle self-collisions within thefine mesh whereas if inflating the coarse mesh we do Addingcollision constraints aggravates the fragility of the outward flow theconstraints can prevent a flowing face from ever leaving the volumeof the fine mesh (see Figure 6)

Multigrid Methods based on regular grids or lattices naturallysupport multiresolution numerical methods McAdams et al [2011]successfully employ multigrid on voxelized shapes to animate volu-metric elastic characters The main downside of grid-based methodsis their traditionally poor handling of irregular boundaries Special-ized multigrid methods using adaptive octrees to handle complexboundaries for fractures [Dick et al 2011] and fluids [Ferstl et al2014] exist but are not immune to troubles of regular grids bound-aries must be represented at fine grid levels to avoid aliasing andretain the inputrsquos topology To avoid fusing together geodesicallydistant parts the shape must be modeled in an accommodating poseIf remodeling is not possible the grid size must be chosen smallerthan not just the smallest features but also the smallest void betweenfeatures One solution is to replicate cells in close areas and man-

age adjacencies when two or more replicated patches merge andsplit [Teran et al 2005 Nesme et al 2009 Syacutekora et al 2009]Cell replication is not only difficult to realize robustly but also rid-dles multigrid numerical methods with expensive SIMD-breakingboundary handling code detracting from the performance gains ofmemory-efficient regular grids [Demmel 2004]

Multigrid on unstructured grids or tetrahedral meshes is more tem-peramental and constructing each level requires care [Fish et al1995] Geometric multigrid schemes typically coarsen an inputtetrahedral mesh by removing vertices attempting to connect thoseremaining in a reasonable way [Guillard 1993 Adams amp Demmel1999] Special care is required to maintain any semblance of theoriginal boundary [Brune et al 2011] essentially devolving into con-strained Delaunay tessellation with no guarantee that the coarseningwill not eat away large portions of the domain In many scenariosthe boundary of the domain is assumed to be only as irregular as thecoarsest layer simplifying level design [Feng et al 1997]

A second group of methods generates a multiresolution hierarchyusing decimation Unmodified mesh decimations [Garland amp Heck-bert 1997] have been used for adaptive simulations for visco-elasticsolids [Debunne et al 2001] Such non-nested cages require ex-trapolation or one-to-many mappings to prolongate solutions on thecoarse levels to finer levels We show cases where this fails to con-verge for common linear systems on irregular domains and we showbetter convergence for strictly nesting cages where prolongation is apurely linear interpolation

Algebraic alternatives also exist [Ruge amp Stuumlben 1987] but are rec-ommended only when geometric information is not available [Fal-gout 2006] Recently [Krishnan et al 2013] proposed a multigridpreconditioner for Laplace-based systems on images and surfacesThis method combines the elegance of algebraic techniques withsome geometric information derived from the characteristics of theLaplacian matrix but is limited to special problems

Simplification The majority of surface mesh decimation tech-niques aim to preserve outward appearance with lower and lowermesh resolution [Hoppe 1996 Garland amp Heckbert 1997 Melax1998] Along these lines [Gumhold et al 2003] output decimationsfree of self-intersections ensuring for example that a characterrsquosclothing stays outside its body In contrast our method assumesself-intersection free input decimations and transforms them intonested layers with no intersections across hierarchy layers Recentwork has considered more elaborate decimation goals than appear-ance such as preserving haptic sensations [Otaduy amp Lin 2003b]Otdauy and Lin [2003a] also demonstrate how to combine meshdecimations and bounding volume hierarchies to achieve faster colli-sion detection without affecting visual appearance Our nested cagesare hierarchical decimations strictly containing the input shape en-suring strictly conservative collision detection Rather than workagainst the sophistication of existing shape decimation techniqueswe complement them Our method takes arbitrary decimations asinput and nests them as a post process

Interference-aware processing We credit [Harmon et al 2011]for their ground-breaking introduction of contact handling to main-stream geometry processing Their work inspires us to consider thecontact and collisions tool-set familiar to physically based simula-tion in our geometry processing task In this task our novel flow isessential for finding a feasible starting state

3 Method

The input to our method is a sequence of k ` 1 potentially over-lapping triangle meshes xM0 xM1 xMk Each mesh xMi has a

Input overlapping decimations Output nested cages

M0M1M2M3M4 M0 M1 M2 M3 M4

Figure 7 We deform a set of input overlapping decimations so thateach contains all finer layers (2D illustration)

corresponding list of initial vertex positions xMi P Rniˆ3 and list oftriangle indices Ti P t1 niu

miˆ3 In a typical scenario xM0 isa high-resolution original mesh and xM1 xMk are decimationsof decreasing resolution the method of decimation is unimportant solong as the input meshes all approximate xM0 and are all watertightDepending on the application troublesome input meshes can becleaned as a pre-process using available tools (eg [Attene 2010Jacobson et al 2013])

The output of our method is a new sequence of k lists of vertex posi-tions M1 Mk such that for i ldquo 1 k each Mi ldquo pMiTiq

is a deformed mesh whose surface nests Miacute1 (with M0 ldquo xM0)Recursively this ensures that each Mi lies strictly outside Mj forj ldquo iacute 1 0 We call such meshes nested (see Figure 7)

We preserve the original combinatorics of xM0 xM1 xMk (Ti

are unchanged) respecting the output of whichever problem-specificdecimation routine produced them The nesting property of theoutput meshes is easily verified by testing that at least one vertex(per connected component in the general case) of Miacute1 lies insideMi (eg has positive winding number) and that no intersectionsexist between Miacute1 and Mi

We now describe a general method that produces this nesting prop-erty while also optimizing any problem-specific energy E (seeAlgorithm 1 with additional subroutines in Appendix B)

Algorithm 1 nested_cages(M0 LDecEnergy) NtildeM1 Mk

InputsM0 Initial high-res mesh vertices M0 faces T0

L k-long list of desired mesh resolutionsDec Function object for black-box decimatorEnergy Function object for re-inflation energy and gradient

OutputsM1Mk k-long list of nested cages

beginfor i P t1 ku do

Decimate from previous layer or input mesh xMi ETH Dec

acute

Miacute1 xMiacute1 Lpiqmacr

F ETHMiacute1 pC ETH xMi Rename coarse and fine meshesH ETH Shrinkp pCF q history of shrinking fine mesh Reverse history then Mi will nest Miacute1 Mi ETH ReInflatepH pCEnergyq

Our method operates recursively on two meshes of the sequence at atime we compute Mi by considering only its original embedding

Re-inflate F to F pushing C to C

Flow F to F until inside C

Overlapping pairand CF C

F F

C

FF

C

Figure 8 Our pipeline has two stages for each pair of neighboringcoarse C and fine F layers

xMi and the solution to the previous level Miacute1 In this way wecompute M1M2 Mk in order ensuring nesting between eachsubsequent pair Breaking the problem of nesting many cages intoindividual subproblems is key to our success as it greatly reducesthe complexity of the collision and optimization subproblems

To simplify notation from now on we only consider computingthe new positions of a coarse mesh C from its original mesh pC andthe next finer output mesh F Computing new coarse mesh vertexpositions C involves two phases flow of the fine mesh until it isfully inside the coarse mesh and re-inflation of the fine mesh to itsoriginal embedding while pushing the coarse mesh out of the way(see Figure 8) During the flow we do not care about the fine meshrsquosaesthetic surface quality or even whether it self-intersects becausewe will re-inflate it back to its original positions in the next step

31 Flow

The first step of our pipeline is to move vertices sF of the fine meshalong a flow that minimizes total signed distance to pC integratedover all deforming surface points sp P sF (see Figure 9 top left)

ΦpsFq ldquo

ż

F

spspqdpspq dA (1)

where dpspq is the unsigned distance from sp to the coarse meshand spspq modulates by the appropriate sign (negative inside) Weminimize Φ by taking small steps opposite its gradient direction foreach vertex position sf in sFptq as a function of a fictitious time t

F

C

invalidBsf

Btldquo acutenabla

sfΦpsFq (2)

By following this gradient we flow thefine mesh vertices sFptq until all of sF(not just vertices see inset) is fully insidethe coarse mesh (determined by check-ing for intersections at each time step)

While Φ is similar to data terms found in iterative closest point(ICP) methods for non-rigid registration [Chang et al 2010] thesign modulator spspq is an important difference Minimizing un-signed (positive) distances would flow points toward the surface ofthe coarse mesh Instead by allowing and encouraging negativedistances points flow to the medial axis within the coarse mesh

Since Φ is nonlinear and intractable to compute exactly we approxi-mate the gradient using numerical quadrature For each triangle Ti

incident on vertices a b c we sample s and d at quadrature points

spj with corresponding weights wj j ldquo 1 h

ΦpsFq ldquo

mFyuml

ildquo1

ż

spPTi

spspqdpspq dA laquo

mFyuml

ildquo1

hyuml

jldquo1

wjspspjqdpspjq

spj ldquo λasfa ` λb

sfb ` λcsfc

where λa λb λc are the barycentric coordinates of spj in Ti andmF

is the number of fine mesh triangles We use second-order quadraturerules and see diminishing returns with more exact schemes

The difficulty of differentiating the unsigned distance function dpspjq

remains To tackle this we adapt the successful ICP approach of non-rigid registration techniques Namely we assume that the closestpoint pq˚j to each spj and sign spspjq ldquo s˚j remain constant duringeach small time step (one could consider modifications common toICP eg point-to-plane distance but our goal is not to align the twosurfaces rather to flow one inside the other)

We may now push the gradient through the summation to the termsinvolving each vertex position sf

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j nablasf spj acute pq˚j (3)

where Npsfq gathers all triangles incident on vertex sf Applying thechain rule and handling the special case where spj laquo pq˚j (ie whenour assumption that spspjq ldquo s˚j is invalid) we arrive at

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j pnablasf spjq

Tnablaspj spj acute pq˚j (4)

ldquo acuteyuml

iPNpsfq

hyuml

jldquo1

wjλfgi (5)

where gi ldquo

s˚jppiacuteq˚

i

ppiacuteq˚i

if ppi acute q˚i ą ε

npq˚i q otherwise(6)

where λf is the barycentric coordinate of spi corresponding to sf andnpq˚i q is the unit normal at q˚i For q˚i near edges and vertices weuse an angle-weighted normal [Baerentzen amp Aanaes 2005]

We use a step size ∆t laquo 10acute3 (after scaling inputs to unit diameter)After each step we update signs s˚i and closest points q˚i for allquadrature points We terminate if all signs are negative and nointersection exists between sF and pC

inputs failed flow

Our signed distance flow is not guaran-teed to always succeed Indeed in diffi-cult cases (eg very coarse meshes withvery thin features or highly concave ver-tices) the flow converges without mov-ing the fine mesh fully inside the coarsemesh (see inset) It is possible for allquadrature points on the fine mesh toflow toward the medial axis of the coarse mesh while stretchingtriangles through corners leaving intersections (yellow cage facets)

In particularly difficult cases we propose an additional step wereverse the picture and expand the coarse mesh flowing it away fromthe current fine mesh along its signed distance field Contact forcesmust also be included in this case to ensure the coarse mesh doesnot flow into a configuration where it self-intersects Fortunately inthese hard cases only a few expansion steps are typically necessary

We experimented with an alternative formulation where we onlyconsider expansion of the coarse mesh but this proved problematic

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

age adjacencies when two or more replicated patches merge andsplit [Teran et al 2005 Nesme et al 2009 Syacutekora et al 2009]Cell replication is not only difficult to realize robustly but also rid-dles multigrid numerical methods with expensive SIMD-breakingboundary handling code detracting from the performance gains ofmemory-efficient regular grids [Demmel 2004]

Multigrid on unstructured grids or tetrahedral meshes is more tem-peramental and constructing each level requires care [Fish et al1995] Geometric multigrid schemes typically coarsen an inputtetrahedral mesh by removing vertices attempting to connect thoseremaining in a reasonable way [Guillard 1993 Adams amp Demmel1999] Special care is required to maintain any semblance of theoriginal boundary [Brune et al 2011] essentially devolving into con-strained Delaunay tessellation with no guarantee that the coarseningwill not eat away large portions of the domain In many scenariosthe boundary of the domain is assumed to be only as irregular as thecoarsest layer simplifying level design [Feng et al 1997]

A second group of methods generates a multiresolution hierarchyusing decimation Unmodified mesh decimations [Garland amp Heck-bert 1997] have been used for adaptive simulations for visco-elasticsolids [Debunne et al 2001] Such non-nested cages require ex-trapolation or one-to-many mappings to prolongate solutions on thecoarse levels to finer levels We show cases where this fails to con-verge for common linear systems on irregular domains and we showbetter convergence for strictly nesting cages where prolongation is apurely linear interpolation

Algebraic alternatives also exist [Ruge amp Stuumlben 1987] but are rec-ommended only when geometric information is not available [Fal-gout 2006] Recently [Krishnan et al 2013] proposed a multigridpreconditioner for Laplace-based systems on images and surfacesThis method combines the elegance of algebraic techniques withsome geometric information derived from the characteristics of theLaplacian matrix but is limited to special problems

Simplification The majority of surface mesh decimation tech-niques aim to preserve outward appearance with lower and lowermesh resolution [Hoppe 1996 Garland amp Heckbert 1997 Melax1998] Along these lines [Gumhold et al 2003] output decimationsfree of self-intersections ensuring for example that a characterrsquosclothing stays outside its body In contrast our method assumesself-intersection free input decimations and transforms them intonested layers with no intersections across hierarchy layers Recentwork has considered more elaborate decimation goals than appear-ance such as preserving haptic sensations [Otaduy amp Lin 2003b]Otdauy and Lin [2003a] also demonstrate how to combine meshdecimations and bounding volume hierarchies to achieve faster colli-sion detection without affecting visual appearance Our nested cagesare hierarchical decimations strictly containing the input shape en-suring strictly conservative collision detection Rather than workagainst the sophistication of existing shape decimation techniqueswe complement them Our method takes arbitrary decimations asinput and nests them as a post process

Interference-aware processing We credit [Harmon et al 2011]for their ground-breaking introduction of contact handling to main-stream geometry processing Their work inspires us to consider thecontact and collisions tool-set familiar to physically based simula-tion in our geometry processing task In this task our novel flow isessential for finding a feasible starting state

3 Method

The input to our method is a sequence of k ` 1 potentially over-lapping triangle meshes xM0 xM1 xMk Each mesh xMi has a

Input overlapping decimations Output nested cages

M0M1M2M3M4 M0 M1 M2 M3 M4

Figure 7 We deform a set of input overlapping decimations so thateach contains all finer layers (2D illustration)

corresponding list of initial vertex positions xMi P Rniˆ3 and list oftriangle indices Ti P t1 niu

miˆ3 In a typical scenario xM0 isa high-resolution original mesh and xM1 xMk are decimationsof decreasing resolution the method of decimation is unimportant solong as the input meshes all approximate xM0 and are all watertightDepending on the application troublesome input meshes can becleaned as a pre-process using available tools (eg [Attene 2010Jacobson et al 2013])

The output of our method is a new sequence of k lists of vertex posi-tions M1 Mk such that for i ldquo 1 k each Mi ldquo pMiTiq

is a deformed mesh whose surface nests Miacute1 (with M0 ldquo xM0)Recursively this ensures that each Mi lies strictly outside Mj forj ldquo iacute 1 0 We call such meshes nested (see Figure 7)

We preserve the original combinatorics of xM0 xM1 xMk (Ti

are unchanged) respecting the output of whichever problem-specificdecimation routine produced them The nesting property of theoutput meshes is easily verified by testing that at least one vertex(per connected component in the general case) of Miacute1 lies insideMi (eg has positive winding number) and that no intersectionsexist between Miacute1 and Mi

We now describe a general method that produces this nesting prop-erty while also optimizing any problem-specific energy E (seeAlgorithm 1 with additional subroutines in Appendix B)

Algorithm 1 nested_cages(M0 LDecEnergy) NtildeM1 Mk

InputsM0 Initial high-res mesh vertices M0 faces T0

L k-long list of desired mesh resolutionsDec Function object for black-box decimatorEnergy Function object for re-inflation energy and gradient

OutputsM1Mk k-long list of nested cages

beginfor i P t1 ku do

Decimate from previous layer or input mesh xMi ETH Dec

acute

Miacute1 xMiacute1 Lpiqmacr

F ETHMiacute1 pC ETH xMi Rename coarse and fine meshesH ETH Shrinkp pCF q history of shrinking fine mesh Reverse history then Mi will nest Miacute1 Mi ETH ReInflatepH pCEnergyq

Our method operates recursively on two meshes of the sequence at atime we compute Mi by considering only its original embedding

Re-inflate F to F pushing C to C

Flow F to F until inside C

Overlapping pairand CF C

F F

C

FF

C

Figure 8 Our pipeline has two stages for each pair of neighboringcoarse C and fine F layers

xMi and the solution to the previous level Miacute1 In this way wecompute M1M2 Mk in order ensuring nesting between eachsubsequent pair Breaking the problem of nesting many cages intoindividual subproblems is key to our success as it greatly reducesthe complexity of the collision and optimization subproblems

To simplify notation from now on we only consider computingthe new positions of a coarse mesh C from its original mesh pC andthe next finer output mesh F Computing new coarse mesh vertexpositions C involves two phases flow of the fine mesh until it isfully inside the coarse mesh and re-inflation of the fine mesh to itsoriginal embedding while pushing the coarse mesh out of the way(see Figure 8) During the flow we do not care about the fine meshrsquosaesthetic surface quality or even whether it self-intersects becausewe will re-inflate it back to its original positions in the next step

31 Flow

The first step of our pipeline is to move vertices sF of the fine meshalong a flow that minimizes total signed distance to pC integratedover all deforming surface points sp P sF (see Figure 9 top left)

ΦpsFq ldquo

ż

F

spspqdpspq dA (1)

where dpspq is the unsigned distance from sp to the coarse meshand spspq modulates by the appropriate sign (negative inside) Weminimize Φ by taking small steps opposite its gradient direction foreach vertex position sf in sFptq as a function of a fictitious time t

F

C

invalidBsf

Btldquo acutenabla

sfΦpsFq (2)

By following this gradient we flow thefine mesh vertices sFptq until all of sF(not just vertices see inset) is fully insidethe coarse mesh (determined by check-ing for intersections at each time step)

While Φ is similar to data terms found in iterative closest point(ICP) methods for non-rigid registration [Chang et al 2010] thesign modulator spspq is an important difference Minimizing un-signed (positive) distances would flow points toward the surface ofthe coarse mesh Instead by allowing and encouraging negativedistances points flow to the medial axis within the coarse mesh

Since Φ is nonlinear and intractable to compute exactly we approxi-mate the gradient using numerical quadrature For each triangle Ti

incident on vertices a b c we sample s and d at quadrature points

spj with corresponding weights wj j ldquo 1 h

ΦpsFq ldquo

mFyuml

ildquo1

ż

spPTi

spspqdpspq dA laquo

mFyuml

ildquo1

hyuml

jldquo1

wjspspjqdpspjq

spj ldquo λasfa ` λb

sfb ` λcsfc

where λa λb λc are the barycentric coordinates of spj in Ti andmF

is the number of fine mesh triangles We use second-order quadraturerules and see diminishing returns with more exact schemes

The difficulty of differentiating the unsigned distance function dpspjq

remains To tackle this we adapt the successful ICP approach of non-rigid registration techniques Namely we assume that the closestpoint pq˚j to each spj and sign spspjq ldquo s˚j remain constant duringeach small time step (one could consider modifications common toICP eg point-to-plane distance but our goal is not to align the twosurfaces rather to flow one inside the other)

We may now push the gradient through the summation to the termsinvolving each vertex position sf

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j nablasf spj acute pq˚j (3)

where Npsfq gathers all triangles incident on vertex sf Applying thechain rule and handling the special case where spj laquo pq˚j (ie whenour assumption that spspjq ldquo s˚j is invalid) we arrive at

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j pnablasf spjq

Tnablaspj spj acute pq˚j (4)

ldquo acuteyuml

iPNpsfq

hyuml

jldquo1

wjλfgi (5)

where gi ldquo

s˚jppiacuteq˚

i

ppiacuteq˚i

if ppi acute q˚i ą ε

npq˚i q otherwise(6)

where λf is the barycentric coordinate of spi corresponding to sf andnpq˚i q is the unit normal at q˚i For q˚i near edges and vertices weuse an angle-weighted normal [Baerentzen amp Aanaes 2005]

We use a step size ∆t laquo 10acute3 (after scaling inputs to unit diameter)After each step we update signs s˚i and closest points q˚i for allquadrature points We terminate if all signs are negative and nointersection exists between sF and pC

inputs failed flow

Our signed distance flow is not guaran-teed to always succeed Indeed in diffi-cult cases (eg very coarse meshes withvery thin features or highly concave ver-tices) the flow converges without mov-ing the fine mesh fully inside the coarsemesh (see inset) It is possible for allquadrature points on the fine mesh toflow toward the medial axis of the coarse mesh while stretchingtriangles through corners leaving intersections (yellow cage facets)

In particularly difficult cases we propose an additional step wereverse the picture and expand the coarse mesh flowing it away fromthe current fine mesh along its signed distance field Contact forcesmust also be included in this case to ensure the coarse mesh doesnot flow into a configuration where it self-intersects Fortunately inthese hard cases only a few expansion steps are typically necessary

We experimented with an alternative formulation where we onlyconsider expansion of the coarse mesh but this proved problematic

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Re-inflate F to F pushing C to C

Flow F to F until inside C

Overlapping pairand CF C

F F

C

FF

C

Figure 8 Our pipeline has two stages for each pair of neighboringcoarse C and fine F layers

xMi and the solution to the previous level Miacute1 In this way wecompute M1M2 Mk in order ensuring nesting between eachsubsequent pair Breaking the problem of nesting many cages intoindividual subproblems is key to our success as it greatly reducesthe complexity of the collision and optimization subproblems

To simplify notation from now on we only consider computingthe new positions of a coarse mesh C from its original mesh pC andthe next finer output mesh F Computing new coarse mesh vertexpositions C involves two phases flow of the fine mesh until it isfully inside the coarse mesh and re-inflation of the fine mesh to itsoriginal embedding while pushing the coarse mesh out of the way(see Figure 8) During the flow we do not care about the fine meshrsquosaesthetic surface quality or even whether it self-intersects becausewe will re-inflate it back to its original positions in the next step

31 Flow

The first step of our pipeline is to move vertices sF of the fine meshalong a flow that minimizes total signed distance to pC integratedover all deforming surface points sp P sF (see Figure 9 top left)

ΦpsFq ldquo

ż

F

spspqdpspq dA (1)

where dpspq is the unsigned distance from sp to the coarse meshand spspq modulates by the appropriate sign (negative inside) Weminimize Φ by taking small steps opposite its gradient direction foreach vertex position sf in sFptq as a function of a fictitious time t

F

C

invalidBsf

Btldquo acutenabla

sfΦpsFq (2)

By following this gradient we flow thefine mesh vertices sFptq until all of sF(not just vertices see inset) is fully insidethe coarse mesh (determined by check-ing for intersections at each time step)

While Φ is similar to data terms found in iterative closest point(ICP) methods for non-rigid registration [Chang et al 2010] thesign modulator spspq is an important difference Minimizing un-signed (positive) distances would flow points toward the surface ofthe coarse mesh Instead by allowing and encouraging negativedistances points flow to the medial axis within the coarse mesh

Since Φ is nonlinear and intractable to compute exactly we approxi-mate the gradient using numerical quadrature For each triangle Ti

incident on vertices a b c we sample s and d at quadrature points

spj with corresponding weights wj j ldquo 1 h

ΦpsFq ldquo

mFyuml

ildquo1

ż

spPTi

spspqdpspq dA laquo

mFyuml

ildquo1

hyuml

jldquo1

wjspspjqdpspjq

spj ldquo λasfa ` λb

sfb ` λcsfc

where λa λb λc are the barycentric coordinates of spj in Ti andmF

is the number of fine mesh triangles We use second-order quadraturerules and see diminishing returns with more exact schemes

The difficulty of differentiating the unsigned distance function dpspjq

remains To tackle this we adapt the successful ICP approach of non-rigid registration techniques Namely we assume that the closestpoint pq˚j to each spj and sign spspjq ldquo s˚j remain constant duringeach small time step (one could consider modifications common toICP eg point-to-plane distance but our goal is not to align the twosurfaces rather to flow one inside the other)

We may now push the gradient through the summation to the termsinvolving each vertex position sf

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j nablasf spj acute pq˚j (3)

where Npsfq gathers all triangles incident on vertex sf Applying thechain rule and handling the special case where spj laquo pq˚j (ie whenour assumption that spspjq ldquo s˚j is invalid) we arrive at

Bsf

Btlaquo acute

yuml

iPNpsfq

hyuml

jldquo1

wjs˚j pnablasf spjq

Tnablaspj spj acute pq˚j (4)

ldquo acuteyuml

iPNpsfq

hyuml

jldquo1

wjλfgi (5)

where gi ldquo

s˚jppiacuteq˚

i

ppiacuteq˚i

if ppi acute q˚i ą ε

npq˚i q otherwise(6)

where λf is the barycentric coordinate of spi corresponding to sf andnpq˚i q is the unit normal at q˚i For q˚i near edges and vertices weuse an angle-weighted normal [Baerentzen amp Aanaes 2005]

We use a step size ∆t laquo 10acute3 (after scaling inputs to unit diameter)After each step we update signs s˚i and closest points q˚i for allquadrature points We terminate if all signs are negative and nointersection exists between sF and pC

inputs failed flow

Our signed distance flow is not guaran-teed to always succeed Indeed in diffi-cult cases (eg very coarse meshes withvery thin features or highly concave ver-tices) the flow converges without mov-ing the fine mesh fully inside the coarsemesh (see inset) It is possible for allquadrature points on the fine mesh toflow toward the medial axis of the coarse mesh while stretchingtriangles through corners leaving intersections (yellow cage facets)

In particularly difficult cases we propose an additional step wereverse the picture and expand the coarse mesh flowing it away fromthe current fine mesh along its signed distance field Contact forcesmust also be included in this case to ensure the coarse mesh doesnot flow into a configuration where it self-intersects Fortunately inthese hard cases only a few expansion steps are typically necessary

We experimented with an alternative formulation where we onlyconsider expansion of the coarse mesh but this proved problematic

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

conformalized mean curvature flow

our signed distance flow successful re-inflation

failed re-inflation

Figure 9 Our method directly flows the fine mesh (blue) inside the coarse mesh (wireframe) In contrast curvature flow [Kazhdan et al 2012]shrinks the fine mesh but strays outside the coarse mesh During re-inflation this causes unnecessary collisions leading to failure

Self-contacts may obstruct the flow early on disrupting furtherprogress (see Figure 6) In addition the signed distance field outsidethe fine mesh is in general more complicated than inside the coarsemesh there are more cusps and more variation due to more surfacevariation in the fine mesh The coarse mesh inflates too far outsidethe fine mesh or gets stuck too early then struggles to shrink backinto place (particularly around and inside concavities)

Experiments with alternative flows We experimented withmore elegant flows that induce shrinking effects [Taubin 1995 Des-brun et al 1999 Crane et al 2013] Of particular interest were flowsthat eventually degenerate to the shapersquos medial axis [Wang amp Lee2008 Au et al 2008 Tagliasacchi et al 2012] or to a round point[Kazhdan et al 2012] but we observed that these often flow the sur-face outside of its own original volume (much less that of a nearbycoarse decimation) particularly for non-convex and high-genus sur-faces Such wandering flows caused unnecessary complications inthe re-inflation step we describe next In Figure 9 we compare tothe conformalized mean curvature flow of [Kazhdan et al 2012]a particularly promising method as it is guaranteed to flow sphere-topology surfaces to round points (easily embeddable in the coarsemesh) and that has proven useful in the past [Sacht et al 2013] How-ever for complicated shapes the flow deviates dramatically from theoriginal surface thus hindering further processing For high genusshapes it does not resolve intersections upon convergence

We also experimented with modifications to the surface distancefunction [Peng et al 2004] observing that it was not appreciablymore robust than the usual L8 distance In fact simpler exper-iments of flowing a mesh against itself reveal that designing aninward flow with guarantees is surprisingly difficult Even pickinginward pointing normals at mesh vertices is non-trivial In fact theusual uniform-area-angle-weighted normals are not guaranteed topoint inward One effective but inelegant normal definition is totetrahedralize the inner volume and choose a normal pointing towardthe center of an incident tetrahedron to each vertex But even flowingalong inward pointing normals at vertices is not guaranteed to nest amesh inside itself Counterexamples exist to show that sometimesno inward flow is possible (see Appendix A)

32 Re-inflation

After the flow step sF is fully inside pC We now restore the fine meshto its original vertex positions F detecting and resolving collisionswith the coarse mesh along the way (see Figure 8)

Jumping directly from sF to F in a single linear step would typicallyintroduce an unwieldy number of simultaneous collisions too many

to disentangle Fortunately our previously described signed distanceflow provides a meaningful path taking sF back to F we simplyexactly reverse the motion of the fine mesh restoring it to its originalposition in as many iterations as were taken by the flow As thecoarse mesh moves we detect and respond to would-be intersectionsbetween the expanding fine mesh and the current coarse mesh

We can describe each reverse step in our flow in terms of a displace-ment per time step that is in terms of virtual velocities For ease ofnotation we mirror the trajectories of the fine mesh on the time axisso that time continues to point forward (this means wlog t ldquo 0is the moment when the flow with N steps finishes and t ldquo N∆tis the moment when the fine mesh returns to its original positions)For the fine mesh the positions after the next reverse time step areknown and thus so are its velocities

UF ptq ldquosFpt`∆tq acute sFptq

∆t (7)

where UF ptq P RnFˆ3 are instantaneous per-vertex velocities

The positions of the coarse mesh Cpt`∆tqmdashand in turn its similarlydefined velocities UCptqmdashare not fixed In general there are aninfinite number of feasible choices of UCptq so that the repositionedcoarse mesh Cpt ` ∆tq remains free of intersections with itselfand with the re-inflating fine mesh sF pt `∆tq To regularize thisproblem we introduce a generic energy EpF pCCq measuring thequality of the coarse mesh positions We optimize this energy toupdate C at each reverse time step

minCpt`∆tq

Eacute

F pCCpt`∆tqmacr

subject to (8)

Cpsq does not intersect itself s P rt t`∆ts (9)

Cpsq does not intersect sF psqs P rt t`∆ts (10)

where we are careful to solve the continuous-time collision problemrather than only checking for instantaneous collisions at s ldquo tand s ldquo t `∆t This ensures the re-inflating fine mesh does notcompletely tunnel through some part of the coarse mesh

By reformulating our problem in a manner familiar to physicalsimulation we may leverage state of the art contact detection (eg[Brochu et al 2012 Wang 2014]) and response methods Abstractlywe can treat these methods as ldquoblack boxesrdquo (velocity filters) Weinput the fine mesh sF ptq coarse mesh Cptq and desired velocitiesUF ptq and U˚

Cptq where U˚Cptq is a descent direction minimizing

E The black box outputs new adjusted velocities U`F ptq and U`

Cptqsatisfying the non-intersection constraints 9-10

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Evol Esarap Evarap

Figure 10 For a coarse cage around the Anchor optimizing totalvolume Evol can create zero-volume tents (left inset) but tight fitselsewhere (next inset) surface ARAPEsarap keeps the surface qualitybut loosens the fit volumetric ARAPEvarap balances these two goals

There remains one interesting twist Our problem requires the finemesh to return exactly to its original positions U`

F ptq ldquo UF ptq Inphysically-based simulation parlance this is tantamount to assigningthe fine mesh infinite mass While collision handling is a black boxin theory in practice the many many collisions that occur betweenthe coarse and fine meshes the self-intersecting and degeneratenature of the initial fine mesh and the fact that the moving mesh hasinfinite mass all contribute to a very challenging contact problembeyond the scope of typical cloth and thin shell collision codes Wefound two methods that can solve the problem successfully

First we adapt the surface tracking method of [Brochu amp Bridson2009] to deal better with infinite masses by removing the rigidimpact zone phase (similar adaptations of other methods are probablypossible eg [Volino amp Magnenat-Thalmann 2006 Mueller et al2015])

In cases when this method fails to find a feasible solution we subdi-vide ∆t recursively In particularly difficult cases too many subdivi-sions are needed suggesting failure to progress To handle these hardcases we fall back on a more robust but slower method speculativeasynchronous contact mechanics [Ainsley et al 2012] This methodis an extension of the only known method to guarantee intersectionprevention and positive progress for finite mass objects [Harmonet al 2009] Even this algorithm does not guarantee that the colli-sions can be resolved (in cases where the fine mesh tries to ldquopinchrdquothe coarse mesh no solution can possibly exist see Figure 22) butin practice we see success albeit at a slow pace

Choice of energy We briefly describe the implementations andunique benefits of energies we tested (see Figure 10)

The simplest energies are those measuring vertex displacement in aleast squares sense

Einit ldquo Cpt`∆tq acute pC2C (11)

euml U˚Cptq bdquo pCacuteCpt`∆tq

Estep ldquo Cpt`∆tq acuteCptq2C (12)

euml U˚Cptq bdquo Cptq acuteCpt`∆tq

where Einit and Estep penalize displacement from the coarse meshrsquosinitial positions and from its position at the beginning of the timestep respectively These energies successfully regularize the spaceof feasible solutions but are not representative of energies useful tointeresting applications

For multiresolution hierarchies or collision detection we propose a

volume energy to encourage very tight fitting cages

Evol ldquo

ż

VolpCpt`∆tqq

1 dV ldquo

ż

Cpt`∆tq

x uml n dA (13)

euml U˚Cptq bdquo acutenablaEvol ldquo acuteNpt`∆tq

where N are the area-weighted vertex normals

During re-inflation minimizing Evol immediately starts to shrink-wrap the coarse mesh Cptq around the expanding fine mesh sF ptqIf sF ptq needs to expand a significant amount then this tight shrink-wrap behavior causes unnecessary collisions early in the reverseflow Therefore we propose minimizing Estep for t ą 0 in order tofind a feasible state before switching to Evol only at t ldquo N∆t

The null space of Evol is spanned by all zero-volume meshes disre-garding shape quality or surface area Shape is retained only by thefine mesh as an obstacle In some applications eg low-resolutionconservative contact replacements or deformation cages surfaceappearance or shape-preservation is important We explored surface-based [Sorkine amp Alexa 2007] and volumetric [Chao et al 2010]forms of as-rigid-as-possible energies (aka co-rotational elasticity)

Esarap ldquo

nCyuml

ildquo1

argminRPSOp3q

yuml

jPNpiq

eijpt`∆tq acuteRpeij2 (14)

euml U˚Cptq bdquo acutenablaEsarap

Evarap ldquoyuml

TPTargminRPSOp3q

yuml

tijuPT

eijpt`∆tq acuteRpeij2 (15)

euml U˚Cptq bdquo acutenablaCEvarap

where eijpt ` ∆tq and peij are the edge vectors between verticesi and j of the unknown coarse mesh Cpt ` ∆tq and the originalcoarse mesh pC and T is a list of tetrahedra tessellating pC Weuse TETGEN to create a graded mesh with few auxiliary variables atinternal Steiner vertices [Si 2003] Computing gradients nablaEsarap andnablaEvarap involves first optimizing for ldquobest fit rotationsrdquo R via polardecomposition and then computing a sparse matrix product [Chaoet al 2010] Pure gradient descent of the volumetric ARAP energy isinefficient as the gradient at interior vertices remains zero until theirneighbors move We accelerate minimization of this energy usinga local-global optimization [Sorkine amp Alexa 2007] we updateboundary vertices using gradient descent then optimize for the inte-rior while holding the boundary fixed This converges quickly whengiven an initial guess from the previous gradient computation Inany case our ldquoblack boxrdquo collision handling dominates computationtime so gradient computation is not a bottleneck

We continue to minimize the energy even after the fine mesh hasreturned to its original position until either Cpt`∆tq convergesor until bisecting the step length ∆t does not decrease the energyThe combination of our energy-minimizing re-inflation and signed-distance flow leads to minimal coarse cage expansion (see Figure 9)

Our method is effectively projected gradient descent For simpledisplacement energies higher-order alternatives do not apply Weexperimented with Newtonrsquos method for the ARAP energies butsaw little improvement

4 Results and applications

We implemented a prototype of our method as a serial MATLABprogram We report timings of our unoptimized code for a fewrepresentative examples in Table 1 recorded on an iMac Intel Corei7 35GHz computer with 8GB memory As expected the bottle-neck is the collision-free re-inflation step We experimented with a

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Model name Fig F k tflow tre Energy

SWAT 21 9820 1 5s 269s SymmetryAnchor 11 10778 6 6s 43s Evol

Warrior 11 26658 7 2s 86s Evarap

Pelvis 11 40316 7 11s 460s Evol

Bunny 13 52910 7 11s 202s Evarap

Mug 11 74720 7 7s 54s Evol

Octopus 11 500000 11 13s 63s Estep

Table 1 We report the average time per cage to flow tflow and tore-inflate tre

wide variety of shapes ranging from CAD models characters andscanned objects (see Figure 11) By default we compute layers sothat each coarser layer has 2acute

23 times as many facets as the previousfiner layer a ratio chosen so that resulting tetrahedral meshes willhave approximately 8 times fewer elements For most meshes wecompute seven layers with fewer for lower resolution inputs In oursupplemental material we attach all input models correspondingoutput cages and a small program to visualize volumetric slices

Our method is agnostic to the decimator used to create the inputmeshes xM1 xMk In this way we inherit the feature set of thedecimator Figure 12 compares using the regular mesh inducingdecimator in [CGAL] (default for all remaining examples) and thefeature-adaptive decimator of [Botsch et al 2002]

To test robustness we compare computing nested cages on the Bunnyand the same model corrupted with noise in the normal direction(see Figure 13) The resulting layers tightly hug both shapes

We also conducted stress tests to evaluate how well our method scaleswith the number of layers We nest 25 tightly fitting layers aroundthe Horse in Figure 2 and 50 around Max Planck in Figure 14We purposefully continue nesting cages around the the Gargoyle inFigure 11 top left until only eight vertices of an extremely coarsecage remain

For some applications (eg conservative collision detection) thereis no need for the output cage to be homeomorphic to the inputmesh and indeed preserving tiny handles unnecessarily increasesthe complexity of the cage Our definition of the problem in Section 1allows the cage to have less handles than the input mesh Figure 15illustrates this point where we generate a cage that is homeomorphicto the input mesh and another cage that has smaller genus

Constructing our nested cages can be considered expensive precom-putation for a multiresolution linear system solver However oncecage meshes are computed and their interiors are meshed with tetra-hedra (eg using [Si 2003]) the volumetric multigrid solver is sleekand memory efficient A single multiresolution V-cycle for a Poissonequation with homogeneous Dirichlet boundary conditions insidethe volume of the Octopus with over seven million vertices takes14 seconds using 2GB max memory With 14 more V-cycles thesolution converges for a total time of 21 seconds (see Figure 16) Incontrast MATLABrsquos backslash operator thrashes using over 22GBof memory and finishing in over 16 minutes CHOLMODrsquos Choleskyfactorization with reordering is mildly better than MATLAB solvingvia backsubstitution in 10 minutes but suffers from similar memoryissues during factorization which takes over an hour using 17GBmax memory due to high fill-in In terms of precomputation ourtime consuming cage computation lives at a much earlier stagethan system-matrix factorization before determining constraints orboundary conditions and before even choosing the particular sys-tem being solved This is even true for inhomogeneous systems

Figure 11 Each triplet shows input model slice through all nestedlayers and outermost coarsest layer As a stress test we purpose-fully continue nesting cages around Gargoyle to a very coarse level(top left) The topological holes of the high-genus Fertility are main-tained across all layers (top right) The deep concavity of the Mugdoes not get smoothed away in coarser levels (bottom right)

Regular decimation CGAL Adaptive decimation OPENMESH

Figure 12 By post-processing meshes from any existing decimatorour output inherits desired regularity or adaptivity of the decimation

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Figure 13 Noise added in the normal direction to the input bunnydoes not affect our ability to generate seven quality outer layers

Figure 14 We fit 50 layers tightly around Max Planckrsquos head

Figure 15 Depending on the target application our method gener-ates cages homeomorphic to the input mesh (center) or with handlesremoved (right)

7M tetrahedra vertices Single V-cycle Converged solution

Figure 16 A single multigrid v-cycle takes 14 secs on this 7M-vertex volumetric Poisson equation in the Octopus With 14 moreiterations (21 secs) the residual error matches a direct solverrsquos (11mins back substitution only)

Right-hand side Solutions for increasing diffusion rates

Figure 17 We solve a diffusion equation pλ∆ ` Iqx ldquo b forvarious diffusion rates λ with our nested cages in a volumetricmultiresolution solver (top surface values via Neumann boundaryconditions bottom slice through tet-mesh volumes)

where local metrics vary between solves In this case the internaltet-meshing might need to be recomputed (seconds for Octopus)but our boundary cages can be reused Since all fine mesh verticesare inside coarse-mesh tetrahedra we use linear interpolation forprolongation and its transpose for restriction [Demmel 2004]

10-2

10-4

10-6

10-8

100

naivedecimation

our cages

Residual error

number of v-cycles

As we do not alter the core iterative na-ture of multiresolution we benefit fromits flexibility For example we mayquickly change the diffusion rate in aheat equation solved in the volume ofthe Pelvis (see Figure 17) Factorizationbased solvers in general scrap previ-ous precomputation after such a globalchange to the system matrix Multireso-lution hardly notices and previous solu-tions become warm starts We employ Neumann boundary condi-tions and notice that naively decimating the input mesh leads to adivergent solver (inset) agreeing with previous analysis that nestingis important for such boundary conditions [Chan et al 1999] Be-cause naive decimations do not nest the prolongation operator mustextrapolate for fine mesh vertices lying outside the coarse domainIt may be possible to tweak extrapolation parameters to handle thesecases with naive decimation but an automatic method for correctingextrapolation for convergence is not obvious For comparisons wetried linear extrapolation from the nearest tet constant interpolationof nearest vertex linear interpolation at the closest point on nearestface We compare to the most favorable choice

On less challenging domains naive decimations can be used butmay require many relaxation (aka smoothing) iterations on eachlevel of each v-cycle In Figure 18 we compute smooth geodesicsvia two Poisson equations in the volume of the Armadillo [Craneet al 2013] Using our nested cages the multiresolution solverconverges independent of the number of relaxation iterations used(typically fewer relaxation iterations and more v-cycles is preferable)In contrast multiresolution using naive non-nested decimations con-verge when using a large number of relaxation iterations and thenat a rate equivalent to single relaxation iteration with our meshes

A single enclosing cage is useful for creating a lower dimensionalvolumetric domain for elastic simulation of an input model that is ei-ther too high resolution or too complex due to meshing imperfections[Xu amp Barbic 2014] In Figure 19 we compare to extracting the

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

100

10-5

10-10

10-15

105

1010

1015

naive

oursnumber of v-cycles

1 5 10

15

20

151020

15

Solution Relative residual error number of relaxtion iterations

Figure 18 We solve for smooth geodesics over a volumetric tetra-hedral mesh inside the Armadillo Using naive overlapping andshrinking decimations leads to divergence unless a very large num-ber of relaxation iterations is used Ours is always convergent

[Jacobson et al 2013] [Xu amp Barbic 2014] Ours

Simulation on our coarse cage with embedded artifact-ridden input

Figure 19 Extracting an outer hull with Jacobson et al [2013]fails to coarsen the domain (top left) Contouring a distance fieldachieves nesting at a large iso-level but fuses the legs (top center)Our coarse cage fits the input tightly and provides a reduced domainfor real-time physics

outer hull of the multi-component and self-intersecting Frankensteinusing [Jacobson et al 2013] While technically a ldquoperfectly tight fitrdquothis cage fails to coarsen the domain and meshing near intersectionscreates sliver triangles problematic for numerics We also compareto signed-distance field contouring [Xu amp Barbic 2014] which cre-ates a loose fit joining the legs near the knees With the same vertexcount our cage is a tight fit making it especially suitable for elasticsimulation with collision handling The deformation of the volumeinside the coarse cage is then propagated via linear interpolation tothe embedded mesh (see also accompanying video)

Another application area for nested cages is collision detection forrigid objects if an object does not collide against a surface enclosinga second object this certifies that the two objects do not collide eitherBounding sphere cubes and higher-degree polytopes are often usedto quick-reject candidate collisions for this reason but these convexcages lose effectiveness when objects are concave or have holes andcavities On the other hand a coarse nested cage is ideal for this pur-pose since the nesting property guarantees correctness and the tightfit allows the coarse cage to efficiently reject nearly all false positivesduring collision detection As a proof of concept we simulated drop-ping eighteen instances of the octopus mesh (Figure 11 bottom-left)one by one into a narrow tank where they collide with each other andthe tank walls (with coefficient of restitution 099) using continuous-time collision detection (see inset) We compared the performanceof two different broad phase strategies for collision detection

Figure 20 Left to right a quad mesh is quickly sketched atop theHand and our pipeline moves it outside the input while planarizingquads A cage-based deformation is applied via harmonic coordi-nates computed over the volume inside the planar-quad polyhedron(a few coordinates visualized in pseudocolor) These weights aresmooth inside each quad In contrast triangulating the quads wouldlead to non-smooth meshing-dependent values in each quad (twoalternative triangulations)

in the first bounding cubes around sweptspacetime volumes are used to prunedistant pairs of objects from consider-ation then kDOP bounding volume hi-erarchies are built to find candidate col-liding vertex-face pairs which are thenpassed to the continuous-time narrowphase The second strategy is the sameexcept that we first check if the octopusrsquoscoarse cage is colliding before buildingthe BVH on the octopus itself We foundthat the latter strategy is bdquo 8ˆ fasterfor intuitive reasons the octopusrsquos manyprotruding arms causes it to easily nestlenear other copies of itself so that theirconvex hulls overlap but our tight coarsecages do not Nesting is applicable forrigid or nearly rigid objects but it is notobvious how to track cages along withdeformable bodies unless for exampledeformations could be precomputed

The ability to customize our optimization energy enables not justbetter cages but also better generalized barycentric coordinates Inparticular harmonic coordinates are defined for arbitrary polyhedrayet most works implement them inside triangle-mesh cages only[Joshi et al 2007] To utilize popular quad-dominant meshes ascages all faces must be outside the input model and planar Sincesuch cages are difficult to model manually many implementationssimply triangulate high-order facets [Joshi et al 2007] We comple-ment the recent sketch-based quad-meshing tool [Takayama et al2013] post-processing its output to enclose the input model and min-imize a planarization energy [Poranne et al 2013] Quad-dominantcages are easier to control as their visualization is less cluttered (seeFigure 20) More importantly harmonic coordinates constructed(via their recursive definition) on the planar-quad polyhedron arealso higher quality coordinates are smooth functions inside eachquad In contrast coordinates of a triangulated cage would dependheavily on the choice of diagonals splitting each quad

Generalizations beyond watertight meshes Though notstrictly meeting our input criteria we apply our method to poly-gon soups In Figure 21 we again adapt the optimization energythis time to maintain the reflectional symmetry of the coarse inputcage The input polygon soup SWAT man is riddled with meshingartifacts but we still flow it inside Though details on the expandinginput mesh are asymmetric (see hip pockets or hands) the energyminimization keeps the cage symmetric

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

Overlapping cage Enclosing cageFlow Deformation

Figure 21 SWAT man is a polygon soup with 2806 intersectingtriangle pairs 24 non-manifold edges 51 boundary loops and 51components Our shrinking flow is robust to such artifacts Once in-side the coarse overlapping input cage we re-inflate it and producea fully exterior cage used to deform the embedded model

Figure 22 If an expanding coarse mesh collides with itself (green)it creates a pinch preventing processing of further coarser layers

5 Limitations and future work

We plan to optimize the performance of both the signed distancefield flow and the re-inflation steps Collision detection and responsedominates running time and our prototype naively recomputes ac-celeration data-structures rather than updating them continuously

Our insight to break the multi-layer nesting problem into pairwisesubproblems ensures tractability but in some cases leads to con-verging at an ldquoartificial local minimumrdquo If a coarse cage collideswith itself during inflation then it may create a pinch that blocksinflation of subsequent coarse layers (see Figure 22) One solutionis to iterate through the fine layers to make sufficient room in theseproblem areas but defining this relaxation direction is not obvious

In cases where the input coarse cage begins too far away from thefine mesh the signed-distance flow will fail for example by flowingvertices of a triangle into opposite parts of the coarse mesh Addinga small amount of smoothing on the flowing fine mesh or expandingthe coarse mesh alleviates some of these problems but a generalsolution is elusive The correct assignment seems related to correctlymatching medial axes of both meshes perhaps an avenue of futureimprovement

We believe the performance of our multigrid solver could be furtherimproved by parameter tuning and experimenting with differentcoarsening gradations We would also like to consider using ourmeshes to build multigrid preconditioners for conjugate gradientsolvers We expect that higher order PDEs with more involvedboundary conditions will receive an even greater benefit from ournested cages

It would be interesting to analyze formally the convergence of ournested cages along the lines of [Chan amp Zou 1996] who consider thethen-available non-nested hierarchies

Our cages are designed for volumetric multigrid solvers and are notimmediately applicable to surface-based multiresolution problems(cf [Aksoylu et al 2005 Chuang et al 2009]) Whether nesting isat all useful for surface problems remains an open question

In conclusion nested cages prove to be a powerful tool in a varietyof applications Our signed-distance flow consistently finds initialfeasible states for our constraint-based optimization By leverag-ing state-of-the-art collision handling tools from physically basedsimulation we are able to generate cages that in turn enable fasterphysical simulations more-efficient linear system solvers and betterreal-time deformation user interfaces We hope that our algorithmrsquossuccess encourages more multiresolution volumetric methods usingunstructured meshes in geometry processing computer graphicsand beyond

Acknowledgements

Humanoid models courtesy Ilya Baran were initially created usingCosmic Blobs(R) software developed by Dassault Systegravemes Solid-Works Corp Medical models courtesy of Muhibur Rasheed Wethank Derek Bradley Keenan Crane Eitan Grinspun and DanielePanozzo for illuminating discussions Eric Price for brainstormingthe NP completeness proof Henrique Maia Papoj Thamjaroenpornand Sarah Abraham for proofreading and Peter Schroeder RichardKenyon Alexander I Bobenko Helmut Pottmann and JohannesWallner for organizing the DDG Oberwolfach and Seggau Geometryworkshops The Columbia Computer Graphics Group is supportedby the NSF Intel The Walt Disney Company and Autodesk Fundedin part by NSF grant DMS-1304211 We thank the Visgraf Lab andIMPA for the technical support and software resources CNPq forthe first authorrsquos PhD fellowship and CAPES and FAPESC forsupporting the presentation of this work at SIGGRAPH Asia 2015

References

ADAMS M AND DEMMEL J W 1999 Parallel multigrid solverfor 3d unstructured finite element problems In Proceedings ofthe 1999 ACMIEEE Conference on Supercomputing

AINSLEY S VOUGA E GRINSPUN E AND TAMSTORF R2012 Speculative parallel asynchronous contact mechanics ACMTrans Graph 31 6

AKSOYLU B KHODAKOVSKY A AND SCHROumlDER P 2005Multilevel Solvers for Unstructured Surface Meshes SIAM Jour-nal on Scientific Computing 26 4 1146

ATTENE M 2010 A lightweight approach to repairing digitizedpolygon meshes The Visual Computer 26 11 1393ndash1406

AU O K-C TAI C-L CHU H-K COHEN-OR D ANDLEE T-Y 2008 Skeleton extraction by mesh contraction ACMTrans Graph 27 3

BAERENTZEN J A AND AANAES H 2005 Signed distancecomputation using the angle weighted pseudonormal Trans Visamp Comp Graphics 11 3 (May)

BARAFF D WITKIN A AND KASS M 2003 Untangling clothACM Trans Graph 22

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Spatialdeformation transfer In Proc SCA 67ndash74

BEN-CHEN M WEBER O AND GOTSMAN C 2009 Varia-tional harmonic maps for space deformation ACM Trans Graph28 3

BOTSCH M STEINBERG S BISCHOFF S AND KOBBELT L2002 OpenMesh ndash a generic and efficient polygon mesh datastructure In OpenSG Symposium

BROCHU T AND BRIDSON R 2009 Robust topological opera-tions for dynamic explicit surfaces SIAM Sci Comp 31 4

BROCHU T EDWARDS E AND BRIDSON R 2012 Efficientgeometrically exact continuous collision detection ACM TransGraph 31 4

BRUNE P R KNEPLEY M G AND SCOTT L R 2011 Un-structured geometric multigrid in two and three dimensions oncomplex and graded meshes CoRR abs11040261

CAMPEN M AND KOBBELT L 2010 Polygonal BoundaryEvaluation of Minkowski Sums and Swept Volumes ComputGraph Forum 29 5 1613ndash1622

CGAL Computational Geometry Algorithms Libraryhttpwwwcgalorg

CHAN T F AND WAN W 2000 Robust multigrid methods fornonsmooth coefficient elliptic linear systems J Comput ApplMath 123 1-2

CHAN T F AND ZOU J 1996 A convergence theory of multi-level additive schwarz methods on unstructured meshes Numeri-cal Algorithms 13 2 365ndash398

CHAN T F SMITH B AND ZOU J 1996 Overlapping schwarzmethods on unstructured meshes using non-matching coarse gridsNumer Math 73 149ndash167

CHAN T F GO S AND ZOU J 1999 Boundary treatmentsfor multilevel methods on unstructured meshes SIAM Journal onScientific Computing 21 1 46ndash66

CHANG W LI H MITRA N J PAULY M AND WANDM 2010 Geometric registration for deformable shapes InEurographics 2010 Tutorial Notes

CHAO I PINKALL U SANAN P AND SCHROumlDER P 2010A simple geometric model for elastic deformations ACM TransGraph 29 4

CHUANG M LUO L BROWN B J RUSINKIEWICZ S ANDKAZHDAN M 2009 Estimating the laplace-beltrami operatorby restricting 3d functions In Proc SGP 1475ndash1484

CRANE K PINKALL U AND SCHROumlDER P 2013 Robustfairing via conformal curvature flow ACM Trans Graph 32 4

DEBUNNE G DESBRUN M CANI M-P AND BARR A H2001 Dynamic real-time deformations using space amp time adap-tive sampling Proceedings of SIGGRAPH 2001 31ndash36

DEMMEL J 2004 Multigrid overview httpwwwcsberkeleyedu~demmel

DENG Z-J LUO X-N AND MIAO X-P 2011 Automaticcage building with quadric error metrics Comp Sci amp Tech 263

DESBRUN M MEYER M SCHROumlDER P AND BARR A H1999 Implicit fairing of irregular meshes using diffusion andcurvature flow In Proccedings of ACM SIGGRAPH 317ndash324

DICK C GEORGII J AND WESTERMANN R 2011 A hexahe-dral multigrid approach for simulating cuts in deformable objectsTrans Vis amp Comp Graphics 17 11

DICKOPF T 2010 Multilevel methods based on non-nested meshesPhD thesis Universitaumlt Bonn

EPPSTEIN D 2015 When is it possible to ldquoshrinkrdquo a polyhedronMathOverflow httpmathoverflownetq206750(version 2015-05-16)

FALGOUT R 2006 An introduction to algebraic multigrid comput-ing Computing in Science Engineering (Nov)

FENG Y PERIC D AND OWEN D 1997 A non-nested galerkinmulti-grid method for solving linear and nonlinear solid mechan-ics problems Comp methods in applied mech amp eng 144 3

FERSTL F WESTERMANN R AND DICK C 2014 Large-scaleliquid simulation on adaptive hexahedral grids Trans Vis ampComp Graphics 20 10

FISH J PANDHEERADI M AND BELSKY V 1995 An efficientmultilevel solution scheme for large scale non-linear systems IntJournal for Numerical Methods in Eng 38 10 1597ndash1610

GARLAND M AND HECKBERT P S 1997 Surface simplificationusing quadric error metrics In Proc SIGGRAPH

GUILLARD H 1993 Node-nested multi-grid method with Delau-nay coarsening Research Report RR-1898

GUMHOLD S BORODIN P AND KLEIN R 2003 Intersectionfree simplification IJSM 155ndash176

HARMON D VOUGA E SMITH B TAMSTORF R ANDGRINSPUN E 2009 Asynchronous contact mechanics ACMTrans Graph 28 3

HARMON D PANOZZO D SORKINE O AND ZORIN D 2011Interference aware geometric modeling ACM Trans Graph 306

HOPPE H 1996 Progressive meshes In Proc SIGGRAPH

JACOBSON A KAVAN L AND SORKINE-HORNUNG O 2013Robust inside-outside segmentation using generalized windingnumbers ACM Trans Graph 32 4

JOSHI P MEYER M DEROSE T GREEN B AND SANOCKIT 2007 Harmonic coordinates for character articulation ACMTrans Graph 26 3 71

KAZHDAN M BOLITHO M AND HOPPE H 2006 Poissonsurface reconstruction In Proc SGP 61ndash70

KAZHDAN M SOLOMON J AND BEN-CHEN M 2012 Canmean-curvature flow be modified to be non-singular ComputGraph Forum 31 5

KRISHNAN D FATTAL R AND SZELISKI R 2013 Effi-cient preconditioning of laplacian matrices for computer graphicsACM Trans Graph 32 4

MCADAMS A ZHU Y SELLE A EMPEY M TAMSTORFR TERAN J AND SIFAKIS E 2011 Efficient elasticityfor character skinning with contact and collisions ACM TransGraph 30 (Aug) 371ndash3712

MEHRA R ZHOU Q LONG J SHEFFER A GOOCH AAND MITRA N J 2009 Abstraction of man-made shapes ACMTrans Graph 28 5

MELAX S 1998 A simple fast and effective polygon reductionalgorithm Game Developer Magazine 44ndash49

MUELLER M CHENTANEZ N KIM T-Y AND MACKLINM 2015 Air meshes for robust collision handling ACM TransGraph 34 4

NESME M KRY P G JERAacuteBKOVAacute L AND FAURE F 2009Preserving topology and elasticity for embedded deformable mod-els ACM Trans Graph 28 3

OTADUY M A AND LIN M C 2003 CLODs Dual hierarchiesfor multiresolution collision detection In Proc SGP

OTADUY M A AND LIN M C 2003 Sensation preservingsimplification for haptic rendering ACM Trans Graph 22

PENG J KRISTJANSSON D AND ZORIN D 2004 Interactivemodeling of topologically complex geometric detail ACM TransGraph 23 3 635ndash643

PETERHANS C 2012 Interactive Surface Reconstruction Masterrsquosthesis ETH Zurich

PLATIS N AND THEOHARIS T 2003 Progressive hulls forintersection applications Comput Graph Forum 22 2

PORANNE R OVREIU E AND GOTSMAN C 2013 Interactiveplanarization and optimization of 3d meshes In Comput GraphForum vol 32 152ndash163

RUGE J AND STUumlBEN K 1987 Algebraic multigrid Multigridmethods 3

SACHT L JACOBSON A PANOZZO D SCHUumlLLER C ANDSORKINE-HORNUNG O 2013 Consistent volumetric discretiza-tions inside self-intersecting surfaces In Proc SGP

SANDER P V GU X GORTLER S J HOPPE H AND SNY-DER J 2000 Silhouette clipping In Proc SIGGRAPH

SHEN C OrsquoBRIEN J F AND SHEWCHUK J R 2004 Inter-polating and approximating implicit surfaces from polygon soupACM Trans Graph 23 3 896ndash904

SI H 2003 TETGEN A 3D delaunay tetrahedral mesh generatorhttptetgenberliosde

SORKINE O AND ALEXA M 2007 As-rigid-as-possible surfacemodeling In Proc SGP 109ndash116

SYacuteKORA D DINGLIANA J AND COLLINS S 2009 As-rigid-as-possible image registration for hand-drawn cartoon animationsIn Proc NPAR

TAGLIASACCHI A ALHASHIM I OLSON M AND ZHANG H2012 Mean curvature skeletons Comput Graph Forum 31 5

TAKAYAMA K PANOZZO D SORKINE-HORNUNG A ANDSORKINE-HORNUNG O 2013 Sketch-based generation andediting of quad meshes ACM Trans Graph 32 4

TAUBIN G 1995 A signal processing approach to fair surfacedesign In Proceedings of ACM SIGGRAPH 351ndash358

TERAN J SIFAKIS E BLEMKER S S NG-THOW-HING VLAU C AND FEDKIW R 2005 Creating and simulatingskeletal muscle from the visible human data set Trans Vis ampComp Graphics 11 3

VOLINO P AND MAGNENAT-THALMANN N 2006 Resolv-ing surface collisions through intersection contour minimizationACM Trans Graph 25 3

VOUGA E SACHT L AND JACOBSON A 2015 Polyhedralnesting is NP-complete Tech rep in supplementary materials

WANG Y-S AND LEE T-Y 2008 Curve-skeleton extractionusing iterative least squares optimization Trans Vis amp CompGraphics 14 4

WANG H SIDOROV K A SANDILANDS P AND KOMURA T2013 Harmonic parameterization by electrostatics ACM TransGraph 32 5

WANG H 2014 Defending continuous collision detection againsterrors ACM Trans Graph 33 4

WICKER M LANKER H AND GROSS M 2006 Untanglingcloth with boundaries In Proc VMV

XIAN C LIN H AND GAO S 2009 Automatic generation ofcoarse bounding cages from dense meshes In Proc SMA

XIAN C LIN H AND GAO S 2012 Automatic cage generationby improved OBBs for mesh deformation The Visual Computer

XIAN C ZHANG T AND GAO S 2013 Semantic cage genera-tion for fe mesh editing In CADG

XIAN C LI G AND XIONG Y 2015 Efficient and effectivecage generation by region decomposition Computer Animationand Virtual Worlds 26 2 173ndash184

XU H AND BARBIC J 2014 Signed distance fields for polygonsoup meshes Graphics Interface 2014

YE J AND ZHAO J 2012 The intersection contour minimizationmethod for untangling oriented deformable surfaces In ProcSCA

Appendix A Flow counterexample

There exist polyhedra that cannot be continuously flowed insidethemselves [Eppstein 2015] Consider the surface constructed inFigure 23 right Though inward pointing normals can be defined atall vertices any non-negative (even infinitesimal) inward movementof the vertices will introduce ldquoedge-edgerdquo collisions with the originalsurface To see this consider the set of points inside the polyhedronthat can be seen by the central vertex c of the star This set changesdiscontinuously for any motion of c no matter which direction ischosen to flow c there exists some neighbor n such that c loses sightof not only n but also an entire neighborhood around n Thereforethere exists no inward flow of all of the vertices where c maintainssight with all of its neighbors

Figure 23 Take every other vertex around the star surface on the leftand rotate it about the origin to create the ldquoorigami pinwheelrdquo onthe right Vertices of this new surface cannot be continuously flowedinward without creating intersections with the original surface

Appendix B Pseudocode

Algorithm 2 Shrinkp pCF q Ntilde H

InputspC Initial coarse mesh (will remain constant)F Initial fine mesh (possibly overlapping with pC)

OutputsH Fine mesh history H ETH tsFp0q sFp∆tq sFpN∆tqu

beginH ETH tF u Initialize history with input fine meshwhile pC does not nest H last do

nablaΦ ETH 0 Initialize gradients to zerofor each quadrature point spi on H last do

qETH closest point to spi on pC

sETH

1 if spi is outside pCacute1 otherwise

Distance sign

if spi acute q ą 1e-5 thengETH spspi acute qqspi acute q

else If too close use normal [Baerentzen amp Aanaes2005] gETH npqq

for each vertex j in H last do wi is the weight of the quadrature point andλij is the hat function of vertex j evaluated atquadrature point spi nablaΦpjq ETH Φpjq ` wiλijg

∆tETH 1e-3 Default time stepH pushpH lastacute∆t umlnablaΦ )

Algorithm 3 ReinflatepH pCEnergyq Ntilde C

InputsH Fine mesh history H ETH tsFp0q sFp∆tq sFpN∆tqupC Initial coarse meshEnergy Function object for re-inflation energy and gradient

OutputsC Final nested cage

beginF0 ETH H first Initial fine meshF ETH H pop Shrunken fine meshC ETH pC Initialize output cagewhile H is not empty do

β ETH βinitp ldquo 1e-2q Initial step sizeEmin ETH8 Initial minimum energyUF ETH H popacute F Desired velocities for fine meshrepeat

UC ETH acuteβ nablaEnergypF0 C pCq mdashmdash coarse mesh Filter velocities eg modified [Brochu amp Bridson2009] or [Ainsley et al 2012] UC ETH FilterpFUF CUCq

if EnergypC `UCq ą Emin thenβ ETH β2 Decrease step sizeif β ă βminp ldquo 1e-3q then break No progress

elseC ETH C `UC Step coarse meshEmin ETH EnergypCq Update energyβ ETH 11β Slightly increase step size

if UC ă ∆Cpldquo 1e-5q then break ConvergedF ETH F `UF Step fine mesh