Abstract:
Systems and methods for automatically animating a character based on an existing corpus of animation are described. The character may be from a previously produced feature animated film, and the data used for training may be the data used to animate the character in the film. A low-dimensional embedding for subsets of the existing animation corresponding to different semantic labels may be learned by mapping high-dimensional rig control parameters to a latent space. A particle model may be used to move within the latent space, thereby generating novel animations corresponding to the space&#39;s semantic label, such as a pose. Bridges may link a first pose of a first model within the latent space that is similar to a second pose of a second model of the space. Animations corresponding to transitions between semantic labels may be generated by creating animation paths that traverse a bridge from one model into another.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application claims priority under 35 U.S.C. §119(e) to U.S. Provisional Patent Application Ser. No. 62/280,654, titled “Repurposing Hand Animation for Interactive Applications,” filed Jan. 19, 2016, the contents of which are incorporated herein by reference in their entirety for all purposes. 
     
    
     BACKGROUND 
       [0002]    1. Field 
         [0003]    The present disclosure relates to computer-generated animation and, more specifically, to repurposing existing animated content of a character to synthesize new animated content of the character. 
         [0004]    2. Related Art 
         [0005]    A computer-generated feature animation is typically a labor- and time-intensive process that results in the creation of characters with compelling and unique personalities. However, because of the labor- and time-intensive nature of computer-generated feature animation, taking one of these characters and synthesizing new content consisting of compelling and expressive animation of the character presents a challenge. 
         [0006]    Statistical methods have been used to analyze and synthesize new motion data (e.g., as described in Brand and Hertzmann 2000, Mukai and Kuriyama 2005, and Lau et al. 2009). In particular, the Gaussian Process Latent Variable Model (GPLVM) (e.g., as described in Lawrence 2006) has been used for a number of applications directed to animation, such as satisfying constraints, tracking human motion (e.g., as described in Grochow et al. 2004, Urtasun et al. 2005, and Wang et al. 2008), or providing interactive control (e.g., as described in Ye and Liu 2010 and Levine et al. 2012). The GPLVM is used to reduce the dimension of the motion data and to create a statistical model of the animation. 
         [0007]    However, while GPLVM tends to keep far data separated in a reduced dimensional space, it makes no effort to keep similar data points close together. Thus, to address this shortcoming, modifications to the GPLVM have been proposed to make it better suited for modeling motion data by addressing this limitation of the model. For example, back constraints (e.g., as described in Lawrence and Quirionero Candela 2006) have been applied to the GPLVM to preserve local distances. For another example, dynamic models (e.g., as described in Wang et al. 2006 and Lawrence 2007) have been introduced to model the time dependencies in animation data. For another example, a connectivity prior (e.g., as described in Levine et al. 2012) has been proposed to ensure a high degree of connectivity among the animation data embedded in the low-dimensional latent space. 
         [0008]    Another shortcoming of the GPLVM is that the prior methods that model animation data using a GPLVM have only been used for full-body motion capture data. Similar techniques have not been applied to manually created animation for a film-quality character. A key difference between motion capture data and manually created film-quality animation is that the manually created animation from a film-quality animation lies in a significantly higher dimensional space than the motion capture data. 
         [0009]    Furthermore, data-driven approaches to character control and animation synthesis have focused only on full-body tasks, which are based on motion graphs (e.g., as described in Kovar et al. 2002, Lee et al. 2002, Treuille et al. 2007, Lo and Zwicker 2008, and Lee et al. 2009). These methods use a graph structure to describe how motion clips from a library can be connected and reordered to accomplish a task. However, while these approaches perform well with a large training set, smaller data sets are not well-suited for motion graphs because of a lack of variety and transitions in the motions. 
         [0010]    Similarly, other existing methods for character control include data-driven and physics-based approaches (e.g., as described in Coros et al. 2009, Muico et al. 2009, Levine et al. 2012, and Tan et al. 2014) are applied to full-body human motion or hand motion (e.g., as described in Andrews and Kry 2013). Thus, the tasks that the controllers are trained for can be quantifiably measured, such as locomotion or reaching tasks. However, existing methods do not animate a non-human character&#39;s face because tasks for facial animation are difficult to quantify. 
         [0011]    Facial animation of non-human characters can be controlled by re-targeting recorded expressions. A commonly used method is blendshape mapping (e.g., as described in Buck et al. 2000, Chai et al. 2003, Seol et al. 2011, Bouaziz et al. 2013, and Cao et al. 2013), which maps expressions from an input model onto corresponding expressions from the target character. Then, motion is generated by blending between the different facial shapes of the character. This approach uses an input model, such as a video recording of a human, to drive the animation of the character. Blendshape mapping approaches, however, control facial animation with recordings of a model. In addition, blendshape mapping approaches require that the character&#39;s face be animated with blendshapes. 
         [0012]    Lastly, as is well-known in the field, animated characters are controlled through an underlying rig, which deforms a surface mesh that defines a character. A variety of methods exist to map a character&#39;s rig controls to deformations of the surface mesh (e.g., as described in Barr 1984, Sederberg and Parry 1986, Magnenat-Thalmann et al. 1988, Singh and Fiume 1998, and Lewis et al. 2000). However, a technique that does not make assumptions about rig controls, and thus does not depend on an implementation of a particular type of mapping method, is needed. 
       SUMMARY 
       [0013]    In one exemplary embodiment, new animated content of a character is rendered based on existing animated content of the character. In particular, a first set of rig parameters corresponding to a first plurality of frames of the existing animated content of the character is received. A second set of rig parameters corresponding to a second plurality of frames of the existing animated content of the character is received. The first and second sets of rig parameters have a first dimension. A first set of model parameters is generated based on the first set of rig parameters. A second set of model parameters is generated based on the second set of rig parameters. The first and second sets of model parameters have a second dimension smaller than the first dimension. A latent space is generated that comprises a first semantic model, a second semantic model, and a bridge. The latent space has the second dimension. The first semantic model is generated based on the first set of model parameters. The second semantic model is generated based on the second set of model parameters. The bridge links the first semantic model and the second semantic model. The new animated content of the character is generated based on a location within the latent space. 
     
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         [0014]    The patent or application file contains at least one drawing executed in color. Copies of this patent or patent application publication with color drawings will be provided by the Office upon request and payment of the necessary fee. 
           [0015]    The present application can be best understood by reference to the following description taken in conjunction with the accompanying drawing figures, in which like parts may be referred to by like numerals. 
           [0016]      FIG. 1  illustrates exemplary existing animated content of a character. 
           [0017]      FIG. 2  illustrates exemplary new animated content of the character rendered based on the existing content. 
           [0018]      FIG. 3  illustrates an exemplary process of rendering new animated content from existing animated content. 
           [0019]      FIG. 4  illustrates an exemplary three-dimensional latent space learned from a training set of examples of a roar of the character. 
           [0020]      FIG. 5  illustrates an exemplary cross-section plot of a pose matching optimization function. 
           [0021]      FIG. 6  illustrates four examples of best-matching poses identified between two different models within the latent space. 
           [0022]      FIG. 7  illustrates exemplary particle trajectories through the latent space. 
           [0023]      FIG. 8  illustrates an exemplary computing system. 
       
    
    
     DETAILED DESCRIPTION 
       [0024]    The following description is presented to enable a person of ordinary skill in the art to make and use the various embodiments. Descriptions of specific devices, techniques, and applications are provided only as examples. Various modifications to the examples described herein will be readily apparent to those of ordinary skill in the art, and the general principles defined herein may be applied to other examples and applications without departing from the spirit and scope of the present technology. Thus, the disclosed technology is not intended to be limited to the examples described herein and shown, but is to be accorded the scope consistent with the claims. 
         [0025]    For descriptive purposes, throughout this disclosure, software, software modules, software objects, and the like may be described as performing various functions. One of ordinary skill in the art, however, will recognize that software may not actively perform any function and instead may include instructions that are executable on a computer processor. As such, although software may be described herein as performing a function, it should be appreciated that a computer processor or other computing device may typically perform those functions attributed herein to software modules or objects by executing computer instructions provided by the software modules or objects. 
         [0026]    As noted above, creating characters with compelling and unique personalities for a computer-generated feature animation can be labor and time intensive. Thus, as described below, existing animated content of a character can be repurposed by mapping rig control parameters to a latent space in order to synthesize new animated content of the character. 
         [0027]    For example,  FIG. 1  depicts existing animated content  102 - 108  of Toothless from the feature animated film  How to Train Your Dragon  2.  FIG. 2  depicts newly synthesized animation of Toothless generated using exemplary process  300  described below and depicted in  FIG. 3 . 
         [0028]    In  FIG. 3 , at block  302 , a first set of rig parameters corresponding to a first plurality of frames of the existing animated content of the character is received. At block  304 , a second set of rig parameters corresponding to a second plurality of frames of the existing animated content of the character is received. The first and second sets of rig parameters have a first dimension. 
         [0029]    In some embodiments, the first plurality of frames is associated with a first pose of the character and the second plurality of frames is associated with a second pose of the character. The second pose is different than the first pose. The first pose can comprise a particular facial expression of the character. 
         [0030]    At block  306 , a first set of model parameters is generated based on the first set of rig parameters. At block  308 , a second set of model parameters is generated based on the second set of rig parameters. The first and second sets of model parameters have a second dimension that is smaller than the first dimension. 
         [0031]    In some embodiments, a first set of intermediate space parameters and a second set of intermediate space parameters are generated from the first set of rig parameters and the second set of rig parameters, respectively. Then, the first set of model parameters and the second set of model parameters are generated based on the first set of rig parameters and the second set of rig parameters, respectively. 
         [0032]    In some embodiments, a first set of scaled parameters and a second set of scaled parameters are generated from the first set of rig parameters and the second set of rig parameters, respectively. Then, the first set of intermediate space parameters and the second set of intermediate space parameters are generated based on the first set of scaled parameters and the second set of scaled parameters, respectively. 
         [0033]    In some embodiments, generating a set of model parameters from a set of intermediate space parameters comprises applying a non-linear dimensionality reduction algorithm to the set of intermediate space parameters. In some embodiments, this non-linear dimensionality reduction algorithm is a Gaussian process latent variable model (GPLVM). In some embodiments, generating the set of intermediate space parameters from a set of scaled parameters comprises applying a linear dimensionality reduction algorithm to the set of scaled parameters. In some embodiments, this linear dimensionality reduction algorithm is principal component analysis. 
         [0034]    At block  310 , a latent space that comprises a first semantic model, a second semantic model, and a bridge is generated. The latent space has a dimension equal to the second dimension. The first semantic model is generated based on the first set of model parameters. The second semantic model is generated based on the second set of model parameters. The bridge links the first semantic model and the second semantic model. 
         [0035]    In some embodiments, creating the bridge comprises identifying a first transition point within the first semantic model, identifying a second transition point within the second semantic model, and linking the first transition point with the second transition point. In some examples, the first transition point and the second transition point are identified based on similarities between a frame associated with the first transition point and a frame associated with the second transition point. In some embodiments, the first transition point and the second transition point are identified using a pose-matching optimization function. 
         [0036]    At block  312 , the new animated content of the character is rendered based on a location within the latent space. In some embodiments, rendering the new animated content of the character based on the location within the latent space comprises determining a model parameter that corresponds to the location within the latent space, determining a rig parameter that corresponds to the model parameter, and then rendering a frame of animation associated with the determined rig parameter. In some embodiments, rendering the new animated content of the character based on the location within the latent space comprises determining a model parameter that corresponds to the location within the latent space, determining an intermediate space parameter that corresponds to the model parameter, determining a scaled parameter that corresponds to the intermediate space parameter, determining a rig parameter that corresponds to the scaled parameter, and then rendering a frame of animation associated with the determined rig parameter. 
         [0037]    In some embodiments, a particle model is used to move a particle within the latent space, and the rendered new animated content of the character corresponds to the particle&#39;s location (i.e., position) within the latent space as the particle is moved within the latent space. The particle is moved in accordance with an animation curve embedded within the latent space, and is moved between two or more different animation curves via one or more bridges between the animation curves. 
         [0038]    In some embodiments, it is determined whether the particle is not moved for at least a predetermined amount of time. The character may be “idling” when the particle is not moved for at least the predetermined amount of time. In some examples, if it is determined that the particle is not moved for at least the predetermined amount of time, the particle is moved around a hover point within the latent space, and the particle is not moved beyond a predetermined distance from the hover point. A “hovering” particle adds variety to the idling pose of the character. 
         [0039]    Some of the particulars of process  300 , including the mathematics involved in process  300 , are set forth in more detail below. 
       1.1 Scaling Rig Controls 
       [0040]    In one exemplary embodiment, given a large set of training animation of the character, represented as a sequence of rig control parameters, a mapping is generated between a low dimensional latent space and the rig parameters. The sequence of rig control parameters correspond to a sequence of frames of the animated character. For example,  FIG. 1  illustrates four frames  102 - 108  of a synthesized roar animation of the character Toothless the dragon  100  from the feature animated film  How to Train Your Dragon  2. The facial expression of Toothless  100  differs in each frame, as each frame represents a specific stage of the roar. The specific pose (e.g., facial expression) of Toothless  100  shown in frames  102 - 108  can be represented by a corresponding sequence of rig control parameters. 
         [0041]    The mapping between the low dimensional latent space and the rig parameters may be generated in three stages. First, each rig control parameter in the training data is scaled to proportionally weight the controls to changes in the final mesh. Second, the training animation data is reduced linearly. In some embodiments, the training animation data is reduced linearly using Principal Component Analysis (PCA). Third, the training data is non-linearly reduced and mapped to a lower dimensional latent space. In some embodiments, the Gaussian Process Latent Variable Model (GPLVM) is used to non-linearly reduce the training data to a three dimensional latent space. After an embedding of the training animation data in the latent space is found, any arbitrary point in the latent space may be mapped to values for the rig controls. This process of mapping from a set of rig control parameters to a low dimensional latent space is described in greater detail below. 
         [0042]    In some embodiments, it is assumed that the rig control parameters p, when evaluated, produce a surface mesh. The i th  vertex of this mesh is given by the function e i (p). In some embodiments, it is further assumed that the rig evaluation function e(p) is continuous, but no other assumptions are made. Thus, the evaluation function will be highly nonlinear. 
         [0043]    Depending on how the evaluation function e(p) is defined, large changes in some rig control parameters can result in small changes in the output surface mesh while small changes in other parameters can result in large changes in the mesh. Specifically, for some setting of the rig control parameters p, the value 
         [0000]    
       
         
           
              
             
               
                 ∂ 
                 
                   e 
                    
                   
                     ( 
                     p 
                     ) 
                   
                 
               
               
                 ∂ 
                 
                   p 
                   i 
                 
               
             
              
           
         
       
     
         [0000]    may be large for the i th  rig control parameter, but the value 
         [0000]    
       
         
           
              
             
               
                 ∂ 
                 
                   e 
                    
                   
                     ( 
                     p 
                     ) 
                   
                 
               
               
                 ∂ 
                 
                   p 
                   j 
                 
               
             
              
           
         
       
     
         [0000]    may be small for some other rig control parameter. Thus, there exists the possibility that some rig controls will have a very small effect on the surface mesh but have a large variance across the training animation data. If PCA is applied in this case, each component of the data will be scaled such that the principal axes of the transformation do not align with these controls with high variance but low influence on the mesh. 
         [0044]    In some embodiments, to avoid the above-described situation, the rig control parameters are scaled about the sample average to obtain z=W(p− p )+ p , where W represents a diagonal matrix and w i  represents the amount to scale the i th  rig control parameter by. W is chosen such that a unit change in the scaled rig control parameter space approximately corresponds with a unit change in the surface mesh. Specifically, for the i th  rig control parameter, 
         [0000]    
       
         
           
             
               
                 
                    
                   
                     
                       
                         
                           ∂ 
                           
                             ∂ 
                             
                               z 
                               i 
                             
                           
                         
                          
                         
                           e 
                           ( 
                           
                             
                               
                                 W 
                                 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 ( 
                                 
                                   z 
                                   - 
                                   
                                     p 
                                     _ 
                                   
                                 
                                 ) 
                               
                             
                             + 
                             
                               p 
                               _ 
                             
                           
                            
                         
                       
                       = 
                       1 
                     
                     , 
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where z is any possible value of the scaled rig control parameters. Then, p=W −1 z and the chain rule may be used to find that 
         [0000]    
       
         
           
             
               
                 
                   
                      
                     
                       
                         
                           ∂ 
                           
                             e 
                              
                             
                               ( 
                               p 
                               ) 
                             
                           
                         
                         
                           ∂ 
                           
                             p 
                             i 
                           
                         
                       
                        
                       
                         
                           ∂ 
                           
                             ∂ 
                             
                               z 
                               i 
                             
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 w 
                                 i 
                                 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     z 
                                     i 
                                   
                                   - 
                                   
                                     
                                       p 
                                       _ 
                                     
                                     i 
                                   
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 p 
                                 _ 
                               
                               i 
                             
                           
                           ] 
                         
                       
                     
                      
                   
                   = 
                   1. 
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0045]    In some embodiments, Equation (2) is used to solve for the weights to find that 
         [0000]    
       
         
           
             
               w 
               i 
             
             = 
             
               
                  
                 
                   
                     ∂ 
                     
                       e 
                        
                       
                         ( 
                         p 
                         ) 
                       
                     
                   
                   
                     ∂ 
                     
                       p 
                       i 
                     
                   
                 
                  
               
               . 
             
           
         
       
     
         [0000]    Because e(p) is a generally nonlinear function, Equation (2) cannot be satisfied for all possible values of p for a fixed W. Instead, the norm of the partial derivative can be approximated by evaluating the rig at the sample mean  p  of the training data and at several points about the mean. For rig control parameter i, a least squares error problem can be constructed to approximate the norm of the partial derivative by 
         [0000]    
       
         
           
             
               
                 
                   
                      
                     
                       
                         ∂ 
                         
                           e 
                            
                           
                             ( 
                             p 
                             ) 
                           
                         
                       
                       
                         ∂ 
                         
                           p 
                           i 
                         
                       
                     
                      
                   
                   ≈ 
                   
                     
                       argmin 
                       w 
                     
                      
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             - 
                             2 
                           
                         
                         2 
                       
                        
                       
                           
                       
                        
                       
                         
                           ( 
                           
                             
                                
                               
                                 
                                   e 
                                    
                                   
                                     ( 
                                     
                                       p 
                                       _ 
                                     
                                     ) 
                                   
                                 
                                 - 
                                 
                                   e 
                                    
                                   
                                     ( 
                                     
                                       
                                         p 
                                         _ 
                                       
                                       + 
                                       
                                         nσ 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                               
                                
                             
                             - 
                             w 
                           
                            
                         
                          
                         
                           nσ 
                           i 
                         
                          
                         
                           
                              
                             ) 
                           
                           2 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where σ i  is a vector with the sample standard deviation of the i th  rig control parameter in the i th  position and zeros elsewhere. For example, in Equation (3), the set of values n ∈ {−2, −1, 0, 1, 2} was found to produce good results. This least squares problem is solved separately for each w i . 
       1.2 Linear Dimensionality Reduction 
       [0046]    Generally, a fully-rigged main character for a feature animation film can have on the order of thousands of rig controls. Depending on the amount and/or nature of the rig controls, some of these rig controls may not be used in the training data. For example, some rig controls may only have a small, almost imperceptible effect on the animation and, as such, may not be used in the training data. In some embodiments, to remove these minimally-impactful controls and simplify the data, the dimension of the training data is linearly reduced using Principal Component Analysis (PCA). Consequently, small variations in the training data are treated as noise and are removed. This initial linear reduction also helps to improve the results of a subsequent non-linear dimensionality reduction, for example a Gaussian Process Latent Variable Model (GPLVM) based reduction, that may be applied to the training data later on in the reduction process. 
         [0047]    To demonstrate an exemplary use of PCA for linear dimensionality reduction, let z represent the scaled rig control parameters of a single frame of animation. There are D rig  control parameters and N total number of frames of animation in the training set. The scaled animation data may be represented as =[z 1 , z 2 , z 3 . . . . , z N ], where z i  ∈            D     rig    is a column vector corresponding with the i th  frame of animation. The sample mean of the data Z is denoted as  z . To compute the principal components of the training data, the mean is subtracted from each frame of animation. The singular value decomposition of the normalized data can then be computed using 
         [0000]        Z =UΣV T ,   (4)
 
         [0000]    where the matrix  Z  is the matrix Z with the sample mean subtracted from each column of the matrix. 
         [0048]    The columns of the matrix U contain the principal components of the training data. The number of principal components d pea  to use can be determined by considering the explained variance of the model. For example, the explained variance can be given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       v 
                        
                       
                         ( 
                         d 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             i 
                             - 
                             1 
                           
                           d 
                         
                          
                         
                             
                         
                          
                         
                           σ 
                           1 
                           2 
                         
                       
                       
                         
                           ∑ 
                           
                             i 
                             - 
                             1 
                           
                           k 
                         
                          
                         
                             
                         
                          
                         
                           σ 
                           1 
                           2 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where σ i   2  is the i th  singular value of the normalized matrix  Z  and k is the rank of the matrix. In this example, the d pca  is chosen such that v(d pca )≈0.85. With the number of principal components chosen, the transformation matrix T pca , which contains the first d pca  columns of the matrix U, is defined. The training data may then be represented as a d pca ×n matrix Y given by 
         [0000]      Y=T pca   T   Z .   (6)
 
         [0049]    The difference between running PCA on the original and scaled rig control parameters may be evaluated to determine the effect scaling the parameters have on the quality of the dimensionality reduction. If enough principal components are used to ensure that the explained variance is at or above 85%, there may be no discernible difference in quality of the animations between the scaled and original rig control parameters, but the GPLVMs described in the following section tend to perform better with the scaled rig control parameters. The difference between the original rig control parameters and the compressed data, measured as ∥z−T pca T pca   T z∥, may be much larger when using the scaled rig control parameters compared to the unscaled parameters. When a small number of principal components are used, animations compressed with the scaled rig control parameters are visually better than the animations compressed with the unscaled data. Furthermore, the unscaled version often contains objectively undesirable meshes, such as the jaw of a character passing through the roof of its mouth. Therefore, quantitative comparisons in the rig control parameter space may not be sufficient to evaluate the effectiveness of the disclosed method. 
         [0050]    1.3 Nonlinear Dimensionality Reduction 
         [0051]    In some embodiments, having generated the linearly reduced data in the matrix Y, a low-dimensional embedding through the use of a Gaussian Process Latent Variable Model (GPLVM) is computed. The GPLVM is a generative, probabilistic model that is used to map nonlinearly the PCA transformed data Y to a set of points X in a latent space of dimension d gplvm  where d gplvm &lt;d pca . Dynamics in the latent space can be modeled by placing a Gaussian process prior on the points X. This dynamics prior keeps temporally close data points close together spatially. Because the models are trained using multiple segments of animation, the GPLVM with a dynamics prior tends to keep separate segments far apart in the latent space. This separation is caused by the GPLVM placing dissimilar frames of animation far apart without trying to place similar frames near each other. Therefore, a connectivity prior can be used to pull together similar frames of animation from separate segments. 
         [0052]    The GPLVM models the training data Y as the output of a Gaussian process from the low dimensional embedding of the points X. It is assumed that each output of the Gaussian process is independent so that 
         [0000]      log  p ( Y|X )=Σ i=1   d     pca    log  N ( y   i ,:|0, K   x ),   (7)
 
         [0000]    which can be expressed as 
         [0000]    
       
         
           
             
               
                 
                   
                     log 
                      
                     
                         
                     
                      
                     
                       p 
                        
                       
                         ( 
                         
                           Y 
                            
                           X 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       
                         - 
                         
                           
                             d 
                             pca 
                           
                           2 
                         
                       
                        
                       
                          
                         
                           K 
                           x 
                         
                          
                       
                     
                     - 
                     
                       
                         1 
                         2 
                       
                        
                       
                         tr 
                          
                         
                           ( 
                           
                             
                               K 
                               x 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               YY 
                               T 
                             
                           
                           ) 
                         
                       
                     
                     + 
                     
                       const 
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The i th  row of Y is denoted as y i,: . For the entries in the kernel matrix K x , a radial basis function may be used. For example, the radial basis function is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       k 
                       x 
                     
                      
                     
                       ( 
                       
                         
                           x 
                           i 
                         
                         , 
                         
                           x 
                           j 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         σ 
                         rbf 
                         2 
                       
                        
                       
                         exp 
                          
                         
                           ( 
                           
                             
                               - 
                               
                                 1 
                                 
                                   2 
                                    
                                   
                                     l 
                                     x 
                                     2 
                                   
                                 
                               
                             
                              
                             
                               
                                  
                                 
                                   
                                     x 
                                     i 
                                   
                                   - 
                                   
                                     x 
                                     j 
                                   
                                 
                                  
                               
                               2 
                             
                           
                           ) 
                         
                       
                     
                     + 
                     
                       
                         δ 
                         ij 
                       
                        
                       
                         
                           σ 
                           white 
                           2 
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The kernel parameters σ rbf   2 , σ white   2 , and l 2  are optimized when the GPLVM is trained. 
         [0053]    In some embodiments, the input data is composed of multiple segments of animation, and the dynamics of each segment are modeled. For example, a Gaussian process prior is placed on the latent points X. The input to the Gaussian process is time t and an indicator s where s i =j indicates that frame i is part of the j th  animation segment. The indicator s is used in the kernel function to ensure that each segment is independent of all the others. Further, the dynamics prior is given by 
         [0000]      ψ D ( X, s, t )=Σ i=1   d     gplvm    log  N ( X   i,: |0,  K   st ),   (10)
 
         [0000]    which can be expressed as 
         [0000]      ψ D ( X, s, t )=−½Σ i=1   d     gplvm      x   i,:   T    K   st   −1   x   i,: +const.   (11)
 
         [0000]    As such, the entries in the kernel matrix K st  can be given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         k 
                         st 
                       
                        
                       
                         ( 
                         
                           
                             t 
                             i 
                           
                           , 
                           
                             t 
                             j 
                           
                           , 
                           
                             s 
                             i 
                           
                           , 
                           
                             s 
                             j 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         1 
                          
                         
                           [ 
                           
                             
                               s 
                               i 
                             
                             = 
                             
                               s 
                               j 
                             
                           
                           ] 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               ς 
                               rbf 
                               2 
                             
                              
                             
                               exp 
                                
                               
                                 ( 
                                 
                                   - 
                                   
                                     
                                       
                                         ( 
                                         
                                           
                                             t 
                                             i 
                                           
                                           - 
                                           
                                             t 
                                             j 
                                           
                                         
                                         ) 
                                       
                                       2 
                                     
                                     
                                       2 
                                        
                                       
                                         l 
                                         t 
                                         2 
                                       
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                           + 
                           
                             
                               ς 
                               white 
                               2 
                             
                              
                             
                               δ 
                               ij 
                             
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where 1[s i =s j ] is the indicator function that returns 1 if s i  and s j  are equal and 0 otherwise. 
         [0054]    In some embodiments, the connectivity prior allows for a modelling of the degree of connectivity amongst the latent points X by using graph diffusion kernels. For example, if G is a fully connected graph with a vertex for each training point in the latent space, then the edge weights of the graph can be defined as 
         [0000]        w ( x   i   , x   j )=∥ x   i   −x   j ∥ −p .   (13)
 
         [0055]    The weights represent the probability of a transition from x i  to x j . The value of p determines the preference for transitions between closer points. The connectivity prior defines a random walk process on G and considers the latent points X to be well-connected if all points are likely to be reached from any other point through the random walk. 
         [0056]    In some embodiments, the connectivity of the latent points is modeled as a diffusion kernel using, for example, the negative normalized graph Laplacian H=T −1/2 T −1/2 . The matrix T is diagonal with entries T ii =Σ j  w(x i , x i ), and the matrix L is defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     L 
                     i 
                   
                    
                   j 
                    
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 ∑ 
                                 k 
                               
                                
                               
                                 w 
                                  
                                 
                                   ( 
                                   
                                     
                                       x 
                                       i 
                                     
                                     , 
                                     
                                       x 
                                       k 
                                     
                                   
                                   ) 
                                 
                               
                             
                              
                             
                                 
                             
                           
                         
                         
                           
                             i 
                             = 
                             j 
                           
                         
                       
                       
                         
                           
                             
                               - 
                               
                                 w 
                                  
                                 
                                   ( 
                                   
                                     
                                       x 
                                       i 
                                     
                                     , 
                                     
                                       x 
                                       j 
                                     
                                   
                                   ) 
                                 
                               
                             
                              
                             
                                 
                             
                           
                         
                         
                           
                             i 
                             ≠ 
                             j 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0057]    The graph diffusion kernel can be computed by applying the function K d =exp βH, where β is a user-defined diffusion rate. Having computed the graph diffusion kernel, the connectivity prior can be calculated using the function: 
         [0000]      ψ C ( x )= w   c  Σ i  Σ j    K   ij   d ,   (15)
 
         [0000]    where w c  is a user-defined parameter specifying the weight of the connectivity prior. 
         [0058]    Combining the dynamics and connectivity priors, the conditional probability of X may be expressed as 
         [0000]        p ( X|t, s ) ∝ exp ψ D ( X, s, t ) ext ψ C  ( X )   (16)
 
         [0000]    The latent points X and the hyper-parameters σ rbf , σ white , and l x  can be estimated through maximum a posteriori (MAP) estimation. As such, the following can be maximized: 
         [0000]      log  p ( X, σ   rbf , σ white   , l   x   |Y, s, t )=log  p ( Y|K )+ψ D ( X, s, t )+ψ C ( X ).   (17)
 
         [0059]    To maximize Equation (17), a scaled conjugate gradient can be used. The initial guess for the latent points is the first d gplvm  rows of Y. The hyper-parameters for the dynamics prior are manually set and these values are not optimized. 
         [0060]      FIG. 4  illustrates a plot of nine animation curves embedded in an exemplary three-dimensional latent space  400 . The exemplary three-dimensional latent space  400  is learned for a training set of nine examples of a roar of Toothless  100  with a total of 393 frames. Representative images of six of the nine different roars of Toothless  100  that correspond to an animation curve embedded in the latent space  400  are shown. Roar  402  A depicted in image  402  corresponds to animation curve  402 B within the latent space  400 . Roar  404 A depicted in image  404  corresponds to animation curve  404 B within the latent space  400 . Roar  406 A depicted in image  406  corresponds to animation curve  406 B within the latent space  400 . Roar  408 A depicted in image  408  corresponds to animation curve  408 B within the latent space  400 . Roar  410 A depicted in image  410  corresponds to animation curve  410 B within the latent space  400 . Roar  412 A depicted in image  412  corresponds to animation curve  412 B within the latent space  400 . 
       1.4 Mapping to Rig Controls 
       [0061]    Once a trained model is generated, rig control values can be reconstructed from a new point x′ in the latent space. In some embodiments, the most likely point in the d pca  dimensional space given the new point and the GPLVM model is first identified. Next, the matrix of principal components is multiplied to the identified point in the d pca  dimensional space to obtain the scaled rig control parameters. Finally, the scaling factors are divided out and the mean is added to each parameter. 
         [0062]    The distribution of a new point y given the corresponding latent point x and the GPLVM model M is a Gaussian distribution, where 
         [0000]        p ( y|x, M )= N ( y|YK   x   −1   k   x ( x ),  k   x ( x, x )− k   x ( x ) T   K   x   k   x ( x )),   (18)
 
         [0000]    and where k x (x) is a column vector whose i th  entry is given by k x x i =k x (x i , x). Because the distribution is Gaussian, the most likely point in the d pca  dimensional space can be given by the mean YK x   −1 k x (x). The product YK x   −1  is precomputed, thus allowing this pose reconstruction problem to run linearly to the size of the training data for the model. 
       2. Animation Synthesis in Latent Space 
       [0063]    In some embodiments, new animations are synthesized by generating a new path P=[x 1 , x 2 , . . . , x t ] through the latent space. The rig control parameters for each point in the path is computed by mapping the point from the latent space to the high dimensional rig control space. Because the latent space provides a continuous mapping, any smooth curve in this low-dimensional space results in smooth animation curves for each rig control parameter. 
         [0064]    To synthesize a new path, a particle moving through the latent space can be simulated, and its position over time can be tracked. In some examples, the particle is controlled using a Lagrange multiplier method to enforce constraints on the system. In some examples, if a path that does not stray too far from a user-defined point is desired, a constraint is defined to enforce this behavior. In some examples, to add variations and noise to the path, a random force is applied. The particle simulation method works well for synthesizing facial animations. 
         [0065]    In order to achieve real-time performance, it can be helpful if the number of training points in the GPLVM is small. Thus, in some embodiments, in order to condense the overall number of training points in the GPLVM, the training data is divided into sufficiently small subsets of training data, where each subset of data corresponds with a specific type of pose (e.g., a facial expression or action and/or a bodily expression or action), such as a roar. As such, a separate GPLVM is trained on each subset of training data that corresponds with a specific type of pose, with each subset of training data generating a model within the latent space that corresponds with the specific type of pose of its respective subset of training data. However, because these latent spaces are separate, points from one model (e.g., corresponding to a first pose of the character) to another model (e.g., corresponding to the second pose of the character) have to be mapped. The mapping allows a particle to transition between models, which in turn allows for the synthesis of poses across multiple subsets of the training data corresponding to different types of poses of the character. 
       2.1 Particle Simulation 
       [0066]    In some embodiments, curves in the latent space are synthesized by tracking the position of a particle in the latent space over time. The input to a simulation is a path p(t) that the particle follows through time. In some examples, two constraints are applied to the system and a “random” force to add noise to the path. The first constraint ensures that the particle does not move too far from the path. The second constraint ensures that the particle remains in areas of high probability in the GPLVM. Because there may be instances where both constraints cannot be satisfied simultaneously, the path-following constraint is modeled as a hard constraint that must be satisfied, and the other constraint is modeled as a soft constraint that may be violated. 
         [0067]    In some embodiments, given some path p(t) parametrized by time, it is required that the particle does not drift too far away from the curve. Thus, to enforce this requirement, the following inequality constraint is applied: 
         [0000]      ∥ x−p ( t )∥ 2   −r   2 ≧0.   (19)
 
         [0000]    This inequality constraint ensures that the particle at location x stays within a distance r from the point p(t) at time t. Forward simulation with this constraint can be computed using the Lagrange multiplier method. 
         [0068]    Further, a force F acting on the particle at time t is defined. Subsequently, the Lagrange multiplier method is applied to compute an additional force F c  that is applied to the particle to ensure that the constraint is satisfied. For example, the constraint force is given by F c =λg, where g=x(t)−p(t), the multiplier λ for a particle of unit mass is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     λ 
                      
                     
                       
                         
                           
                             - 
                             
                               g 
                               T 
                             
                           
                            
                           F 
                         
                         + 
                         G 
                       
                       
                         
                           g 
                           T 
                         
                          
                         g 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and the scalar G is given by 
         [0000]        G =( {dot over (x)} ( t )− p {dot over (()} t )) T ( x ( t ){dot over (−)} p {dot over (()} t ))+2α g   T   x ( t )− g   T ( p ( t )){dot over ())}∔½β 2   9   g   T    g−r   2 ).   (21)
 
         [0000]    The parameters α and β are selected by the user to control how quickly a system violating the constraints returns to a state satisfying them. For example, a β of β=α 2  can be set. In this case, the term F c  described above will apply a force to satisfy the equality constraint ∥x(t)−p(t)∥2−r2=0. Further, to allow the particle to move freely within the radius around the target point, the term F c  can be constrained to only point towards the target point p(t), which is accomplished by setting λ=0 whenever λ&gt;0. 
         [0069]    The second constraint pushes the particle towards high probability regions in the latent space. The GPLVM provides a probability distribution over the latent space p(x(t)|M), and this distribution is used to push the particle towards “probable” regions, which may provide better reconstructed poses as compared to less probable regions of the latent space. However, models trained with facial animations are capable of synthesizing reasonable poses from less likely regions of the latent space. Generally, these lower probability poses do not contain visual defects such as an overly stretched face or interpenetrating meshes. Therefore, keeping the particle in a high probability region is not critical, and thus may be violated if necessary to satisfy the path constraint. 
         [0070]    In some embodiments, the likelihood constraint is modeled as a force applied to the particle that points in the direction of the gradient of the PDF. The magnitude of the force can be determined by the value of the PDF evaluated at the particle&#39;s current location. For example, if the value is above some empirically chosen quantity v, the magnitude is small, and if the value is below v, the magnitude is large. These properties are modeled as a sigmoid function so that the force function is continuous for numerical integration. As such, the magnitude can be expressed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                     = 
                     
                       α 
                        
                       
                         1 
                         
                           1 
                           + 
                           
                             exp 
                              
                             
                               ( 
                               
                                 
                                   p 
                                   ( 
                                   
                                     
                                       x 
                                        
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                      
                                     
                                       M 
                                       - 
                                       v 
                                     
                                   
                                 
                                 l 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and the constraint force can be expressed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       F 
                       GPLVM 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       S 
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                      
                     
                       
                         
                           ∂ 
                           
                             p 
                             ( 
                             
                               
                                 x 
                                  
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                                
                               M 
                             
                           
                         
                         
                           ∂ 
                           x 
                         
                       
                       / 
                       
                         
                            
                           
                             
                               ∂ 
                               
                                 p 
                                 ( 
                                 
                                   
                                     x 
                                      
                                     
                                       ( 
                                       t 
                                       ) 
                                     
                                   
                                    
                                   M 
                                 
                               
                             
                             
                               ∂ 
                               x 
                             
                           
                            
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The parameters a and l are defined by the user. The user can also control the magnitude of the force when the constraint is not satisfied and how quickly the magnitude approaches a. Computing the partial derivatives of the Gaussian process takes time quadratic to the size of the training data. However, if the size of the training set is small, the computations can be done in real-time. 
         [0071]    In some embodiments, in addition to these constraint forces, a random force F rand (t) is applied to add variation to the particle&#39;s path. This force is modeled as a randomly drawn, zero-mean Gaussian process 
         [0000]        F   rand ( t )˜           P (0,  k ( t, t ′)).   (24)
 
         [0000]    Each component of F rand (t) is independent of all others. The co-variance function is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       k 
                        
                       
                         ( 
                         
                           t 
                           , 
                           
                             t 
                             ′ 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       αexp 
                        
                       
                         ( 
                         
                           
                             - 
                             
                               1 
                               
                                 2 
                                  
                                 γ 
                               
                             
                           
                            
                           
                             
                               ( 
                               
                                 t 
                                 - 
                                 
                                   t 
                                   ′ 
                                 
                               
                               ) 
                             
                             2 
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where α and γ are user-defined parameters that control the magnitude and smoothness of the random force. This random force adds noise and variations to the particle&#39;s movement through the latent space. As such, there can be at least small variations in each repetition that a particle follows a particular path. This allows for the synthesis of unique animations with small but noticeable differences even along the same path. 
         [0072]    Further, the particle can be simulated forward in time using, for example, a fourth-order Runge-Kutta integration method. A piecewise linear function is used for the path p(t), which is defined by a set of points [p 1 , p 2 , . . . , p n ] such that p(t i )=p i  and t i  is the time of the i th  frame of animation. Integration across multiple frames of animation is avoided to prevent integration over discontinuities in the piecewise path function p(t). Section 4.3, below, describes an exemplary process for defining p(t). 
       2.2 Mapping Between Models 
       [0073]    In general, a large set of heterogeneous motions cannot be accurately embedded in a low dimensional (e.g., d≦5) latent space. Therefore, in some embodiments, the training data is divided into small subsets of similar poses (e.g., similar facial expressions), and the embedding in the latent space is computed for each subset separately. However, a drawback of training separate models is that synthesizing animations transitioning amongst multiple models cannot be synthesized using a particle simulation method without a continuous path between the models. That is, an animation that smoothly transitions from one pose to another pose cannot be synthesized under the particle simulation method without a continuous path for the particle to follow between the different models. 
         [0074]    As such, in some embodiments, a path is created between two models M 1  and M 2  by first computing a set S of corresponding points in both models within the latent space. For example, a pair of matching points (x 1 , x 2 ), where x 1  ∈ M 1  and x 2  ∈ M 2 , is included in S if ∥g(x 1 ; M 1 )−g(x 2 ; M 2 )∥ 2 &lt;ε, where g(x; M) is the function that maps x to the rig control parameter space. This enables the identification of points within the models M 1  and M 2  whose reconstructed poses are similar. The set of matching points identifies points in the two models, which are connected to form bridges between the two models. For example, to create a curve that moves between model M 1  to model M 2 , a path in M 1  that ends at a matching point in S and a path that starts at the matching point in M 2  is created to form a bridge. 
         [0075]    In some embodiments, to identify a pair of matching points for models M 1  and M 2 , a point x 1  ∈ M 1  is used as a basis for computing the reconstructed rig control parameters z 1 =g(x 1 ; M 1 ). Then, the point z 1  is transformed by the linear dimensionality reduction specified by model M 2    
         [0000]        ŷ   1   =T   2   T   [W   2 ( z   1   −m   2 )],   (26)
 
         [0000]    where T 2  represents the first d principal components of the PCA transformation given in model M 2 , W 2  represents the diagonal matrix of scale values for each component, and m 2  represents the mean of training data used in model M 2 . 
         [0076]    Next, the point x 2  in the latent space of model M 2  is found, where 
         [0000]    
       
         
           
             
               
                 
                   
                     x 
                     2 
                   
                   = 
                   
                     
                       argmin 
                       x 
                     
                      
                     
                       
                          
                         
                           
                             
                               y 
                               ^ 
                             
                             1 
                           
                           - 
                           
                             
                               argmax 
                               y 
                             
                              
                             
                               
                                 log 
                                  
                                 p 
                               
                               ( 
                               
                                 
                                   y 
                                    
                                   x 
                                 
                                 , 
                                 
                                   M 
                                   2 
                                 
                               
                               ) 
                             
                           
                         
                          
                       
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Because y i =f(x)+∈, where ∈ is additive Gaussian white noise, the maximum of p(y|x, M 2 ) occurs when y=f* where f*=K*[K x ] −1 Y 2  is the noise-free output for the test point x. Therefore, Equation (27) can be re-written as 
         [0000]    
       
         
           
             
               
                 
                   
                     x 
                     2 
                   
                   = 
                   
                     
                       argmin 
                       x 
                     
                      
                     
                       
                         
                            
                           
                             
                               
                                 y 
                                 ^ 
                               
                               1 
                             
                             - 
                             
                               
                                 
                                   
                                     K 
                                     * 
                                   
                                    
                                   
                                     [ 
                                     
                                       K 
                                       x 
                                     
                                     ] 
                                   
                                 
                                 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 Y 
                                 2 
                               
                             
                           
                            
                         
                         2 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
         [0077]    As such, the problem of finding the best matching x 2  ∈ M 2  given the point x 1  ∈ M 1  can now be formulated as a nonlinear optimization problem, which can be solved using the scaled conjugate gradient algorithm. However, because the function is multi-modal, the optimization algorithm is evaluated multiple times with randomly selected initial values to attempt to find the global minimizer. Further, large steps are not taken during the optimization routine because the gradient of the objective function quickly goes to zero as x 2  moves away from the training points in the model as illustrated, for example, in the cross section plot  500  of the objective function  502  depicted in  FIG. 5 . The pose matching optimization function  502  shows the nonlinear behavior of the function and the flat regions as the function extends to the left and the right. 
         [0078]    In some embodiments, in order to create an animation that transitions between two or more models, a first curve can be generated in the first model that ends at one of the precomputed transition points, and a second curve can be generated in the second model that starts at the corresponding transition point from the first model. Then, the animation may be synthesized by reconstructing the poses along the two curves and rendering the animation from the second model right after the animation from the first model. 
         [0079]      FIG. 6  illustrates four sample pairs  602 ,  604 ,  606 , and  608  of the best-matching poses of Toothless  100  found between two different models. In each pair, the pose on the left is generated from a model trained on animations with grumpy-looking animations, and the pose on the right is generated from happy-looking animations. That is, in pair  602 , pose  602 A is a grumpy-looking Toothless  100 , and pose  602 B is a happy-looking Toothless  100  that is a best-matching happy pose to grumpy pose  602 A. In pair  604 , pose  604 A is a grumpy-looking Toothless  100 , and pose  604 B is a happy-looking Toothless  100  that is a best-matching happy pose to grumpy pose  604 A. In pair  606 , pose  606 A is a grumpy-looking Toothless  100 , and pose  606 B is a happy-looking Toothless  100  that is a best-matching happy pose to grumpy pose  606 A. In pair  608 , pose  608 A is a grumpy-looking Toothless  100 , and pose  608 B is a happy-looking Toothless  100  that is a best-matching happy pose to grumpy pose  608 A. 
         [0080]    However, as shown in  FIG. 6 , the poses reconstructed from matching latent points in two different models may not necessarily be identical. As a result, there can be a discontinuity in the animation at the transition between the two models. In some embodiments, to overcome this problem, a short blend is performed between the two poses in the rig control parameter space at the transition point. 
       2.3 Synthesis Control 
       [0081]    In some embodiments, an interactive application with a set of commands provides intuitive control of the character&#39;s poses (e.g., facial expressions). These commands provide control over the particular pose the character is expressing at a specific time during the synthesized animation. With these poses, the synthesis algorithm can generate transitions between the poses and models specified in the commands. Four example commands, a MOVE command, an IDLE command, a TRANSITION command, and a PLAY SEGMENT command, are described in greater detail below. 
         [0082]    First, an exemplary MOVE command is described. The MOVE command takes a target point tin the latent space as input. The synthesized animation is controlled by moving the particle from its current position in the latent space to the target point. This is accomplished by setting the particle&#39;s path function p(t). Different processes may be used to generate the path. In some examples, a straight line is created from the current point to the target. In other examples, the shortest path is used in a weighted graph G of the training data, where the weights are computed by Equation (13) in the same way that they are used for the connectivity prior.  FIG. 7  illustrates a side-by-side comparison of the particle trajectories through the latent space these two example processes. Plot  700  shows function  702  that is defined as a series of straight lines between points  704  A-  704  E. By contrast, plot  710  shows corresponding points  714  A-  714  E, but function  712  is instead defined as the shortest path through the weighted graph. In some examples, the start and end points may also be added as vertices in the graph. Further, in some examples, resulting path may be re-sampled so that 
         [0000]    
       
         
           
              
             
               
                 ∂ 
                 
                   p 
                    
                   
                     ( 
                     t 
                     ) 
                   
                 
               
               
                 ∂ 
                 t 
               
             
              
           
         
       
     
         [0000]    is constant for all t. This ensures that the particle follows the path at a consistent speed. Both of the described path-generating processes create compelling animation. A difference between the two processes is that the straight line path is shorter, and thus a particle following this path will reach the target in less time. 
         [0083]    Second, an exemplary IDLE command is described. A character is said to be “idling” if the character is not performing a particular action and is instead in a non-active (e.g., “neutral”) state. In such situations, it may be beneficial for the character to demonstrate an “idling” animation, where the pose (e.g., expression) of the character is controlled as it idles. As discussed, each set of training data consists of animations having similar poses (e.g., expressions). For example, one set may include only animation poses corresponding to a happy facial expression. Thus, each model corresponds with a single expression, and the type of expression of the character&#39;s face can be controlled by using the appropriate model. As such, idling animations can be synthesized by selecting a point p in the latent space and letting the particle “hover” around that point. Further, a radius r may be defined that can be adjusted to control how far the particle is allowed to stray away from point p. In some examples, this is accomplished by setting the path function that the particle follows to p(t)=p for a range of time t ∈ T in which the particle is to hover around the point. In some examples, to add variety to the animation, multiple latent points may be used. With multiple points, the synthesis is controlled by first picking a point from the set to move to. Next, the particle hovers about that point for a fixed or predetermined amount of time. When a new point is selected, the simulation repeats by moving to the new point and hovering around the new point. 
         [0084]    Third, an exemplary TRANSITION command is described. The TRANSITION command is used to generate a continuous animation when moving between two models. In some embodiments, the TRANSITION command uses, in combination, the previously described MOVE and IDLE commands. Thus, to transition from model M 1  to model M 2 , the particle is moved from its current position in model M 1  to the nearest precomputed matching point in the latent space. When the particle is close to the matching point, it “idles” about that point and the particle in M 2  also begins to “idle” about the corresponding matching point. The transition is completed by performing a blend between the high-dimensional rig control parameters from the two models while the particles are idling. 
         [0085]    Fourth, an exemplary PLAY SEGMENT command is described. In some situations, playing a portion of (e.g., a segment of) an unmodified animation directly from the training data may be desirable. In some embodiments, the unmodified animation is played by using the embedding of the sequence in the latent space. The MOVE command can then be used to position the particle near the starting pose of the animation. When the particle is close enough to the starting pose of the animation, the simulation is stopped, and the particle is moved along the path of the embedded animation. When moving the particle to the start, the radius r is adjusted to ensure that it has moved close to the start to avoid discontinuities when the animation segment is played. 
       4. Animation System 
       [0086]      FIG. 8  illustrates an exemplary animation system  800  that can be used to implement the animation synthesis process discussed above. The animation synthesis process can be implemented, for example, in either hardware or in software stored on a non-transitory computer-readable storage medium. The system can be configured to generate, modify, and evaluate the animation synthesis process for repurposing existing animated content of a character, as well as external processes used to render a computer-generated image of the character. The system can be further configured to receive input from a user and to display graphics, an image, or scene of an animation based on the animation synthesis process. 
         [0087]    The animation system  800  can be configured to receive user input from an input device  820 . The input device  820  can be any device that receives input from the user and transmits it to the animation system  800 . For example, the input device  820  can be a keyboard, a mouse, a tablet, a stylus, or the like. Those skilled in the art will recognize that other types of input devices can also be used. 
         [0088]    The animation system  800  can be configured to output graphics, images, or animation to an output device  830 . The output device  830  can include any device that receives data from the animation system and presents the data to the user. For example, the output device  830  may include a liquid crystal display, a set of light-emitting diodes, a projector, or the like. Those skilled in the art will recognize that other types of output devices can also be used. 
         [0089]    The animation system  800  may further include a central processing unit  802 . The central processing unit may include one or more processing cores. The central processing unit  802  may be coupled to and able to communicate with the input device  820 . Although the animation system  800  is illustrated with one central processing unit  802 , the animation system  800  may include multiple processing units. The animation system  800  may also include a graphics processing unit  804 . The graphics processing unit  804  may be dedicated to processing graphics-related data. The graphics processing unit  804  may include a single processing core or multiple processing cores. Although the animation system  800  is illustrated with one graphics processing unit  804 , the animation system  800  may include a plurality of graphics processing units. The central processing unit  802  and/or the graphics processing unit  804  may be coupled to and be able to communicate data to the output device  830 . 
         [0090]    In one example, the animation system  800  may include one or more processors and instructions stored in a non-transitory computer-readable storage medium, such as a memory or storage device, that, when executed by the one or more processors, perform animation rendering using an animation synthesis process, as described above. In the context of the embodiments described herein, a “non-transitory computer-readable storage medium” can be any medium that can contain or store the program for use by or in connection with the instruction execution system, apparatus, or device. The non-transitory computer-readable storage medium can include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, a portable computer diskette (magnetic), a random access memory (RAM) (magnetic), a read-only memory (ROM) (magnetic), an erasable programmable read-only memory (EPROM) (magnetic), a portable optical disc such a CD, CD-R, CD-RW, DVD, DVD-R, or DVD-RW, or flash memory such as compact flash cards, secured digital cards, USB memory devices, memory sticks, and the like. 
         [0091]    The animation system  800  may include volatile memory  806 , which is a non-transitory computer-readable storage medium, in communication with the central processing unit  802 . The volatile memory  806  may include, for example, random access memory, such as dynamic random access memory or static random access memory, or any other type of volatile memory. The volatile memory  806  may be used to store data or instructions during the operation of the animation system  800 . Those skilled in the art will recognize that other types of volatile memory can also be used. 
         [0092]    The animation system  800  may also include non-volatile memory  808 , which is a non-transitory computer-readable storage medium, in communication with the central processing unit  802 . The non-volatile memory  808  may include flash memory, hard disks, magnetic storage devices, read-only memory, or the like. The non-volatile memory  808  may be used to store animation data, synthesis algorithm data, computer instructions, or any other information. Those skilled in the art will recognize that other types of non-volatile memory can also be used. 
         [0093]    The animation system  800  is not limited to the devices, configurations, and functionalities described above. For example, although a single volatile memory  806 , non-volatile memory  808 , central processing unit  802 , graphics processing unit  804 , input device  820 , and output device  830  are illustrated, a plurality of any of these devices can be implemented internal or external to the animation system  800 . In addition, the animation system  800  may include a network access device for accessing information on a network, such as an internal network or the Internet. Those skilled in the art will recognize that other configurations of the animation system  800  can be used. 
         [0094]    Various exemplary embodiments are described herein. Reference is made to these examples in a non-limiting sense. They are provided to more broadly illustrate applicable aspects of the disclosed technology. Various changes may be made and equivalents may be substituted without departing from the true spirit and scope of the various embodiments. In addition, many modifications may be made to adapt a particular situation, material, composition of matter, process, process act(s), or step(s) to the objective(s), spirit, or scope of the various embodiments. Further, as will be appreciated by those with skill in the art, each of the individual variations described and illustrated herein has discrete components and features that may be readily separated from or combined with the features of any of the other several embodiments without departing from the scope or spirit of the various embodiments.