Active Animations of Reduced Deformable Models with ...gamma.cs.unc.edu/ActiveAnim/Final.pdfgenerate...

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 [email protected].© 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.

https://doi.org/10.1145/nnnnnnn.nnnnnnn

https://doi.org/10.1145/nnnnnnn.nnnnnnn

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


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


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


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


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.


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


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


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Ãĳckert 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.


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


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).


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


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


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Ãĳckert 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.


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


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


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


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Ãĳckert 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


https://doi.org/10.1145/1457515.1409118

https://doi.org/10.1145/1457515.1409118

https://doi.org/10.1145/1576246.1531359

https://doi.org/10.1145/1576246.1531359

https://doi.org/10.1145/1186822.1073300

https://doi.org/10.1145/1778765.1778818

https://doi.org/10.1145/2185520.2185566

https://doi.org/10.1145/2185520.2185566

https://doi.org/10.1145/1964921.1964986

https://doi.org/10.1145/1275808.1276439

https://doi.org/10.1561/2200000016

https://doi.org/10.1561/2200000016

https://doi.org/10.1145/566654.566623

https://doi.org/10.1111/j.1467-8659.2011.02058.x

https://doi.org/10.1111/j.1467-8659.2011.02058.x

https://doi.org/10.1145/566570.566622

https://doi.org/10.1145/1576246.1531394

https://doi.org/10.1145/1576246.1531394

https://doi.org/10.1109/TVCG.2005.13

https://doi.org/10.1145/2185520.2185565

https://doi.org/10.1007/s10851-014-0528-x

https://doi.org/10.1145/2185520.2185568

https://doi.org/10.1145/2461912.2461922

https://doi.org/10.1145/2461912.2461922

http://graphics.cs.berkeley.edu/papers/Hauser-IDU-2003-06/

http://graphics.cs.berkeley.edu/papers/Hauser-IDU-2003-06/

https://doi.org/10.1145/2185520.2185567

https://doi.org/10.1016/j.gmod.2005.03.007

https://doi.org/10.1016/j.gmod.2005.03.007

https://doi.org/10.1145/1186562.1015735

https://doi.org/10.1177/0278364911406761

http://arxiv.org/abs/http://dx.doi.org/10.1177/0278364911406761

https://doi.org/10.1145/2019627.2019640

https://doi.org/10.1145/2019627.2019640

https://doi.org/10.1145/2019406.2019415

https://doi.org/10.1007/BF01589116

https://doi.org/10.1007/BF01589116

https://doi.org/10.1145/2508363.2508427

https://doi.org/10.1145/2185520.2185539

https://doi.org/10.1145/2508363.2508365

https://doi.org/10.1109/ICRA.2016.7487091


http://dl.acm.org/citation.cfm?id=1006058.1006087

https://doi.org/10.1145/2816795.2818090

https://doi.org/10.1145/3072959.3073602

https://doi.org/10.1145/3072959.3073602

https://doi.org/10.1145/74334.74355

https://doi.org/10.1145/74334.74355

https://doi.org/10.3389/fncom.2013.00138

https://doi.org/10.3389/fncom.2013.00138

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


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:


https://doi.org/10.1145/2601097.2601156

https://doi.org/10.1145/2601097.2601156

https://doi.org/10.1145/2185520.2185522

https://doi.org/10.1145/37401.37427


https://doi.org/10.1145/2185520.2185521

https://doi.org/10.1145/2185520.2185521

https://doi.org/10.1145/54852.378507

https://doi.org/10.1145/2897824.2925916

https://doi.org/10.1145/1275808.1276501

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


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


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.


Active Animations of Reduced Deformable Models with ...gamma.cs.unc.edu/ActiveAnim/Final.pdfgenerate...

Documents

Transcript of Active Animations of Reduced Deformable Models with ...gamma.cs.unc.edu/ActiveAnim/Final.pdfgenerate...