# Patent

## Title
Local, deformable precomputed radiance transfer

## Abstract

Computer graphics image rendering techniques render images using a precomputed radiance transfer (PRT) to model local effects such as bumps, wrinkles, or other detailed features on an arbitrarily deformable model's surface. The techniques apply zonal harmonics (ZH) which approximate spherical functions as sums of circularly symmetric functions around different axes. By spatially varying both the axes and coefficients of these basis functions, approximations can fit to spatially varying transfer signals. Compared to the spherical harmonic (SH) basis, the ZH basis yields a more compact approximation, and can be rotated at a low computational expense suitable for dense per-vertex or per-pixel evaluation. This allows PRT to be mapped onto deforming models which re-orient the local coordinate frame.

## Background
COPYRIGHT AUTHORIZATION
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by any one of the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.
TECHNICAL FIELD
The present invention relates to computer graphics image rendering techniques, and more particularly relates to lighting and shadowing of a modeled object in the rendered image.
BACKGROUND
Real-time lighting effects like soft shadows and subsurface scattering can be obtained with graphics rendering techniques that involve precomputed radiance transfer (PRT). Images generated using these techniques exhibit a compelling realism lacking from traditional computer graphics with its emphasis on hard shadows and opaque surfaces. However, PRT techniques have been limited to static objects or highly constrained, precomputed sequences.
PRT methods for static objects can be categorized as low-frequency (such as described by Sloan, P., Kautz, J., and Snyder, J., “Precomputed Radiance Transfer For Real-Time Rendering In Dynamic, Low-Frequency Lighting Environments,” Proc. of SIGGRAPH '02, 527-536; and Sloan, P., Hall, J., Hart, J., and Snyder, J., “Clustered Principal Components For Precomputed Radiance Transfer,” Proc. of SIGGRAPH '03, 382-391) and all-frequency (such as described by Ng, R., Ramamoorthi, R., and Hanrahan, P., “All-Frequency Shadows Using Non-Linear Wavelet Lighting Approximation,” Proc. of SIGGRAPH '03, 376-381; Liu, X., Sloan, P., Shum, H., and Snyder, J., “All-Frequency Precomputed Radiance Transfer For Glossy Objects,” Proc. of 2004 Eurographics Symposium on Rendering; and Wang, R., Tran, J., and Luebke, D., “All-Frequency Relighting Of Non-Diffuse Objects Using Separable BRDF Approximation,” Proc. of 2004 Eurographics Symposium on Rendering), according to the lighting and shading frequencies handled. Though more general, all-frequency PRT is problematic because it tabulates much more data per point to represent transfer from higher-dimensional lighting vectors, and many more points per object to represent higher frequency shading variation over that object. The resulting data sets are enormous, and remain unwieldy even after sophisticated compression techniques are applied.
PRT has also been applied to deformable models (described by James, D., And Fatahalian, K., “Precomputing Interactive Dynamic Deformable Scenes,” Proc. of SIGGRAPH '03, 879-887) but the preprocessing was essentially done for each pose of the object in a low-dimensional control space: the space of elastic deformations caused by an impulse at an arbitrary instant (i.e., a “poke”). Models can only be poked, they can't be bent or twisted, walk, or flap their wings. This did not permit capturing local effects for models where the deformations are not known in advance, and so can have arbitrarily many degrees of freedom.
Bi-scale radiance transfer (described by Sloan, P., Liu, X., Shum, H., And Snyder, J., “Bi-Scale Radiance Transfer,” Proc. of SIGGRAPH '03, 370-375) and environmental lighting with BTFs (described by Muller, G., Meseth, J., And Klein, R., “Fast Environmental Lighting For Local-PCA Encoded BTFs,” Proc. of Computer Graphics International, 198-205) capture both local and distant transfer effects on static objects. The distant level, represented as transfer matrices, is required not only to obtain distant effects but also to rotate the lighting vector to the local frame. If the object deforms, this rotation is impractical to tabulate and so must be performed dynamically at each surface point. These methods also capture view dependent parallax effects using 4D textures.
SUMMARY
Image rendering techniques described herein model radiance transfer over a deformable surface, using a technique referred to herein as Local, Deformable Precomputed Radiance Transfer (LDPRT). This technique focuses on extending PRT to dynamic, arbitrarily deformable objects.
One implementation of the LDPRT technique described herein is restricted to local PRT: how to encapsulate the realistic shading effects mentioned above but from detailed surface features, such as wrinkles and bumps commonly represented as texture maps, where the feature's shading influence is spatially nearby. Distant effects, such as shadowing from one limb of an articulated figure onto its trunk or another limb, are difficult because the required PRT simulation depends on the figure's pose. When this pose is parameterized by more than one or two degrees of freedom, both the preprocessing and run-time costs become overwhelming on current hardware.
Even for local PRT, previous methods are inadequate. To understand the difficulty involved, consider a diffuse object, whose self-transfer at some point can be represented as a transfer vector which is dotted with the light vector to produce the diffuse shade at that point. In previous work, transfer and lighting vectors were represented using spherical harmonics (SH), a compact basis for low-frequency lighting. If the object is static, previous techniques simply record a PRT vector at each point as a preprocess, assuming the lighting is in a global coordinate frame. If the object rotates rigidly, we can rotate the lighting vector from the rotated into the original (rest) orientation of the object, once for all its points, before computing the per-point shading dot product. But if the object deforms nonrigidly, we must rotate the lighting to the rest frame, on-the-fly at every surface point. SH rotation is costly and unsuited for real-time evaluation on graphics hardware over dense point sets.
The described LDPRT technique solves this problem by rotating transfer to the deformed frame instead of rotating lighting to the rest frame. The technique approximates transfer with zonal harmonics (ZH), which represents spherical functions as a sum of lobes or circularly symmetric functions (as described by, e.g., Whittaker, E., And Watson, G., “A Course in Modern Analysis, 4th Ed.,” Cambridge University Press, Cambridge, England). The ZH representation allows on-the-fly rotation, simply by rotating each lobe's axis, and is easily evaluated per-pixel and in real-time on graphics hardware. With a simple implementation, shading speed is comparable to previous methods using the SH basis, but can be significantly accelerated by a precomputation over the lighting environment.
The LDPRT technique described herein contributes a new representation for local, low frequency, quickly-rotatable radiance transfer. LDPRT has two advantages over previous methods. It allows local PRT effects to be mapped onto any static or deforming surface. And it performs the precomputation over a single mesh or texture patch, not over every pose of a deforming model. The LDPRT technique applies sums of zonal harmonics with spatially varying directions and coefficients to allow fast transfer rotation and shading. This model generalizes previous convolution and “bent normal” methods, providing controllably low approximation error when fit to PRT signals from arbitrary local geometry. Results achieved with the LDPRT technique that are described herein show realistic effects such as soft shadows, inter-reflections, and subsurface scattering from textural features, mapped onto dynamic models and synthesized in real-time on graphics hardware.
Additional features and advantages of the invention will be made apparent from the following detailed description of embodiments that proceeds with reference to the accompanying drawings.



BRIEF DESCRIPTION OF THE DRAWINGS
The file of this patent contains at least one drawing executed in color. Copies of this patent with color drawing(s) will be provided by the Patent and Trademark Office upon request and payment of the necessary fee.
FIG. 1 is a block diagram of a software architecture of a computer graphics rendering system incorporating local, deformable precomputed radiance transfer for image rendering.
FIGS. 2A-B are color photographic images of a computer-generated “bat” model demonstrating shading effects achieved using a local, deformable precomputed radiance transfer technique.
FIGS. 3A-D are color photographic images depicting an example of a randomly generated spherical signal, together with zonal harmonics approximations of the signal.
FIGS. 4A-D are color photographic images depicting example 4 lobe zonal harmonics basis functions used in the zonal harmonics approximations depicted in FIGS. 3B-D.
FIGS. 5A-E are color photographic images depicting the LDPRT technique applied to an example model of objects with a diffuse surface approximated at various numbers of ZH lobes.
FIGS. 6A-D are color photographic images depicting an example glossy model approximated using the LDPRT technique.
FIG. 7 is a flow diagram illustrating a process performed in the system of FIG. 1 for rendering an image using LDPRT.
FIGS. 8A-B are color photographic images of an exemplary deformed 3d modeled object surface (bumps), comparing results achieved (A) unshadowed; and (B) shadowed via LDPRT.
FIGS. 9A-C are color photographic images of an exemplary deformed 3d modeled object surface (waffle), comparing results achieved (A) unshadowed; (B) shadowed via LDPRT; and (C) subsurface.
FIGS. 10A-B are color photographic images of an exemplary deformed 3d modeled object surface (wrinkles), comparing results achieved (A) unshadowed; and (B) shadowed via LDPRT.
FIGS. 11A-B are color photographic images of an exemplary deformed 3d modeled object (vase), comparing results achieved (A) unshadowed; and (B) shadowed via LDPRT.
FIGS. 12A-C are color photographic images of an exemplary deformed 3d modeled object (cylinder), comparing results achieved (A) unshadowed; (B) shadowed via LDPRT; and (C) inter-reflected.
FIGS. 13A-C are color photographic images of an exemplary deformed 3d modeled object (Mayan face), comparing results achieved (A) ray-traced; (B) undeformed shading; and (C) with LDPRT.
FIGS. 14A-E are color photographic images of an exemplary deformed 3d modeled object (vase) with various LDPRT textures mapped thereon, including (A) bumps, 64×64; (B) weave, 32×32; and (C) waffle (subsurface, 64×64; (D) waffle (glossy), 128×128; and (E) swirl, 128×128.
FIG. 15 is a block diagram of a suitable computing environment for implementing the bi-scale radiance transfer image rendering of FIG. 1.



DETAILED DESCRIPTION
1. Computer Graphics Image Rendering System Overview
With reference to FIG. 1, a software architecture of a computer graphics image rendering system 100 provides image rendering of a modeled object with a local, deformable precomputed radiance transfer (LDPRT) image rendering technique described herein. In general, the software architecture includes a radiance transfer precomputation 120, an image rendering engine 140, and a graphics display driver 180. In the local, deformable precomputed radiance transfer rendering technique described more fully below, the precomputation 120 performs a pre-processing stage of the technique, which precomputes radiance self-transfer (PRT) data 130 from a geometric object model 110. The geometric model 110 can be a triangulated mesh, wavelet composition, or any other representation of the geometry of the object being modeled, as well as a height field or other model of the meso-scale structure of the object. The image rendering engine 140 then uses the PRT data 130 to render images of the deformable modeled object for a deformation 135, a dynamically variable lighting environment 150 and a viewing direction 160, which can be selectively varied or set with user controls 170 or alternatively by programming. The graphics display driver 180 outputs the images to an image output device (e.g., to a monitor, projector, printer or like).
In some embodiments of the graphics image rendering system, the LDPRT precomputation of simulator 120 and image rendering by the engine 140 can be implemented on a single computer, such as that described in the section entitled, Computing Environment, below. More generally, the simulator 120 can be run on a separate computer, and the resulting data then transferred to the computer on which the rendering engine 140 runs to produce the graphics images.
2. Zonal Harmonics for Precomputed Radiance Transfer
2.1 Zonal Harmonics for Spherical Functions
Spherical harmonics (SH) represent a scalar spherical function




  
    
      
        
          
            f
            ⁡
            
              (
              s
              )
            
          
          ,
          
            s
            =
            
              
                (
                
                  
                    s
                    x
                  
                  ,
                  
                    s
                    y
                  
                  ,
                  
                    s
                    z
                  
                
                )
              
              ∈
              
                
                  S
                  2
                
                ⁢
                
                  
                
                ⁢
                via
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            f
            ⁡
            
              (
              s
              )
            
          
          =
          
            
              
                ∑
                
                  l
                  =
                  0
                
                
                  n
                  -
                  1
                
              
              ⁢
              
                
                  ∑
                  
                    m
                    =
                    
                      -
                      1
                    
                  
                  
                    +
                    1
                  
                
                ⁢
                
                  
                    f
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  ⁢
                  
                    
                      y
                      
                        l
                        ⁢
                        
                          
                        
                        ⁢
                        m
                      
                    
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
            
            =
            
              f
              ·
              
                y
                ⁡
                
                  (
                  s
                  )
                
              
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




where n is the order of the SH expansion, y(s) is the vector of SH basis functions, and ƒ is the vector of coefficients for ƒ(s). Both vectors have n2 components. One property of the SH representation is that arbitrary rotations of ƒ(s) can be represented exactly using independent rotations of the coefficients ƒlm in each band, which is indexed by a constant value of l and has 2l+1 components.

A function g(s) which is circularly symmetric about the z axis can be represented more simply as




  
    
      
        
          g
          ⁡
          
            (
            s
            )
          
        
        =
        
          
            g
            ⁡
            
              (
              
                s
                z
              
              )
            
          
          =
          
            
              ∑
              
                l
                =
                0
              
              
                n
                -
                1
              
            
            ⁢
            
              
                g
                l
              
              ⁢
              
                
                  y
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    0
                  
                
                ⁡
                
                  (
                  
                    s
                    z
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




where sz is the z component of the spherical point s, and the basis functions yl0(s) are a subset of the SH basis functions (m=0) given by Legendre polynomials and dependent only on sz. Such functions are also called zonal harmonics (ZH) because their zeroes form parallels (lines of constant latitude), which divide the sphere into zones. Note that sz is just the cosine of the angle between s and the z axis and is often written cos θ when spherical functions are parameterized by the angular variables (θ, φ).

Spherical convolution of the functions ƒ and g is then given by




  
    
      
        
          
            f
            *
            
              g
              ⁡
              
                (
                s
                )
              
            
          
          =
          
            
              
                ∑
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁢
              
                
                  
                    y
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
                ⁢
                
                  (
                  
                    
                      
                        
                          4
                          ⁢
                          π
                        
                        
                          
                            2
                            ⁢
                            l
                          
                          +
                          l
                        
                      
                    
                    ⁢
                    
                      g
                      l
                    
                  
                  )
                
                ⁢
                
                  f
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
              
            
            =
            
              
                ∑
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁢
              
                
                  
                    y
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
                ⁢
                
                  g
                  l
                  *
                
                ⁢
                
                  f
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        where
      
    
    
      
        (
        3
        )
      
    
  
  
    
      
        
          g
          l
          *
        
        =
        
          
            
              
                4
                ⁢
                π
              
              
                
                  2
                  ⁢
                  l
                
                +
                1
              
            
          
          ⁢
          
            g
            l
          
        
      
    
    
      
        (
        4
        )
      
    
  




In matrix/vector notation, we write this as ƒ*g(s)=y†(s)G*ƒ where y(s) and ƒ are vectors of SH coefficients as before, y† is the transpose of y, and G* is a diagonal matrix composed of the convolution coefficients gl* each repeated 2l+1 times in successive bands l=0, l=1, etc. For example, for n=3 the diagonal of G* is the 9D vector (g0*, g1*, g1*, g1*, g2*, g2*, g2*, g2*, g2*).

The convolution property allows us to rotate any circularly symmetric function and find its resulting SH coefficients. Define the function ĝ(s)=g(R−1s) where the rotation R maps the z axis to an arbitrary axis s*. To find the coefficients of ĝ, we have




  
    
      
        
          
            ∫
            
              S
              2
            
          
          ⁢
          
            
              f
              ⁡
              
                (
                s
                )
              
            
            ⁢
            
              
                g
                ^
              
              ⁡
              
                (
                s
                )
              
            
            ⁢
            
              d
              s
            
          
        
        =
        
          
            f
            *
            
              g
              ⁡
              
                (
                
                  s
                  *
                
                )
              
            
          
          =
          
            
              ∑
              
                l
                ⁢
                
                  
                
                ⁢
                m
              
            
            ⁢
            
              
                f
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁢
              
                
                  g
                  ^
                
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
            
          
        
      
    
    
      
        (
        5
        )
      
    
  




where the last equality is true by the orthogonality of the SH basis. Since this is true for any function ƒ, substituting the definition of ƒ*g, we obtain

ĝlm=ylm(s*)gl*  (6)

yielding the rotated coefficients, where gl* is defined in equation (4). This observation gives rise to the zonal harmonic representation, which represents ƒ(s) as the sum of N circularly symmetric lobes, indexed by i. A component of ƒ is approximated by {tilde over (ƒ)} via





  
    
      
        
          
            f
            
              l
              ⁢
              
                
              
              ⁢
              m
            
          
          ≈
          
            
              f
              ~
            
            
              l
              ⁢
              
                
              
              ⁢
              m
            
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
              
                y
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁡
              
                (
                
                  s
                  i
                  *
                
                )
              
            
            ⁢
            
              g
              il
              *
            
          
        
      
    
    
      
        (
        7
        )
      
    
  




We write this in matrix/vector notation as





  
    
      
        
          
            f
            ≈
            
              f
              ~
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              y
              ⁢
              
                
              
              ⁢
              
                †
                ⁡
                
                  (
                  
                    s
                    i
                    *
                  
                  )
                
              
              ⁢
              
                G
                i
                *
              
            
          
        
        ⁢
        
          
        
      
    
    
      
        (
        8
        )
      
    
  




The continuous reconstruction of ƒ(s) is then approximated by





  
    
      
        
          
            f
            ⁡
            
              (
              s
              )
            
          
          ≈
          
            
              f
              ~
            
            ⁡
            
              (
              s
              )
            
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            y
            ⁢
            
              
            
            ⁢
            
              †
              ⁡
              
                (
                
                  s
                  i
                  *
                
                )
              
            
            ⁢
            
              G
              i
              *
            
            ⁢
            
              y
              ⁡
              
                (
                s
                )
              
            
          
        
      
    
    
      
        (
        9
        )
      
    
  




Here, the sl* are called the lobe axes and the set of n coefficients gl* per lobe are called the lobe coefficients. When N=1, we call the ZH approximation single-lobe, and multi-lobe if N>1.

The advantage of this representation is its simplicity of spherical rotation. Define a rotated version of ƒ(s) via {circumflex over (ƒ)}(s)=ƒ(R−1s) where R is a 3D rotation matrix. Given the vector ƒ of SH coefficients, this rotation can be performed by applying a (2l+1)×(2l+1) rotation matrix in each band, an operation that is O(n3) in the SH order n and computationally very costly (see digression below). Using the ZH representation however, the operation is O(N) where typically N≦4 and trivial to evaluate:




  
    
      
        
          f
          ^
        
        ≈
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            y
            ⁢
            
              
            
            ⁢
            
              †
              ⁡
              
                (
                
                  Rs
                  i
                  *
                
                )
              
            
            ⁢
            
              G
              i
              *
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




In other words, the rotated ZH representation rotates the lobe axes to Rsi* while the lobe coefficients gi* and thus the diagonal matrices Gi* remain unchanged (compare to equation (8)).

Each ZH lobe is axially symmetric. Negating the lobe direction and all its odd l lobe coefficients results in an identical function.
2.2 Applying Zonal Harmonics to Precomputed Radiance Transfer
Diffuse PRT Applying these ideas to PRT, assume that a low frequency lighting environment is represented in the SH basis as a vector e. For a diffuse surface, the transfer vector can be represented by another SH vector tp which varies over points on the surface p. The shading result is then given by rp=e·tp, which is simply the spherical integral of source radiance e(s) times the object's transfer, tp(s), which encapsulates how the object shadows and scatters light onto itself at point p. For example, the transfer can be represented as an order 6 SH expansion, so that these vectors are 36D. For simplicity in the notation, the subscript p is dropped in the following discussion though transfer remains a spatially-varying quantity.
Now instead of recording transfer vectors in the SH basis, t, the system 100 records N lobe axes si*, and for each axis its n coefficients gi* which determine a diagonal matrix Gi*. The transfer vector is approximated using equations (7,8) as




  
    
      
        
          
            t
            ≈
            
              t
              ~
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              y
              ⁢
              
                
              
              ⁢
              
                †
                ⁡
                
                  (
                  
                    s
                    i
                    *
                  
                  )
                
              
              ⁢
              
                G
                i
                *
              
            
          
        
        ,
        
          

        
        ⁢
        
          
            
              t
              ~
            
            
              l
              ⁢
              
                
              
              ⁢
              m
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                
                  y
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
                ⁡
                
                  (
                  
                    s
                    i
                    *
                  
                  )
                
              
              ⁢
              
                g
                il
                *
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




A continuous spherical function {tilde over (t)}(s) can be reconstructed from the vector {tilde over (t)} via equation (9) as





  
    
      
        
          
            t
            ~
          
          ⁡
          
            (
            s
            )
          
        
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            y
            ⁢
            
              
            
            ⁢
            
              †
              ⁡
              
                (
                
                  s
                  i
                  *
                
                )
              
            
            ⁢
            
              G
              i
              *
            
            ⁢
            
              y
              ⁡
              
                (
                s
                )
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  




and the shading result is then given by r={tilde over (t)}·e or





  
    
      
        r
        =
        
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              y
              ⁢
              
                
              
              ⁢
              
                †
                ⁡
                
                  (
                  
                    s
                    i
                    *
                  
                  )
                
              
              ⁢
              
                G
                i
                *
              
              ⁢
              e
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                ∑
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁢
              
                
                  
                    y
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      i
                      *
                    
                    )
                  
                
                ⁢
                
                  g
                  il
                  *
                
                ⁢
                
                  e
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
              
            
          
        
      
    
    
      
        (
        13
        )
      
    
  




The ZH transfer model therefore makes shading evaluation simple and, what's more, allows the transfer vector to be rotated easily to any frame using (10). Note that the N lobe axes and coefficients vary over the surface as did the original PRT vector t.

For example, this diffuse PRT technique can be used to shade the wings of a “bat” model that deforms to achieve a “flapping” motion in the computer-generated photographic images of FIGS. 2A-B. As the bat flaps its wings, LDPRT at any point on the bat can quickly be rotated from the rest coordinate frame where it is stored to the current, deformed orientation. In these example images, a single-lobe ZH model represents diffuse PRT including subsurface scatter. On currently available graphics hardware, these example images can be generated at real-time rendering rates (i.e., 240 Hz).
Glossy PRT For glossy objects, exit radiance is view-dependent rather than constant. The linearity of light transport means that exit radiance can be represented as a linear operator (matrix) on the source lighting vector e, given by r(v)=y†(v)Me where M is an n2×n2 transfer matrix and v is the view direction. M takes source lighting e in the SH basis and produces an exit radiance spherical function, also in the SH basis.
We can reduce the number of rows in M by specializing the output basis to the object's reflectance properties using a view/light factoring of its BRDF (such as described by Liu, X., Sloan, P., Shum, H., And Snyder, J., “All-Frequency Precomputed Radiance Transfer For Glossy Objects,” Proc. of 2004 Eurographics Symposium on Rendering; and Wang, R., Tran, J., And Luebke, D., “All-Frequency Relighting Of Non-Diffuse Objects Using Separable BRDF Approximation,” Proc. of 2004 Eurographics Symposium on Rendering). If b(v, s) is the BRDF, parameterized by view direction v and light direction s, the idea is to sample it over many view and light directions and perform a singular value decomposition (SVD) over the resulting matrix of samples. Using the SH basis for lighting, define a nv×n2 matrix B where nv is the number of view samples, given by the following integral over the hemisphere H={s|sz≧0}:




  
    
      
        
          B
          ij
        
        =
        
          
            
              ∫
              H
              
                
              
            
            ⁢
            
              
                b
                ⁡
                
                  (
                  
                    
                      v
                      i
                    
                    ,
                    s
                  
                  )
                
              
              ⁢
              
                
                  y
                  j
                
                ⁡
                
                  (
                  s
                  )
                
              
              ⁢
              
                s
                z
              
              ⁢
              
                
              
              ⁢
              
                d
                s
              
            
          
          =
          
            
              
                (
                
                  U
                  ⁢
                  
                    
                  
                  ⁢
                  Σ
                  ⁢
                  
                    
                  
                  ⁢
                  V
                
                )
              
              ij
            
            ≈
            
              
                (
                
                  
                    U
                    ~
                  
                  ⁢
                  
                    
                      Σ
                      ~
                    
                    ⁢
                    
                      V
                      ~
                    
                  
                
                )
              
              ij
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




UΣV is the SVD of B. Selecting only the nb largest singular values yields the approximation Ũ{tilde over (Σ)}{tilde over (V)}, where Ũ is nv×nb, {tilde over (Σ)} is a nb×nb diagonal matrix, and {tilde over (V)} is nb×n2.

Given B, glossy shading may be expressed as r(v)=γ\(v)BTe where T is the transfer matrix going from source to transferred incident radiance, as described by Kautz, J., Sloan, P., And Snyder, J., “Fast, Arbitrary BRDF Shading For Low-Frequency Lighting Using Spherical Harmonics,” Eurographics Workshop on Rendering, 291-296. γ(v) is an nv-dimensional vector that simply interpolates the correct components of exit radiance for a specified view direction v, and depends on the view parameterization. Using the SVD, shading is approximated by

r(v)≈(y\(v)Ũ)({tilde over (Σ)}{tilde over (V)}T)e=u(v)M′e  (15)

M′ is a nb×n2 BRDF-specialized transfer matrix and u(v)=(y\(v)Ũ) is an nb-dimensional view factor vector generated by the SVD. The approximation reduces the number of rows in the transfer matrix from n2(M) to nb(M′).

Now, the system 100 fits a ZH model to each of M′'s nb rows, just as it did for the diffuse transfer vector t. In other words, a diffuse transfer vector is just a single-row transfer matrix. The result is a quickly rotatable representation for glossy transfer that can be applied to deformable models. The final shade is given by evaluating each of the nb scalars using equation (13) for each row of M′, and then dotting that result with the nb-dimensional vector u(v), or




  
    
      
        
          r
          ⁡
          
            (
            v
            )
          
        
        =
        
          
            ∑
            
              j
              =
              1
            
            
              n
              b
            
          
          ⁢
          
            
              
                u
                j
              
              ⁡
              
                (
                v
                )
              
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  1
                
                N
              
              ⁢
              
                
                  ∑
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
                ⁢
                
                  
                    
                      y
                      
                        l
                        ⁢
                        
                          
                        
                        ⁢
                        m
                      
                    
                    ⁡
                    
                      (
                      
                        s
                        ji
                        *
                      
                      )
                    
                  
                  ⁢
                  
                    g
                    jil
                    *
                  
                  ⁢
                  
                    e
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                
              
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




where j varies over M_rows. u(v) is a 32×32 texture, which composes a mapping from square to disk (such as described by Shirley, P., And Chiu, K., “A Low Distortion Map Between Disk And Square,” Journal of Graphics Tools 2, 3, 45-52) with an area-preserving mapping from disk to hemisphere.

Rotating Transfer vs. Light In an alternative implementation of the system 100, another possible solution to the problem posed by deformable models is to fit a ZH model to the lighting e rather than the transfer vector t or matrix M′. Instead of rotating transfer into the deformed coordinate frame, this alternative implementation rotates lighting into the rest coordinate frame. The advantage is that a ZH fit is no longer needed over each point on the object or texture patch.
There are three reasons why applying the ZH model to transfer instead of lighting is generally the preferred implementation in many applications. First, lighting is typically a higher-frequency signal requiring more lobes than transfer for an accurate fit. More lobes incurs more run-time rendering cost. Transfer signals for diffuse or semi-glossy surfaces are smoother than lighting because they are modulated by a cosine and the object's BRDF, and because reflectance and visibility are limited in dynamic range. Colored lighting also requires a separate ZH model per color channel while transfer can often be approximated by a single channel modulated by a constant color. The term constant in this context means independent of the lighting direction s, not spatially constant. The single-channel transfer approximation is exact for shadowing and accurate for other effects assuming spatial color variation is low.
Second, ZH fitting requires slow, non-linear optimization best done as a pre-process. But it must be done at every frame if the lighting is dynamic and at every point if it is local (spatially-varying).
Third, the preferred implementation admits a significant rendering speed-up described in Section on “Rendering” below. It depends on a precomputation over a fixed lighting environment shared by many points, and can not be similarly applied to transfer which varies spatially.
2.3 ZH Error Analysis
A constant (DC) signal (n=1) can be represented by a single coefficient. The illustrated system 100 therefore stores the DC coefficient explicitly, and fits ZH lobes to the remaining components, l>0. A linear SH function (n=2) can be exactly reproduced using any three linearly independent vectors as lobe directions. Therefore, when three or more lobes are used, the illustrated system 100 stores the linear components directly to reduce storage.
A linear SH function is also circularly symmetric about an axis, because the basis functions are linear polynomials in sx, sy, and sz. That axis of symmetry for a linear SH vector ƒ is given by normalizing the 3D vector of its linear basis coefficients (−ƒ11, −ƒ1−1, ƒ10). We call this the optimal linear lobe for ƒ. Higher order SH expansions however can not be represented exactly as a finite sum of rotated Legendre functions of the same order. Fortunately, error approaches 0 rapidly as N increases.
FIGS. 3B-D show ZH fit results for a difficult, randomly generated SH function depicted in FIG. 3A. The original signal was randomly generated as a unit-length SH vector (of n=6). In the graph images, positive values are colored red, and negative blue. The ZH approximations shown in FIGS. 3B-D use increasing numbers of lobes N, which are shown in FIGS. 4A-D. In particular, the ZH approximation shown in FIG. 3B approximates the original signal (FIG. 3A) with one lobe (N=1), resulting in RMS error equal to 0.751. The ZH approximations in FIGS. 3C and 3D use N=2 and N=4 lobes, respectively; and achieve substantial decreases in error (i.e., RMS=0.517 and RMS=0.116, respectively). An example with N=6 lobes (not shown) further decreases the RMS error to 0.00908, or less than 1% of the original signal's L2 norm.
For the diffuse PRT (just described above), the ZH model fits even better as illustrated by the example shown in FIGS. 5A-E. This example uses sixth order SH lighting (n=6). For single-lobe models (N=1), using the optimal linear lobe (as shown in FIG. 5B) results in higher error (RMS=0.292 versus RMS=0.264) than fitting optimally to all 36 components of the transfer vector (as shown in FIG. 5C), as would be expected. The optimal linear approximation (FIG. 5B) is spatially smoother, though. The LDPRT example in FIG. 5C uses a two-lobe ZH approximation, which lowers the error to RMS=0.123. A four lobe approximation (FIG. 5E) matches the original signal well, both visually and in terms of error measurement (RMS=0.016).
FIGS. 6A-D shows a glossy model shaded with fourth-order lighting (n=4), using the technique described by Cook, R., And Torrance, K., “A reflectance model for computer graphics,” ACM Trans. Gr. 1, 1, 7-24 with glossiness=0.3. A singular value decomposition (SVD) and BRDF-specialized transfer (as shown in FIG. 6B) provides a good approximation with only nb=3 rows instead of n2=16 in the original model. A glossy LDPRT using a ZH approximation with N=3 lobes per row is shown in FIG. 6C, which then provides an accurate fit with nbN=9 total lobes. FIG. 6D shows the glossy LDPRT of FIG. 6C mapped over the surface of a “vase” model.
2.4 SH Rotation
General SH rotation can be computed most efficiently by converting to zyz Euler angles. This is because rotation around the z axis by an angle θ of a component band l has a special form that can be performed by l−1 2D rotations of the ±m, |m|>0 components by an angle mθ. Rotation around z is therefore O(n2).
Unfortunately, the required y rotation is more difficult. A simple method to rotate around y by an angle φ is to further decompose it into a series of three rotations: a rotation of +90° around x, followed by a z rotation by φ, followed by a rotation of −90° around x. These two x rotations are inverses and thus transposes because they are themselves high-dimensional rotation matrices. It also turns out that these x rotations are sparse: asymptotically only 25% of the (2l+1)×(2l+1) rotation matrix components are nonzero as l→∞. Exploiting this sparsity reduces computation, but it is only a constant factor reduction, so x rotation remains O(n3). Note that the sparsity of ±90° rotation around x means that the method asymptotically requires a number of multiplies equal to 50% of the number of components in the SH rotation matrix, and thus compares favorably to methods for instantiating that matrix through recursive rules, such as that described by Choi, C., Ivanic, J., Gordon, M., And Ruedenberg, K., “Rapid And Stable Determination Of Rotation Matrices Between Spherical Harmonics By Direct Recursion,” The Journal of Chemical Physics 111, 19 (November), 8825-8831.
We include a table of total multiplication counts for rotating various SH orders using the zxzxz method:
















n = 3
n = 4
n = 5
n = 6
n = 7
n = 8
n = 9







53
121
217
345
509
713
961









The table assumes the linear band l=1 is rotated using the more efficient method of a 3×3 rotation matrix. The constant band l=0 is not changed by rotation. Conversion of a rotation matrix to Euler angles is not included here, but requires 5 multiplies, a reciprocal, and a square root.

SH rotation is very costly for the sixth order lighting (n=6) we use and rapidly gets worse at higher order. Three such rotations must be computed for colored lighting, amounting to more than a thousand multiplies. This should be compared to N≦4 3×3 rotations of a lobe axis from equation (10) for diffuse transfer.
3. Creating ZH Transfer Modes
3.1 Tabulated Models
Using nonlinear optimization, the ZH model may be fit to an arbitrary spherical functions expressed in the SH basis. The objective function ψ to be minimized is simply the L2 norm of the vector difference of the ZH approximation {tilde over (t)} from equation (11) with the original transfer vector t being approximated, or




  
    
      
        Ψ
        =
        
          
            
              
              
                
                  t
                  ~
                
                -
                t
              
              
            
            2
          
          =
          
            
              ∫
              
                S
                2
              
              
                
              
            
            ⁢
            
              
                
                  (
                  
                    
                      
                        t
                        ~
                      
                      ⁡
                      
                        (
                        s
                        )
                      
                    
                    -
                    
                      t
                      ⁡
                      
                        (
                        s
                        )
                      
                    
                  
                  )
                
                2
              
              ⁢
              
                
              
              ⁢
              
                d
                s
              
            
          
        
      
    
    
      
        (
        17
        )
      
    
  




By the orthogonality of the SH basis, this vector distance equals the squared difference between the continuous functions {tilde over (t)}(s) and t(s) integrated over the sphere.

Note that the ZH transfer model must be fit over many points on an object or in a patch of local texture, so that this optimization is applied many times. Fitting glossy PRT is similar, except that it is done for each row in M′ from equation (15).
Single-Lobe Fitting For a single-lobe ZH model, if the lobe axis s* is fixed, then the lobe coefficients that best approximate a given SH vector t are given in closed form as




  
    
      
        
          g
          l
          *
        
        =
        
          
            
              ∑
              
                m
                =
                
                  -
                  l
                
              
              
                +
                l
              
            
            ⁢
            
              
                
                  y
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
                ⁡
                
                  (
                  
                    s
                    *
                  
                  )
                
              
              ⁢
              
                t
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
            
          
          
            
              ∑
              
                m
                =
                
                  -
                  l
                
              
              
                +
                l
              
            
            ⁢
            
              
                y
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
                2
              
              ⁡
              
                (
                
                  s
                  *
                
                )
              
            
          
        
      
    
    
      
        (
        18
        )
      
    
  




This formula simply computes the least-squares best match of the single lobe coefficient gl* to the 2l+1 components of the basis function evaluation y(s*) in each band l. The denominator above is a constant, Σmylm2(s)=(2l+1)/(4π), so the LDPRT technique in the illustrated system 100 (FIG. 1) precomputes a table of reciprocals of this sum of squares for each band index l.

The illustrated implementation of the system 100 fits a single-lobe model to a given SH vector t by looping over a set of directions formed by uniformly sampling a hemi-cube. A hemi-cube suffices because opposite directions produce the same ZH model (see, Section, “ZH Representation for Spherical Functions” above). The system 100 also adds the optimal direction for just the linear part of the vector (see, Section, “ZH Error Analysis” above). For each direction used as a lobe axis, the system 100 computes the lobe coefficients using equation (18). The system 100 then runs BFGS minimization (such as described by Press, W., Teukolsky, S., Vetterling, W., And Flannery, B., “Numerical Recipes in C, Second Edition,” Cambridge University Press, Cambridge, England) using this result as a starting point and both the lobe axis and lobe coefficients as minimization variables. The optimized direction yielding the smallest error (as shown in equation (17)) is the final result.
Optimization Notes Since BFGS is a derivative-based method, the illustrated implementation of the system 100 includes the derivatives of the objective function (17) with respect to the minimization variables:




  
    
      
        
          
            ∂
            Ψ
          
          
            ∂
            
              g
              l
              *
            
          
        
        =
        
          2
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                  y
                  
                    l
                    ⁢
                    
                      
                    
                    ⁢
                    m
                  
                
                ⁡
                
                  (
                  
                    s
                    *
                  
                  )
                
              
              ⁢
              
                (
                
                  
                    
                      t
                      ~
                    
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  -
                  
                    t
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                
                )
              
            
          
        
      
    
    
      
        (
        19
        )
      
    
  
  
    
      
        
          
            ∂
            Ψ
          
          
            ∂
            
              s
              *
            
          
        
        =
        
          2
          ⁢
          
            
              ∑
              
                l
                ⁢
                
                  
                
                ⁢
                m
              
            
            ⁢
            
              
                ∇
                
                  
                    y
                    
                      l
                      ⁢
                      
                        
                      
                      ⁢
                      m
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      *
                    
                    )
                  
                
              
              ⁢
              
                
                  g
                  l
                  *
                
                ⁡
                
                  (
                  
                    
                      
                        t
                        ~
                      
                      
                        l
                        ⁢
                        
                          
                        
                        ⁢
                        m
                      
                    
                    -
                    
                      t
                      
                        l
                        ⁢
                        
                          
                        
                        ⁢
                        m
                      
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        20
        )
      
    
  




The gradients of the SH basis functions ylm with respect to the spherical point s* were computed using Maple but can also be derived using the recurrence relations for SH evaluation.
To constrain 3D points s* to lie on the sphere, we substitute h(s*)=s*/∥s*∥ for s* in the above equations. The gradient of ylm·h replaces the gradient of ylm in (20), given by

∇′ylm=Jh\∇ylm  (21)

where Jh is the 3×3 Jacobian of the normalization of function h.

Multi-Lobe Fitting To fit a multi-lobe model, the illustrated implementation of system 100 iteratively applies the above algorithm. The system 100 fits a single lobe, subtracts its reconstruction (equation 11) from the vector being approximated, and then fits the next lobe to the residual, up to N lobes. A local minimum can then be reached by applying the BFGS algorithm to all lobe parameters simultaneously. To speed things up, the system 100 first freezes lobe directions and optimizes only the lobe coefficients to get closer to a local minimum before applying BFGS over all lobe parameters.
Not surprisingly, additional searching often finds a better minimum. The system 100 applies further computation when the fit error is high, by trying randomly-generated sets of N lobe directions and then locally optimizing with BFGS.
3.2 Parametric Models
Translucent Thin-Membrane Model A simple model for diffuse translucency is shown in FIG. 1. It uses a cosine weighting function centered around the outward-pointing surface normal direction and an attenuated cosine weighting in the opposite direction, given by the spherical function




  
    
      
        
          g
          ⁡
          
            (
            
              s
              ⁢
              
                
              
              ⁢
              ζ
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    s
                    ⁢
                    
                      
                    
                    ⁢
                    ζ
                  
                  ,
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    s
                    ⁢
                    
                      
                    
                    ⁢
                    ζ
                  
                  ≥
                  0
                
              
            
            
              
                
                  
                    
                      -
                      α
                    
                    ⁢
                    
                      
                    
                    ⁢
                    s
                    ⁢
                    
                      
                    
                    ⁢
                    ζ
                  
                  ,
                
              
              
                otherwise
              
            
          
          }
        
      
    
    
      
        (
        22
        )
      
    
  




where α≦1 is the transparency, and sζ=s·ζ is the cosine of the angle s makes with the surface normal ζ.

Since this is a circularly symmetric function around ζ, it can be represented using a single-lobe ZH, where the lobe axis is the surface normal ζ and the lobe coefficients are given by




  
    
      
        
          g
          l
          *
        
        =
        
          {
          
            
              
                
                  
                  ⁢
                  
                    
                      
                        2
                        /
                        3
                      
                      ⁢
                      
                        (
                        
                          1
                          -
                          α
                        
                        )
                      
                    
                    ,
                  
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                  =
                  1
                
              
            
            
              
                
                  
                  ⁢
                  
                    
                      2
                      ⁢
                      
                        (
                        
                          1
                          +
                          α
                        
                        )
                      
                      ⁢
                      
                        (
                        
                          
                            
                              (
                              
                                -
                                1
                              
                              )
                            
                            
                              
                                l
                                /
                                2
                              
                              -
                              1
                            
                          
                          
                            
                              (
                              
                                l
                                +
                                2
                              
                              )
                            
                            ⁢
                            
                              (
                              
                                l
                                -
                                1
                              
                              )
                            
                          
                        
                        )
                      
                      ⁢
                      
                        (
                        
                          
                            l
                            !
                          
                          
                            
                              
                            
                            ⁢
                            
                              
                                2
                                
                                  
                                    
                                  
                                  ⁢
                                  l
                                
                              
                              ⁢
                              
                                
                              
                              ⁢
                              
                                
                                  (
                                  
                                    
                                      (
                                      
                                        l
                                        /
                                        2
                                      
                                      )
                                    
                                    !
                                  
                                  )
                                
                                2
                              
                            
                          
                        
                        )
                      
                    
                    ,
                  
                
              
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  1
                  ⁢
                  
                    
                  
                  ⁢
                  even
                
              
            
            
              
                
                  
                  ⁢
                  
                    0
                    ,
                  
                
              
              
                otherwise
              
            
          
          }
        
      
    
    
      
        (
        23
        )
      
    
  




This is the sum of two cosine-weighting functions, given by equation (8) in Ramamoorthi, R., And Hanrahan, P., “An Efficient Representation For Irradiance Environment Maps,” Proc. of SIGGRAPH '01, 497-500. One just represents the response of a diffuse surface to low-frequency lighting. The other is scaled by transparency and oriented opposite to the normal direction to account for translucency. These coefficients are also divided by π to convert irradiance to exit radiance.
A spatially-varying translucency map (α) can be applied to enhance realism, as in the bat example. We also note that a subsurface scattering simulation can be performed to parameterize a more sophisticated model based on membrane thickness and scattering properties rather than simple transparency.
Wrinkle Model For example, the system 100 can model a wrinkle as a simple sinusoidal groove, parameterized by location along the groove cross-section, x, and groove depth d. The system 100 extrudes this groove and performs a diffuse PRT simulation on the resulting parameterized height field. The system 100 then fits a 3-lobe ZH model to its diffuse transfer signal. This fit uses bilinear basis functions which produce parameters for 3 lobes (axis and coefficients) as a 32×32 map of (x,d). DC and linear SH coefficients are explicitly stored, and fit with bilinear basis functions.
In performing the ZH fit, it is important to establish a correspondence between lobes. Independently fitting a ZH model to each (x,d) point does not match lobes at neighboring (x,d) and so causes artifacts when they are interpolated. The system 100 can instead perform a single optimization over the entire (x,d) space. Using bilinear basis functions in (x,d) for each lobe parameter and fitting to a more highly sampled version of the PRT signal automatically penalizes lack of correspondence between lobes. An initial guess for the optimizer is computed by a linear least squares fit of an optimal linear lobe (see, Section entitled, “ZH Error Analysis” above) with two additional lobes placed symmetrically around it, by a locally optimized angle. The final optimization then uses the conjugate gradient method described by Press, W., Teukolsky, S., Vetterling, W., And Flannery, B., “Numerical Recipes in C, Second Edition,” Cambridge University Press, Cambridge, England.
4. LDPRT Rendering
FIG. 7 depicts a process 700 performed by the computer rendering system 100 (FIG. 1) for rendering an image using the LDPRT technique. This image rendering using LDPRT begins by projecting the lighting of the modeled lighting environment into the SH basis to produce the lighting vector e, as shown as action 710. Then, for a plurality of points p on the deforming object (e.g., for each vertex, or other distribution of points over a surface of the object) as indicated in loop 711-715, the rendering process 700 does the following:

    
    
        1. computes the rotation Rp from the rest coordinate frame into deformed frame (action 712),
        2. applies Rp to the N ZH axes (nbN axes for glossy) at p:Rpsi* (action 713),
        3. evaluates equation (13) (equation (16) for glossy) for the shading result or exit radiance (action 714).

The local deformed frame Rp can be computed on the CPU or in a vertex shader and is then interpolated using rasterization hardware. For example, the images of the example bat model (FIGS. 2A-B) were computed using skinning. The third step is done in a pixel shader.

    
    


Evaluating equation (13) can be sped up by storing the SH basis functions y(s) in spherical tables. This is useful when we wish to apply local lighting, which varies over points on the object. For distant lighting shared over many surface points, there's an even better speed-up described below.
Lighting-Specialized LDPRT To accelerate shading in equation (13), we can specialize ZH transfer evaluation to a particular lighting environment, e. A spherical table is created, ê(s) from points sεS2 into Rn where n is the SH order, via




  
    
      
        
          
            
              e
              ^
            
            l
          
          ⁡
          
            (
            s
            )
          
        
        =
        
          
            ∑
            
              m
              =
              
                -
                l
              
            
            
              +
              l
            
          
          ⁢
          
            
              
                y
                
                  l
                  ⁢
                  
                    
                  
                  ⁢
                  m
                
              
              ⁡
              
                (
                s
                )
              
            
            ⁢
            
              e
              
                l
                ⁢
                
                  
                
                ⁢
                m
              
            
          
        
      
    
    
      
        (
        24
        )
      
    
  




Now equation (13) simplifies to the following simple computation




  
    
      
        r
        =
        
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                
                  e
                  ^
                
                ⁡
                
                  (
                  
                    s
                    i
                    *
                  
                  )
                
              
              ·
              
                g
                i
                *
              
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                ∑
                
                  l
                  =
                  0
                
                
                  n
                  -
                  1
                
              
              ⁢
              
                
                  
                    
                      e
                      ^
                    
                    l
                  
                  ⁡
                  
                    (
                    
                      s
                      i
                      *
                    
                    )
                  
                
                ⁢
                
                  g
                  il
                  *
                
              
            
          
        
      
    
    
      
        (
        25
        )
      
    
  




requiring just N look-ups of ê at the lobe axes si* and N n-dimensional dot products between this result and the lobe coefficients gi*. Computation in (13) is reduced from O(n2N) to O(nN). Tabulated vectors are reduced from n2-dimensional (y(s)) to n-dimensional (ê(s)). For small N, the computation is even simpler than the n2-dimensional dot products required by the SH basis. The reduction is easily derived from (13) by grouping the elm and ylm(si*) factors and performing the inner sum over m to generate êl. We use a 64×32 map for ê(s), parameterized by latitude/longitude.

5. Results
FIGS. 8A-14E illustrate various shading effects achieved by rendering using the LDPRT rendering process 700 (FIG. 7). For the “unshadowed” results (shown in FIGS. 8A, 9A, 10A, 11A, and 12A), the shading on the object's surface simply integrates over a lighting hemisphere, but without blocking or scattering the source radiance. They are equivalent to rendering with spatially-varying normals which index an irradiance map, as described by Ramamoorthi, R., And Hanrahan, P., “An Efficient Representation For Irradiance Environment Maps,” Proc. of SIGGRAPH '01, 497-500.
On the other hand, by including transfer effects in the precomputed simulation, the LDPRT rendering process 700 can incorporate shadowing for both diffuse (FIGS. 8B, 9B, 10B, 11B, 12B, 14A, 14B and 14E) and glossy surfaces (FIG. 14D), diffuse inter-reflection (FIG. 13C), and subsurface scattering (FIGS. 2A-B, 9C and 14C). The subsurface waffle texture (FIGS. 9C and 14C) simulates geometry whose thin bottom layer transmits more light than its sides. It was derived from an actual scattering simulation, and not the simple model described above in Section 3.2, entitle “Parametric Models.” FIG. 8A shows the sharpest shadow we can cast with sixth-order SH lighting. All textures can be mapped onto any surface, no matter how it deforms.
The illustrated LDPRT implementation doesn't include distant effects like shadowing of the bat's wings onto its body (e.g., in FIGS. 2A-B), or effects from multiple occluding translucent layers (e.g., with the subsurface effects illustrated in FIG. 14C). The high-frequency local geometry is rendered properly in the front-most layer, masking these errors and maintaining a realistic appearance.
Two methods generate LDPRT from geometry: simulating a local texture patch which can be mapped onto various objects (as shown in FIGS. 14A-E), or PRT simulation on an entire mesh which can then be deformed. FIGS. 13A-C shows results from the latter method on a Mayan head. The mesh has been bent and twisted; the figure compares ray tracing the deformed model (in FIG. 13A), applying the undeformed PRT shading (in FIG. 13B), and applying LDPRT (in FIG. 13C). The results of the LDPRT rendering matches better by allowing the local coordinate frame to be rotated.
Local patch geometry is specified by a mesh (for the waffle in FIGS. 9A-C, and bumps in FIGS. 8A-B) or by inferring height fields from images (for the weave in FIG. 14B, and swirl in FIG. 14E). The height field can be inferred using the simple technique of mapping albedo to height. In the example images shown here, all LDPRT textures are diffuse except FIG. 14D. For diffuse textures in the example images, the parameters n=6 and N=4 were used, with the exception of the bat (FIG. 2A-B) where n=3 and N=1. For example image of the glossy texture (FIG. 14D), the parameters n=4, N=3, and nb=3 were used for 9 total lobes. For the LDPRT textures in these examples where N>1, the DC and linear SH coefficients are stored directly and can be bilinearly interpolated; the ZH lobes are fit to the remaining, higher-order SH coefficients and are point sampled.
Examples of the above-discussed parametric models are shown in FIGS. 2A-B (translucent thin membrane model) and in FIGS. 10A-B (wrinkle model). For the example wrinkle model in FIGS. 10A-B, the groove location is made a function of angle around a smooth cylinder, which is then deformed.
Preprocessing (i.e., pre-computing the LDPRT) for these example images was dominated by the ZH fit. The most expensive fits were less than 30 minutes: namely, the Mayan head with 17575 vertices in FIG. 13C, the subsurface waffle (64×64) in FIG. 14C and the swirl (128×128) in FIG. 14E. The preprocessing time depends on the size of the texture (or number of mesh vertices), the number of lobes, and the complexity of the PRT signal. Smaller textures (e.g., the weave in FIG. 14B) take just a few minutes. The PRT simulations took from 4-10 minutes with 5000 rays per point. All examples were simulated and rendered with single-channel transfer. These timings were achieved on a computer equipped with a 3.0 Ghz P4 processor and a Geforce 6800 Ultra graphics card.
We recorded run-time rendering rates of between 100-200 Hz for the diffuse examples (3-channel lighting) and 70-100 Hz for the glossy example (1-channel lighting). This includes the time to build the light specialized map each frame (1430 Hz by itself).
6. Computing Environment
The above described graphics image rendering system 100 (FIG. 1) that implements the local, deformable precomputed radiance transfer image rendering techniques can be implemented on any of a variety of computing devices and environments, including computers of various form factors (personal, workstation, server, handheld, laptop, tablet, or other mobile), distributed computing networks, and Web services, as a few general examples. The image rendering techniques can be implemented in hardware circuitry, as well as in software 1580 executing within a computer or other computing environment, such as shown in FIG. 15.
FIG. 15 illustrates a generalized example of a suitable computing environment 1500 in which the described techniques can be implemented. The computing environment 1500 is not intended to suggest any limitation as to scope of use or functionality of the invention, as the present invention may be implemented in diverse general-purpose or special-purpose computing environments.
With reference to FIG. 15, the computing environment 1500 includes at least one processing unit 1510 and memory 1520. In FIG. 15, this most basic configuration 1530 is included within a dashed line. The processing unit 1510 executes computer-executable instructions and may be a real or a virtual processor. In a multi-processing system, multiple processing units execute computer-executable instructions to increase processing power. The memory 1520 may be volatile memory (e.g., registers, cache, RAM), non-volatile memory (e.g., ROM, EEPROM, flash memory, etc.), or some combination of the two. The memory 1520 stores software 1580 implementing the computer graphics image rendering system 100 with local, deformable precomputed radiance transfer.
A computing environment may have additional features. For example, the computing environment 1500 includes storage 1540, one or more input devices 1550, one or more output devices 1560, and one or more communication connections 1570. An interconnection mechanism (not shown) such as a bus, controller, or network interconnects the components of the computing environment 1500. Typically, operating system software (not shown) provides an operating environment for other software executing in the computing environment 1500, and coordinates activities of the components of the computing environment 1500.
The storage 1540 may be removable or non-removable, and includes magnetic disks, magnetic tapes or cassettes, CD-ROMs, CD-RWs, DVDs, or any other medium which can be used to store information and which can be accessed within the computing environment 1500. The storage 1540 stores instructions for the software 1580 of the computer graphics image rendering system implementing the local, deformable precomputed radiance transfer techniques.
The input device(s) 1550 (e.g., for devices operating as a control point in the device connectivity architecture 100) may be a touch input device such as a keyboard, mouse, pen, or trackball, a voice input device, a scanning device, or another device that provides input to the computing environment 1500. For audio, the input device(s) 1550 may be a sound card or similar device that accepts audio input in analog or digital form, or a CD-ROM reader that provides audio samples to the computing environment. The output device(s) 1560 may be a display, printer, speaker, CD-writer, or another device that provides output from the computing environment 1500.
The communication connection(s) 1570 enable communication over a communication medium to another computing entity. The communication medium conveys information such as computer-executable instructions, audio/video or other media information, or other data in a modulated data signal. A modulated data signal is a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired or wireless techniques implemented with an electrical, optical, RF, infrared, acoustic, or other carrier.
The local, deformable precomputed radiance transfer image rendering techniques herein can be described in the general context of computer-readable media. Computer-readable media are any available media that can be accessed within a computing environment. By way of example, and not limitation, with the computing environment 1500, computer-readable media include memory 1520, storage 1540, and combinations of any of the above.
The techniques herein can be described in the general context of computer-executable instructions, such as those included in program modules, being executed in a computing environment on a target real or virtual processor. Generally, program modules include routines, programs, libraries, objects, classes, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The functionality of the program modules may be combined or split between program modules as desired in various embodiments. Computer-executable instructions for program modules may be executed within a local or distributed computing environment.
For the sake of presentation, the detailed description uses terms like “determine,” “generate,” “adjust,” and “apply” to describe computer operations in a computing environment. These terms are high-level abstractions for operations performed by a computer, and should not be confused with acts performed by a human being. The actual computer operations corresponding to these terms vary depending on implementation.
In view of the many possible embodiments to which the principles of our invention may be applied, we claim as our invention all such embodiments as may come within the scope and spirit of the following claims and equivalents thereto.

## Claims

1. A method of rendering a graphics image using a computer having a processor, memory and display, the method comprising:
calculating, by the processor, data of radiance transfer for a plurality of points over a surface of a modeled object for a rest coordinate frame, where the radiance transfer data for low frequency lighting is represented as a function of at least a sum of one or more products of coefficients and circularly symmetric basis functions, where the circularly symmetric basis functions have plural separate lobe axes and wherein the circularly symmetric basis functions are zonal harmonics;
based on the radiance transfer data, evaluating, by the processor, radiance transfer over at least a portion of the surface of the modeled object from a lighting environment for a view direction; and
producing an image of the modeled object as lit according to the radiance transfer evaluation on the display.

2. The method of claim 1 wherein the calculating radiance transfer data is performed as a precomputation for the points sampled over a surface of the modeled object.

3. The method of claim 1 wherein the calculating radiance transfer data is calculated from a parameterized model of the radiance transfer over the surface of the modeled object, wherein the parameterized model defines the radiance transfer at the points over the surface of the modeled object as a function of at least one parameter varying according to location of the points over the surface of the modeled object, in combination with the function of at least the sum of one or more products of coefficients and circularly symmetric basis functions.

4. The method of claim 1 wherein the calculating data of radiance transfer comprises:
calculating a radiance transfer vector at a sampled point; and
approximating the vector using zonal harmonics.

5. The method of claim 4 wherein the approximating the radiance transfer vector comprises, iteratively performing the following up to a desired number of zonal harmonics lobes:
fitting a zonal harmonics lobe to a residual of the radiance transfer vector, the residual initially being the spherical harmonics vector; and
subtracting the fitted zonal harmonics lobe from the current residual to produce a residual for a next iteration.

6. The method of claim 1 wherein the modeled object is deformable, the method further comprising:
deforming the modeled object, thereby causing orientations of at least some of the sampled points on the modeled object to change to respective deformed coordinate frames;
for a sampled point on the modeled object whose orientation has changed to a respective deformed coordinate frame,
applying a rotation to the radiance transfer data of the sampled point from the rest coordinate frame to the respective deformed coordinate frame of the sampled point; and
evaluating radiance transfer of the sampled point from a lighting environment for a view direction based on the rotated radiance transfer data of the sampled point.

7. The method of claim 6 wherein applying the rotation to the radiance transfer data comprises applying the rotation to axes of the circularly symmetric basis functions.

8. The method of claim 1 wherein the modeled object is deformable, the method further comprising:
deforming the modeled object, thereby causing orientations of at least some of the sampled points on the modeled object to change to respective deformed coordinate frames;
for a sampled point on the modeled object whose orientation has changed to a respective deformed coordinate frame,
applying a rotation to the incident light from the lighting environment from the rest coordinate frame to the respective deformed coordinate frame of the sampled point; and
evaluating radiance transfer of the sampled point from the rotated incident light of the lighting environment for a view direction based on the radiance transfer data of the sampled point.

9. The method of claim 1 wherein the radiance transfer data represents shadowing and light scattering of local surface features of the modeled object at the sampled point.

10. The method of claim 9 wherein the radiance transfer data further represents translucence of the modeled object at the sampled point.

11. At least one data carrying storage medium having encoded thereon a software program executable on an image rendering system for a method of rendering graphics images of a modeled object based on data of local, deformable precomputed radiance transfer for sampled locations over a surface of the modeled object, the method comprising:
for a plurality of locations on the modeled object:
computing a rotation from a rest coordinate frame of the precomputed radiance transfer data to a deformed frame for the respective location;
applying the rotation to the precomputed radiance transfer data of the respective location;
based on the rotated radiance transfer data of the respective location, evaluating radiance transfer from a lighting environment for a view direction to yield a shading result for the respective location; and

producing an image of the modeled object with the locations on the modeled object shaded according to their respective shading result;
wherein the radiance transfer data for a respective location on a diffuse surface of the modeled object for low frequency lighting is a matrix Gi* of coefficients in a zonal harmonics representation having lobe axes si*.

12. The computer-readable data carrying storage media of claim 11 wherein the evaluating comprises calculating the shading result according to the equation




  
    r
    =
    
      
        ∑
        
          i
          =
          1
        
        N
      
      ⁢
      
        y
        ⁢
        
          
        
        ⁢
        
          †
          ⁡
          
            (
            
              s
              i
              *
            
            )
          
        
        ⁢
        
          G
          i
          *
        
        ⁢
        e
      
    
  
  ,




where e is a lighting vector representing incident lighting from the lighting environment.

13. The computer-readable data carrying storage media of claim 11 wherein the radiance transfer data for a respective location on a glossy surface of the modeled object is a BRDF-specialized transfer matrix M′ resulting from a singular value decomposition of coefficients in a zonal harmonics representation having lobe axes si* over a sampling of view and light directions, and the evaluating comprises calculating the shading result according to the equation, r(v)=u(v)M′e, where u(v) is a view factor vector and e is a lighting vector representing incident lighting from the lighting environment.

14. A graphics image processing system for rendering images of a deformable modeled object, comprising:
a lighting simulator operating to perform a lighting simulation of the modeled object to produce a set of radiance transfer matrices for a set of sampled locations over a surface of the modeled object representing radiance response including local effects to incident low frequency lighting at the respective sampled locations, where the radiance transfer matrices contain a set of coefficients for a representation of the radiance response at the respective sampled location as a sum of products of the coefficients multiplied by circularly symmetric basis functions, where said circularly symmetric basis functions comprise functions on separate lobe axes and wherein the circularly symmetric basis functions are zonal harmonics;
a run-time image rendering engine operating to determine lighting from a lighting environment for each of a plurality of viewed locations on the modeled object in an image as a function of incident lighting from the lighting environment, the set of radiance transfer matrices, and rotations for the viewed locations from a rest coordinate frame to a deformed frame on the modeled object in a deformed position; and
a display driver operating to present the image of the modeled object in the lighting environment with the determined lighting on a display.

15. The graphics image processing system of claim 14 wherein the lighting simulator operates to produce the radiance transfer matrices by calculating a radiance transfer vector at a viewed location, and approximating the vector using zonal harmonics.

16. The graphics image processing system of claim 15 wherein the lighting simulator approximate the radiance transfer vector by iteratively performing the following up to a desired number of zonal harmonics lobes:
fitting a zonal harmonics lobe to a residual of the radiance transfer vector, the residual initially being the spherical harmonics vector; and
subtracting the fitted zonal harmonics lobe from the current residual to produce a residual for a next iteration.

17. The graphics image processing system of claim 14 wherein the run-time image rendering engine further operates to apply the rotations from the rest coordinate frame to the respective deformed coordinate frame for the viewed locations to the respective radiance transfer matrices of the viewed locations, and to determine lighting of the viewed locations by evaluating radiance transfer from the lighting environment for the view direction based on the respective rotated radiance transfer matrices of the viewed locations.

18. The graphics image processing system of claim 14 wherein the run-time image rendering engine further operates to apply the rotations from the rest coordinate frame to the respective deformed coordinate frame for the viewed locations to the incident light from the lighting environment, and to determine lighting of the viewed locations by evaluating radiance transfer from rotated incident light from the lighting environment based on the respective radiance transfer matrices of the viewed locations.