Virtual Reality & Physically-Based Simulation

Transcription

1 Virtual Reality & Physically-Based Simulation Mass-Spring-Systems G. Zachmann University of Bremen, Germany cgvr.cs.uni-bremen.de

2 Definition: A mass-spring system is a system consisting of: 1. A set of point masses m i with positions x i and velocities v i, i = 1 n ; 2. A set of springs, where s ij connects masses i and j, with rest length l 0, spring constant k s (= stiffness) and the damping coefficient k d Advantages: Very easy to program Ideally suited to study different kinds of solving methods Ubiquitous in games (cloths, capes, sometimes also for deformable objects) Disadvantages: Some parameters (in particular the spring constants) are not obvious, i.e., difficult to derive No built-in volumetric effects (e.g., preservation of volume) Mass-Spring-Systems 5

3 rk Example Mass-Spring System: Cloth ms is a popular multi-discipline topic robotics, animation [20], and medical ods and models have been proposed to able bodies, such as, (1) implicit surte di erence approaches [23], (2) mass9, 1], (3) the Boundary Element Method ) the Finite Element Method (FEM) he Finite Volume Method (FVM) [22], article systems [20, 25, 8]. While specific accurate scientific/engineering simulan provide visually plausible emulations. e finite element method (FEM) targets ntations of the stress/decomposition of ed to more approximate systems, such g method. g work by Grinspun et al. [11], presented membrane method which connected the stance constraints for the edges in conngular constraints for the faces to synody mesh. Our methodvirtual uses disg. Zachmann Realityonly & Simulation s and attempts to account for the sur- Fig. 3 Thin Surfaces Concept - Illustrating the problem this paper addresses and solves. (a) a thin surface can be connected by any number of distance constraints, however, due to the constraints being parallel, the surface will be unable to keep its rigidity; (b) simple example of a flat surface attached to a wall, the surface will bend under the influence of gravity; (c) Grinspun et al. [11] presented a solution to rectify the problem by adding angular springs to neighbouring faces; (d) our approach solves the problem by adding virtual paralle layers to the surface that can be connected to provide rigidity to the mesh so it can support itself. Fig. 4 Point-Mass Coupling - Mass-Spring-Systems Spatial coupling of neighws 17 January bouring constraints along the surface axis, which we can also

4 A Single Spring (Plus Damper) Given: masses m i and m j with positions x i, x j i j Let r ij = x j x i x j x i The force between particles i and j : f ij r ij -f ij 1. Force exerted by spring (Hooke's law): m i k s m j f ij s = k s r ij (kx j x i k l 0 ) l 0 acts on particle i in the direction of j k d 2. Force exerted on i by damper: f ij d = k d((v i v j ) r ij )r ij 3. Total force on i : 4. Force on m j : Mass-Spring-Systems 7

5 Remarks A spring-damper element in reality: Alternative spring force: Notice: from (4) it follows that the total momentum is conserved Momentum p = v. m Fundamental physical law (follows from Newton's laws) Note on terminology: f ij s = k s r ij kx j x i k l 0 l 0 English "momentum" = German "Impuls" = velocity mass English "Impulse" = German "Kraftstoß" = force time Mass-Spring-Systems 8

6 Simulation of a Single Spring From Newton s law, we have: ẍ = 1 m f Convert differential equation (ODE) of order 2 into ODE of order 1: ẋ (t) =v(t) v (t) = 1 m f(t) Initial values (boundary values): v(t 0 )=v 0, x(t 0 )=x 0 "Simulation" = "Integration of ODE's over time" By Taylor expansion we get: x(t + t) =x(t)+ t ẋ (t)+o t 2 Analogously: à This integration scheme is called explicit Euler integration Mass-Spring-Systems 9

7 The Algorithm for a Mass-Spring System forall particles i : initialize x i, v i, m i loop forever: forall particles i : f i forall particles i : v i += x i += f g + f coll i + t fi m i t v i j,(i,j) S f(x i, v i, x j, v j ) render the system every n-th time f g = gravitational force f coll = penalty force exerted by collision (e.g., from obstacles) Mass-Spring-Systems 10

8 Advantages: Can be implemented very easily Fast execution per time step Is "trivial" to parallelize on the GPU ( "Massively Parallel Algorithms") Disadvantages: Stable only for very small time steps - Typically Δt sec! With large time steps, additional energy is generated "out of thin air", until the system explodes J Example: overshooting when simulating a single spring Errors accumulate quickly Mass-Spring-Systems 11

9 Example for the Instability of Euler Integration Consider the differential equation ẋ (t) = kx(t) The exact solution: x(t) =x 0 e kt Euler integration does this: Case : t > 1 k x t oscillates about 0, but approaches 0 (hopefully) Case : x t! t > 2 k x t+1 = x t + t( kx t ) x t+1 = x t (1 k t) <0 Mass-Spring-Systems 12

10 Visualization: position time ẋ (t) = x(t) Terminology: if k is large the ODE is called "stiff " The stiffer the ODE, the smaller Δt has to be Mass-Spring-Systems 13

11 Visualization of Error Accumulation Consider this ODE: ẋ (t) = x2 x 1 Exact solution: x(t) = r cos(t + ) r sin(t + ) The solution by Euler integration moves in spirals outward, no matter how small Δt! Conclusion: Euler integration accumulates errors, no matter how small Δt! Mass-Spring-Systems 14

12 Visualization of Differential Equations The general form of an ODE (ordinary differential equation): ẋ (t) =f( x(t), t ) Visualization of f as a vector field: Notice: this vector field can vary over time! Solution of a boundary value problem = path through this field Mass-Spring-Systems 16

13 Other Integrators Runge-Kutta of order 2: Idea: approximate f( x(t), t ) by using the derivative at positions x(t) and x( t+ ½Δt ) The integrator (w/o proof): a 1 = v t a 2 = 1 m f(xt, v t ) b 1 = v t ta 2 b 2 = 1 m f xt ta 1, v t ta 2 x t+1 = x t + tb 1 v t+1 = v t + tb 2 Runge-Kutta of order 4: The standard integrator among the explicit integration schemata Needs 4 function evaluations (i.e., force computations) per time step Order of convergence is: e( t) =O t 4 Mass-Spring-Systems 17

14 Runge-Kutta of order 2: Euler Runge-Kutta of order 4: Mass-Spring-Systems 18

15 Verlet Integration A general, alternative idea to increase the order of convergence: utilize values from the past Verlet integration = utilize x( t - Δt ) Derivation: Develop the Taylor series in both time directions: x(t + t) =x(t)+ tẋ (t)+ 1 2 t2 ẍ (t)+ 1 6 t3... x (t)+o t 4 x(t t) =x(t) tẋ (t)+ 1 2 t2 ẍ (t) 1 6 t3... x (t)+o t 4 Mass-Spring-Systems 19

16 Add both: Initialization: x( t) =x(0) + tv(0) t2 f(x(0), v(0)) m Remark: the velocity does not occur any more! (at least, not explicitly) Mass-Spring-Systems 20

17 Constraints Big advantage of Verlet over Euler & Runge-Kutta: it is very easy to handle constraints Definition: constraint = some condition on the position of one or more mass points Examples: 1. A point must not penetrate an obstacle 2. The distance between two points must be constant, or distance must be some maximal distance Mass-Spring-Systems 21

18 Example: consider the constraint 1. Perform one Verlet integration step 2. Enforce the constraint: x 1 x 2! = l 0 d d d = 1 t+1 ( x 2 x t+1 1 l 0 ) 2 ~ x 1 l ~ 0 x 2 x t+1 1 = x t dr 12 x t+1 2 = x t+1 2 dr 12 Problem: if several constraints are to constrain the same mass point, we need to employ constraint satisfaction algorithms Mass-Spring-Systems 22

19 Time-Corrected Verlet Integration Big assumption in basic Verlet: time-delta's are constant! Solution for non-constant Δt's: t i = t i 1 + t i 1 Time steps are: and Expand Taylor series in both directions: t i+1 = t i + t i x(t i + t i ) and x(t i t i 1 ) t i t i 1 Divide the expansions by and, respectively, then add both, like in the derivation of the basic Verlet Rearranging and omitting higher-order terms yields: x(t i + t i )=x(t i )+ t i t i 1 x(t i ) x(t i t i 1 ) + ẍ (t i ) t i + t i 1 2 t i Note: basic Verlet is a special case of time-corrected Verlet Mass-Spring-Systems 23

20 Implicit Integration (a.k.a. Backwards Euler) All explicit integration schemes are only conditionally stable I.e.: they are only stable for a specific range for Δt This range depends on the stiffness of the springs Goal: unconditionally stability One option: implicit Euler integration explicit implicit x t+1 i = x t i + tv t i x t+1 i = x t i + tv t+1 i v t+1 i = v t i + t 1 m i f(x t ) v t+1 i = v t i + t 1 m i f(x t+1 ) Now we've got a system of non-linear, algebraic equations, with x t+1 and v t+1 as unknowns on both sides implicit integration Mass-Spring-Systems 25

21 Solution Method Write the whole spring-mass system with vectors (n = #mass points): x v 0 x 0 x 1 v 0 v x 1 x = B A = x 2 v 1 x 3, v = B B C. A = v 2 f 0 (x) B C v 3, f(x) A B A f n 1 (x) x n 1 x 3n 1 v n 1 v 3n 1 f i = 0 1 f 3i+0 f 3i+1 (x) A, M 3nx3n = f 3i+2 (x) 0 m 0 m 0 m 0 m 1 m 1... m n 1 m n 1 1 C A m n 1 Mass-Spring-Systems 26

22 Write all the implicit equations as one big system of equations : Plug (2) into (1) : Mv t+1 = Mv t + tf(x t+1 ) (1) x t+1 = x t + t v t+1 (2) Mv t+1 = Mv t + t f( x t + tv t+1 ) (3) Expand f as Taylor series: (4) Mass-Spring-Systems 27

23 Plug (4) into (3): Mv t+1 = Mv t + t f(x f(xt ) tv t+1 {z } K = Mv t + tf(x t )+ t 2 Kv t+1 K is the Jacobi-Matrix, i.e., the derivative of f wrt. x: K = @x 0 f 0 K is called the tangent stiffness matrix - (The normal stiffness matrix is evaluated at the equilibrium of the system: here, the matrix is evaluated at an arbitrary "position" of the system in phase space, hence the name @x 1 f 3n 1 @x 0 f 3n 3n 1 f 3n 1 Mass-Spring-Systems 28 1 C A

24 Reorder terms : Now, this has the form: Solve this system of linear equations with any of the standard iterative solvers Don't use a non-iterative solver, because A changes with every simulation step We can "warm start" the iterative solver with the solution as of last frame - Incremental computation Mass-Spring-Systems 29

25 Computation of the Stiffness Matrix First, understand the anatomy of matrix K : A spring (i,j) adds the following four 3x3 block matrices to K : 3i 3j i j 3i 3j Matrix K ij arises from the derivation of f i = (f 3i, f 3i+1, f 3i+2 ) wrt. x j = (x 3j, x 3j+1, x 3j+2 ): K ij = In the following, consider only f s (spring force) @x 3j 3j+1 3j+2 @x 3j f 3j+2 f 3i+2 Mass-Spring-Systems 30 1 C A

26 First of all, compute K ii : K i f i (x i, x j x j x i = k s (x j x i ) l i kx j x i k = k s 0 I kx j x i k (x j x i ) (x j x i )> I l j x i k 0 kx j x i k 2 1 A = k s 1 I + l 0 kx j x i k I + l 0 kx j x i k (x 3 j x i )(x j x i ) T Mass-Spring-Systems 31

27 Reminder: kxk q x1 + x x 3 2 = xt kxk Mass-Spring-Systems 32

28 From some symmetries, we can analogously derive: K ij = xj f i (x i, x j )= K ii K jj = xj f j (x i, x j )= xj ( f i (x i, x j )) = K ii Mass-Spring-Systems 33

29 Overall Algorithm for Solving Implicit Euler Integration Initialize K = 0 For each spring (i,j) compute K ii, K ij, K ji, K jj and accumulate it to K at the right places Compute b = Mv t + tf(x t ) Solve the linear equation system Av t+1 = b Compute x t+1 = x t + t v t+1 Mass-Spring-Systems 34

30 Advantages and Disadvantages Explicit integration: + Very easy to implement - Small step sizes needed - Stiff springs don't work very well - Forces are propagated only by one spring per time step Implicit Integration: + Unconditionally stable + Stiff springs work better + Global solver forces are being propagated throughout the whole spring-mass system within one time step - Large stime steps are needed, because one step is much more expensive (if real-time is needed) - The integration scheme introduces damping by itself (might be unwanted) Mass-Spring-Systems 35

31 Visualization of: ẋ (t) = x(t) position time Informal Description: Explicit jumps forward blindly, based on current information Implicit tries to find a future position and a backwards jump such that the backwards jump arrives exactly at the current point (in phase space) Mass-Spring-Systems 36

32 Demo Mass-Spring-Systems 37

33 Mesh Creation for Volumetric Objects How to create a mass-spring system for a volumetric model? Challenge: volume preservation! Approach 1: introduce additional, volume-preserving constraints Springs to preserve distances between mass points Springs to prevent shearing Springs to prevent bending No change in model & solver required You could also introduce "angle-preserving springs" that exert a torque on an edge Mass-Spring-Systems 39

34 Approach 2 (and still simple): model the inside volume explicitly Create a tetrahedron mesh out of the geometry (somehow) Each vertex (node) of the tetrahedron mesh becomes a mass point, each edge a spring Distribute the masses of the tetrahedra (= density volume) equally among the mass points Mass-Spring-Systems 40

35 Generation of the tetrahedron mesh (simple method): Distribute a number of points uniformly (perhaps randomly) in the interior of the geometry (so called "Steiner points") Dito for a sheet/band above the surface Connect the points by Delaunay triangulation (see my course "Computational Geometry for CG") Anchor the surface mesh within the tetrahedron mesh: Represent each vertex of the surface mesh by the barycentric combination of its surrounding tetrahedron vertices Mass-Spring-Systems 41

36 Approach 3: kind of an "in-between" between approaches 1 & 2 Create a virtual shell around the two-manifold mesh Connect the shell with the "real" mesh by diagonal springs Video: 1. no virtual shells, 2. one virtual shell, 3. several virtual shells Mass-Spring-Systems 42

37 Collision Detection for Mass-Spring Systems Put all tetrahedra in a 3D grid (use a hash table!) In case of a collision in the hash table: Compute exact intersection between the 2 involved tetrahedra Mass-Spring-Systems 43

38 Collision Response Given: objects P and Q (= tetrahedral meshes) that collide Task: compute a penalty force Naïve approach: For each mass point of P that has penetrated, compute its closest distance from the surface of Q force = amount + direction Q Problem: Implausible forces P "Tunneling" (s. a. the chapter on force-feedback) Mass-Spring-Systems 44

39 Examples: inconsistent consistent Mass-Spring-Systems 45

40 ge 1 Consistent Penalty Forces 1. Phase: identify all points of P that penetrate Q Q Algorithm Stage 2 ied as colliding! spatial hashing! border points, intersecting edges, and in P are detected! extended spatial hashin 2. Phase: determine all edges of P that intersect the surface of Q For each such edge, compute the exact intersection point xi colliding point For each non-colliding point bord inter inter inter intersection point, compute a normal ni - E.g., by barycentric interpolation of the vertex Computer Science - Computer Graphics Laboratory University of Freiburg - Institute of Computer Science - Compu normals of Q G. Zachmann Virtual Reality & Simulation WS 17 January 2018 Mass-Spring-Systems 46

41 penetration depth d(p) approximated using th points xi and normals n 3. Phase: compute the approximate force for border points! Border point = a point p that penetrates Q and is incident to an intersecting edge Observation: a border point can be incident to several intersecting edges Set the penetration depth for point p Q to d(p) = k i =1 (xi, p) (xi k i =1 p) ni (xi, p) where d(p) = approx. penetration depth of mass point p, xi = point of the intersection of an edge incident to p with surface Q, ni = normal to surface of Q at point xi, and G. Zachmann (xi, p) = P 1 xi Virtual Reality & Simulation p WS 17 January 2018 Mass-Spring-Systems 47

42 Direction of the penalty force on border points: r(p) = P k i=1!(x i, p) n i P k i=1!(x i, p) 4. Phase: propagate forces by way of breadth-first traversal through the tetrahedron mesh k i=1 (p i, p) (p i p) r i + d(p i ) d(p) = k i=1 (x i, p) where p i = points of P that have been visited already, p = point not yet visited, r i = direction of the estimated penalty force in point p i. Mass-Spring-Systems 48

43 Visualization Mass-Spring-Systems 49

44 Video Mass-Spring-Systems 50