active animations of reduced deformable models with ...gamma.cs.unc.edu/activeanim/final.pdfgenerate...
Post on 06-Oct-2020
4 Views
Preview:
TRANSCRIPT
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
Active Animations of Reduced Deformable Models with EnvironmentInteractions
ZHERONG PAN, University of North Carolina at Chapel HillDINESH MANOCHA, University of North Carolina at Chapel Hill
(a) (b) (c)
Fig. 1. Active deformable animations automatically generated by our approach: A letter T jumping (a), a spider walking (b), and a fish swimming (c). Thereduced configuration spaces of these deformable bodies have 5 − 15 DOFs. We present an efficient spacetime optimization formulation that takes intoaccount physics constraints and environmental interactions.
We present an efficient spacetime optimization method to automaticallygenerate animations for a general volumetric, elastically deformable body.Our approach can model the interactions between the body and the environ-ment and automatically generate active animations. We model the frictionalcontact forces using contact invariant optimization and the fluid drag forcesusing a simplified model. To handle complex objects, we use a reduced de-formable model and present a novel hybrid optimizer to search for the localminima efficiently. This allows us to use long-horizon motion planning toautomatically generate animations such as walking, jumping, swimming,and rolling. We evaluate the approach on different shapes and animations,including deformable body navigation and combining with an open-loopcontroller for realtime forward simulation.
CCS Concepts: • Computing methodologies → Physical simulation;
Additional Key Words and Phrases: deformable body, optimal control, loco-motion
ACM Reference format:Zherong Pan and Dinesh Manocha. 2017. Active Animations of ReducedDeformable Models with Environment Interactions. ACM Trans. Graph. 1, 1,Article 1 (January 2017), 17 pages.https://doi.org/10.1145/nnnnnnn.nnnnnnn
1 INTRODUCTIONPhysically-based deformable animation is a well-studied problem incomputer graphics and related areas. Early methods such as [Müllerand Gross 2004; Terzopoulos et al. 1987] focus on passive anima-tions using numerical simulations. These techniques are widely usedto generate plausible simulations of clothes [Bridson et al. 2002],plants [Barbič and Zhao 2011], human tissues [Chentanez et al.
Permission to make digital or hard copies of all or part of this work for personal orclassroom use is granted without fee provided that copies are not made or distributedfor profit or commercial advantage and that copies bear this notice and the full citationon the first page. Copyrights for components of this work owned by others than ACMmust be honored. Abstracting with credit is permitted. To copy otherwise, or republish,to post on servers or to redistribute to lists, requires prior specific permission and/or afee. Request permissions from permissions@acm.org.© 2017 Association for Computing Machinery.0730-0301/2017/1-ART1 $15.00https://doi.org/10.1145/nnnnnnn.nnnnnnn
2009], etc. Such passive animations are frequently used in moviesand games to increase the realism. On the other hand, generatingcontrolled or active deformable body animations [Coros et al. 2012;Kim and Pollard 2011; Tan et al. 2012] is considered more challeng-ing, especially when a deformable body’s movements are governedby physics-based constraints. In such cases, additional control in-puts, such as keyframes or rest shapes, need to be determined basedon a deformable body’s interactions with the environment in orderto generate the animation. This can be computationally challengingfor deformable bodies with a high number of degrees of freedom(DOFs). To simplify the problem, previous methods [Hahn et al. 2012;Harmon and Zorin 2013; Kim and James 2011; Liu et al. 2013; Xu andBarbič 2016] partition the deformable body’s DOFs into controlledDOFs and uncontrolled DOFs. In practice, prior techniques specifythe trajectories of controlled DOFs using manual keyframes anduse physics-based simulation algorithms to generate movementscorresponding to uncontrolled DOFs, i.e., the secondary dynamics.Such techniques are widely used for physical character rigging. Ingeneral, it is hard to generate controlled deformable body anima-tions without user intervention or specifications. The animators notonly need to manually partition the DOFs into controlled DOFs andthe uncontrolled DOFs, but they also need to specify the movementsof the controlled DOFs.
Main Results: We present a new method for active deformablebody animations. The input to our method is a volumetric meshrepresentation of the body, a specification of the environment, anda high-level objective function that is used to govern the object’smovement. Our algorithm can automatically compute active an-imations of the deformable body and can generate motions cor-responding to walking, jumping, swimming, or rolling, as shownin Figure 1. We compute the animations using a novel spacetimeoptimization algorithm and formulate the objective function takinginto account dynamics constraints as well as various interactionswith the environment. These include collisions, frictional contactforces and fluid drag forces. Compared with keyframe-based meth-ods, we use objective functions to control the animation. In practice,
2018-03-17 02:32 page 1 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
1:2 • Pan, et al
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
these objective functions are more general and easier for the user tospecify. For example, to generate walking animation, user can justspecify the target walking speed, instead of manually specifying thewalking poses corresponding to different timesteps. Furthermore,our approach can be easily combined with partial keyframe data toprovide more user control.Some of the novel components of our work include:• A spacetime optimization formulation based on reduced de-formable models (Section 4), that takes into account environ-ment interactions.• A hybrid spacetime optimization algorithm (Section 5), whichis more than an order of magnitude faster than previousspacetime optimization methods.• We combine our spacetime optimization algorithm with dy-namic movement primitives (DMP), which have been usedin robotics [Schaal 2006]. DMP improves the performanceof our algorithm in terms of avoiding suboptimal solutions.Furthermore, we present a two-stage animation framework.During the first stage, we compute the animation trajectoriesusing DMP as a prior. These animations are then tracked andcomposed together at realtime using DMP as a controller(Section 6).
We demonstrate the benefits of our method by evaluating its per-formance on different complex deformable bodies with thousands ofvertices and 5 − 15 DOFs in different environments (Section 6). Forunderwater swimming, we use DMP as an open-loop controller togenerate realtime swimming animations (Figure 12). For contact-richlocomotion, the optimized animations are tracked at realtime usinga feedback controller (Figure 19). Finally, we formulate keyframe-based control as a special case of our method and show animationscontrolled using partial keyframes and high-level control objectives(Figure 18).
2 RELATED WORKOur work is inspired by prior work on passive/active deformablebody animations and model reduction. In this section, we give abrief overview of related work.Passive Deformable Body Animation has been an active area
of research for more than three decades. The most popular de-formable model, especially for deformable bodies without skeletons,is the finite element method (FEM) [Irving et al. 2006; Terzopou-los et al. 1987]. These methods of deformable body modeling havecomputational complexity that is superlinear in the number of dis-crete elements, and they therefore are not suitable for interactiveapplications. Many deformable bodies such as human bodies andanimals have embedded rigid skeletons. Robust methods such as[Capell et al. 2002; Hahn et al. 2012; Kim and Pollard 2011] havebeen proposed to model skeletons’ interactions with soft tissues. Inthis paper, we use FEM to model a deformable body.Active Deformable Body Animation is used by animators or
artists to direct the animation while satisfying the physics-basedconstraints. Early works in this area [Barbič et al. 2009, 2012; Bergouet al. 2007; Schulz et al. 2014] try to make the deformable body followa user-provided animation by applying external forces. However,deformable bodies in real life, such as worms, snakes, and fishes,
can only move themselves by generating internal forces. To respectthis property, [Coros et al. 2012; Kim and Pollard 2011; Tan et al.2012] control virtual deformable bodies to follow a given animationby applying internal forces only. Our work can be considered ascomplimentary to these methods. We generate animations that canbe used as input to these previous methods, with a focus on reduceddeformable models. Deformable body control methods can also becategorized based on the underlying user interfaces: [Barbič et al.2009, 2012; Bergou et al. 2007; Kim and Pollard 2011; Schulz et al.2014] require the user to specify a set of spacetime keyframes, while[Coros et al. 2012; Tan et al. 2012] and our approach specify thegoals for controlling the animation using objective functions. Wefurther show that conventional keyframe-based user-interface canbe incorporated into our system using additional objective functions.
SpacetimeOptimizationMany techniques for deformable bodyanimations are based on spacetime optimization [Witkin and Kass1988]. Solving these optimization problems can be challenging dueto the high-dimensional search space. Some algorithms param-eterize the search space using low-dimensional representationssuch as splines [Hildebrandt et al. 2012] and functional spaces[Mukadam et al. 2016]. Another challenging issue is handling ofnon-smoothness constraints in the optimization formulation, due toenvironment interactions corresponding to collisions and contacts.Previous work either use sampling-based methods [Xu and Bar-bič 2016], complementarity constrained optimizations [Peng et al.2017], or a smooth variant of the contact model [Mordatch et al.2012, 2013]. In our work, we handle the high-dimensionality usingreduced deformable models. We optimize the environmental forcesby using or developing smooth variants of contact and fluid dragforce models. Finally, we solve the optimization problem using ahybrid method.
Model Reduction is a practical method for fast deformable bodysimulations. It is based on the observation that only visually salientdeformations need to be modeled. The earliest reduced model isbased on Linear Modal Analysis (LMA) [Hauser et al. 2003; Pentlandand Williams 1989], which is only accurate for infinitesimal defor-mations. Methods for non-linear and large deformations have beenproposed in [An et al. 2008; Barbič and James 2005; Choi and Ko2005]. In this paper, we use the rotation-strain space dynamic model[Pan et al. 2015] because it can preserve the key characteristics ofdeformable bodies with a lower-dimensional configuration spacerepresentation. However, our method can also be used with otherreduced dynamic models.
3 PROBLEM FORMULATIONIn this section, we formulate the problem of generating deformablebody animation as a spacetime optimization. Our method searchesin the space of deformable body animations with a fixed number ofKtimesteps. We denote an animation trajectory as: QK =
(q1 · · · qK
),
where each state vector qi uniquely determines the position of adeformable body at time instance i∆t , where ∆t is a fixed timestepsize.
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 2 (pp. 1-17)
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
Active Animations of Reduced Deformable Models with Environment Interactions • 1:3
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
v j (0)
u
c
w
v j (q)(a)
(b) (c) (d)
Fig. 2. The deformable body is represented as a triangle mesh (a). With adeformation bases set (b), its position is parameterized by local deforma-tion u , a global rigid translation c (c), and rotation w (d). The Euclideancoordinates of jth vertex v j (blue dot) can be recovered by transformationfunction v j (q).
3.1 Input & OutputIn Section 5, we present an efficient optimizer to robustly search forthe animation trajectory QK by solving the following problem:
argminQK ,F,E
E(QK ,F , E),
where, besides the animation trajectory QK , we also search for theinternal forces (F ) and external forces (E ) on the deformable bodyat every time instance. Our overall algorithm takes the followingcomponents as an input:• A volumetric mesh representation of the deformable bodywith V vertices
(v1 · · · vV
).
• A specification of the environment, including type of theenvironment (in water, or on the ground) and parametersof the environment (e.g., drag force coefficient in water, orcontact friction coefficient on the ground).• The form of high level objective Eobj and its parameters. Forexample, in order for a deformable body to walk to a tar-get position, Eobj will penalize the distance between currentcenter of mass c and the target position, and its parameterscorrespond to the target position’s coordinates.
3.2 Objective Function for Spacetime OptimizationBy spacetime optimization, we assume that the desired deformablebody animation corresponds to the local minima of an objectivefunction. As a result, this objective function must encode all therequirements for a physically correct and plausible deformable bodyanimation. We model these requirements by taking four differentenergy terms into account in E(QK ):
E(QK ) = Ephys + Eobj + Eenv + Ehint. (1)As outlined in Figure 3, the first term Ephys models all the shapechanges that occur within the deformable body, i.e., the dynamicsthat result from the internal forces. It penalizes any violation in thedeformable body’s equation of motion (Section 4.1.1) and any colli-sions between different parts of the deformable body (Section 4.1.2).The second term Eobj is a task-dependent objective function spec-ified by user (see Section 3.1). The environmental force term Eenv(Section 4.2) models all the dynamic interactions between the de-formable object and the environment, i.e. due to the external forces.It also penalizes any violation in the constraints that the environ-mental forces, such as frictional contact forces, must satisfy. Finally,
obj
envhint
phys
Fig. 3. We highlight various components used in our spacetime optimizationalgorithm that can also be used for animation tracking and controlledforward animation.
the last term Ehint (Section 4.3) guides the optimizer to avoid localminima that may result in less plausible animations.
3.3 Configuration Space ParametrizationAlthough our method can work with any parametrization of thedeformable body’s configuration q, different parametrizations re-sult in drastically different computational cost. A straightforwardmethod is to use volumetric meshes with V vertices
(v1 · · · vV
)and define q as all the vertices’ Euclidean coordinates. In this case,the dimension of the configuration space, |q |, scales linearly withthe number of vertices and may be several thousands for moder-ately complex deformable models. Using optimization algorithms insuch a large search space is only practical for very short animations.Indeed, [Bergou et al. 2007; Tan et al. 2012] used this vertex-basedparametrization for tracking deformable body animation in a frame-by-frame manner, i.e., K = 1.Instead, we represent the configuration of a deformable body
using a rigid-coupled reduced model defined as:q =
(u c w
)T, (2)
whereu parametrizes the deformable body’s non-rigid deformationsin its local frame of reference. This is complemented with a rigidtransformation in the world coordinates parametrized using a globaltranslation c and rotation w , as illustrated in Figure 2. By using aprecomputed dataset of deformation bases, the dimension of localdeformation |u | in Equation 2 is usually no more than 20. Moreover,methods such as cubature approximation [An et al. 2008] and fastsandwich transform (FST) [Kim and James 2011] can be used toefficiently recover a vertex v j ’s Euclidean coordinates using thetransformation function v j (q). This transformation function cantake a different form depending on the underlying reduced dynamicmodels. We refer readers to Section 6.2 for more analysis in terms ofcombining our method with different reduced dynamic models. Awidely-known model is the reduced StVK [Barbič and James 2005].Instead, we use the recently proposed rotation-strain (RS) space dy-namic model [Pan et al. 2015] because it achieves comparable resultswith a lower-dimensional configuration space, i.e., a smaller |u |. Weprovide the details about the computation of v(q) in Appendix C .We denote the reconstructed Euclidean coordinates representationas:
q̄(q) =(v1(q)v2(q) · · · vV (q)
)T.
These formulationsmake it computationally tractable to numericallyoptimize a complex nonlinear function E(QK ). Moreover, Equation 2
2018-03-17 02:32 page 3 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
1:4 • Pan, et al
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
is very convenient in terms of formulating our objective functionsEobj. For example, we could use a function in c to direct a deformablebody to walk to a specific position, or a function inw to specify thata deformable body should stay balanced.
4 OBJECTIVE TERMSIn this section, we present details of the objective function used forspacetime optimization.
4.1 Physics-Based ConstraintsThe first term Ephys penalizes any violation of the equations ofmotion (EOM), and our formulation is similar to prior work [Barbičet al. 2009, 2012]. In addition, we also penalize any self-penetrationsor collisions with static obstacles. Altogether, Ephys is representedas:
Ephys(QK ) =K−1∑i=2
EEOM(qi−1,qi ,qi+1) + Ecoll(qi ) + Eself(qi ).
4.1.1 Equations ofMotion. Sinceqi only represents a deformablebody’s position, EEOM models the dynamic behavior using 3 con-secutive frames. One advantage of this formulation is that we canuse a position-based large timestep integrator [Hahn et al. 2012]to formulate our EOM. An implicit-Euler scheme determines qi+1from qi−1,qi using the following optimization formulation:
qi+1 = argminq
[A(q)TMA(q)
2∆t2 + P(q) − FTi u − ETi q̄(q)]
A(q) ≜ q̄(q) − 2q̄(qi ) + q̄(qi−1),whereM is the mass matrix constructed from the volumetric meshof the deformable body using FEM, F represents the internal con-trol forces and E corresponds to the environmental forces such asgravitational forces, fluid drag forces, and frictional contact forces.P is the elastic potential energy, and we model this energy termusing the rotation-strain space linear elastic energy P(q) = uTKu/2,where K is the isotropic stiffness matrix. Even with an arbitrarilylarge ∆t , the above time integrator is always stable. The term EEOMis simply defined as the norm of gradient:
EEOM(qi−1,qi ,qi+1) =12 (3) ∂q̄(qi+1)
∂q
TMA(qi+1) +
∂[P(qi+1) − Fi
Tui+1 − EiT q̄(qi+1)
]∂q
2
,
where we exclude internal forces Fi and external forces Ei fromour argument list to save space. These forces can be functions of qi ,eliminated analytically, or optimized as separate subproblems.
4.1.2 Collision Avoidance. Collision handling is regarded as achallenging problem in terms of deformable body simulation. In ourmethod, we use two terms to approximately avoid collisions. Forcollisions with static obstacles, we formulate an energy term as:
Ecoll(q) =Ccoll
2
V∑j=1
max(dist(v j (q)), 0)2, (4)
where dist(v) is the signed distance from a vertex’s position to staticobstacles, which is positive when there is penetration and negative
otherwise. To evaluate this function for vertices, we precompute asigned distance field for the static obstacles.
Handling self-collisions is even more challenging. In order to gen-erate animations such as walking and jumping, many deformablebodies have thin structures that function as legs. Successful han-dling of self-collisions between such thin structures usually requirescontinuous collision detection (CCD), as illustrated in Figure 4. Wemake use of our reduced representation and use an approximateCCD scheme. Given a configuration q =
(u c w
)that has self-
penetrations, we first search for colliding pairs of vertices by recon-structing q̄(qi ) from qi and run a conventional discrete collision de-tection.
(a) (b)
Fig. 4. To resolve collisions betweenthin components (a), we use approxi-mate continuous collision handling (b).
As shown in [Barbič and James2010], considering only vertex-vertex collisions is enoughfor plausible handling of self-penetrations in reduced-modeldeformable body animations.Moreover, we observe that self-penetrations are invariant tothe global rigid transformation(c w
), so we only look at the
local deformation componentu of q. Since we already knowthat the undeformed configu-ration, i.e., u = 0, has no self-collisions, we can use a line-searchalgorithm in u to find the largest η ∈ (0, 1] such that ηu has noself-collisions. We can then approximate the direction of separationas:
dab ≜va (ηu) −vb (ηu)∥va (ηu) −vb (ηu)∥
,
this direction is treated as a fixed vector in each iteration of opti-mization, i.e. its derivatives are ignored. Finally, for each pair ofvertices va (u) and vb (u) in collision, we add an energy term:
Eabself(u) = max((vb (u) −va (u))Tdab , 0)2,and Eself is then defined as:
Eself(u) =Cself
2
V∑a=1
V∑b=1
Eabself(u)Iab , (5)
where the last Iab is an indicator of whether va (q) and vb (q) are incollision.
4.2 Environmental Force ModelSince we allow only internal forces F as the control input, a de-formable body must make use of external environmental forces Eto move around. We consider two kinds of environmental forces:frictional contact forces and fluid drag forces. The frictional contactforces are used for generating contact-rich animations such as walk-ing, balancing, rolling or jumping. The fluid drag forces are used forunderwater swimming.
4.2.1 Frictional Contact Force Model. To model the frictionalcontact forces, we use contact invariant optimization (CIO) [Mor-datch et al. 2012, 2013] and leave external forces E as an additionaloptimizable variable. However, E must satisfy two additional con-straints. First, the contact force on vertex v j , E j should lie inside
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 4 (pp. 1-17)
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
Active Animations of Reduced Deformable Models with Environment Interactions • 1:5
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
the frictional cone, we have:∥E ji ∥ ∥ ≤ µE ji ⊥, (6)
where ∥ and ⊥ are the tangent and normal component of the con-tact force, respectively, and µ is the frictional coefficient. The bigadvantage of CIO is that it allows the optimizer to jointly search forboth contact forces and contact points by introducing the so-calledcontact-integrity term defined as:
Eenv(qi ,qi−1, E ji ) = CenvK∑i=2
V∑j=1
(7)
(∥dist(v j (qi ))∥2 + ∥(v j (qi ) −v j (qi−1))∥ ∥2)∥Eji ∥
2.This term essentially encourages every external force E to havemaximal velocity dissipation and every contact point to stay on thecontact manifold. In this work, we use a slightly different formu-lation from [Mordatch et al. 2013] and use a quadratic penalty forE . In this way, the objective function E(QK ) becomes a quadraticfunction when we are optimizing only with respect to E . Togetherwith Equation 6, we can find the optimal E , given QK , by solvinga quadratic constrained QP (QCQP) problem. In Equation 7, thefunction dist(•) returns the closest distance to the environmentalobstacles. We compute this efficiently by precomputing a distancefield for the environment and we then use a smoothing algorithm[Calakli and Taubin 2011] so that dist(•) is C1-continuous.
4.2.2 Fluid Drag Force Model. The fluid drag forces, Ei , are notfree variables but functions of qi ,qi−1. [Yuksel et al. 2007] useda quadratic drag force model, which is defined as a summationof forces on each triangular surface patch (va ,vb ,vc ). Similar tothe case with elastic energy, this quadratic drag force model has acorresponding potential energy defined follows:
ETi q̄ = ET (qi+1,qi )q̄(qi+1) = Cdrag
∑va,b,c
Pdragabc (8)
Pdragabc (qi ,qi−1) ≜ max(NT
abcUabc , 0)UTabcBabc (qi+1),
where we have also approximated the surface patch force as a pointforce on the barycenter Babc . Here Nabc is the area-weighted nor-mal andUabc is the barycenter’s relative velocity against fluid, asillustrated in Figure 5. Note that Equation 8 only takes effect when asurface patch is moving towards the fluid body. However, Equation 8cannot be used by a gradient-based numerical optimizer becausethe gradient is discontinuous. We propose a continuous model by aslight modification:
Pdragabc (qi ,qi−1) ≜ max(NT
abcUabc , 0)2 N
TabcBabc (qi+1)∥Nabc ∥2 + ϵ
,
which is C1-continuous, and we set ϵ = 10−6 to avoid degeneracy.This newmodel only relates drag forces with the normal componentof the relative velocity. Since no other constraints or conditions areimposed on E , we define Eenv = 0 for the fluid drag model.
4.3 Controller Parametrization and Shuffle AvoidanceThe two terms, Ephys,Eenv, cannot uniquely determine an anima-tion. Therefore, we add two terms that model the prior knowledgein plausible character animations: controller parametrization andshuffle avoidance.
-1-0.5
0 0.5
1 -1
-0.5
0
0.5
1
0
0.5
1
1.5
2
-1-0.5
0 0.5
1 -1
-0.5
0
0.5
1
0
0.5
1
1.5
2
Uabc
∥U∥ ∥
Babc
∥U⊥∥
Nabc
va
vc
vb
∥Eabc ∥
∥U∥ ∥ ∥U⊥∥
∥Eabc ∥
∥U∥ ∥ ∥U⊥∥
(a) (b) (c)
Fig. 5. Fluid drag force is applied on each surface patch (va, vb, vc ). Theforce strength depends on the surface normal N and relative velocity U (a).We also plot the force strength with respect to tangential relative velocityU∥and normal relative velocity U⊥. Our new formulation is C1-continuous (b),while the original formulation has a discontinuous gradient (c), especiallywhen the relative velocity is almost tangential (shown with a red rectangle).
Fig. 6. A letter T jumping forward. With DMP regularization term EDMP,its center of mass (blue) traces out a periodic trajectory.
4.3.1 Periodic and Temporal Smoothness. First, we notice thatfor several kinds of animations, including walking, swimming, androlling, the deformable body should move in a periodic manner.Moreover, the desired animation is temporally smooth.
Algorithm 1 Algorithm to update CDMP.
1: Evaluate A← ∑K−1i=2 EEOM(qi−1,qi ,qi+1)
2: Evaluate B ← ∑K−1i=2 ∥F
ji − DMP(i∆t ,Wj )∥2
3: if B > 0.1A then ▷ Control input does not match DMP4: CDMP ← 2.1CDMP ▷ Enforce better match5: end if6: if B < 0.01A then ▷ Control input matches DMP7: CDMP ← 0.5CDMP ▷ Allow more animation explorations8: end if
To respect this property, we use a general representation: Dy-namic Movement Primitives (DMP) [Schaal 2006] to parameterizethe control inputs. DMP is a special open-loop controller parametriza-tion that can represent many complex robotic tasks such as tennisplaying and walking. DMP is capable of representing both peri-odic and non-periodic tasks. The latter is useful, e.g., for jumpinganimations. A periodic DMP controller is defined as:
DMPp (t ,W) =N∑n=1
αnexp(β2ncos(τ t − µn )), (9)
and a non-periodic DMP controller is defined as:
DMPnp (t ,W) =N∑n=1
αnexp(−(βnt − µn )2)t . (10)
Note that DMP can be considered a special kind of one-input-one-output neural network using exp() and cos() as the activation func-tion, where N is the number of neurons in each layer and the
2018-03-17 02:32 page 5 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
1:6 • Pan, et al
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
neural-net weights areW ≜ (αn , βn , µn ,τ ). In practice, we needone DMP function for each component of Fi so that the total numberof additional variables to be determined is |W| × |Fi | = |W| × |u |.We denote the DMP for the jth component of Fi using superscriptj . In order to guide the optimizer to look for control inputs that canbe represented using DMP, we introduce an additional energy term:
EDMP(Fi ) =CDMP
2
|Fi |∑j=1∥F j
i − DMPp/np (i∆t ,Wj )∥2. (11)
We simultaneously optimize QK andWj . We also adaptively ad-just the weighting of this term so that EDMP is almost zero afterthe iterative algorithm converges. As a result, the output of DMPfunction DMPp/np matches the required internal control forces F j
iexactly and DMPp/np can be used as an open-loop controller af-ter spacetime optimization. To achieve such exact match betweenF ji and DMPp/np , we use a simple adaptive penalty method [Boyd
et al. 2011]. Specifically, we use Algorithm 1 to adjust CDMP afterevery iteration of optimization. Our scheme allows the optimizerto quickly explore the space of new animations, while keeping∥F j
i − DMP(i∆t ,Wj )∥2 small. Figure 6 illustrates the effect of thisheuristic term.
4.3.2 Shuffle Avoidance. As observed in [Mordatch et al. 2013],another artifact due to the lack of internal actuation structure isthe shuffling movement across the contact manifold. This meansthat the contact points are always in close proximity to the solidboundary. To mitigate this artifact, we introduce an additional hintterm Eshuffle defined as:
Eshuffle(qi ,qi−1) (12)
= Cshuffle
V∑j=1∥(v j (qi ) −v j (qi−1))∥ ∥2exp(−γdist(v j (qi ))),
where γ is the distance attenuation coefficient. For each vertex v j ,we penalize its tangential velocity attenuated by its distance fromstatic obstacles. In this way, the shuffling artifact is removed byasking a walker to lift its legs to move forward. The effect of thishint term is illustrated in Figure 7. We combine the above two hintsand Tikhonov regularization, giving:
Ehint(QK ) =K−1∑i=2
Creg2 ∥Fi ∥
2 + Eshuffle(qi ,qi−1) + EDMP(Fi ). (13)
5 SPACETIME OPTIMIZATIONIn this section, we present our efficient, hybrid optimizer tominimizethe objective function:
argminQK ,F,E,W
E(QK ,F , E ,W), (14)
where different subproblem solvers are used for minimizing withrespect to each of the 4 free variables: QK ,F , E ,W. As a specialcase, E is not a free variable for swimming animations using ourfluid dragmodel.Without loss of generality, we consider Equation 14for presentation. Since the objective function is C1-continuous, ourfirst attempt was to use an off-the-shelf implementation of theLBFGS algorithm [Liu and Nocedal 1989]. However, we found outthat even for small problems, having very small |u | and K , it takesa large number of iterations to converge. Instead, we present a
Algorithm 2 The hybrid optimization algorithm.1: ▷ Setup multiple initial guesses for DMP periods2: 2π/τ ← 0.2, 0.4, · · · , 5(s)3: for iteration=0, · · · do4: ▷ Evaluate function values and gradients5: Evaluate E(QK ), ∂E(QK )
∂QK6: Evaluate an approximation to ∂2E(QK )
∂QK 2 denoted as H7: ▷ Update trajectory, see [Lourakis 2005] for more details8: do9: QnewK ← QK − (H + dI)−1 ∂E(QK )
∂QK10: if E(QnewK ) > E(QK ) then11: increase d12: else13: decrease d14: end if15: while E(QnewK ) > E(QK )16: QK ← QnewK17: ▷ Update contact forces (Equation 3,6,7)18: if Using frictional contact model then19: for i = 2, · · · ,K − 1 in parallel do20: Update Ei using [Todorov 2011]21: end for22: end if23: ▷ Update DMP weights for all initial guess (Equation 11)24: ifW is not updated in the last 10 iterations then25: for Each initial guess do26: Update DMP weightsW using 100027: iterations of LBFGS [Liu and Nocedal 1989]28: end for29: ChooseW leading to smallest EDMP30: end if31: if Using frictional contact model then32: ▷ Adaptive contact handling (Equation 7, 12)33: for all 1 ≤ i ≤ K and 1 ≤ j ≤ V do34: if dist(v j (qi )) > ϵ1 and ∥E ji ∥ < ϵ2max
i, j∥E ji ∥ then
35: Exclude v j (qi ) from Eenv,shuffle36: else37: Include v j (qi ) in Eenv,shuffle38: end if39: end for40: end if41: end for
novel hybrid optimization algorithm that converges in much feweriterations.
5.1 Hybrid OptimizerTo accelerate the rate of convergence, we first notice that F appearsonly in EEOM, and EDMP as a quadratic function. Therefore, we cansolve for F analytically and eliminate it. We further observe thatthe other three sets of variables (QK , E ,W) appear in the objectivefunction with special structures. The DMPweight vectorW appearsonly in EDMP and optimizingW amounts to a small neural-networktraining problem for which LBFGS is proven to be very effective.
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 6 (pp. 1-17)
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
Active Animations of Reduced Deformable Models with Environment Interactions • 1:7
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
Example LBFGS(s) Hybrid(s)2D Crawling 1534 182D Rolling 823 12
Table 1. Performance of LBFGS and our hybrid solver on two examples: 2Dworm crawling and 2D ball rolling. Our approach is significantly faster.
(a)
(b)
Fig. 7. Frames highlighting the dragon walking trajectory using our ap-proach. In the result without Eshuffle (a), the dragon’s foot is always in closeproximity to the floor plane (blue). The artifact is mitigated using Eshuffle(b). Therefore, we observe more secondary dynamics in (b), e.g., around thetail (green).
The external force E is a quadratic function in both EEOM and Eenv,and Ei for each timestep i is separable and can be solved in parallel.Together with constraint Equation 6, finding the optimal E amountsto solving a QCQP problem, for which special solvers are known. Forexample, we use a primal interior-point method [Todorov 2011]. Wefound that solving QCQP is faster than solving QP with a linearizedfrictional model because it requires fewer constraints and makes useof coherence in the intermediate solutions between the consecutiveiterations by allowing warm-starting. We can update these variablesW, E , and QK in an alternate manner. Finally, for trajectory QKitself, LBFGS can still be used, but we found that LBFGS does notuse gradient information effectively. A large number of gradientevaluations are performed inside the line-search scheme and LBFGSusually chooses a conservative step size. Therefore, we choose theLevenberg-Marquardt (LM) method for updating QK . The outlineof our method is given in Algorithm 2, and we provide the low-leveldetails in Appendix B . Table 1 shows a comparison between oursolver and LBFGS on two small 2D problems.
5.2 Efficient Function EvaluationThe costliest step in our algorithm is the evaluation of the functionvalues, including the gradient and approximate hessian. We com-bine several techniques to accelerate these evaluations. First, wenotice that v j (qi ), the recovered vertex j’s Euclidean coordinatesfrom reduced representation at timestep i , appears in almost ev-ery objective term. Moreover, these values are independent of eachother. Therefore, we can compute and store v j (qi ), ∂v j
∂qi, ∂2v j
∂qi 2 forall 1 ≤ i ≤ K and 1 ≤ j ≤ V in parallel, before each evaluation. Weprovide some hints for computing the second derivatives ∂2v j
∂qi 2 inAppendix C . The overhead of these computations is independentof the number of vertices V . We also utilize this information toassemble the hessian. This assembly step can be a computational
(a) (b) (c)
Fig. 8. For the spider (top) and fish (bottom) models (a), we visualize thekinetic cubatures (b) and surface patch cubatures (c). In both cases, only asmall fraction of elements need to be considered for the summation. Thisfraction is 12% for the spider and 0.7% for the fish model.
bottleneck because we have to evaluate the summations over allthe vertices that appear in the physics violation term EEOM, in thecollision avoidance term Ecoll,self, in the environmental force termEenv, and finally in the shuffle avoidance term Eshuffle.
5.2.1 Accelerating the Assembly of Ecoll,self. For collision avoid-ance terms, only very few vertices will contribute non-zero valuesto the objective function. Therefore, we use a bounding volumehierarchy [James and Pai 2004] to update the non-zero terms. Thisdata-structure can be updated solely using reduced representation|q |, and the update for different timesteps can be performed in par-allel.
5.2.2 Accelerating the Assembly of Eenv,shuffle. In the previoussection, we used cubature approximation to accelerate the fluiddrag forces. For frictional contact forces, however, all the verticesin close proximity to the static obstacles will contribute non-zerovalues to Eenv and Eshuffle. Since these vertices cannot be determinedduring the precomputation stage, we dynamically update them.Specifically, we remove vertex v j (qi ) from Eenv if dist(v j (qi )) > ϵ1and ∥E ji ∥ < ϵ2max
i, j∥E ji ∥. After Eenv is updated, we update Eshuffle
accordingly, since Eshuffle is also very small for vertices that are farfrom the static obstacles. These updates can be accelerated using abounding volume hierarchy.
5.2.3 Accelerating the Assembly of EEOM. [An et al. 2008; Barbičand James 2005] have addressed the problem of accelerating theassembly of EEOM. Specifically, summation over all vertices appearsin two places of EEOM highlighted below:
∂q̄(qi+1)∂q
TMA(qi+1) +
∂
[P − Fi
Tu − EiT q̄
](qi+1)
∂q.
We use the cubature approximation [An et al. 2008] to acceleratethese two terms. The blue part above corresponds to the kineticcubature used in [Pan et al. 2015]; see Appendix C.2 for more details.The red part above corresponds to the fluid drag force, which is asummation over all the surface patches. Cubature approximationassumes that:ET (qi+1,qi )q̄(qi+1) = Cdrag
∑va,b,c
Pdragabc ≈
∑va,b,c ∈T
CabcPdragabc , (15)
i.e., the sum over all surface patches can be approximated using the
2018-03-17 02:32 page 7 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
1:8 • Pan, et al
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
weighted sum of a selected set of surface patches T . As illustratedin Figure 8, this greatly reduces the computational overhead.The set T and weights Cabc are computed via dictionary learn-
ing. Specifically, we first construct a dataset of D exemplary de-formations {q1,q2, · · · ,qD } according to Gaussian distribution asdescribed as in [An et al. 2008]. Then for each pair of qi ,qi+1, wecompute the groundtruth fluid drag force. The problem of findingT and Cabc is formulated as the following sparse coding problem:
argminCabc
∥Cabc∥0 +D−1∑i=1∥
∑va,b,c
∂[CdragP
dragabc −CabcP
dragabc
]∂qi+1
∥2
s.t. Cabc ≥ 0, (16)
which is solved using iteratively reweighted Lasso optimization asin [Pan et al. 2015]. We take partial derivative in Equation 16 so that
we are measuring error in drag force ∂P dragabc∂q , instead of the corre-
sponding potential energy Pdragabc . Finally, T consists of all surface
patches with non-zero Cabc.
5.3 Robustness to Suboptimal SolutionsIt is well-known that spacetime optimization is prone to bad localminima leading to suboptimal solutions, except for simple cases[Barbič et al. 2012]. In our algorithm, there are two energy termsthat can result in the computation of bad local minima. One is thecontact integrity term, Eenv, which models the non-smoothnessof frictional contacts. The other one is EDMP, which models thetrajectory smoothness and periodic movements.In terms of EDMP, previous methods [RÃijckert and D’Avella
2013; Schaal 2006] use sampling-based methods to search for theglobal optimum. Since we only use a gradient-based local optimizer,EDMP could result in the computation of a bad local minima. In-deed, we found that our optimizer can have difficulty in terms offinding good DMP parametersW. At a local minima, several DMPneurons usually have same values of (αn , βn , µn ), values in Equa-tion 9 or Equation 10, meaning that we are wasting parameters. Inaddition, we found that the period parameter τ can get stuck ina local minima very close to our initial guess. In this section, weintroduce some simple modifications to overcome these problems.
Fig. 9. When user sets a target point(green) too far away (5 meters to theright) and uses very few timesteps (20in this case), the Letter T chooses to leanitself too much to recover from fallingdown.
We first initialize the phaseshift uniformly in the phasespace, i.e., µn = 2πn/N , andwe initialize αn , βn to verysmall random values. To avoidthe period parameter τ fallinginto a bad local minima, weuse multiple initial guess forτ and run an LBFGS optimiza-tion from each initial guessin Line 25 of Algorithm 2.In our experiments, we set2π/τ = 0.2, 0.4, · · · , 5(s) andrun LBFGS 25 times very 10 iterations to avoid bad local minima.After that, we get 25 candidate DMP parameters,W, and we choose
the candidate leading to the smallest EDMP. Such multiple LBFGS op-timizations will result in additional computational overhead duringthe first few iterations of optimization. As the optimizer gets closerto a local minima, τ will converge to a same local minima for severalcandidates of DMP parameters, and we can merge these candidatesinto one. In addition, if a certain candidate is never chosen as thebest during the last 100 iterations, we remove this candidate fromfurther consideration. In practice, we have only 2 − 3 remainingcandidates after 500 iterations.The approach highlighted above greatly increases the chances
that our optimization algorithm computes a good local minima with-out significant computational overhead. This is because periodicDMP formulation (Equation 9) is guiding the whole trajectory tofollow a same gait. When our optimization algorithm finds a usefulgait, this information is quickly encoded into the DMP controllerand reused to compute the entire trajectory using the EDMP formu-lation. In order to highlight this feature, we show two swimmingtrajectories computed using our optimization algorithm. In orderto compute the trajectory shown in Figure 10 (a), we initialize thespider pose to u = c = w = 0 at all timesteps. While to generateFigure 10 (b), we initialize the spider to a different random poseat every timestep. Moreover, the convergence history of these twooptimization schemes are plotted in Figure 11. Our optimizer con-verges to two different but almost equally effective swimming gaitswith very small objective function values. This means that althoughthere are numerous local minima, most of them leads to plausibleanimations. However, bad local minima can still happen especiallyin contact-rich animations and we illustrate one such failure casein Figure 9.
Time (second)
-200-100 0
100 200
0 2 4 6 8 10
Control Force
Magnitude
-200-100 0
100 200
0 2 4 6 8 10
Control Force
Magnitude
Time (second)
(a)
(b)
(c)
(d)
Fig. 10. We show two swimming trajectories optimized using static ini-tialization (a) and random initialization (b). For both trajectories, we plotthe locus of the deformable body’s center of mass (white curve) and themagnitude of control forces in (c,d). The goal is to move 5 meters to theleft after 10 seconds. Our optimizer finds two different but almost equallyeffective gaits.
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 8 (pp. 1-17)
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
Active Animations of Reduced Deformable Models with Environment Interactions • 1:9
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
Objective
Function
Iteration
50 150 250 350 450
100 200 300 400 500 600 700
Static (a)Random (b)
Fig. 11. We plot the convergence history using static initialization (a) andrandom initialization (b). Both optimizations reduce the objective functionto less than 1% of the original value. This plot shows that many local minimaof our objective function leads to plausible animations. There are some jit-tering during the optimization. This is because the adaptive penalty method(Algorithm 1) is adjusting CDMP.
Name Value
Ccoll (Equation 4) 102
Cself (Equation 5) 102
µ (Equation 6) 0.7Cenv (Equation 7) 101/l2Cdrag (Equation 8) 103
N (Equation 9, 10) 5CDMP (Equation 11) dynamicCshffle (Equation 12) 10−1
γ (Equation 12) log(10)/l
Name Value
Creg (Equation 13) 10−3
ϵ1 (Section 5.2.2) 3lϵ2 (Section 5.2.2) 0.01D (Equation 16) 1000∆t 0.05sYoung’s modulus 105PaPoisson’s ratio 0.48Mass density ρ 1kд/m3
Gravity 9.81m/s2
Table 2. Parameters.
6 RESULTSIn this section, we highlight the results on complex benchmarks.Parameter Choices: We use an identical set of parameters listed
in Table 2 for all the benchmarks. The coefficient of the physicsviolation term is 1. Some parameters are related to l , which is theaverage element size. If a deformable body has volume vol and isdiscretized using P FEM elements, then l = (vol/P)1/3. An exceptionis the coefficient for EDMP, which is adaptively adjusted within theoptimization algorithm.Benchmarks: We implemented our method in C++ and tested it
on many benchmarks using a desktop machine with dual E5-267012-core CPU 2.1GHz and 12GB of memory. Given only a volumetricmesh and a definition of the environment, we first precompute thereduced dynamic model using [Pan et al. 2015]. We also precomputethe surface cubatures to approximate the fluid drag forces. We useOpenMP to parallelize the function and gradient evaluations andrun at most 10000 iterations of optimizations or stop early, if therelative error of ∥ ∂E(QK )
∂QK ∥ is smaller than 10−3. The setup andcomputational cost in each benchmark is summarized in Table 3and analyzed below.Fish Swimming: Fishes have the simplest deformable bodies
and can be used for testing the performance of our method. Asillustrated in Figure 1, a fish swims by simply swinging its body, sowe use a reduced configuration space of small DOFs: |u | = 5, i.e.,|q | = 11. Under this setting, we command the fish to swim straightforward in a gravityless environment using the following objective:
Example V /P |u | Pre./PreSF.(min) K/#QK Opt.(hr) App.Fish Swimming (Fig.12a) 2118/7812 5 0.8/0.1 200/3 1.7 DMPSpider Swimming (Fig.12b) 1054/4033 10 1.2/0.3 200/3 2.5 DMPSpider SwimmingReduced StVK (Fig.21a) 1054/4033 65 4.6/0.3 200/1 3.9 None
Spider Walking (Fig.13) 1054/4033 10 1.2/ 200/4 5.2 FBDragon Walking (Fig.7) 929/1854 10 1.3/ 200/1 2.2 NoneLetter T Walking (Fig.19a) 1523/3042 15 1.1/ 200/4 4.5 FBLetter T WalkingReduced StVK (Fig.21b) 1523/3042 65 4.2/ 200/1 3.1 None
Beam Jumping (Fig.14) 1024/640 10 1.1/ 100/1 1.1 NoneCross Rolling (Fig.16) 623/1499 10 1.3/ 200/1 2.1 NoneDinosaur Walking (Fig.18) 1493/5249 15 0.9/ 200/1 1.9 None
Table 3. Benchmark setup and computational overhead. From left to right,number of verticesV /number of FEM elements P , DOFs of local deformation|u |, precomputation time for building reduced dynamic model/computingsurface patch cubatures, number of frames/number of trajectories, timespent on optimization, and the supported application: DMP means we useDMP as open-loop controller to drive forward simulation, FB means that weuse feedback controller to track the animation (both of these are realtime).
Emoveobj (QK ) = C
moveobj
K∑k=2∥ck+1 − ck − exp(wk+1)vc∆t ∥2/2, (17)
where exp(wk+1) transforms the velocity to a global frame of ref-erence and vc is the target swimming speed in a local frame ofreference. In addition, we add a balance energy to encourage fixedorientation:
Ebalobj(QK ,d) = Cbalobj
K∑k=2∥exp(wk )d − d ∥2/2, (18)
where d is the balance direction. Here we use d = д, the unit gravi-tational direction. We can even navigate the fish to an arbitrary 3Dpoint by optimizing 3 trajectories: swimming forward, swimmingleft, and swimming right. For swimming left and right, we add thefollowing objective functions in addition to Equation 17:
Eturnobj (QK ,d)
= Cturnobj
K∑k=2∥exp(wk+1) − exp(θd∆t)exp(wk )∥2/2, (19)
where θd is the target rotating speed, we use d = д again. Afterthe optimization, the DMP function can be used as an open-loopcontroller to generate controlled forward simulations at real-timeframerate. In Figure 12 (a), we wrap our forward simulator into asampling-based motion planner, RRT* [Karaman and Frazzoli 2011],to navigate the fish to look for food plants.
Spider Swimming: We also evaluated our approach on a morecomplex model: a four-legged spider. More degrees of freedom areused to allow each leg to move independently, so we use moreDOFs: |u | = 10, i.e., |q | = 16. Again, we optimize to generate 3trajectories with the same τ and µn for all trajectories. However,for the first trajectory we set vc = 1,θ = 0, and for the other twowe set vc = 0,θ = ±1 so that the spider cannot turn itself aroundwhile swimming forward. This gives very different gaits for turningand swimming forward. We again use DMP to drive the realtimeforward simulator and wrap it into a motion planner, as illustratedin Figure 12 (b).
2018-03-17 02:32 page 9 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1:10 • Pan, et al
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
(a) (b)
Fig. 12. We use RRT* to navigate physical swimming characters, the fish(a) and the spider (b), to look for food plants (green). The white line is thelocus of the deformable body’s center of mass computed using RRT*.
(a) (b)
Fig. 13. The spider walking on planar ground (a) and V-shaped ground (b).
Spider Walking: To analyze the walking animation, we use thesame spider model and objective Equation 17 but replace the fluiddrag force model with the frictional contact force model. However,we observe that this optimization takes approximately twice asmany iterations to converge due to the contact-integrity term Eenvand the shuffle avoidance term Eshuffle. In Figure 13, we illustratethe walking gaits for two kinds of environments.Similar to swimming, we allow a user to navigate the spider on
the ground by optimizing 4 trajectories: walking left, right, back-ward, and forward, where the objective function is Equation 19 withcorrespondingvc . We then use a feedback controller similar to [Tanet al. 2012] to drive forward simulator. Specifically, we optimizeE(QK ) over one timestep (K = 3) with the objective function:
Etrackobj (QK ) = Ctrackobj (q̄(q2) − q̄(q∗))TM(q̄(q2) − q̄(q∗))/2, (20)
where q∗k is the configuration of the tracked trajectory. Due to the ef-ficiency of reduced representation, such short-horizon optimizationcan be solved at realtime framerates.Letter TWalking: A more challenging example is Letter T walk-
ing, as illustrated in Figure 6. This model has no static stability, soit must keep jumping to move around. Again, we first optimize 4trajectories and then track these trajectories at realtime to navigatethe character.Beam Jumping: Jumping is an essential component in many
animations. To generate these animations, we use the followingobjective function:
Ejumpobj (QK ) = C
jumpobj ∥д
T cK/2 − h∥2/2 + (21)
Cjumpobj ∥(I − дд
T )(cK/2 − cK/2−1 − exp(wK/2)vc∆t)∥2/2,where the first term specifies the target altitude and the secondterm specifies the target horizontal velocity vc so that the charactercan jump forward. Using different h and vc , we generate a series ofresults in Figure 14 and Figure 15 for a small beam, where the beamexhibits huge and varied deformations.
(a) (b) (c)
Fig. 14. Different frames during a beam jumping with different targetaltitudes (yellow arrow); (a): h = 2, (b): h = 3, and (c): h = 4.
(a) (b) (c)
Fig. 15. Different frames during a beam jumping forward with differenttarget distance (yellow arrow); (a): ∥vc ∥ = 2, (b): ∥vc ∥ = 2.5, and (c):∥vc ∥ = 3 (the target altitude h = 3).
(b)
(a)
Fig. 16. (a): An X-shaped deformable body walking by rolling. (b): The restshape.
(c)
(b)
(a)
Fig. 17. To compute the navigation path for the spider, we optimize 3trajectories: swimming forward (a), turning left (b), and turning right (c)(the timestep index increases along the arrow, and the white bodies markthe most deformed configurations). These differences in the gaits can berepresented by different DMP parameters αn and βn only.
Cross Rolling: As illustrated in Figure 16 (b), we generate arolling animation for a cross-shaped deformable body by combiningthe objective functions given in Equation 18 and Equation 19.
6.1 Combining our Algorithm with Partial Keyframe DataAlthough our main contribution is a control framework that doesnot require keyframes, we can easily take keyframes into consid-eration to provide more flexibility to a user. These keyframes caneither be specified fully or partially. A full keyframe specifies atarget position for each of the V vertices, while a partial keyframe
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 10 (pp. 1-17)
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
Active Animations of Reduced Deformable Models with Environment Interactions • 1:11
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
(a)
(c)(b)
Fig. 18. We show a walking dinosaur guided by both our high-level objec-tives and user-specified keyframes in (a) so that its head is looking around.And the upper-body partial keyframes are illustrated in (b,c). Each of thesekeyframes contains 788 of the 1493 vertices.
only specifies a target position for a subset of vertices on the de-formable body. For example, in Figure 18 (a), we show a dinosaurwalking on the ground with its head swinging periodically to theleft and right. The dinosaur’s head is guided by a set of M partialkeyframes illustrated in Figure 18 (b). The keyframes only specifythe head and torso poses and we leave the leg poses to be deter-mined by other objective function terms.We denote these keyframesas ukey1 , · · · ,u
keyM specified at timesteps t1, · · · , tM . Note that these
keyframes only specify the dinosaur’s deformable poses u and donot affect the global transformation (c,w). The keyframe guiding isachieved using an additional objective function:
Ekeyobj (QK ) = C
keyobj
M∑i=1∥I (q(ukeyi ) − q(uti ))∥
2/2, (22)
where I is an importance-weighting matrix allowing the users tospecify partial keyframes. In our example, I is a diagonal matrixwith diagonal value 1 around the head and torso (788 vertices) and0 elsewhere.
6.2 AnalysisWe summarize objective functions used in all benchmarks in Table 4and analyze several aspects of our method.Two-Stage Algorithm: A drawback of our method is that the
optimization formulation takes a more complex form, and the re-sulting optimization algorithm takes longer time than [Barbič et al.2009]. Fortunately, the DMP function returned by the optimizercan be used as a swimming controller to generate more swimminganimation at realtime, as illustrated in Figure 12. This makes ourmethod much more useful than a simple keyframe interpolation.
Example Eobj
Fish Swimming Eobj = Emoveobj + E
turnobj + E
balobj, vc =
(1 0 0
)T,θ = 0,±1,d = д
Spider Swimming Eobj = Emoveobj + E
turnobj + E
balobj,
vc =(1 0 0
)T,θ = 0 or vc =
(0 0 0
)T,θ = ±1,d = д
Walking Eobj = Emoveobj + E
balobj, vc =
(±1 0 ±1
)T,d = д
Dinosaur Walking Eobj = Emoveobj + E
balobj + E
keyobj , vc =
(±1 0 ±1
)T,d = д
Jumping Eobj = Ejumpobj + E
balobj, h = 2/3/4,vc =
(2/2.5/3 0 0
)T,d = д
Rolling Eobj = Eturnobj + Ebalobj, vc =
(1 0 0
)T,θ = 1,d = vc × д/∥vc × д∥
Cmoveobj = Cturn
obj = Cjumpobj = C
keyobj = 10−1 and Cbal
obj = 10−2
Table 4. Objective function used in each benchmark.
However, to generate realtime contact-rich animations, such aswalking and jumping, we have to use a feedback controller insteadof DMP controller. This is because the contact forces are very sensi-tive to the discrepancy between forward simulation model and thephysics model used in spacetime optimization (model discrepancy).
Multi-Tasking: In order to make the realtime animations di-rectable, we need to simultaneously optimize multiple animationtrajectories to allow amotion planner to pick trajectory online. How-ever, if we sequentially run separate optimizations, the generatedgaits can be quite different, e.g., the fish might swing its body withdifferent frequencies to swim in different directions. This artifactcan be mitigated if we use the same DMP parameters τ and µnfor all the trajectories to ensure the same period of movement andphase shift, i.e., DMPs differ only in αn and βn for different tasks.This idea has been previously used for DMP-based reinforcementlearning [RÃijckert and D’Avella 2013]. As illustrated in Figure 17,DMP can represent large gait differences using different αn and βnonly, while the rhythms of the movements are synchronized. Weuse this strategy in all the navigation examples.
QualityMeasure: For jumping animation, we do not require anymanual bases design such as basis expansion [Tan et al. 2012]. Thereason is that we formulated physics constraints as soft constraintsand physics constraints are violated for small tracking errors. Tomeasure the violation to EOM at each frame (qi−1,qi ,qi+1), we firstsolve Equation 3 using qi−1,qi to find a physically correct q∗i+1 bycalling a conventional deformable body simulator. Next, we recoverthe vertex positions from qi+1,q∗i+1 to compute q̄(qi+1), q̄(q∗i+1). Wemeasure the EOM violation by computing the average distancebetween q̄(qi+1), q̄(q∗i+1) of V vertices, and comparing it with theaverage FEM element size l :√
∥q̄(qi+1) − q̄(q∗i+1)∥2/V /l .According to the plot in Figure 19, the physics violation over thewhole trajectory is always less then half of average element sizeand is neglectable. The physics violation data for other examplescan be found in Appendix A . However, manual bases design cansometimes be needed. For example, very different rolling gaits aregenerated in Figure 16, by restricting the bases to the 2D plane.
Effect of Different Parameters: Instead of using keyframes,the result of our algorithm depends on two sets of parameters.A first set of parameters are listed in Table 2. These parametersare considered internal and not exposed to users. The second setof parameters, which are listed in Table 4, are exposed to users.
2018-03-17 02:32 page 11 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1:12 • Pan, et al
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
(a)
(b)
(c)
Fig. 19. (a): Navigating the letter T across obstacles (yellow) to reach goalpositions (green). (b): A plot of the relative physical violation in (a) with re-spect to average FEM element size. Throughout the trajectory, the violationsto EOM are very small. (c): Two most violated frames in the spider walkingtrajectory (q∗i+1 drawn in green); the differences are indistinguishable.
Actual Swimming Speed
Desired Swimming Speed
reference
0
1
2
3
4
5
6
7
8
9
10
0 1 2 3 4 5 6 7 8 9 10 Actual Walking Speed
Desired Walking Speed 0
1
2
3
4
5
6
7
8
9
10
0 1 2 3 4 5 6 7 8 9 10
(a) (b)
Fig. 20. We generate 9 spider walking trajectories (a) and 9 spider swimmingtrajectories (b), using different target moving speed vc . We plot the actualwalking/swimming speed compared with the desired speed. These actualvalues are very close to desired values. However, there are still cases wherethe discrepancy between actual and desired values are large (green circles).
These parameters have clear meanings such as walking, swimming,or rolling speed. In Figure 20, we highlight the effectiveness ofperforming animation control. We generated 9 walking/swimmingtrajectories using different target moving speed vc . Since we modelEob j as a soft penalty, the desired speed cannot be achieved exactly.However, according to Figure 20, the discrepancy between actual anddesired moving speeds are very small. Therefore, we expose moreparameters to the users compared with keyframe-based methods[Barbič et al. 2009; Schulz et al. 2014], these parameters have intuitivemeanings and are helpful for animation control.
We also noticed two cases from Figure 20 (green circles) where thediscrepancy between desired and actual moving speed are relativelylarge. If the desired speed is too small, then our optimizer considersEobj as unimportant and it is given lower importance in order toreduce the residue in other objective terms. If the desired speed istoo large, it can result in self-collisions or the optimizer falls into abad local minima, as shown in Figure 9.
External vs. Internal Control Forces: Theoretically, our al-gorithm only uses internal forces. To understand this, note thatinternal forces are forces whose values and torques sum up to zero.In other words, internal forces are forces that cannot change c,w ofq. Since a conservative force equals the negative partial derivativesof the corresponding potential energy, any potential energy withzero derivative against c,w corresponds to the internal forces. Thisis the case with our potential energy FTu in Equation 3.
However, since we formulate the physical correctness as a penaltyterm, EEOM, rather than a hard constraint, there is some residualEEOM , 0 at the local minima. This residual can be interpreted asa violation of the physical correctness, or as a ghost external force.If we write EEOM(qi−1,qi ,qi+1) = ∥Eдhosti
Tq̄∥, we are actually
controlling the deformable body using both internal force Fi and anadditional ghost external force Eдhosti , but our objective functionis designed to guide the optimizer to search for a solution withminimal ghost external force magnitude.Using soft penalty instead of hard constraints also allows us
to generate realtime deformable body animations by tracking anoptimized animation. For example, having the letter-T balanced on asingle contact point in Figure 19 is very challenging, which usuallyrequires control over long horizons. However, with soft penalty, wecan track the animation by control over only one timestep usingEquation 20 as the objective function.
Other Reduced Models: Although we choose [Pan et al. 2015],our method can also work with other reduced models. This can bedone by modifying the transformation function q̄(q) and the kineticenergy P in Equation 3. In Appendix D, we analyze the case with twokinds of different but widely used reduced models: LMA [Pentlandand Williams 1989] and reduced StVK [Barbič and James 2005]. Andtwo examples are illustrated in Figure 21 (a,b).A drawback of these alternative models is that they require a
higher-dimensional configuration space to achieve similar results as[Pan et al. 2015]. In our experiments, we use |u | = 65 and each opti-mization becomes 3-5 times slower according to Table 1. However,from the plots of DMP control force magnitudes, Figure 21 (c,d), wenotice that the optimal F is actually very sparse. In other words,much computations are wasted on looking for small, unimportantcontrol forces. Such analysis suggests that [Pan et al. 2015] is abetter choice.
Although our formulation can alsoworkwith fullspace deformablemodels by replacing q̄ with identity function, this approach can becomputationally very expensive. As reported in [Pan et al. 2015],using a reduced model accelerates the evaluation of q̄(q) by twoorders of magnitude. In our experiments, cubature accelerates theevaluation of fluid drag forces by at least an order of magnitudeusing Equation 15. Since function evaluation is the major bottleneckof spacetime optimization, we expect it will take weeks or evenmonths to finish an optimization using fullspace models. As a re-sult, it is important to use reduced deformable models for efficiencyreasons.
Other (Partial) Keyframe-basedMethods:Ourmethod allowsa user to specify partial keyframes to control parts of a deformablebody that does not involve environmental interactions. A differentapproach is proposed in [Schulz et al. 2014], which uses partial
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 12 (pp. 1-17)
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
Active Animations of Reduced Deformable Models with Environment Interactions • 1:13
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
-80-40 0 40 80 120
0 2 4 6 8 10Control Force
Magnitude
-400-300-200-100 0
100 200
0 2 4 6 8 10Control Force
Magnitude
Time (second)
Time (second)
(a)
(b)
(c)
(d)
Fig. 21. We computed the animations corresponding to spider swimming(a) and letter T walking (b) using reduced StVK [Barbič and James 2005]as the underlying deformable model. In addition, we plot the control forcemagnitude for the spider in (c) and for the letter T in (d). We use differentcurves to plot each F j . Since |u | = 65, we have 65 curves in each plot.However, most of these curves are centered around zero axis. This meansthat the magnitude of control forces for most j are very small and F is quitesparse.
keyframes to manually specify parts that involve environmentalinteractions. Overall, our approach is complementary and gener-ates different deformations or animations. The two benchmarkscorrespond to cross-shape walking (Figure 22) and cactus jumping(Figure 23) and we have compared the animations in the video. Inboth these examples, we encode the objective into the functionsshown in Equation 17 and Equation 21. In practice, our approachrequires less user input. We also observed that our deformationpatterns in jumping animation are quite different from [Schulz et al.2014].
7 LIMITATIONS AND FUTURE WORKWe present a method to automatically generate active animations ofreduced deformable bodies, where the user provides a high-level ob-jective and the animation is generated automatically using spacetimeoptimization. We take into account physics constraints, environ-mental forces in terms of CIO and fluid drag models, and DMP-basedcontroller parametrization, so that the local minima of our objec-tive function corresponds to a plausible animation. By evaluatingobjective functions and function gradients in a subspace, the op-timization can be accomplished within several hours on a singledesktop machine. Although optimization is offline, the results canbe used to generate animations at realtime rates. For swimminganimations, the optimized DMPs can be used as a controller forforward simulation. Unfortunately, DMP cannot be used as con-trollers for contact-rich animations. Since DMP is not a feedbackcontroller, model discrepancy can quickly accumulate, leading to
(a) (c)
(b): Image courtesy of [Schulz et al. 2014]
Fig. 22. We compare our method with partial keyframe-based method. Ourmethod can generate a cross-shape walking motion (a) similar to the results(b) in [Schulz et al. 2014] obtained using keyframe set (c).
(a)
(c)(b): Image courtesy of [Schulz et al. 2014]
Fig. 23. Our method generating a cactus-jumping motion (a) similar to theresults (b) in [Schulz et al. 2014] obtained using keyframe set (c). However,our deformation patterns are quite different compared with those in [Schulzet al. 2014].
failures such as falling. In these cases, DMP is just used as a periodicand smoothness prior.Our approach has some limitations. First, our method inherits
all the limitations of the underlying reduced model. For example,current reduced model [Pan et al. 2015] cannot work with userspecified skeletons. Working with skeletons is a desirable featurein terms of modelling some animal-like deformable bodies, suchas the fish, where deformable tissues are covering skeletal bones.In addition, although our method requires no keyframes or userdesigns, we still ask the users to choose the form of Eobj and theirparameters in Section 6. Moreover, without the keyframes, our an-imations may not exhibit the same level of naturalness as someprior keyframe-based methods [Barbič et al. 2009]. For example,the dinosaur’s walking gait is not symmetric in Figure 18 due tothe asymmetric rest pose. And it can be difficulty to generate thehandstand example of [Schulz et al. 2014] in Figure 23. Moreover,our optimizer may get stuck in a bad local minima due to insuffi-cient DOFs of the reduced configuration space, a sub-optimal basesset, or an inappropriate settings of the weights. Furthermore, theinherent limitations of CIO term [Mordatch et al. 2013] for con-tact modeling and the fluid drag model can also affect our results.For example, we cannot have a deformable body bouncing off theground since the CIO term only models inelastic contacts. CIO alsoallows inexact contacts to occur anywhere in the air, not only on
2018-03-17 02:32 page 13 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1:14 • Pan, et al
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
the ground. Finally, like all the optimization-based motion planners,the performance of our method is still governed by a large set ofparameters. Some parameters, such as the number of DMPs (N),are determined empirically. We have not evaluated the sensitivityof our method with respect to these parameters.There are avenues for future work. First, incorporating some
body-specific priors can be helpful in several ways. For example,for many muscle-driven deformable bodies, the user might want toparameterize the controller using muscle-tendon units [Wang et al.2012] to generate more life-like animations. Another part that maybenefit from user interactions is the identification of deformationbases in Figure 2. Currently, we identify these components usingstandard techniques [Pan et al. 2015] that are designed for visualsimulation. However, it is not known if a base set for plausible visualsimulation is suitable for character locomotion. It is also attractive toconsider the optimization method as a general feedback controller,instead of an open-loop controller, for reduced deformable modelsusing reinforcement learning [Peng et al. 2017]. Finally, developingcontrol methods for two-way couple deformable body and articu-lated body will provide more flexibility to users. A starting pointcan be [Xu and Barbič 2016].
ACKNOWLEDGEMENTThis research is supported in part by Army Research Office andNational Science Foundation.
REFERENCESSteven S. An, Theodore Kim, and Doug L. James. 2008. Optimizing Cubature for
Efficient Integration of Subspace Deformations. In ACM SIGGRAPH Asia 2008 Papers(SIGGRAPH Asia ’08). ACM, New York, NY, USA, Article 165, 10 pages. https://doi.org/10.1145/1457515.1409118
Jernej Barbič, Marco da Silva, and Jovan Popović. 2009. Deformable Object AnimationUsing Reduced Optimal Control. In ACM SIGGRAPH 2009 Papers (SIGGRAPH ’09).ACM, New York, NY, USA, Article 53, 9 pages. https://doi.org/10.1145/1576246.1531359
Jernej Barbič and Doug L. James. 2005. Real-Time Subspace Integration for St. Venant-Kirchhoff Deformable Models. In ACM SIGGRAPH 2005 Papers (SIGGRAPH ’05).ACM, New York, NY, USA, 982–990. https://doi.org/10.1145/1186822.1073300
Jernej Barbič and Doug L. James. 2010. Subspace Self-collision Culling. ACM Trans.Graph. 29, 4, Article 81 (July 2010), 9 pages. https://doi.org/10.1145/1778765.1778818
Jernej Barbič, Funshing Sin, and Eitan Grinspun. 2012. Interactive Editing of DeformableSimulations. ACM Trans. Graph. 31, 4, Article 70 (July 2012), 8 pages. https://doi.org/10.1145/2185520.2185566
Jernej Barbič and Yili Zhao. 2011. Real-time Large-deformation Substructuring. InACM SIGGRAPH 2011 Papers (SIGGRAPH ’11). ACM, New York, NY, USA, Article 91,8 pages. https://doi.org/10.1145/1964921.1964986
Miklós Bergou, Saurabh Mathur, Max Wardetzky, and Eitan Grinspun. 2007. TRACKS:Toward Directable Thin Shells. In ACM SIGGRAPH 2007 Papers (SIGGRAPH ’07).ACM, New York, NY, USA, Article 50. https://doi.org/10.1145/1275808.1276439
Stephen Boyd, Neal Parikh, Eric Chu, Borja Peleato, and Jonathan Eckstein. 2011.Distributed Optimization and Statistical Learning via the Alternating DirectionMethod of Multipliers. Found. Trends Mach. Learn. 3, 1 (Jan. 2011), 1–122. https://doi.org/10.1561/2200000016
Robert Bridson, Ronald Fedkiw, and John Anderson. 2002. Robust Treatment of Col-lisions, Contact and Friction for Cloth Animation. ACM Trans. Graph. 21, 3 (July2002), 594–603. https://doi.org/10.1145/566654.566623
F. Calakli and G. Taubin. 2011. SSD: Smooth Signed Distance Surface Reconstruc-tion. Computer Graphics Forum 30, 7 (2011), 1993–2002. https://doi.org/10.1111/j.1467-8659.2011.02058.x
Steve Capell, Seth Green, Brian Curless, Tom Duchamp, and Zoran Popović. 2002.Interactive Skeleton-driven Dynamic Deformations. In Proceedings of the 29th AnnualConference on Computer Graphics and Interactive Techniques (SIGGRAPH ’02). ACM,New York, NY, USA, 586–593. https://doi.org/10.1145/566570.566622
Nuttapong Chentanez, Ron Alterovitz, Daniel Ritchie, Lita Cho, Kris K. Hauser, KenGoldberg, Jonathan R. Shewchuk, and James F. O’Brien. 2009. Interactive Simulationof Surgical Needle Insertion and Steering. InACMSIGGRAPH 2009 Papers (SIGGRAPH
’09). ACM, New York, NY, USA, Article 88, 10 pages. https://doi.org/10.1145/1576246.1531394
Min Gyu Choi and Hyeong-Seok Ko. 2005. Modal warping: real-time simulation of largerotational deformation and manipulation. IEEE Transactions on Visualization andComputer Graphics 11, 1 (Jan 2005), 91–101. https://doi.org/10.1109/TVCG.2005.13
Stelian Coros, Sebastian Martin, Bernhard Thomaszewski, Christian Schumacher,Robert Sumner, and Markus Gross. 2012. Deformable Objects Alive! ACM Trans.Graph. 31, 4, Article 69 (July 2012), 9 pages. https://doi.org/10.1145/2185520.2185565
Guillermo Gallego and Anthony Yezzi. 2015. A Compact Formula for the Derivative ofa 3-D Rotation in Exponential Coordinates. Journal of Mathematical Imaging andVision 51, 3 (March 2015), 378–384. https://doi.org/10.1007/s10851-014-0528-x
Fabian Hahn, Sebastian Martin, Bernhard Thomaszewski, Robert Sumner, Stelian Coros,and Markus Gross. 2012. Rig-space Physics. ACM Trans. Graph. 31, 4, Article 72(July 2012), 8 pages. https://doi.org/10.1145/2185520.2185568
David Harmon and Denis Zorin. 2013. Subspace Integration with Local Deformations.ACM Trans. Graph. 32, 4, Article 107 (July 2013), 10 pages. https://doi.org/10.1145/2461912.2461922
Kris K. Hauser, Chen Shen, and James F. O’Brien. 2003. Interactive Deformation UsingModal Analysis with Constraints. In Graphics Interface. CIPS, Canadian Human-Computer Commnication Society, 247–256. http://graphics.cs.berkeley.edu/papers/Hauser-IDU-2003-06/
Klaus Hildebrandt, Christian Schulz, Christoph von Tycowicz, and Konrad Polthier.2012. Interactive Spacetime Control of Deformable Objects. ACM Trans. Graph. 31,4, Article 71 (July 2012), 8 pages. https://doi.org/10.1145/2185520.2185567
G. Irving, J. Teran, and R. Fedkiw. 2006. Tetrahedral and Hexahedral Invertible FiniteElements. Graph. Models 68, 2 (March 2006), 66–89. https://doi.org/10.1016/j.gmod.2005.03.007
Doug L. James and Dinesh K. Pai. 2004. BD-tree: Output-sensitive Collision Detectionfor Reduced Deformable Models. In ACM SIGGRAPH 2004 Papers (SIGGRAPH ’04).ACM, New York, NY, USA, 393–398. https://doi.org/10.1145/1186562.1015735
Sertac Karaman and Emilio Frazzoli. 2011. Sampling-based algorithmsfor optimal motion planning. The International Journal of Robotics Re-search 30, 7 (2011), 846–894. https://doi.org/10.1177/0278364911406761arXiv:http://dx.doi.org/10.1177/0278364911406761
Junggon Kim and Nancy S. Pollard. 2011. Fast Simulation of Skeleton-driven DeformableBody Characters. ACM Trans. Graph. 30, 5, Article 121 (Oct. 2011), 19 pages. https://doi.org/10.1145/2019627.2019640
Theodore Kim and Doug L. James. 2011. Physics-based Character Skinning Us-ing Multi-domain Subspace Deformations. In Proceedings of the 2011 ACM SIG-GRAPH/Eurographics Symposium on Computer Animation (SCA ’11). ACM, NewYork, NY, USA, 63–72. https://doi.org/10.1145/2019406.2019415
Dong C. Liu and Jorge Nocedal. 1989. On the limited memory BFGS method forlarge scale optimization. Mathematical Programming 45, 1 (1989), 503–528. https://doi.org/10.1007/BF01589116
Libin Liu, KangKang Yin, Bin Wang, and Baining Guo. 2013. Simulation and Control ofSkeleton-driven Soft Body Characters. ACM Trans. Graph. 32, 6, Article 215 (Nov.2013), 8 pages. https://doi.org/10.1145/2508363.2508427
Manolis IA Lourakis. 2005. A brief description of the Levenberg-Marquardt algorithmimplemented by levmar. (2005).
Igor Mordatch, Emanuel Todorov, and Zoran Popović. 2012. Discovery of ComplexBehaviors Through Contact-invariant Optimization. ACMTrans. Graph. 31, 4, Article43 (July 2012), 8 pages. https://doi.org/10.1145/2185520.2185539
Igor Mordatch, Jack M. Wang, Emanuel Todorov, and Vladlen Koltun. 2013. AnimatingHuman Lower Limbs Using Contact-invariant Optimization. ACM Trans. Graph. 32,6, Article 203 (Nov. 2013), 8 pages. https://doi.org/10.1145/2508363.2508365
M. Mukadam, X. Yan, and B. Boots. 2016. Gaussian Process Motion planning. In2016 IEEE International Conference on Robotics and Automation (ICRA). 9–15. https://doi.org/10.1109/ICRA.2016.7487091
Matthias Müller and Markus Gross. 2004. Interactive Virtual Materials. In Proceedingsof Graphics Interface 2004 (GI ’04). Canadian Human-Computer CommunicationsSociety, School of Computer Science, University of Waterloo, Waterloo, Ontario,Canada, 239–246. http://dl.acm.org/citation.cfm?id=1006058.1006087
Zherong Pan, Hujun Bao, and Jin Huang. 2015. Subspace Dynamic Simulation UsingRotation-strain Coordinates. ACM Trans. Graph. 34, 6, Article 242 (Oct. 2015),12 pages. https://doi.org/10.1145/2816795.2818090
Xue Bin Peng, Glen Berseth, Kangkang Yin, and Michiel Van De Panne. 2017. DeepLoco:Dynamic Locomotion Skills Using Hierarchical Deep Reinforcement Learning. ACMTrans. Graph. 36, 4, Article 41 (July 2017), 13 pages. https://doi.org/10.1145/3072959.3073602
A. Pentland and J. Williams. 1989. Good Vibrations: Modal Dynamics for Graphicsand Animation. SIGGRAPH Comput. Graph. 23, 3 (July 1989), 207–214. https://doi.org/10.1145/74334.74355
Elmar RÃijckert and Andrea D’Avella. 2013. Learned parametrized dynamic movementprimitives with shared synergies for controlling robotic andmusculoskeletal systems.Frontiers in Computational Neuroscience 7 (2013), 138. https://doi.org/10.3389/fncom.2013.00138
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 14 (pp. 1-17)
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
Active Animations of Reduced Deformable Models with Environment Interactions • 1:15
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
Model (X × Y × Z ) lFish 2 × 1.2 × 0.2 0.071Spider 1.65 × 0.51 × 1.65 0.079Letter T 1.00 × 1.24 × 0.1 0.037
Model (X × Y × Z ) lDragon 1.52 × 0.71 × 1.03 0.075Beam 0.2 × 2 × 0.2 0.14Cross 1 × 1 × 0.1 0.042
Table 5. Model parameters used in our experiment. From left to right, modelname, bounding box size (X × Y × Z ), and average FEM element size l.
Stefan Schaal. 2006. Dynamic movement primitives-a framework for motor controlin humans and humanoid robotics. In Adaptive motion of animals and machines.Springer, 261–280.
Christian Schulz, Christoph von Tycowicz, Hans-Peter Seidel, and Klaus Hildebrandt.2014. Animating Deformable Objects Using Sparse Spacetime Constraints. ACMTrans. Graph. 33, 4, Article 109 (July 2014), 10 pages. https://doi.org/10.1145/2601097.2601156
Jie Tan, Greg Turk, and C. Karen Liu. 2012. Soft Body Locomotion. ACM Trans. Graph.31, 4, Article 26 (July 2012), 11 pages. https://doi.org/10.1145/2185520.2185522
Demetri Terzopoulos, John Platt, Alan Barr, and Kurt Fleischer. 1987. Elastically De-formable Models. In Proceedings of the 14th Annual Conference on Computer Graphicsand Interactive Techniques (SIGGRAPH ’87). ACM, New York, NY, USA, 205–214.https://doi.org/10.1145/37401.37427
E. Todorov. 2011. A convex, smooth and invertible contact model for trajectory optimiza-tion. In 2011 IEEE International Conference on Robotics and Automation. 1071–1076.https://doi.org/10.1109/ICRA.2011.5979814
Jack M. Wang, Samuel R. Hamner, Scott L. Delp, and Vladlen Koltun. 2012. OptimizingLocomotion Controllers Using Biologically-based Actuators and Objectives. ACMTrans. Graph. 31, 4, Article 25 (July 2012), 11 pages. https://doi.org/10.1145/2185520.2185521
Andrew Witkin and Michael Kass. 1988. Spacetime Constraints. In Proceedings of the15th Annual Conference on Computer Graphics and Interactive Techniques (SIGGRAPH’88). ACM, New York, NY, USA, 159–168. https://doi.org/10.1145/54852.378507
Hongyi Xu and Jernej Barbič. 2016. Pose-space Subspace Dynamics. ACM Trans. Graph.35, 4, Article 35 (July 2016), 14 pages. https://doi.org/10.1145/2897824.2925916
Cem Yuksel, Donald H. House, and John Keyser. 2007. Wave Particles. In ACMSIGGRAPH 2007 Papers (SIGGRAPH ’07). ACM, New York, NY, USA, Article 99.https://doi.org/10.1145/1275808.1276501
A PHYSICS VIOLATIONWe provide the physics violation data for all the examples in Table 6.We use the same criterion:√
∥q̄(qi+1) − q̄(q∗i+1)∥2/V /l .Compared with the average FEM element size l , the error due tophysics violation is very small. The parameters for all the volumetricdeformable models are provided in Table 5.
B OPTIMIZATION ALGORITHMIn this section we summarize our main Algorithm 2. The skeletonof this algorithm is an LM optimizer. We refer readers to [Lourakis2005] for a brief introduction of this simple method. In our experi-ments, LM performs much better than LBFGS for two reasons. First,LM uses JT J approximation of the hessian which usually leads to abetter step size estimation. Second, although LM needs to search forthe so-called damping coefficient as in the process of the line-searchscheme, it requires only function value evaluations which are muchfaster than gradient evaluations used by the line-search scheme ofLBFGS.
However, a minor problem with using an LM algorithm is that itassumes the objective function is a sum of squares, which is violatedby Eshuffle. In Appendix B.1, we show that a marginal modificationto [Lourakis 2005] will allow us to handle Eshuffle.After every successful LM iteration, we update E ; we updateW every 10 iterations. Since each update leads to an energy valuedecrease, the algorithm is guaranteed to converge eventually. Finally,we also update the active vertices contributing to Eenv and Eshuffle
Fish Swimming Spider Swimming
Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0
0.05
0.1
0.15
0.2
0.25
0 20 40 60 80 100 120 140 160 180 200
Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0 0.0001 0.0002 0.0003 0.0004 0.0005 0.0006 0.0007 0.0008 0.0009
0.001
0 20 40 60 80 100 120 140 160 180 200
Spider Walking Letter T Walking
Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0
0.0002
0.0004
0.0006
0.0008
0.001
0.0012
0.0014
0 20 40 60 80 100 120 140 160 180 200 Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0
0.005
0.01
0.015
0.02
0.025
0.03
0.035
0 20 40 60 80 100 120 140 160 180 200
Dragon Walking Beam Jumping
Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0 0.0005
0.001 0.0015
0.002 0.0025
0.003 0.0035
0.004 0.0045
0.005
0 20 40 60 80 100 120 140 160 180 200 Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0
0.005
0.01
0.015
0.02
0.025
0 20 40 60 80 100 120 140 160 180 200
Cross Rolling
Rela
tive P
hysi
cs V
iola
tion
Timestep Index
0 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09
0 20 40 60 80 100 120 140 160 180 200
Table 6. The physics violation of all the 7 benchmarks.
in Line 33. A minor bottleneck in this algorithm is the sparse linearsystem in Line 8, but we notice that the hessian of E(QK ) is a block-tridiagonal matrix that can be inverted with linear time complexity.
B.1 LM Modification for EshuffleConventional LM assumes that the objective function takes theform of E(QK ) = f (QK )T f (QK )/2 where f is a vector of nonlinearterms. This is not the case with Eshuffle. However, among the manyimplementations of LM, the one documented in [Lourakis 2005] isnot limited to the above form. If we have a certain approximation ofthe hessian of E(QK ) denoted as H (not necessarily in the form ofJT J ) and use damping coefficient d , then the update to QK in ourmain algorithm is computed as:
∆QK = −(H + dI)−1 ∂E(QK )∂QK
,
and the decrease in E(QK ) after applying the update is:
∆QTK∂E(QK )∂QK
+12∆Q
TKH∆QK =
12∆Q
TK (∂E(QK )∂QK
− d∆QK ),
which is exactly the expected function value decrease estimationused in [Lourakis 2005]. This allows us to use a non-JT J form ofapproximate hessian for Eshuffle. In our case, we approximate theterm Eshuffle by first order expansion for both v j (qi ) and v j (qi−1),giving:
2018-03-17 02:32 page 15 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1:16 • Pan, et al
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
Eshuffle(qi ,qi−1)
=
V∑j=1∥(v j (qi + ∆qi ) −v j (qi−1 + ∆qi−1))∥ ∥2
exp(−γdist(v j (qi + ∆qi )))
≈V∑j=1∥(v j (qi ) +
∂v j
∂qi∆qi −v j (qi−1) −
∂v j
∂qi−1∆qi−1)∥ ∥2
exp(−γdist(v j (qi ) +∂v j (qi )∂qi
∆qi )),
and use the hessian of the last equation above. Conventional JT Japproximation of the hessian is used for all other terms.
B.2 Eliminating Internal Force TermsIn our objective function, Fi is a quadratic function in EEOM, inthe Tikhonov regularization Creg∥Fi ∥
2/2, and in the DMP regu-larization EDMP. We analytically solve and eliminate Fi from theoptimization as follows:
minFi
EEOM(qi−1,qi ,qi+1) +Creg∥Fi ∥2/2 +CDMPEDMP(Fi )
= minFi
12[∥EOMi − Fi ∥
2 +Creg∥Fi ∥2 +CDMP∥Fi − DMPi ∥2
]=
12
(EOMT
i DMPTi
)Mreg
(EOMiDMPi
)EOMi ≜
(I 0 0
) [ ∂q̄∂q
T(qi+1)MA(qi+1) +
∂[P − Ei
T q̄]
∂q(qi+1)
]
DMPi ≜
©«DMPp/np (i∆t ,W1)DMPp/np (i∆t ,W2)
...
DMPp/np (i∆t ,W|Fi |)
ª®®®®®¬Mreg ≜
11 +Creg +CDMP
(Creg +CDMP −CDMP−CDMP CregCDMP +CDMP
)⊗ I.
C V (Q) AND ITS DERIVATIVESIn this section, we briefly summarize the transformation functionfrom the reduced representation q to a vertex v’s Euclidean coordi-nates as defined in [Pan et al. 2015]. We then provide some guidanceon the computation of ∂v(q)
∂q and ∂2v(q)∂q2 . Since we use the LM algo-
rithm for space-time optimization, most objective terms only requirea first order derivative ∂v(q)
∂q . An exception is the physics violationterm EEOM, which requires second order derivatives.
C.1 Transformation FunctionWe assume that a deformable body is discretized usingV vertices andP elements. For each element j, its deformation gradient is denotedas F j . Vertices’ Euclidean coordinates q̄ can be reconstructed from F j
through Poisson reconstruction. We abbreviate this linear operatoras:
q̄ = ∆−1(F 1T · · · FPT
)T.
It is well-known that F j above has a polar decomposition F j = R jS j
where R j is a rotation and S j is an anisotropic scaling. We can thenuse the Rodrigues formula on the rotation part to get R j = exp(τ j ),where τ j is the rotation vector of element j . The rotation-strain (RS)space is defined by the space spanned by all possible τ j and S j − I:
span(RS) = {(τ 1, · · · ,τ P , S1 − I, · · · , SP − I)|S j is SPD}.RS representation and Euclidean coordinates are equivalent. How-ever, using RS representation is advantageous because the most vi-sually salient deformations lie in a low-dimensional linear subspaceof span(RS). Therefore, we can use conventional linear dimension-ality reduction techniques such as linear modal analysis [Pentlandand Williams 1989] in RS space to arrive at the following low-rankapproximation:
(τ 1, · · · ,τ P , S1 − I, · · · , SP − I) ≈ Bu,where B is a set of bases in the RS subspace. The transformationfunction from u to q̄ can then be defined by combining the aboveequations:
q̄(q) = ∆−1[exp](Bu)[S](Bu)
[exp] (Bu) ≜©«exp(τ 1)
. . .
exp(τ P )
ª®®¬ [S] (Bu) ≜©«S1
...
SP
ª®®¬ .However, this only encodes deformations in the local frame of refer-ence. To allow arbitrary movement in the global frame of reference,we can superimpose a global translation c and rotationw , giving:
q̄(q) =©«exp(w )
. . .
exp(w )
ª®®®¬∆−1[exp](Bu)[S](Bu) +
©«c...
c
ª®®®¬ .
C.2 Kinetic Cubature AccelerationMerely having the low-rank approximation does not accelerate com-putation. The evaluation of q̄ is still computationally costly becauseit requires a summation over all the P elements. This procedurecan be accelerated using cubature approximation by assuming thefollowing approximation:
∆−1[exp](Bu)[S](Bu)=
∑j∆−1j exp(w j )S j ≈
∑j ∈T
CjRS∆−1j exp(w j )S j ,
where ∆−1j is the block of ∆−1 corresponding to the jth element. The
weightingC jRS and the set of cubature elements T are precomputed
using L0-optimization.
C.3 Derivatives
To derive ∂v(q)∂q and ∂2v(q)
∂q2 , we notice that they can always bewritten as a long chain of matrix productions, where each matrixis either a constant, a linear function of q, or a linear functionof exp(w), ∂exp(w )
∂w , and ∂2exp(w )∂w2 . Equations of this form can be
accelerated using fast sandwich transform (FST) [Kim and James2011], i.e., by precomputing high-order tensors and contracting themwith q, exp(w), ∂exp(w )
∂w , and ∂2exp(w )∂w2 at runtime. The remaining
problem is to derive ∂exp(w )∂w and ∂2exp(w )
∂w2 . A closed-form of ∂exp(w )∂w
ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017. 2018-03-17 02:32 page 16 (pp. 1-17)
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
Active Animations of Reduced Deformable Models with Environment Interactions • 1:17
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
can be found in [Gallego and Yezzi 2015]. We now derive ∂2exp(w )∂w2
below using their notations:
R ≜ exp(w) ∂R∂wi
= [vi ]R
∂2R∂wi∂w j
= [ ∂vi∂w j]R + [vi ]
∂R∂w j
vi ≜wiw + [w](I − R)ei
∥w ∥2
= w̄iw̄ −sin(θ )[w̄]2 + (1 − cos(θ ))[w̄]3
θei
=θ − sin(θ )
θw̄iw̄ +
1 − cos(θ )θ
[w̄]ei +sin(θ )θ
ei ,
where we used the identity w̄ = w/∥w ∥, θ = ∥w ∥, [w̄]2 = (w̄w̄T − I),and w̄T [w̄] = 0. Finally, the ∂vi
∂w jabove has the following form:
∂vi∂w j
=θ − sin(θ )
θ2 (ejw̄i + w̄δi j − 2w̄w̄iw̄ j ) +
sin(θ ) − θcos(θ )θ2 w̄w̄iw̄ j +
1 − cos(θ )θ2 [ej − w̄ jw̄]ei +
θsin(θ ) + cos(θ ) − 1θ2 [w̄]eiw̄ j −
sin(θ ) − θcos(θ )θ2 eiw̄ j .
D OTHER REDUCED MODELSIn this section, we analyze the cases where rotation-strain coor-dinates [Pan et al. 2015] is replaced with either LMA [Pentlandand Williams 1989] or reduced StVK [Barbič and James 2005]. Asmentioned in Section 6.2, we need to modify both q̄(q) and P inEquation 3. In both cases, q̄(q) takes the following simple form:
q̄(q) =©«exp(w)
. . .
exp(w)
ª®®¬ (Uu) +©«c...
c
ª®®¬ ,where U is a set of linear deformation bases. Due to the lack ofrotation-strain transformation, we have to introduce more columnstoU than B in order to represent nonlinear deformations. If LMA isused, P takes the same quadratic form as that for rotation-strain co-ordinates, P(q) = uTKu/2. If reduced StVK is used, P(u) is a quarticfunction in u whose polynomial coefficients can be precomputed.
2018-03-17 02:32 page 17 (pp. 1-17) ACM Transactions on Graphics, Vol. 1, No. 1, Article 1. Publication date: January 2017.
top related