implicit integration collision detection

CS-C3100 Fall 2018 – Lehtinen 1

CS-C3100 Computer Graphics Jaakko Lehtinen

Implicit Integration Collision Detection

Philippe Halsman: Dali Atomicus

Good pointers to extra credit in Assignment 4)

http://en.wikipedia.org/wiki/Philippe_Halsman

CS-C3100 Fall 2018 – Lehtinen

In These Slides

2

• Implicit Integration • Collision detection and response

– Point-object and object-object detection – Only point-object response


ODE: Path Through a Vector Field

3

• X(t): path in multidimensional phase space

• f = d/dt X is a vector that sits at each point in phase space, pointing the direction.

“When we are at state X at time t, where will X be after an infinitely small time interval dt ?”

ddt

X = f(X, t)

http://en.wikipedia.org/wiki/Phase_space


Implicit integration

4

• So far, we have seen explicit Euler – X(t+h) = X(t) + h X’(t)

• We also saw midpoint and trapezoid methods – They took small Euler steps, re-evaluated X’ there, and

used some combination of these to step away from the original X(t).

– Yields higher accuracy, but not impervious to stiffness



5


• Implicit Euler uses the derivative at the destination! – X(t+h) = X(t) + h X’(t+h) – It’s implicit because we don’t have X’(t+h),

it depends on where we go



6


• Implicit Euler uses the derivative at the destination! – X(t+h) = X(t) + h X’(t+h) – It’s implicit because we don’t have X’(t+h),

it depends on where we go (HUH?) – Two situations

• X’ is known analytically and everything is closed form (doesn’t happen in practice)

• We need some form of iterative non-linear solver.


• Remember our model problem: x’ = -kx – Exact solution was a decaying exponential x0 e-kt

• Explicit Euler: x(t+h) = (1-hk) x(t) – Here we got the bounds on h to avoid oscillation/explosion

Simple Closed Form Case



• Explicit Euler: x(t+h) = (1-hk) x(t)

• Implicit Euler: x(t+h) = x(t) + h x’(t+h)





• Implicit Euler: x(t+h) = x(t) + h x’(t+h) x(t+h) = x(t) - hk x(t+h) = x(t) / (1+hk) – It’s a hyperbola!





• Implicit Euler: x(t+h) = x(t) + h x’(t+h) x(t+h) = x(t) - h k x(t+h) = x(t) / (1+hk) – It’s a hyperbola!

Implicit Euler is unconditionally stable!

1/(1+hk) < 1, when h,k > 0



Implicit vs. Explicit

From the siggraph PBM notes11


Implicit Euler, Visually

12

Xi Xi+1

Xi+1 = Xi + h f( Xi+1, t+h ) Xi+1 - h f( Xi+1, t+h ) = Xi


Implicit Euler, Visually

13

Xi Xi+1

-hf(X,t)

Xi+1 = Xi + h f( Xi+1, t+h ) Xi+1 - h f( Xi+1, t+h ) = Xi

What is the location Xi+1=X(t+h) such that the derivative there, multiplied by -h, points back to Xi=X(t) where we are starting from?


Implicit Euler and Large Systems

14

• To simplify, consider only time-invariant systems – This means X’ = f(X,t) = f(X) is independent of t – Our spring equations satisfy this already

• Implicit Euler with N-D phase space: Xi+1 = Xi + h f( Xi+1 )


Implicit Euler and Large Systems

15

• To simplify, consider only time-invariant systems – This means X’ = f(X,t) = f(X) is independent of t – Our spring equations satisfy this already


• Non-linear equation, unknown Xi+1 on both the LHS and the RHS – Do you know methods for solving such equations?


Newton’s Method (1D)

16

• Iterative method for solving non-linear equations

• Start from initial guess x0, then iterate

F (x) = 0


Newton, Visually

17

We are heref(x)

Wik

iped

ia u

sers

Ole

gale

xand

rov,

Pbr

oks1

3


Newton, Visually

18

We are here

Let’s approximate f by its tangent at point (xn, f(xn))

f(x)

Wik

iped

ia u

sers

Ole

gale

xand

rov,

Pbr

oks1

3


Newton, Visually

19

We are here

Let’s approximate f by its tangent at point (xn, f(xn))

Then we’ll see where the tangent line crosses zero and take that as

next guess

f(x)

Wik

iped

ia u

sers

Ole

gale

xand

rov,

Pbr

oks1

3


Newton, Visually

20

f(x)

Wik

iped

ia u

sers

Ole

gale

xand

rov,

Pbr

oks1

3

Repeat

xn+2



21



• Also called Newton-Raphson iteration

F (x) = 0

xi+1 = xi �f(xi)f �(xi)



22



F (x) = 0

xi+1 = xi �f(xi)f �(xi)

one step

⇥ f �(xi)(xi+1 � xi) = �f(xi)


Newton’s Method – N Dimensions

23

• 1D:

• Now locations Xi, Xi+1 and F live in N-D phase space • N-D Newton step is just like 1D:

NxN Jacobian matrix

replaces f’

JF (Xi)(Xi+1 �Xi) = �F (Xi)unknown N-D

step from current to next

guess

⇥ f �(xi)(xi+1 � xi) = �f(xi)


Newton’s Method – N Dimensions

24

• Now locations Xi, Xi+1 and F are N-D • Newton solution of F(Xi+1) = 0 is just like 1D:

• Must solve a linear system at each step of Newton iteration – Note that also Jacobian changes for each step

NxN Jacobian matrix

JF (Xi)(Xi+1 �Xi) = �F (Xi)

JF (Xi) =�

�F

�X

⇥

Xi

unknown N-D step from

current to next guess


Questions?

25


Implicit Euler – N Dimensions

26


• Let’s rewrite this as withF (Y ) = 0,

F (Y ) = Y �Xi � hf(Y )



27


• Let’s rewrite this as with

• Then the Y that solves F(Y)=0 is Xi+1

F (Y ) = 0,

F (Y ) = Y �Xi � hf(Y )


• Then iterate until F(Y)=0: – Initial guess (or result of explicit method)

– For each step, solve

– Then set

Y 0 = Xi

JF (Y i)�Y = �F (Y i)

Y is variable Xi is fixed

Y i+1 = Y i + �Y

F (Y ) = Y �Xi � hf(Y )



What is the Jacobian?

29

• Simple partial differentiation...

• Where

F (Y ) = Y �Xi � hf(Y )

JF (Y ) =�

�F

�Y

⇥= I � hJf (Y )

Jf (Y ) =�

�f

�Y

⇥The Jacobian of

the derivative (force) function f


Putting It All Together

30

• Iterate until convergence

– Initial guess (or result of explicit method)

– For each step, solve

– Then set

�I � Jf (Y i)

⇥�Y = �F (Y i)

Y 0 = Xi

Y i+1 = Y i + �Y


Implicit Euler with Newton, Visually

31

Xi=Y0



31

Xi=Y0

Y1



31

Xi=Y0

Y1-hf(X,t)



31

Xi=Y0

Y1



31

Xi=Y0

Y1Y2



31

Xi=Y0

Y1Y2

-hf(X,t)



31

Xi=Y0

Y1Y2



31

Xi=Y0

Y1Y2

Y3



31

Xi=Y0

Y1Y2

Y3

-hf(X,t)



31

Xi=Y0

Y1Y2

Y3



31

Xi=Y0

Y1Y2

Y3Y=Xi+1



32

Xi=Y0

-hf(X,t)

What is the location Xi+1=X(t+h) such that the derivative there, multiplied by -h, points back to Xi=X(t) where we are starting from?

Y=Xi+1


One-Step Cheat

33

• Often, the 1st Newton step may suffice – People often implement Implicit Euler using only one step. – This amounts to solving the system

where the Jacobian and f are evaluated at Xi, and we are using Xi as an initial guess.

�I � h

�f

�X

⇥�X = hf(X)


Questions?

34


Good News

35

• The Jacobian matrix Jf is usually sparse – Only few non-zero entries per row

�I � Jf (Y i)

⇥�Y = �F (Y i)


Good News

36

• The Jacobian matrix Jf is usually sparse – Only few non-zero entries per row – E.g. the derivative of a spring force only depends on the

adjacent masses’ positions • Makes the system cheaper to solve

– Don’t invert the Jacobian! – Use iterative matrix solvers like

conjugate gradient, perhaps with preconditioning, etc.

�I � Jf (Y i)

⇥�Y = �F (Y i)


Implicit Euler Pros & Cons

37



37

• Pro: Stability!



37

• Pro: Stability!

• Cons: – Need to solve a linear system at each step – Stability comes at the cost of “numerical viscosity”, but

then again, you don’t have to worry about explosions. • Recall exp vs. hyperbola



37

• Pro: Stability!

• Cons: – Need to solve a linear system at each step – Stability comes at the cost of “numerical viscosity”, but

then again, you don’t have to worry about explosions. • Recall exp vs. hyperbola

• Note that accuracy is not improved – error still O(h) – There are lots and lots of implicit methods out there!


Reference

38

• Large steps in cloth simulation • David Baraff Andrew Witkin • http://portal.acm.org/citation.cfm?id=280821

http://portal.acm.org/results.cfm?query=author%253AP60514&querydisp=author%253ADavid%2520Baraff&coll=GUIDE&dl=GUIDE&CFID=1991074&CFTOKEN=12116421

http://portal.acm.org/results.cfm?query=author%253AP18516&querydisp=author%253AAndrew%2520Witkin&coll=GUIDE&dl=GUIDE&CFID=1991074&CFTOKEN=12116421

http://portal.acm.org/citation.cfm?id=280821


Example

39Dongsoo Han


Questions?

40


Collisions for Particles

41

• Detection • Response • Overshooting problem

(when we enter the solid)


Examples

42


Detecting Collisions

43

• Easy with implicit equations of surfaces: H(x,y,z) = 0 on the surface H(x,y,z) < 0 inside surface

• So just compute H and you know that you’re inside if it’s negative

• More complex with other surface definitions like meshes – A mesh is not necessarily even closed, what is inside?


Collision Response for ParticlesNv

44



45

vn

vt

v=vn+vt

normal component tangential component



46

• Tangential velocity vt often unchanged

• Normal velocity vn reflects:

• Coefficient of restitution ε

• When ε = 1, mirror reflection

vn

vt

Nv vnew

Nv vnew

ε=1

ε<1


Collisions – Overshooting

47

• Usually, we detect collision when it’s too late: we’re already inside

• Your ODE integrator just evaluates forces, doesn’t know about surfaces!

xi

xi+1



backtracking

48


• Solution: Back up • Compute intersection point • Ray-object intersection! • Compute response there • Advance for remaining

fractional time step

xi

xi+1



fixing

backtracking

49


• Solution: Back up • Compute intersection point • Ray-object intersection! • Compute response there • Advance for remaining

fractional time step

• Other solution: Quick and dirty fixup

• Just project back to object closest point

xi

xi+1


Questions?

http://en.wikipedia.org/wiki/Pong

50

• Pong: ε =1 • http://www.youtube.com/watch?v=sWY0Q_lMFfw • http://www.xnet.se/javaTest/jPong/jPong.html

http://en.wikipedia.org/wiki/Pong

http://www.youtube.com/watch?v=sWY0Q_lMFfw

http://www.xnet.se/javaTest/jPong/jPong.html


Collision Detection in Big Scenes

51

• Imagine we have n objects. Can we test all pairwise intersections? – Quadratic cost O(n2)!

• Simple optimization: separate static objects – But still O(static × dynamic+ dynamic2)

• Can you think of ways of being smarter?


Hierarchical Collision Detection

52

• Use simpler conservative proxies (e.g. bounding spheres)

• Recursive (hierarchical) test – Spend time only for parts of the scene that are close

• Many different versions, we’ll cover only one

• (Remember hierarchical N-body systems from two lectures ago?)


Bounding Spheres

53

• Place spheres around objects • If spheres don’t intersect, neither do the objects! • Sphere-sphere collision test is easy.


Sphere-Sphere Collision Test

C1 C2r1 r2

54

• Two spheres, centers C1 and C2, radii r1 and r2 • Intersect only if ||C1-C2||<r1+r2


Hierarchical Collision Test

55

• Hierarchy of bounding spheres – Organized in a tree

• Recursive test with early pruning

Root encloses whole object

....

....


Examples of Hierarchy

56

• http://isg.cs.tcd.ie/spheretree/

http://isg.cs.tcd.ie/spheretree/


Pseudocode (simplistic version)

57

boolean intersect(node1, node2) // no overlap? ==> no intersection!

if (!overlap(node1->sphere, node2->sphere)

return false // recurse down the larger of the two nodes

if (node1->radius()>node2->radius())

for each child c of node1

if intersect(c, node2) return true

else

for each child c f node2


// no intersection in the subtrees? ==> no intersection!

return false


node 1

node 2

58

boolean intersect(node1, node2)


return false




else



return false




return false




else



return false

72




return false




else



return false

72X




return false




else



return false


Pseudocode (with leaf case)

64



return false

// if there is nowhere to go, test everything

if (node1->isLeaf() && node2->isLeaf())

perform full test between all primitives within nodes // otherwise go down the tree in the non-leaf path

if ( !node2->isLeaf() && !node1->isLeaf() )

// pick the larger node to subdivide, then recurse

else

// recurse down the node that is not a leaf

return false


Other Options

65

• Axis Aligned Bounding Boxes – “R-Trees”

• Oriented bounding boxes – S. Gottschalk, M. Lin, and D. Manocha. “OBBTree: A hierarchical Structure for

rapid interference detection,” Proc. Siggraph 96. ACM Press, 1996

• Binary space partitioning trees; kd-trees


Questions?

66

• http://www.youtube.com/watch?v=nFd9BIcpHX4&feature=related

http://www.youtube.com/watch?v=b_cGXtc-nMg

http://www.youtube.com/watch?v=b_cGXtc-nMg


Deformable Objects

67

• When the objects deform, things get more complex, but modern methods are pretty good with those as well – Barbic, James Subspace Self-Collision Culling,

SIGGRAPH 2010

http://run.usc.edu/selfCD/

http://run.usc.edu/selfCD/


Hierarchy construction

68

• Top down – Divide and conquer

• Bottom up – Cluster nearby objects

• Incremental – Add objects one by one, binary-tree style.


Bounding sphere of a set of points

69

• Trivial given center C – radius = maxi ||C-Pi||

C


Bounding sphere of a set of points

70

• Using axis-aligned bounding box – center=

((xmin+xmax)/2, (ymin+ymax)/2, (zmin, zmax)/2) – Better than the average of the vertices because does not

suffer from non-uniform tessellation


Optimal Bounding Sphere?

71

• Using the centroid of the vertices for the center C is not necessarily optimal.

• Optimal construction is difficult • Other approximations exist.

– We’ll leave it at that.

C


Questions?

72


Top-Down Construction

73

• Take longest scene dimension • Cut in two in the middle

– assign each object or triangle to one side – build sphere around it


Top-Down Construction - Recurse

74

• Take longest scene dimension • Cut in two in the middle

– assign each object or triangle to one side – build sphere/box around it


Questions?

75


Reference

76


The cloth collision problem

Image from Bridson et al.

77

• A cloth has many points of contact • Stays in contact • Requires

– Efficient collision detection – Efficient numerical treatment (stability)


Robust Treatment of Simultaneous Collisions David Harmon, Etienne Vouga, Rasmus Tamstorf, Eitan Grinspun

78

http://www.cs.columbia.edu/cg/RTSC/


That’s All for Today!

79

• ... and for simulation and modeling, for that matter • Next we’ll start to work our way into rendering! • But before that, good luck in your midterm!

Bun

gie

/ ign

.com

implicit integration collision detection

Documents