Abstract:
A method for parallel magnetic resonance imaging (MRI) reconstruction of digital images includes providing a set of acquired k-space MR image data v, a redundant Haar wavelet matrix W satisfying W T W=I, wherein I is an identity matrix, a regularization parameter λ≧0, and a counter limit k, initializing a variable z 0 =Wv, and intermediate quantities p 0 =q 0 =0, calculating y i =arg min z  1/2∥z−(p i +z i )∥ 2   2 +λ∥z∥ 1  for 0≦i≦k, wherein z denotes values of an MR image sought to be reconstructed, updating p i+1 =(p i +z i )−y i , updating z i+1 =arg min z  1/2∥z−(q i +z i )∥ 2   2 +g(z), wherein 
     
       
         
           
             
               g 
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       0 
                       , 
                     
                   
                   
                     
                       
                         z 
                         = 
                         
                           
                             WW 
                             T 
                           
                            
                           z 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         + 
                         ∞ 
                       
                       , 
                     
                   
                   
                     
                       otherwise 
                       ; 
                     
                   
                 
               
             
           
         
       
     
     and updating q i+1 =(q i +y i )−z i−1 , wherein x=W T z is a solution of 
     
       
         
           
             
               
                 min 
                 x 
               
                
               
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       Wx 
                       - 
                       Wv 
                     
                      
                   
                   2 
                   2 
                 
               
             
             + 
             
               λ 
                
               
                 
                    
                   Wx 
                    
                 
                 1 
               
             
           
         
       
     
     that specifies a reconstruction of the MR image.

Description:
CROSS REFERENCE TO RELATED UNITED STATES APPLICATIONS 
       [0001]    This application claims priority from “Redundant, Efficient Haar Minimization”, U.S. Provisional Application No. 61/654,227 of Liu, et al., filed Jun. 1, 2012, the contents of which are herein incorporated by reference in their entirety. 
     
    
     TECHNICAL FIELD 
       [0002]    This disclosure is directed to methods for parallel reconstruction of digital images. 
       DISCUSSION OF THE RELATED ART 
       [0003]    Magnetic resonance imaging (MRI) is a medical imaging technique used in radiology to visualize internal structures of the body in detail. As a non-invasive imaging technique, MRI makes use of nuclear magnetic resonance to image nuclei of atoms inside the body. MRI has been used for imaging the brain, muscles, the heart, cancers, etc. 
         [0004]    The raw data acquired by an MR scanner are the Fourier coefficients, or the so-called k-space data.  FIG. 1(   a ) depicts an MR image and the full k-space data, displayed in a logarithmic scale, and  FIG. 1(   b ) depicts the image obtained by applying an inverse Fourier transform to the k-space data of  FIG. 1(   a ). The k-space data are typically acquired by a series of phase encodings, in which each phase encoding includes a given amount of k-space data that are related to the sampling. For example, with Cartesian sampling, 256 frequency encodings are needed to cover the full k-space of one 256×256 image. The time between the repetitions of the sequence is called the repetition time (TR) and is a measure of the time needed for acquiring one phase encoding. For example, if TR=50 ms, it takes about 12.8 seconds to acquire a full k-space data of one 256×256 image with Cartesian sampling. With the same TR, it takes about 15.4 minutes to acquire the full k-space of a 256×256×72 volume. With higher spatial resolution, the time for acquiring a full k-space may be even greater. In addition, in dynamic cine imaging, one is interested in the study of the motion of an object, such as the heart or blood, over time. This leads to an increased number of phase encodings and increased acquisition time, and one usually has to compromise between spatial resolution and temporal resolution. To reduce the acquisition time, one may undersample the k-space, i.e., reduce the number of acquired phase encodings. For example, if the k-space data are acquired every other line, as shown in  FIG. 1(   c ), the acquisition time can be reduced by half. The relationship between the acquired k-space data and the image to be reconstructed can be written as 
         [0000]        y=F   u   x+n,    (1)
 
         [0000]    where F u  is a given undersampled Fourier transform operator, x denotes the MR image, y is the acquired k-space data, and n denotes the noise introduced in the acquisition. Unlike the full k-space scenario, one cannot directly apply the inverse Fourier transform to the undersampled data acquired in  FIG. 1(   c ), since otherwise an aliased image as shown in  FIG. 1(   d ) is obtained. 
         [0005]    Parallel imaging has been proven effective for reducing acquisition time. Parallel imaging exploits differences in sensitivities between individual coil elements in a receiver array to reduce the number of gradient encodings required for imaging.  FIG. 2  illustrates parallel imaging with 8 coils. In particular, the first two rows of  FIG. 2  show the coil images seen by the individual coil/channel, and the last two rows show the sensitivities of these 8 coils. It can be observed that the 8 coils have different sensitivities. Parallel imaging tries to reconstruct the target image with the undersampled k-space data. 
         [0006]    Sensitivity encoding (SENSE) is a technique that can reduce scan time in magnetic resonance imaging (MRI). A SENSE approach utilizes the spatial information related to the coils of a receiver array for reducing conventional Fourier encoding. In principle, SENSE can be applied to any imaging sequence and k-space trajectories, however, it is particularly feasible for Cartesian sampling schemes. In the SENSE approach, one models the relationship between the target image and the acquired k-space data as: 
         [0000]      y i   =F   u   S   i   x+n   i ,   (2)
 
         [0000]    where y i  is the undersampled k-space data acquired by the i-th coil, and S i  is the coil sensitivity maps, as shown in the last two rows of  FIG. 2 . 
         [0007]    To recover x from EQ. (2), one should note that the target x has certain structures, with which one can better reconstruct x from the undersampled data y. This is where sparse learning can play a role. Typically, x can be computed by minimizing the following expression: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       x 
                     
                      
                     
                       
                         ∑ 
                         i 
                       
                        
                       
                         loss 
                          
                         
                           ( 
                           
                             y 
                             , 
                             
                               
                                 F 
                                 u 
                               
                                
                               
                                 S 
                                 i 
                               
                                
                               x 
                             
                           
                           ) 
                         
                       
                     
                   
                   + 
                   
                     λ 
                      
                     
                         
                     
                      
                     
                       φ 
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where loss(y, F u x) denotes the data fidelity, and φ(x) incorporates prior knowledge about the image to be reconstructed. The efficient optimization of EQ. (3) is key to parallel imaging. 
         [0008]    The data fidelity term is typically defined as the squared distance between the acquired data and the prediction: loss(y, F u x)=1/2∥y−F u S i x∥ 2   2 . The term for φ(x) should incorporate the structure in the target image x.  FIG. 3  illustrates the gradient of the phantom shown in  FIG. 1  along the vertical direction (left) and horizontal direction (right), respectively, and one may observe that such gradient is sparse. 
         [0009]    Redundant Haar minimization, which is the minimization of the combination of the data fidelity and the L 1  regularization via redundant Haar wavelets, has been proven effective for parallel MRI reconstruction. When minimizing via Nesterov&#39;s accelerated gradient algorithm, a key building block is the so-called proximal operator associated with the redundant Haar penalty. Such a proximal operator does not allow a closed form solution, which adds to the difficulty of optimization. A low precision solution of such proximal operator usually leads to slow convergence or no convergence at all. Therefore, it is useful to have an efficient solver for such proximal operator. 
       SUMMARY 
       [0010]    Exemplary embodiments of the invention as described herein generally include methods for solving a proximal operator using a restricted least squares regression algorithm, an alternating algorithm for solving the dual system, and a novel and effective warm start technique for fast convergence. An equivalent relationship is established between a restricted least squares regression algorithm according to an embodiment of the invention, and the alternating algorithm according to an embodiment of the invention. 
         [0011]    According to an aspect of the invention, there is provided a method for parallel magnetic resonance imaging (MRI) reconstruction of digital images, including providing a set of acquired k-space MR image data v, a redundant Haar wavelet matrix W satisfying W T W=I, wherein I is an identity matrix, a regularization parameter λ≧0, and a counter limit k, initializing a variable z 0 =Wv, and intermediate quantities p 0 =q 0 =0, calculating y i =arg min z  1/2∥z−(p i +z i )∥ 2   2 +λ∥z∥ 1  for 0≦i≦k, wherein z denotes values of an MR image sought to be reconstructed, updating p i+1 =(p i +z i )−y i , updating z i+1 =arg min z  1/2∥z−(q i +z i )∥ 2   2 +g(z), wherein 
         [0000]    
       
         
           
             
               g 
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       0 
                       , 
                     
                   
                   
                     
                       
                         z 
                         = 
                         
                           
                             WW 
                             T 
                           
                            
                           z 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         + 
                         ∞ 
                       
                       , 
                     
                   
                   
                     
                       otherwise 
                       ; 
                     
                   
                 
               
             
           
         
       
     
         [0000]    and updating q i+1 =(q i +y i )−z i+1 , wherein x=W T z is a solution of 
         [0000]    
       
         
           
             
               
                 min 
                 x 
               
                
               
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       Wx 
                       - 
                       Wv 
                     
                      
                   
                   2 
                   2 
                 
               
             
             + 
             
               λ 
                
               
                 
                    
                   Wx 
                    
                 
                 1 
               
             
           
         
       
     
         [0000]    that specifies a reconstruction of the MR image. 
         [0012]    According to a further aspect of the invention, 
         [0000]    
       
         
           
             
               
                 
                   argmin 
                   z 
                 
                  
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       z 
                       - 
                       
                         ( 
                         
                           
                             p 
                             i 
                           
                           + 
                           
                             z 
                             i 
                           
                         
                         ) 
                       
                     
                      
                   
                   2 
                   2 
                 
               
               + 
               
                 λ 
                  
                 
                   
                      
                     z 
                      
                   
                   1 
                 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               p 
                               i 
                             
                             + 
                             
                               z 
                               i 
                             
                           
                           ) 
                         
                         - 
                         λ 
                       
                       , 
                       
                         
                           ( 
                           
                             
                               p 
                               i 
                             
                             + 
                             
                               z 
                               i 
                             
                           
                           ) 
                         
                         &gt; 
                         λ 
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               p 
                               i 
                             
                             + 
                             
                               z 
                               i 
                             
                           
                           ) 
                         
                         + 
                         λ 
                       
                       , 
                       
                         
                           ( 
                           
                             
                               p 
                               i 
                             
                             + 
                             
                               z 
                               i 
                             
                           
                           ) 
                         
                         &lt; 
                         
                           - 
                           λ 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                       
                         otherwise 
                         . 
                       
                     
                   
                 
               
             
           
         
       
     
         [0013]    According to a further aspect of the invention, arg min z  1/2∥z−(q i +z i ∥ 2   2 +g(z)=WW T (q i +z i ). 
         [0014]    According to another aspect of the invention, there is provided a method for parallel MRI reconstruction of digital images, including providing a set of acquired k-space MR image data v, a redundant Haar wavelet matrix W satisfying W T W=I, wherein I is an identity matrix, a regularization parameter λ≧0, a counter limit k, an initial value of a dual variable p derived by forming a dual to a quadratic program 
         [0000]    
       
         
           
             
               
                 min 
                 
                   
                     z 
                     : 
                     z 
                   
                   = 
                   
                     
                       WW 
                       T 
                     
                      
                     z 
                   
                 
               
                
               
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       z 
                       - 
                       Wv 
                     
                      
                   
                   2 
                   2 
                 
               
             
             + 
             
               λ 
                
               
                 
                    
                   z 
                    
                 
                 1 
               
             
           
         
       
     
         [0000]    that represents parallel reconstruction of a magnetic resonance (MR) image, and an initial value of a Lagrange multiplier {tilde over (q)} of the constraint an initial value of z=WW T z, calculating 
         [0000]    
       
         
           
             
               
                 p 
                 
                   i 
                   + 
                   1 
                 
               
               = 
               
                 
                   
                     argmin 
                     
                       p 
                       : 
                       
                         
                           
                              
                             p 
                              
                           
                           ∞ 
                         
                         ≤ 
                         λ 
                       
                     
                   
                    
                   
                     1 
                     2 
                   
                    
                   
                     
                        
                       
                         p 
                         - 
                         
                           ( 
                           
                             Wv 
                             - 
                             
                               
                                 ( 
                                 
                                   I 
                                   - 
                                   
                                     WW 
                                     T 
                                   
                                 
                                 ) 
                               
                                
                               
                                 
                                   q 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           ) 
                         
                       
                        
                     
                     2 
                     2 
                   
                    
                   
                       
                   
                    
                   for 
                    
                   
                       
                   
                    
                   0 
                 
                 ≤ 
                 i 
                 ≤ 
                 k 
               
             
             , 
           
         
       
     
         [0000]    calculating an intermediate value y i =(Wv−(I−WW T ){tilde over (q)} i )−p i+1 , updating 
         [0000]    
       
         
           
             
               
                 
                   q 
                   ~ 
                 
                 
                   i 
                   + 
                   1 
                 
               
               = 
               
                 
                   argmin 
                   
                     q 
                     ~ 
                   
                 
                  
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       
                         
                           ( 
                           
                             I 
                             - 
                             
                               WW 
                               T 
                             
                           
                           ) 
                         
                          
                         
                           
                             q 
                             ~ 
                           
                           i 
                         
                       
                       - 
                       
                         ( 
                         
                           Wv 
                           - 
                           
                             p 
                             i 
                           
                         
                         ) 
                       
                     
                      
                   
                   2 
                   2 
                 
               
             
             , 
           
         
       
     
         [0000]    calculating q i+1 =(I−WW T ){tilde over (q)} i+1 , and calculating z i+1 =(Wv−P i+1 )−q i+1 , wherein x=W T z is a solution of 
         [0000]    
       
         
           
             
               
                 min 
                 x 
               
                
               
                 
                   1 
                   2 
                 
                  
                 
                   
                      
                     
                       Wx 
                       - 
                       Wv 
                     
                      
                   
                   2 
                   2 
                 
               
             
             + 
             
               λ 
                
               
                 
                    
                   Wx 
                    
                 
                 1 
               
             
           
         
       
     
         [0000]    that specifies a reconstruction of the MR image. 
         [0000]    
       
         
           
             
               
                 argmin 
                 
                   
                     
                        
                       p 
                        
                     
                     ∞ 
                   
                   ≤ 
                   λ 
                 
               
                
               
                 1 
                 2 
               
                
               
                 
                    
                   
                     p 
                     - 
                     
                       ( 
                       
                         Wv 
                         - 
                         
                           
                             ( 
                             
                               I 
                               - 
                               
                                 WW 
                                 T 
                               
                             
                             ) 
                           
                            
                           
                             
                               q 
                               ~ 
                             
                             i 
                           
                         
                       
                       ) 
                     
                   
                    
                 
                 2 
                 2 
               
             
             = 
             
               { 
               
                 
                   
                     
                       λ 
                       , 
                     
                   
                   
                     
                       
                         
                           ( 
                           
                             Wv 
                             - 
                             
                               
                                 ( 
                                 
                                   I 
                                   - 
                                   
                                     WW 
                                     T 
                                   
                                 
                                 ) 
                               
                                
                               
                                 
                                   q 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           ) 
                         
                         &gt; 
                         λ 
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         - 
                         λ 
                       
                       , 
                     
                   
                   
                     
                       
                         
                           ( 
                           
                             Wv 
                             - 
                             
                               
                                 ( 
                                 
                                   I 
                                   - 
                                   
                                     WW 
                                     T 
                                   
                                 
                                 ) 
                               
                                
                               
                                 
                                   q 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           ) 
                         
                         &lt; 
                         
                           - 
                           λ 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         ( 
                         
                           Wv 
                           - 
                           
                             
                               ( 
                               
                                 I 
                                 - 
                                 
                                   WW 
                                   T 
                                 
                               
                               ) 
                             
                              
                             
                               
                                 q 
                                 ~ 
                               
                               i 
                             
                           
                         
                         ) 
                       
                       , 
                     
                   
                   
                     
                       otherwise 
                       . 
                     
                   
                 
               
             
           
         
       
     
         [0015]    According to a further aspect of the invention, 1/2∥(I−WW T ){tilde over (q)} i −(Wv−p i )∥ 2   2  is minimized by (I−WW T ){tilde over (q)} i+1 =(I−WW T )(Wv−p i ). 
         [0016]    According to a further aspect of the invention, if dual variable p and Lagrange 
         [0017]    According to a further aspect of the invention, if dual variable p and Lagrange multiplier {tilde over (q)} are both initialized to 0, 
         [0000]    
       
         
           
             
               
                 
                   
                     y 
                     i 
                   
                   = 
                     
                    
                   
                     S 
                      
                     
                       ( 
                       
                         
                           Wv 
                           - 
                           
                             
                               ( 
                               
                                 I 
                                 - 
                                 
                                   WW 
                                   T 
                                 
                               
                               ) 
                             
                              
                             
                               
                                 q 
                                 ~ 
                               
                               i 
                             
                           
                         
                         , 
                         λ 
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     S 
                      
                     
                       ( 
                       
                         
                           
                             p 
                             i 
                           
                           + 
                           
                             z 
                             i 
                           
                         
                         , 
                         λ 
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                      
                     
                       
                         
                           argmin 
                           z 
                         
                          
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               
                                 ( 
                                 
                                   
                                     p 
                                     i 
                                   
                                   + 
                                   
                                     z 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                              
                           
                           2 
                           2 
                         
                       
                       + 
                       
                         f 
                          
                         
                           ( 
                           z 
                           ) 
                         
                       
                     
                   
                   , 
                 
               
             
           
         
       
     
         [0000]    wherein S is defined as 
         [0000]    
       
         
           
             
               S 
                
               
                 ( 
                 
                   v 
                   , 
                   λ 
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         v 
                         - 
                         λ 
                       
                       , 
                     
                   
                   
                     
                       
                         v 
                         &gt; 
                         λ 
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         v 
                         + 
                         λ 
                       
                       , 
                     
                   
                   
                     
                       
                         v 
                         &lt; 
                         
                           - 
                           λ 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                     
                   
                   
                     
                       otherwise 
                       . 
                     
                   
                 
               
             
           
         
       
     
         [0018]    According to a further aspect of the invention, if dual variable p and Lagrange multiplier {tilde over (q)} are both initialized to 0, 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           z 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                           
                          
                         
                           
                             WW 
                             T 
                           
                            
                           
                             ( 
                             
                               Wv 
                               - 
                               
                                 p 
                                 
                                   i 
                                   + 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             WW 
                             T 
                           
                            
                           
                             ( 
                             
                               
                                 q 
                                 i 
                               
                               + 
                               
                                 y 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 argmin 
                                 z 
                               
                                
                               
                                 1 
                                 2 
                               
                                
                               
                                 
                                    
                                   
                                     z 
                                     - 
                                     
                                       ( 
                                       
                                         
                                           q 
                                           i 
                                         
                                         + 
                                         
                                           y 
                                           i 
                                         
                                       
                                       ) 
                                     
                                   
                                    
                                 
                                 2 
                                 2 
                               
                             
                             + 
                             
                               g 
                                
                               
                                 ( 
                                 z 
                                 ) 
                               
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     wherein 
                      
                     
                         
                     
                      
                     
                       g 
                        
                       
                         ( 
                         z 
                         ) 
                       
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           
                             
                               z 
                               = 
                               
                                 
                                   WW 
                                   T 
                                 
                                  
                                 z 
                               
                             
                             , 
                           
                         
                       
                       
                         
                           
                             
                               + 
                               ∞ 
                             
                             , 
                           
                         
                         
                           
                             otherwise 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0019]    According to another aspect of the invention, there is provided a non-transitory program storage device readable by a computer, tangibly embodying a program of instructions executed by the computer to perform the method steps for parallel magnetic resonance imaging (MRI) reconstruction of digital images. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0020]      FIG. 1  illustrates MR images and their k-space data, according to an embodiment of the invention. 
           [0021]      FIG. 2  illustrates coil images and coil sensitivity profiles, according to an embodiment of the invention. 
           [0022]      FIG. 3  shows the gradient of a phantom, according to an embodiment of the invention. 
           [0023]      FIG. 4  is a flowchart of a restricted least squares regression algorithm according to an embodiment of the invention. 
           [0024]      FIG. 5  is a flowchart of an alternating algorithm for solving the dual program, according to an embodiment of the invention. 
           [0025]      FIG. 6  is a block diagram of an exemplary computer system for implementing an efficient redundant Haar minimization for parallel MRI reconstruction, according to an embodiment of the invention. 
       
    
    
     DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS 
       [0026]    Exemplary embodiments of the invention as described herein generally include systems and methods for efficient redundant Haar minimization for parallel MRI reconstruction. Accordingly, while the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that there is no intent to limit the invention to the particular forms disclosed, but on the contrary, the invention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention. 
         [0027]    As used herein, the term “image” refers to multi-dimensional data composed of discrete image elements (e.g., pixels for 2-dimensional images and voxels for 3-dimensional images). The image may be, for example, a medical image of a subject collected by computer tomography, magnetic resonance imaging, ultrasound, or any other medical imaging system known to one of skill in the art. The image may also be provided from non-medical contexts, such as, for example, remote sensing systems, electron microscopy, etc. Although an image can be thought of as a function from R 3  to R or R 7 , the methods of the inventions are not limited to such images, and can be applied to images of any dimension, e.g., a 2-dimensional picture or a 3-dimensional volume. For a 2- or 3-dimensional image, the domain of the image is typically a 2- or 3-dimensional rectangular array, wherein each pixel or voxel can be addressed with reference to a set of 2 or 3 mutually orthogonal axes. The terms “digital” and “digitized” as used herein will refer to images or volumes, as appropriate, in a digital or digitized format acquired via a digital acquisition system or via conversion from an analog image. 
         [0028]    Parallel MRI reconstruction can be modeled by the following program: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         min 
                         x 
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               Ax 
                               - 
                               y 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                     + 
                     
                       λ 
                        
                       
                         
                            
                           Wx 
                            
                         
                         1 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where y denotes acquired k-space MR image data, x denotes intensities of the MR image one seeks to reconstruct, A=FS, F=diag(F u , F u , . . . F u ) is a matrix of size cM×cN, F u  is a partial FFT matrix of size M×N, S=[S 1 , S 2 , . . . , S c ] H  is the (conjugate transpose) coil sensitivity maps (CSM) matrix with S, being a matrix of size N×N, W is a redundant Haar wavelet matrix satisfying W T W=I, and λ is the regularization parameter. 
         [0029]    One effective approach for solving EQ. (4) is Nesterov&#39;s algorithm, also known as FISTA (Fast Iterative Shrinkage-Thresholding Algorithm). Given a function to be minimized of the form F(x):=f(x)+g(x), the steps of a FISTA with constant stepsize are as follows, where Step k is repeated until convergence: 
         [0000]    
       
         
           
             
               
                 Input 
                  
                 
                   : 
                 
                  
                 
                     
                 
                  
                 L 
               
               = 
               
                 
                   
                     L 
                      
                     
                       ( 
                       f 
                       ) 
                     
                   
                   - 
                   
                     A 
                      
                     
                         
                     
                      
                     Lipschitz 
                      
                     
                         
                     
                      
                     constant 
                      
                     
                         
                     
                      
                     of 
                      
                     
                         
                     
                      
                     
                       
                         ∇ 
                         f 
                       
                       . 
                       
                         
 
                       
                        
                       Step 
                     
                      
                     
                         
                     
                      
                     0. 
                      
                     
                         
                     
                      
                     Initialize 
                      
                     
                         
                     
                      
                     
                       y 
                       1 
                     
                   
                 
                 = 
                 
                   
                     x 
                     0 
                   
                   ∈ 
                   
                     R 
                     n 
                   
                 
               
             
             , 
             
               
                 t 
                 1 
               
               = 
               0 
             
           
         
       
       
         
           
             Step 
              
             
                 
             
              
             
               k 
               . 
               
                   
               
                
               
                 ( 
                 
                   k 
                   ≥ 
                   1 
                 
                 ) 
               
             
              
             
                 
             
              
             Compute 
           
         
       
       
         
           
             
               
                 x 
                 k 
               
               = 
               
                 
                   p 
                   L 
                 
                  
                 
                   ( 
                   
                     y 
                     k 
                   
                   ) 
                 
               
             
             , 
             
               
 
             
              
             where 
           
         
       
       
         
           
             
               
                 p 
                 L 
               
                
               
                 ( 
                 y 
                 ) 
               
             
             = 
             
               
                 
                   arg 
                    
                   
                       
                   
                    
                   min 
                 
                 x 
               
                
               
                 { 
                 
                   
                     g 
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   + 
                   
                     
                       L 
                       2 
                     
                      
                     
                       
                          
                         
                           x 
                           - 
                           
                             ( 
                             
                               y 
                               - 
                               
                                 
                                   1 
                                   L 
                                 
                                  
                                 
                                   ∇ 
                                   
                                     f 
                                      
                                     
                                       ( 
                                       y 
                                       ) 
                                     
                                   
                                 
                               
                             
                             ) 
                           
                         
                          
                       
                       2 
                     
                   
                 
                 } 
               
             
           
         
       
       
         
           
             
               
                 t 
                 
                   k 
                   + 
                   1 
                 
               
               = 
               
                 
                   1 
                   + 
                   
                     
                       1 
                       + 
                       
                         4 
                          
                         
                             
                         
                          
                         
                           t 
                           k 
                           2 
                         
                       
                     
                   
                 
                 2 
               
             
             , 
             
               
 
             
              
             
               
                 y 
                 
                   k 
                   + 
                   1 
                 
               
               = 
               
                 
                   x 
                   k 
                 
                 + 
                 
                   
                     ( 
                     
                       
                         
                           t 
                           k 
                         
                         - 
                         1 
                       
                       
                         t 
                         
                           k 
                           + 
                           1 
                         
                       
                     
                     ) 
                   
                    
                   
                     ( 
                     
                       
                         x 
                         k 
                       
                       - 
                       
                         x 
                         
                           k 
                           - 
                           1 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0030]    A feature of this algorithm is that it can achieve a convergence rate of O(1/k 2 ), which is optimal for all first-order black-box algorithms. When applying FISTA, a key building block is the proximal operator associated with the regularization term: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       π 
                        
                       
                         ( 
                         v 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           argmin 
                           x 
                         
                          
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               x 
                               - 
                               v 
                             
                              
                           
                           2 
                           2 
                         
                       
                       + 
                       
                         λ 
                          
                         
                           
                              
                             Wx 
                              
                           
                           1 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where v is a result of the gradient descent, i.e., 
         [0000]    
       
         
           
             ( 
             
               y 
               - 
               
                 
                   1 
                   L 
                 
                  
                 
                   ∇ 
                   
                     f 
                      
                     
                       ( 
                       y 
                       ) 
                     
                   
                 
               
             
             ) 
           
         
       
     
         [0000]    in the previous algorithm. The efficient solution of such a proximal operator is a key to the resulting algorithm. However, such a proximal operator does not have a closed form solution. 
         [0031]    An efficient approach according to an embodiment of the invention for solving EQ. (2) incorporates the relationship W T W=I into EQ. (5): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       x 
                     
                      
                     
                       
                         1 
                         2 
                       
                        
                       
                         
                            
                           
                             Wx 
                             - 
                             Wv 
                           
                            
                         
                         2 
                         2 
                       
                     
                   
                   + 
                   
                     λ 
                      
                     
                       
                         
                            
                           Wx 
                            
                         
                         1 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0032]    Let z=Wx, which implicitly induces the following relationship 
         [0000]      z=WW T z.   (7)
 
         [0033]    The above equation indicates that z is in the range space of W. Thus, solving EQ. (6) is equivalent to solving 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         
                           z 
                           : 
                           z 
                         
                         = 
                         
                           
                             WW 
                             T 
                           
                            
                           z 
                         
                       
                     
                      
                     
                       
                         1 
                         2 
                       
                        
                       
                         
                            
                           
                             z 
                             - 
                             Wv 
                           
                            
                         
                         2 
                         2 
                       
                     
                   
                   + 
                   
                     λ 
                      
                     
                       
                         
                            
                           z 
                            
                         
                         1 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0034]    The following theorem justifies the conversion of EQ. (5) into EQ. (8): 
         [0035]    Theorem 1 Let z* be the solution to EQ. (8). Then, x*=W T z* is the optimal solution to EQ. (5). 
         [0036]    Proof: For all x, let z=Wx. We have x=W T z from W T W=I. It is obvious that the relationship in EQ. (7) holds. As z* is the optimal solution to EQ. (8), which satisfies z*=WW T z* and z*=Wx*, we have 
         [0000]      1/2∥ z*−Wv∥   2   2   +λ∥z*∥   1 ≦1/2∥ z−Wv∥   2   2   +λ∥z∥   1    (9)
 
         [0000]    Inserting in z*=WW T z*, z=WW T z, z*=Wx* and z=Wx, we have 
         [0000]      1/2∥ WW   T   z*−Wv∥   2   2   +λ∥Wx*∥   1 ≦1/2∥ WW   T   z−Wv∥   2   2   +λ∥Wx∥   1    (10)
 
         [0000]    which together with W T W=I leads to 
         [0000]      1/2∥ W   T   z*−v∥   2   2   +λ∥Wx*∥   1 ≦1/2∥ W   T   z−v∥   2   2   +λ∥Wx∥   1 .   (11)
 
         [0000]    Incorporating x*=W T z* and x=W T z, we have 
         [0000]      1/2∥ x*−v∥   2   2   +λ∥Wx*∥   1 ≦1/2∥ x−v∥   2   2   +λ∥Wx∥   1 ,   (12)
 
         [0000]    which indicates that x* is the optimal solution to EQ. (5). 
         [0037]    When solving EQ. (4) via FISTA, embodiments of the invention use a “warm” start technique, i.e., solving EQ. (5) with the solution to the previous program as the “warm” start. 
         [0038]    According to an embodiment of the invention, EQ. (8) can be solved via a restricted least squares regression algorithm. For convenience of discussion, let 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         z 
                         ) 
                       
                     
                     = 
                     
                       λ 
                        
                       
                         
                            
                           z 
                            
                         
                         1 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   and 
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
             
               
                 
                   
                     g 
                      
                     
                       ( 
                       z 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           
                             
                               z 
                               = 
                               
                                 
                                   WW 
                                   T 
                                 
                                  
                                 z 
                               
                             
                             , 
                           
                         
                       
                       
                         
                           
                             
                               + 
                               ∞ 
                             
                             , 
                           
                         
                         
                           
                             otherwise 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0039]    A restricted least squares regression algorithm according to an embodiment of the invention is presented in Algorithm 1, which recursively calls the solver to the proximal operator associated with f(.) and g(.), respectively. Algorithm 1 is as follows, with reference to the steps of the flowchart of  FIG. 4 . 
       Algorithm 1: 
       [0040]      
         [0000]    
       
         
               
             
               
               
               
               
             
           
               
                   
               
               
                 Input: W, v, 0 ≦ λ, k 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 1: 
                 z 0  = Wv, p 0  = q 0  = 0 
                 (step 41) 
               
               
                   
                 2: 
                 for i = 0 to k do 
                   
               
               
                   
               
               
                   
                 3: 
                  
         y   i     =       arg                     min   z            1   2                 z   -     (       p   i     +     z   i       )            2   2           +     f        (   z   )             
 
                 (step 42) 
               
               
                   
               
               
                   
                 4: 
                  p i+1  = (p i  + z i ) − y i   
                 (step 43) 
               
               
                   
               
               
                   
                 5: 
                  
         z     i   +   1       =       arg                     min   z            1   2                 z   -     (       q   i     +     z   i       )            2   2           +     g        (   z   )             
 
                 (step 44) 
               
               
                   
               
               
                   
                 6: 
                  q i+1  = (q i  + y i ) − z i+1   
                 (step 45) 
               
               
                   
                 7: 
                 end for 
                 (step 46) 
               
               
                   
                 8: 
                 return z k+1   
               
               
                   
               
             
          
         
       
     
         [0041]    According to an embodiment of the invention, the proximal operator associated with f(.) can be computed by soft shrinkage as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             π 
                             f 
                           
                            
                           
                             ( 
                             v 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               argmin 
                               z 
                             
                              
                             
                               1 
                               2 
                             
                              
                             
                               
                                  
                                 
                                   z 
                                   - 
                                   v 
                                 
                                  
                               
                               2 
                               2 
                             
                           
                           + 
                           
                             f 
                              
                             
                               ( 
                               z 
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           { 
                           
                             
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     - 
                                     λ 
                                   
                                   , 
                                 
                               
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     &gt; 
                                     λ 
                                   
                                   , 
                                 
                               
                             
                             
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     + 
                                     λ 
                                   
                                   , 
                                 
                               
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     &lt; 
                                     
                                       - 
                                       λ 
                                     
                                   
                                   , 
                                 
                               
                             
                             
                               
                                 
                                   0 
                                   , 
                                 
                               
                               
                                 
                                   otherwise 
                                   . 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0042]    According to an embodiment of the invention, the proximal operator associated with g(.) can be computed by orthogonal projection as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       π 
                       g 
                     
                      
                     
                       ( 
                       v 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         
                           argmin 
                           z 
                         
                          
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               v 
                             
                              
                           
                           2 
                           2 
                         
                       
                       + 
                       
                         g 
                          
                         
                           ( 
                           z 
                           ) 
                         
                       
                     
                     = 
                     
                       
                         WW 
                         T 
                       
                        
                       
                         v 
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
         [0043]    Algorithm 1 is guaranteed to converge to the optimal solution of EQ. (8). 
         [0044]    According to an embodiment of the invention, an alternating algorithm can solve the dual of EQ. (8). 
         [0045]    Making use of the dual norm of the l 1  norm, EQ. (8) can be written as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         
                           z 
                           : 
                           z 
                         
                         = 
                         
                           
                             WW 
                             T 
                           
                            
                           z 
                         
                       
                     
                      
                     
                       
                         max 
                         
                           p 
                           : 
                           
                             
                               
                                  
                                 p 
                                  
                               
                               ∞ 
                             
                             ≤ 
                             λ 
                           
                         
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               Wv 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       z 
                       T 
                     
                      
                     
                       p 
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0046]    The objective function in EQ. (17) is convex in z and concave in p, and the constraints are closed convex. Therefore, the von Neuman Lemma that ensures the existence of a solution to the min-max holds, and the min-max can be exchanged to obtain 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       max 
                       
                         p 
                         : 
                         
                           
                             
                                
                               p 
                                
                             
                             ∞ 
                           
                           ≤ 
                           λ 
                         
                       
                     
                      
                     
                       
                         min 
                         
                           
                             z 
                             : 
                             z 
                           
                           = 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               Wv 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       z 
                       T 
                     
                      
                     
                       p 
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0047]    For the inner minimization of EQ. (18), i.e., 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         min 
                         
                           
                             z 
                             : 
                             z 
                           
                           = 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               Wv 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                     + 
                     
                       
                         z 
                         T 
                       
                        
                       p 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0000]    embodiments introduce a Lagrangian variable {tilde over (q)} for the equality constraint. As the constraint is affine, and the objective function is differentiable and convex, strong duality holds. Thus, EQ. (19) can be written as the following equivalent min-max program: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       max 
                       
                         q 
                         ~ 
                       
                     
                      
                     
                       
                         min 
                         
                           
                             z 
                             : 
                             z 
                           
                           = 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               Wv 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       z 
                       T 
                     
                      
                     p 
                   
                   + 
                   
                     
                       〈 
                       
                         
                           z 
                           - 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                         , 
                         
                           q 
                           ~ 
                         
                       
                       〉 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0048]    Thus, embodiments can reformulate EQ. (8) as the following min-max optimization: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       max 
                       
                         
                           q 
                           ~ 
                         
                         , 
                         
                           p 
                           : 
                           
                             
                               
                                  
                                 p 
                                  
                               
                               ∞ 
                             
                             ≤ 
                             z 
                           
                         
                       
                     
                      
                     
                       
                         min 
                         
                           
                             z 
                             : 
                             z 
                           
                           = 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                       
                        
                       
                         
                           1 
                           2 
                         
                          
                         
                           
                              
                             
                               z 
                               - 
                               Wv 
                             
                              
                           
                           2 
                           2 
                         
                       
                     
                   
                   + 
                   
                     
                       z 
                       T 
                     
                      
                     p 
                   
                   + 
                   
                     
                       〈 
                       
                         
                           z 
                           - 
                           
                             
                               WW 
                               T 
                             
                              
                             z 
                           
                         
                         , 
                         
                           q 
                           ~ 
                         
                       
                       〉 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0049]    For the inner minimization, setting the derivative of z to zero, one has 
         [0000]        z=Wv−p −( I−WW   T ) {tilde over (q)}.    (22)
 
         [0050]    Inserting EQ. (22) into EQ. (21), the following dual program can be obtained: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       max 
                       
                         
                           q 
                           ~ 
                         
                         , 
                         
                           p 
                           : 
                           
                             
                                
                               p 
                                
                             
                             ∞ 
                           
                         
                       
                     
                      
                     
                       
                         - 
                         
                           1 
                           2 
                         
                       
                        
                       
                         
                            
                           
                             p 
                             + 
                             
                               
                                 ( 
                                 
                                   I 
                                   - 
                                   
                                     WW 
                                     T 
                                   
                                 
                                 ) 
                               
                                
                               
                                 q 
                                 ~ 
                               
                             
                             - 
                             Wv 
                           
                            
                         
                         2 
                         2 
                       
                     
                   
                   + 
                   
                     
                       1 
                       2 
                     
                      
                     
                       
                         
                            
                           Wv 
                            
                         
                         2 
                         2 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0051]    Embodiments of the invention solve the dual program (23) via an alternating algorithm in Algorithm 2. Step 3 and Step 5 are included for convenience of analyzing the relationship with Algorithm 1. Algorithm 2 is guaranteed to converge as the objective function of EQ. (23) is concave in both {tilde over (q)} and p, and the constraint sets are convex and closed. Algorithm 2 is as follows, with references to step numbers in the flowchart of  FIG. 5   
         [0052]    Algorithm 2 Alternating Algorithm for EQ. (8) 
         [0000]    
       
         
           
             
               
                 
                   
                     Input 
                      
                     
                       : 
                     
                      
                     
                         
                     
                      
                     W 
                   
                   , 
                   v 
                   , 
                   
                     0 
                     ≤ 
                     λ 
                   
                   , 
                   k 
                   , 
                   
                     p 
                     0 
                   
                   , 
                   
                     
                       q 
                       ~ 
                     
                     0 
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     1. 
                      
                     
                         
                     
                      
                     for 
                      
                     
                         
                     
                      
                     i 
                   
                   = 
                   
                     0 
                      
                     
                         
                     
                      
                     to 
                      
                     
                         
                     
                      
                     k 
                      
                     
                         
                     
                      
                     do 
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     2. 
                      
                     
                         
                     
                      
                     
                       p 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                   = 
                   
                     
                       
                         arg 
                          
                         
                             
                         
                          
                         min 
                       
                       
                         p 
                         : 
                         
                           
                             
                                
                               p 
                                
                             
                             ∞ 
                           
                           ≤ 
                           λ 
                         
                       
                     
                      
                     
                       1 
                       2 
                     
                      
                     
                       
                          
                         
                           p 
                           - 
                           
                             ( 
                             
                               Wv 
                               - 
                               
                                 
                                   ( 
                                   
                                     I 
                                     - 
                                     
                                       WW 
                                       T 
                                     
                                   
                                   ) 
                                 
                                  
                                 
                                   
                                     q 
                                     ~ 
                                   
                                   i 
                                 
                               
                             
                             ) 
                           
                         
                          
                       
                       2 
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     51 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     3. 
                      
                     
                         
                     
                      
                     
                       y 
                       i 
                     
                   
                   = 
                   
                     
                       ( 
                       
                         Wv 
                         - 
                         
                           
                             ( 
                             
                               I 
                               - 
                               
                                 WW 
                                 T 
                               
                             
                             ) 
                           
                            
                           
                             
                               q 
                               ~ 
                             
                             i 
                           
                         
                       
                       ) 
                     
                     - 
                     
                       p 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     52 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     4. 
                      
                     
                         
                     
                      
                     
                       
                         q 
                         ~ 
                       
                       
                         i 
                         + 
                         1 
                       
                     
                   
                   = 
                   
                     
                       
                         arg 
                          
                         
                             
                         
                          
                         min 
                       
                       
                         q 
                         ~ 
                       
                     
                      
                     
                       1 
                       2 
                     
                      
                     
                       
                          
                         
                           
                             
                               ( 
                               
                                 I 
                                 - 
                                 
                                   WW 
                                   T 
                                 
                               
                               ) 
                             
                              
                             
                               
                                 q 
                                 ~ 
                               
                               i 
                             
                           
                           - 
                           
                             ( 
                             
                               Wv 
                               - 
                               
                                 p 
                                 i 
                               
                             
                             ) 
                           
                         
                          
                       
                       2 
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     53 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     5. 
                      
                     
                         
                     
                      
                     
                       q 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                   = 
                   
                     
                       ( 
                       
                         I 
                         - 
                         
                           WW 
                           T 
                         
                       
                       ) 
                     
                      
                     
                       
                         q 
                         ~ 
                       
                       
                         i 
                         + 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     54 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     6. 
                      
                     
                         
                     
                      
                     
                       z 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                   = 
                   
                     
                       ( 
                       
                         Wv 
                         - 
                         
                           p 
                           
                             i 
                             + 
                             1 
                           
                         
                       
                       ) 
                     
                     - 
                     
                       q 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     55 
                   
                   ) 
                 
               
             
             
               
                 
                   7. 
                    
                   
                       
                   
                    
                   end 
                    
                   
                       
                   
                    
                   for 
                 
               
               
                 
                   ( 
                   
                     step 
                      
                     
                         
                     
                      
                     56 
                   
                   ) 
                 
               
             
             
               
                 
                   8. 
                    
                   
                       
                   
                    
                   return 
                    
                   
                       
                   
                    
                   
                     z 
                     
                       k 
                       + 
                       1 
                     
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0053]    In Step 2, p i+1  can be computed by a simple projection onto to the l ∞  ball as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             π 
                             ∞ 
                           
                            
                           
                             ( 
                             v 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             argmin 
                             
                               
                                 
                                    
                                   p 
                                    
                                 
                                 ∞ 
                               
                               ≤ 
                               λ 
                             
                           
                            
                           
                             1 
                             2 
                           
                            
                           
                             
                                
                               
                                 p 
                                 - 
                                 v 
                               
                                
                             
                             2 
                             2 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           { 
                           
                             
                               
                                 
                                   λ 
                                   , 
                                 
                               
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     &gt; 
                                     λ 
                                   
                                   , 
                                 
                               
                             
                             
                               
                                 
                                   
                                     - 
                                     λ 
                                   
                                   , 
                                 
                               
                               
                                 
                                   
                                     
                                       v 
                                       i 
                                     
                                     &lt; 
                                     λ 
                                   
                                   , 
                                 
                               
                             
                             
                               
                                 
                                   
                                     v 
                                     i 
                                   
                                   , 
                                 
                               
                               
                                 
                                   otherwise 
                                   . 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0054]    In Step 4, {tilde over (q)} i+1 , the solution to the minimization is not unique. However, (I−WW T ){tilde over (q)} i+1  is unique, and satisfies 
         [0000]      ( I−WW   T ){tilde over ( q )} i+1 =( I=WW   T )( Wv−p   i ).   (25)
 
         [0055]    To see this, for the objective function in Step 4, set the derivative with regard to {tilde over (q)} to zero, to obtain 
         [0000]      ( I−WW   T ) T (( I−WW   T ) {tilde over (q)}   i+1 −( Wv−p   i )).   (26)
 
         [0000]    EQ, (25) can be obtained by using the relationship W T W=I. 
         [0056]    The equivalence between Algorithm 1 and Algorithm 2, when the inputs p 0 , {tilde over (q)} 0 , are both set to zero in Algorithm 2, may be established as follows. 
         [0057]    In Algorithm 2, Step 3 can be computed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           y 
                           i 
                         
                         = 
                           
                          
                         
                           S 
                            
                           
                             ( 
                             
                               
                                 Wv 
                                 - 
                                 
                                   
                                     ( 
                                     
                                       I 
                                       - 
                                       
                                         WW 
                                         T 
                                       
                                     
                                     ) 
                                   
                                    
                                   
                                     
                                       q 
                                       ~ 
                                     
                                     i 
                                   
                                 
                               
                               , 
                               λ 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           S 
                            
                           
                             ( 
                             
                               
                                 
                                   p 
                                   i 
                                 
                                 + 
                                 
                                   z 
                                   i 
                                 
                               
                               , 
                               λ 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               argmin 
                               z 
                             
                              
                             
                               1 
                               2 
                             
                              
                             
                               
                                  
                                 
                                   z 
                                   - 
                                   
                                     ( 
                                     
                                       
                                         p 
                                         i 
                                       
                                       + 
                                       
                                         z 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                               
                               2 
                               2 
                             
                           
                           + 
                           
                             f 
                              
                             
                               ( 
                               z 
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where S is the soft shrinkage operator, defined as 
         [0000]    
       
         
           
             
               S 
                
               
                 ( 
                 
                   v 
                   , 
                   λ 
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         v 
                         - 
                         λ 
                       
                       , 
                     
                   
                   
                     
                       
                         v 
                         &gt; 
                         λ 
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         v 
                         + 
                         λ 
                       
                       , 
                     
                   
                   
                     
                       
                         v 
                         &lt; 
                         
                           - 
                           λ 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                     
                   
                   
                     
                       otherwise 
                       .. 
                     
                   
                 
               
             
           
         
       
     
         [0058]    Step 6 can be computed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           z 
                           
                             i 
                             + 
                             1 
                           
                         
                         = 
                           
                          
                         
                           
                             WW 
                             T 
                           
                            
                           
                             ( 
                             
                               Wv 
                               - 
                               
                                 p 
                                 
                                   i 
                                   + 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             WW 
                             T 
                           
                            
                           
                             ( 
                             
                               
                                 q 
                                 i 
                               
                               + 
                               
                                 y 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               argmin 
                               z 
                             
                              
                             
                               1 
                               2 
                             
                              
                             
                               
                                  
                                 
                                   z 
                                   - 
                                   
                                     ( 
                                     
                                       
                                         q 
                                         i 
                                       
                                       + 
                                       
                                         y 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                               
                               2 
                               2 
                             
                           
                           + 
                           
                             g 
                              
                             
                               ( 
                               z 
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
         [0059]    In Step 2, p i+1  satisfies 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                     
                       i 
                       + 
                       1 
                     
                   
                    
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               argmin 
                               
                                 p 
                                 : 
                                 
                                   
                                     
                                        
                                       p 
                                        
                                     
                                     ∞ 
                                   
                                   ≤ 
                                   γ 
                                 
                               
                             
                              
                             
                               1 
                               2 
                             
                              
                             
                                
                               
                                 p 
                                 - 
                                 
                                   ( 
                                   
                                     Wv 
                                     - 
                                     
                                       
                                         ( 
                                         
                                           I 
                                           - 
                                           
                                             WW 
                                             T 
                                           
                                         
                                         ) 
                                       
                                        
                                       
                                         
                                           q 
                                           ~ 
                                         
                                         i 
                                       
                                     
                                   
                                   ) 
                                 
                               
                                
                             
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 π 
                                 ∞ 
                               
                                
                               
                                 ( 
                                 
                                   Wv 
                                   - 
                                   
                                     
                                       ( 
                                       
                                         I 
                                         - 
                                         
                                           WW 
                                           T 
                                         
                                       
                                       ) 
                                     
                                      
                                     
                                       
                                         q 
                                         ~ 
                                       
                                       i 
                                     
                                   
                                 
                                 ) 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   29 
                   ) 
                 
               
             
           
         
       
     
         [0060]    It is to be understood that embodiments of the present invention can be implemented in various forms of hardware, software, firmware, special purpose processes, or a combination thereof. In one embodiment, the present invention can be implemented in software as an application program tangible embodied on a computer readable program storage device. The application program can be uploaded to, and executed by, a machine comprising any suitable architecture. 
         [0061]      FIG. 6  is a block diagram of an exemplary computer system for implementing a an efficient redundant Haar minimization for parallel MRI reconstruction, according to an embodiment of the invention. Referring now to  FIG. 6 , a computer system  61  for implementing the present invention can comprise, inter alia, a central processing unit (CPU)  62 , a memory  63  and an input/output (I/O) interface  64 . The computer system  61  is generally coupled through the I/O interface  64  to a display  65  and various input devices  66  such as a mouse and a keyboard. The support circuits can include circuits such as cache, power supplies, clock circuits, and a communication bus. The memory  63  can include random access memory (RAM), read only memory (ROM), disk drive, tape drive, etc., or a combinations thereof. The present invention can be implemented as a routine  67  that is stored in memory  63  and executed by the CPU  62  to process the signal from the signal source  68 . As such, the computer system  61  is a general purpose computer system that becomes a specific purpose computer system when executing the routine  67  of the present invention. 
         [0062]    The computer system  61  also includes an operating system and micro instruction code. The various processes and functions described herein can either be part of the micro instruction code or part of the application program (or combination thereof) which is executed via the operating system. In addition, various other peripheral devices can be connected to the computer platform such as an additional data storage device and a printing device. 
         [0063]    It is to be further understood that, because some of the constituent system components and method steps depicted in the accompanying figures can be implemented in software, the actual connections between the systems components (or the process steps) may differ depending upon the manner in which the present invention is programmed. Given the teachings of the present invention provided herein, one of ordinary skill in the related art will be able to contemplate these and similar implementations or configurations of the present invention. 
         [0064]    While the embodiments of the present invention have been described in detail with reference to exemplary embodiments, those skilled in the art will appreciate that various modifications and substitutions can be made thereto without departing from the spirit and scope of the invention as set forth in the appended claims.