This amounts to solving the equations under the constraints u _H imposed by handle vertices. In this equation, k _s and k _b denote the stiffness for surface stretching and bending, respectively, and Δ is the Laplace-Beltrami operator. It can be discretized using the following form: where u _i is the displacement of the i 'th vertex v _i , and v _i ∈ N ₁ (v _i ) are its incident one-ring neighbors. For the per-vertex normalization weights and the edge weights, we are using the de facto standard cotangent discretization [2] . where α _ij and β _ij are the two angles opposite to the edge (v _i , v _j ), and A _i is the Voronoi area of vertex v _i as shown in Figure 27.2 .

Setting up this equation at every free vertex yields the linear system to be solved for the unknown displacements u ∈ R ^{(V − H) × 3} of the (V − H ) free vertices. The matrix A is of size (V − H ) × (V − H ), and A _H is of size (V − H ) × H .

The standard way of computing the displacements would be directly solving the preceding linear equation system. However, we found that precomputing a “basis function” matrix Bu _H = u allows a very efficient evaluation of the large-scale deformation during runtime on the GPU. Basically, the required computation during runtime boils down to a simple matrix-vector multiplication of the basis function matrix B with the handle positions u _H .

The basis function matrix B = − A ⁻¹ A _H depends only on the rest pose mesh and the selection of handle vertices. Each column b _i of B is computed by solving a sparse linear system Ab _i = h _i involving A and the corresponding column h _i of A _H .

At runtime, the large-scale deformation u is obtained from the handle displacement u _H by the matrix product Bu _H = u , which can efficiently be computed in a parallel GPU implementation. The kernel for the matrix multiplication is given in Listing 27.1 .

Before starting the animation sequence, we load all required static data to GPU memory. In the case of the large-scale deformation, this comprises the position of all vertices in their rest pose (float4 *in) and the basis function matrix B _T (float *basis). During animation only the current handle displacements u _H have to be copied to the GPU (float3 *handles) and the LargeScaleKernel kernel function has to be invoked for all face vertices in parallel. The function first copies the commonly accessed handles to fast on-chip shared memory. After that step is completed, the matrix vector multiplication can be carried out in a simple for-loop, and the resulting displacements can be added to rest pose positions. Please note that matrix B is stored transposed to achieve a coalesced memory access pattern.

We require a suitable space and descriptor that controls the interpolation of fine-scale displacements from a set of example poses. At each animation frame, the raw input data describing a pose consists of the positions of the handle vertices. These data are not invariant under rigid transformations; hence, it does not constitute an effective pose descriptor.

As everybody can observe, bulging effects of wrinkles appear due to lateral compression of skin patches. Therefore, we suggest a feature vector that measures skin strain between various points across the face. We define a set of F edges between handle vertices, which yields an F -dimensional feature vector f = [ f ₁ … f _F ] of a pose. The entry f _i represents the relative stretch of the i 'th feature edge, which can be regarded as a measure of strain. Specifically, given the positions of the end points p _{i , 1} and p _{i , 2} and the rest length l _i , we define

Figure 27.3 shows the correlation between the feature vector and wrinkle formation.

Our goal is to use a data-driven approach and learn the connection of skin strain to wrinkle formation. We represent each facial expression by its rotation-invariant feature vector f as described in the last section. Hence, each facial expression corresponds to a point in an F -dimensional pose space, which constitutes the domain of the function we want to learn. Its range is the fine-scale detail correction d , represented as well in a rotation-invariant manner by storing it in per-vertex local frames.

Each of the P example poses corresponds to a feature vector f with its associated fine-scale displacement d . Our goal is now to come up with a function that fulfills the following properties:

This corresponds to a scattered data interpolation problem, for which we employ radial basis functions (RBFs). Hence, the function d : R ^F → R ^{3 V} , mapping a facial pose to 3-D fine-scale displacement, has the form where φ is a scalar basis function, and w _j ∈ R ^{3 V} and f _j are the weight and feature vectors for the j 'th example pose. We employ the biharmonic RBF kernel φ (r ) = r , because it allows for smooth interpolation of sparsely scattered example poses and does not require any additional parameter tuning. More information on smooth scattered data interpolation using RBFs can be found in Carr et al . [5] .

In our basic definition of a function for blending in details, every input example influences all vertices of the face mesh in the same manner because we compute a single feature distance per example pose j . This feature distance is constant over the whole face. Consequently, the set of example poses is required to grow exponentially to sufficiently sample the combinations of independent deformations (e.g., raising both eyebrows versus raising just one eyebrow). As an answer to this problem, we follow the idea of [4] . We break the face into several overlapping areas. Every vertex will be affected only by a small set of nearby strain measurements. This requires us to redefine the function d (f ) to compute feature distances in a per-vertex manner, replacing the global Euclidean metric with a weighted distance metric per vertex v : where f _j,i is the strain of the i 'th strain edge in the j 'th pose. We exploit the fact that every edge measures a local property (i.e., relative stretch of feature edges), and therefore, assign weights α _v,i based on proximity to the edges. Specifically, for a vertex v we define the weight of the i 'th feature edge as a exponentially decaying weight where l _i is the rest length of the feature edge, and L _v,i is the sum of rest pose distances from vertex v to the edge end points. This weight is 1 on the edge and decays smoothly everywhere else, as shown in Figure 27.4 . The parameter β can be used to control the rate of decay, based on the local density of handle vertices. In our experiments we discard weights , and set β so that a vertex is influenced by at most 16 edges.

As a preprocess, the RBF weights w _j have to be computed. We compute the weights so that the displacements of the example poses are interpolated exactly; that is, d (f _i ) = d _i . This reduces to solving 3 · V linear P × P systems, which differ in their right-hand side only.