Abstract:
An optical coherence tomography (OCT) image composed of a plurality of A-scans of a structure is analysed by defining, for each A-scan, a set of neighbouring A-scans surrounding the A-slices scan. Following an optional de-noising step, the neighbouring A-scans are aligned in the imaging direction, then a matrix X is formed from the aligned A-scans, and matrix completion is performed to obtain a reduced speckle noise image.

Description:
FIELD OF THE INVENTION 
       [0001]    The present invention relates to methods and systems for processing optical coherence tomography (OCT) images, to form images with reduced speckle. 
       BACKGROUND OF THE INVENTION 
       [0002]    Optical coherence tomography is an optical signal acquisition and processing method. It captures micrometer-resolution, three-dimensional images from within optical scattering media (e.g., biological tissue). The principle of ocular imaging with OCT is based upon measuring the time-delay of the light reflected from each optical interface when a pencil of light (an “A-scan”) enters the eye. A series of A-scans across the structure permits a cross-sectional reconstruction of a plane through the anterior or posterior segment of the eye. This is known as a B-scan. 
         [0003]    Speckle is problematic for OCT imaging as well as other imaging modalities including synthetic aperture radar (SAR), remote sensing, ultrasound, sonar, etc. In these fields, a substantial amount of signal processing research has been conducted to combat speckle noise, resulting in the development of powerful digital filters for reducing speckle while preserving edge sharpness. Speckle reduction in OCT has been addressed by modifying imaging configurations and through the use of signal processing. 
         [0004]    Existing speckle reduction techniques are mainly based on frames using 1) filters such as Lee filter [1], Kuan filter [2], enhanced LEE filter [3]; 2) anisotropic diffusion such as proposed an anisotropic diffusion [4], speckle reduction anisotropic diffusion (SRAD) [5], detail preserving anisotropic diffusion [6] and orientated speckle reduction anisotropic diffusion [7]. These methods were first proposed for radar images and they are applicable for OCT images. 
         [0005]    Topcon has developed DRI OCT-1, a swept source OCT for posterior imaging, utilizing a wavelength of 1,050 nm. It has a fast scanning speed of 100,000 A-scans/sec. Utilizing this 1,050 nm wavelength, DRI OCT-1 can penetrate deeper compared to the current conventional OCTs with wavelength in the 850 nm range. Visualizing ocular tissues such as choroid or even sclera, can be done within a very short time. Deep range imaging DRI OCT-1 displays detailed structures of not only retina but choroid and even sclera. With the capability of imaging deeper anatomic structures with less influence in scattering, DRI OCT-1 can visualize the entire tomogram with high sensitivity. 
         [0006]    However, in the Topcon DRI OCT-1 swept source OCT, a single frame or slice of the image usually has poor quality due to large speckle noise. Accordingly, conventionally a moving average is computed. For example in the 3D mode with 256 frames, a moving average is computed from 3 to 5 neighboring frames in the DRI OCT-1. Although moving averaging has been shown to be able to reduce speckle noise, the reduction in speckle due to averaging over a small number of neighboring frames is limited. However, if more frames were included in the averaging, blur would appear as a visible artefact, especially in regions where the underlying retinal structures are changing rapidly. 
       SUMMARY OF THE INVENTION 
       [0007]    The present invention aims to provide new and useful methods and systems for analysing an optical coherence tomography (OCT) image composed of a plurality of A-scans, each A-scan being a one-dimensional scan of a structure imaged in a predefined direction. 
         [0008]    In general terms, the present invention proposes reconstructing each A-scan from a set of neighbouring A-scans surrounding the A-scan, i.e. the nearest neighbours of the A-scan in a two-dimensional region extending perpendicular to the imaging direction. 
         [0009]    Another way of expressing this is that, for a given A-scan, the set of neighbouring scans collectively defines a convex hull which is a cylinder extending in the imaging direction, and the A-scan is a line within the convex hull and encircled by the periphery the convex hull. The A-scan may be a substantially central line within the convex hull. As viewed along the imaging direction the set of neighbouring scans has a two-dimensional profile. The convex hull may for example have a rectangular profile or an elliptical profile. 
         [0010]    The A-scans of the neighbourhood are first aligned in the imaging direction, then a matrix X is formed of the aligned A-scans, and matrix completion is performed to obtain a reduced speckle noise image. 
         [0011]    The matrix reduction is performed by seeking a second matrix which minimizes a cost function indicative of the difference between the first matrix X and the second matrix, where the second matrix obeys a complexity constraint. 
         [0012]    In a first case, the second matrix is a single matrix L, and the complexity constraint is that the second matrix L is constrained to have a rank no higher than a predefined value. 
         [0013]    In a second case, the complexity constraint is that, representing the second matrix as the sum of a low rank matrix L and a sparse matrix S, the low rank matrix is constrained to have a rank less than a first predetermined value, and the sparse matrix S is constrained to have a number of non-zero elements less than a second predetermined value. 
         [0014]    In either case, the low rank matrix L is a version of the matrix X in which the speckle noise has been reduced, and the column of the low rank matrix L corresponding to the A-scan of X is a low speckle noise reconstruction of the A-scan. 
         [0015]    A method which is an embodiment of the method may be carried out by an OCT imaging system, such as the Topcon swept source OCT imaging system, to enhance OCT imaging quality. 
         [0016]    One possible specific expression of the present invention is a computer-implemented method of enhancing an optical coherence tomography (OCT) image composed of a plurality of A-scans, each A-scan being indicative of a structure imaged in a predefined direction, the A-scans being grouped as one or more B-scans, the method comprising, for each A-scan:
       (a) defining a respective neighbourhood surrounding the A-scan;   (b) aligning the A-scan in the pre-defined direction with other A-scans in the respective neighbourhood;   (c) using the aligned A-scans to form a first matrix X, respective columns of the first matrix being the aligned A-scans; and   (d) seeking a second matrix which the minimizes a cost function indicative of the difference between the first matrix X and the second matrix, the second matrix being constrained to obey a complexity constraint.       
 
         [0021]    An enhanced version of the A-scan may be obtained from a column of the second matrix. Alternatively, if the complexity constraint on the second matrix is in the form of a complexity constraint on each of multiple matrix components of the second matrix, then an enhanced version of the A-scan may be obtained from a column of one of the matrix components. In either case, further processing steps may be performed to obtain the enhanced version of the A-scan, such as a filtering step. 
         [0022]    The invention may also be expressed in terms of a computer system for performing the method. It may also be expressed as a computer program product (e.g. a tangible data storage device which stores program instructions in non-transitory form) incorporating program instructions which can be run by a processor of a computer system to cause the processor to perform the method. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0023]    An embodiment of the invention will now be described for the sake of example only with reference to the following drawings, in which: 
           [0024]      FIG. 1  is a flow chart showing a method which is an embodiment of the invention; 
           [0025]      FIG. 2  illustrates OCT images of a three-dimensional volume, the OCT images being N B-scans B 1 , B 2 , . . . , B N ; 
           [0026]      FIG. 3  is composed of  FIGS. 3( a ) and 3( b ) , which respectively illustrate two methods of defining a neighbourhood of an A-scan A i,j  as (a) a rectangular neighborhood and (b) a circular/elliptical neighborhood; 
           [0027]      FIG. 4  illustrates an A-scan alignment step of the method of  FIG. 1 ; 
           [0028]      FIG. 5  shows results for image reconstruction using a first version of the method of  FIG. 1 ; 
           [0029]      FIG. 6  shows results for image reconstruction using a second version of the method of  FIG. 1 ; 
           [0030]      FIG. 7  is a box plot of CNR comparing three methods of speckle reduction; and 
           [0031]      FIG. 8  is composed of  FIGS. 8( a )-( f ) , in which  FIGS. 8( a ) and ( d )  show raw OCT data,  FIGS. 8( b ) and 8( e )  show a moving average of the raw data, and  FIGS. 8( c ) and 8( f )  show data obtained by the method of  FIG. 1 . 
       
    
    
     DETAILED DESCRIPTION OF THE EMBODIMENTS 
       [0032]    Referring to  FIG. 1 , a method according to the invention is illustrated. The input to the method is an OCT volume, of the kind which can be produced by a conventional OCT method. The OCT volume is made up of N B-scans (also referred to in the art as “frames” or “slices”), B i  for i=1, 2, . . . N, as illustrated in  FIG. 2 . Each B-scan B i  consists of MA-scans, A i,j =1, 2, . . . , M, which are each one-dimensional scans formed by imaging the object with a one-dimensional pencil of light extending in the direction which is vertical in  FIG. 1 . In other words, the OCT volume consists of a set of A-scan lines A i,j , i=1, 2, . . . , N, j=1, 2, . . . , M, where N is the number of B-scans in the volume and M is the number of A-scans in each B-scan. 
         [0033]    A basic concept underlying the method of  FIG. 1  is to formulate A i,j  as a sum of its underlying clean image l i,j , and noise g i,j , i.e., 
         [0000]    
       
      
       A 
       i,j 
       =l 
       i,j 
       +g 
       i,j  
      
     
         [0000]    The objective is to reconstruct l i,j  from A i,j . It is impossible to solve this problem without some assumptions about l i,j  and n i,j , but the embodiment is motivated by the assumption that l i,j  is very similar within a small neighborhood. Based on this assumption, we model the neighboring A-scans using similar model. 
         [0000]        A   i+p,j+q   =l   i+p,j+q   +g   i+p,j+q , 
         [0000]    where (p, q)εΩ and Ω denotes a “neighborhood” (or “neighbor region”), that is a set of A-scans which are neighbors of, and surround, the A-scan. Thus, the set of A-scans form a two-dimensional array as viewed in the imaging direction. 
         [0034]    There are many ways to define the neighbor region. A first possible definition is as the rectangular region {(p,q)|−n≦p≦n,−m≦q≦m} as illustrated in  FIG. 3( a ) . An alternative possible definition is as the elliptical region 
         [0000]    
       
         
           
             { 
             
               
                 ( 
                 
                   p 
                   , 
                   q 
                 
                 ) 
               
                
               
                  
                 
                   
                     
                       
                         p 
                         2 
                       
                       
                         n 
                         2 
                       
                     
                     + 
                     
                       
                         q 
                         2 
                       
                       
                         
                           m 
                            
                         
                         2 
                       
                     
                   
                   ≤ 
                   1 
                 
                 } 
               
             
           
         
       
     
         [0000]    as illustrated in  FIG. 3( b ) . If n=m then the neighborhoods are respectively square and circular. In the experiments reported below, the neighborhoods were defined as the rectangular neighborhoods of  FIG. 3( a ) , using n=1 and m=2. 
         [0035]    One way to implement this concept would be to define X as the matrix formed by stacking all the A-scans from Ω as columns, i.e., X=[A i−n,j−m , . . . , A i+n,j+m ], L=[l i−n,j−m , . . . , l i+n,j+m ], G=[g i−n,j−m , . . . , g i+n,j+m ]. Each column in L may be assumed to be very similar, so the rank of L is expected to be low, and accordingly the method can use low rank matrix completion to solve L from given X. 
         [0036]    Unfortunately, applying the above technique directly to raw OCT volume may lead to some blur of the A-scans due to content changes among neighboring A-scans. In addition, the inevitable eye movement also leads to some misalignment. For this reason,  FIG. 1  includes a step  2  of aligning the A-scans, before the A-scan reconstruction by matrix completion is performed in step  3 . 
         [0037]    Furthermore, the original OCT A-scans are affected by large speckle noise, which make it challenging job to align these A-scans in step  2 . Therefore, a pre-processing step  1  is used to reduce the noise before step  2  is carried out. 
         [0038]    Many algorithms [1]-[7] can be used for the noise-reduction step  1 . We use the SRAD algorithm [5]. SRAD is applied on every scan B i . Specifically, given an intensity image I 0  (x, y), the output image I(x, y; t) is evolved according to the PDE: 
         [0000]    
       
         
           
             { 
             
               
                 
                   
                     
                       
                         
                           ∂ 
                           I 
                         
                         
                           ∂ 
                           t 
                         
                       
                       = 
                       
                         div 
                          
                         
                           [ 
                           
                             
                               c 
                                
                               
                                 ( 
                                 q 
                                 ) 
                               
                             
                             · 
                             
                               ∇ 
                               I 
                             
                           
                           ] 
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         I 
                          
                         
                           ( 
                           
                             t 
                             = 
                             0 
                           
                           ) 
                         
                       
                       = 
                       
                         I 
                         0 
                       
                     
                   
                 
               
               , 
             
           
         
       
     
         [0000]    where c(q) denotes the diffusion coefficient computed with 
         [0000]    
       
         
           
             
               c 
                
               
                 ( 
                 q 
                 ) 
               
             
             = 
             
               
                 1 
                 / 
                 
                   ( 
                   
                     1 
                     + 
                     
                       
                         [ 
                         
                           
                             
                               q 
                               2 
                             
                              
                             
                               ( 
                               
                                 x 
                                 , 
                                 
                                   y 
                                   ; 
                                   t 
                                 
                               
                               ) 
                             
                           
                           - 
                           
                             
                               q 
                               0 
                               2 
                             
                              
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                         ] 
                       
                       / 
                       
                         [ 
                         
                           
                             
                               q 
                               0 
                               2 
                             
                              
                             
                               ( 
                               t 
                               ) 
                             
                           
                            
                           
                             ( 
                             
                               1 
                               + 
                               
                                 
                                   q 
                                   0 
                                   2 
                                 
                                  
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                         ] 
                       
                     
                   
                   ) 
                 
               
                
               
                   
               
                
               or 
             
           
         
       
       
         
           
             
               
                 c 
                  
                 
                   ( 
                   q 
                   ) 
                 
               
               = 
               
                 exp 
                  
                 
                   { 
                   
                     
                       - 
                       
                         [ 
                         
                           
                             
                               q 
                               2 
                             
                              
                             
                               ( 
                               
                                 x 
                                 , 
                                 
                                   y 
                                   ; 
                                   t 
                                 
                               
                               ) 
                             
                           
                           - 
                           
                             
                               q 
                               0 
                               2 
                             
                              
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                         ] 
                       
                     
                     / 
                     
                       [ 
                       
                         
                           
                             q 
                             0 
                             2 
                           
                            
                           
                             ( 
                             t 
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             1 
                             + 
                             
                               
                                 q 
                                 0 
                                 2 
                               
                                
                               
                                 ( 
                                 t 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                       ] 
                     
                   
                   } 
                 
                  
                 
                     
                 
                  
                 and 
               
             
              
             
                 
             
           
         
       
       
         
           
             
               q 
                
               
                 ( 
                 
                   x 
                   , 
                   
                     y 
                     ; 
                     t 
                   
                 
                 ) 
               
             
             = 
             
               
                 
                   
                     
                       
                         ( 
                         
                           1 
                           / 
                           2 
                         
                         ) 
                       
                        
                       
                         
                           ( 
                           
                             
                                
                               
                                 ∇ 
                                 I 
                               
                                
                             
                             / 
                             I 
                           
                           ) 
                         
                         2 
                       
                     
                     - 
                     
                       
                         ( 
                         
                           1 
                           / 
                           16 
                         
                         ) 
                       
                        
                       
                         
                           ( 
                           
                             
                               
                                 ∇ 
                                 2 
                               
                                
                               I 
                             
                             / 
                             I 
                           
                           ) 
                         
                         2 
                       
                     
                   
                   
                     
                       [ 
                       
                         1 
                         + 
                         
                           
                             ( 
                             
                               1 
                               / 
                               4 
                             
                             ) 
                           
                            
                           
                             ( 
                             
                               
                                 
                                   ∇ 
                                   2 
                                 
                                  
                                 I 
                               
                               / 
                               I 
                             
                             ) 
                           
                         
                       
                       ] 
                     
                     2 
                   
                 
                 . 
               
             
           
         
       
     
         [0000]    In the experimental results presented below, the iteration was performed 50 times. 
         [0039]    In the A-scan alignment step  2 , neighboring A-scans A i+p,j+q , (p,q)εΩ are aligned to A i,j  by a vertical translation A p,q  (i.e., moving up or down) such that the difference in between is minimized, where Q denotes the locations of neighboring A-scans. From our experience, computing the difference from an A-scan alone may lead to a result dominated by local speckle noise. Therefore, we compute the difference between A i,j  and A i+p,j+q  using their neighboring A-scans as well. 
         [0040]    In step  2 , for each p and q we define a group (“window”) of A-scans centered at A i+p,j+q  and A i,j , i.e., G i+p,j+q =[A i+p,j+q−w ,A i+p,j+q−w+1 , . . . , A i+p,j+q+w ] and G i,j =[A i,j−w ,A i,j−w+1 , . . . ,A i,j+w ] where w determines the window size, is used to compute the alignment. We find vertical translation Δ p,q  on G i+p,j+q  such that the difference between the translated G i+p,j+q  and G i,j  is minimized Many block matching algorithms can be used to find the alignment. In our numerical investigation of the embodiments, we use the diamond search strategy [8] to find the vertical translation because of its efficiency and easy implementation. 
         [0041]    We now present two methods by which step  3  can be carried out, i.e. two versions of step  3 . A first sub-step of both methods is to combine the aligned A-scans as the columns of the matrix X. That is, X=[A i−n,j−m , . . . , A i+n,j+m ], where the content of the bracket is understood to be the aligned A-scans. Method 1: First, the embodiment decomposes X as a sum of low rank part and noise part, i.e., 
         [0000]        X=L+G,   (1)
 
         [0000]    where L is the low rank part with rank (L)≦r, and G is the noise. In the experiments reported below, we set r=2. 
         [0042]    The above decomposition is solved by minimizing the decomposition error: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       L 
                     
                      
                     
                       
                          
                         
                           X 
                           - 
                           L 
                         
                          
                       
                       F 
                       2 
                     
                   
                   , 
                   
                     
                       
                         s 
                         . 
                         t 
                         . 
                         
                           
                               
                           
                            
                           
                               
                           
                         
                          
                         rank 
                       
                        
                       
                           
                       
                        
                       
                         ( 
                         L 
                         ) 
                       
                     
                     ≤ 
                     r 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0043]    The notation ∥C∥ F  of any matrix X denotes the Frobenius norm of the matrix (i.e. the Euclidean norm of a vector formed by stacking the columns of the matrix). 
         [0044]    The optimization problem above is solved by the bilateral random projections [9] algorithm. The algorithm is summarized as follows: 
         [0045]    Algorithm 1 for solving L
       Generate a random matrix A 1      A 1 εR D×r ; where D is the number of pixels in an A-scan   Compute {tilde over (L)}=(XX T ) q X; (we use q=2)   Y 1 ={tilde over (L)}A 1 ,A 2 =Y 1      Y 2 ={tilde over (L)} T Y 1 ,Y 1 ={tilde over (L)}Y 2      Using standard methods, calculate QR decomposition Y 1 =Q 1 R 1 , Y 2 =Q 2 R 2 , where Q 1  and Q 2  are orthogonal matrices and R 1  and R 2  are upper triangular matrices;       
 
         [0000]        L=Q   1   [R   1 ( A   2   T   Y   1 ) −1   R   2   T ] 1/(2q+1)   Q   2   T ; 
         [0052]    Method 2: In the second method, the embodiment decomposes the X as a sum of low rank part, sparse part and noise part, i.e., 
         [0000]        X=L+S+G,   (3)
 
         [0000]    where L is the low rank part with rank (L)≦r, S is the sparse part with card(S)≦k and G is the noise. In the experiments reported below, r was equal to 2, and k was set as 30% of the total elements of the matrix S. 
         [0053]    The above decomposition is solved by minimizing the decomposition error: 
         [0000]    
       
         
           
               
             
               
                 
                   
                     
                       
                         min 
                         
                           L 
                           , 
                           S 
                         
                       
                        
                       
                         
                            
                           
                             X 
                             - 
                             L 
                             - 
                             S 
                           
                            
                         
                         F 
                         2 
                       
                     
                     , 
                     
                       
 
                     
                      
                     
                       
                         s 
                         . 
                         t 
                         . 
                         
                             
                         
                          
                         
                           rank 
                           ( 
                           L 
                           ) 
                         
                       
                       ≤ 
                       r 
                     
                     , 
                     
                       
 
                     
                      
                     
                       
                         card 
                          
                         
                           ( 
                           S 
                           ) 
                         
                       
                       ≤ 
                       
                         k 
                         . 
                       
                     
                   
                 
                 
                   
                     ( 
                     2 
                     ) 
                   
                 
               
             
           
         
       
     
         [0054]    The optimization problem above is solved by alternatively solving the following two sub-problems until convergence. 
         [0000]    
       
         
           
               
             
               { 
               
                 
                   
                     
                       
                         L 
                         t 
                       
                       = 
                       
                         arg 
                          
                         
                             
                         
                          
                         
                           
                             min 
                             
                               
                                 rank 
                                  
                                 
                                   ( 
                                   L 
                                   ) 
                                 
                               
                               ≤ 
                               r 
                             
                           
                            
                           
                             
                                
                               
                                 X 
                                 - 
                                 
                                   L 
                                   
                                     t 
                                     - 
                                     1 
                                   
                                 
                                 - 
                                 
                                   S 
                                   
                                     t 
                                     - 
                                     1 
                                   
                                 
                               
                                
                             
                             F 
                             2 
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         S 
                         t 
                       
                       = 
                       
                         arg 
                          
                         
                             
                         
                          
                         
                           
                             min 
                             
                               
                                 card 
                                  
                                 
                                   ( 
                                   S 
                                   ) 
                                 
                               
                               ≤ 
                               k 
                             
                           
                            
                           
                             
                                
                               
                                 X 
                                 - 
                                 
                                   L 
                                   
                                     t 
                                     - 
                                     1 
                                   
                                 
                                 - 
                                 
                                   S 
                                   
                                     t 
                                     - 
                                     1 
                                   
                                 
                               
                                
                             
                             F 
                             2 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0055]    The algorithm is summarized as follows: 
       Algorithm 2 for Solving L 
       [0056]    Initialize t:=0; L 0 =X; S 0 =0;
 
While ∥X−L t −S t ∥ F   2 /∥X∥ F   2 &gt;ε, do
 
t:=t+1;
 
{tilde over (L)}=[(X−S t−1 )(X−S t−1 ) T ] q (X−S t−1 );
 
Generate a random matrix A 1 εR D×r ; here D is the number of pixels in an A-scan.
 
Compute Y 1 ={tilde over (L)}A 1 ,A 2 =Y 1 ;
 
Y 2 ={tilde over (L)} T Y 1 , Y 1 ={tilde over (L)}Y 2  
 
Calculate QR decomposition Y 1 =Q 1 R 1 , Y 2 =Q 2 R 2 ;
 
If rank(A 2   T Y 1 )&lt;r then r=rank(A 2   T Y 1 ), go to the first step; end if;
 
L t =Q 1 [R 1 (A 2   T Y 1 ) −1 R 2   T ] 1/(2q+1) Q 2   T ;
 
S 1 =δ Ω (X−L t ), Ω is the nonzero subset of the first k largest entries of |X−L t |; δ Ω  is the projection of a matrix to Ω.
 
End while
 
         [0057]    Note that the term “column” is used here with a meaning which includes also a row of the matrix; in other words, in principle, X could be formed by stacking the aligned A-scans as the rows of X, but then the transpose of X would be applied before the equations are solved in methods 1 and 2. 
         [0058]    It can be see that the first method is a special case of the second method with S=0. The main difference is that the second model separates the difference due to content change from the noise. 
         [0059]    Although  FIG. 1  shows no further processing steps, optionally various filters can be applied on the reconstructed A-scan volumes. Suitable filters include enhanced Lee, adaptive Wiener filters, etc. For example, an adaptive Wiener filter may be used. In addition, a threshold may be applied to assist the de-noising. Mathematically, we apply the following process: 
         [0000]    
       
         
           
             
               L 
                
               
                 ( 
                 
                   x 
                   , 
                   y 
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         T 
                         low 
                       
                     
                     
                       
                         
                           L 
                            
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         &lt; 
                         
                           T 
                           low 
                         
                       
                     
                   
                   
                     
                       
                         L 
                          
                         
                           ( 
                           
                             x 
                             , 
                             y 
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           T 
                           low 
                         
                         ≤ 
                         
                           L 
                            
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         ≤ 
                         
                           T 
                           high 
                         
                       
                     
                   
                   
                     
                       
                         T 
                         high 
                       
                     
                     
                       
                         
                           L 
                            
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                         &gt; 
                         
                           T 
                           high 
                         
                       
                     
                   
                 
                 , 
               
             
           
         
       
     
         [0060]    Where T low  and T high  are two adaptively determined thresholds. 
       Results 
       [0061]    We first present results of the use of the embodiment for the method 1 (i.e. the first variant of step  3 ). For convenience, we examine the B-scan formed from the reconstructed A-scans.  FIG. 5  shows an example of the image recovery including:
       (i) a B-scan of the original data (labelled the “raw image”),   (ii) the recovered image (labelled the “clean part”). Each column has been obtained from a respective performance of method 1. That is, for a given column of the raw image, a corresponding matrix X is formed. From each X, corresponding matrices L and G are formed by method 1. For each column of the raw image, the corresponding column of the “clean part” image is the column of the corresponding matrix L which has the same position in the corresponding matrix L which the raw image column has in the corresponding matrix X.   (iii) a “noise part” image. For each column of the raw image, the corresponding column of the “noise part” image is the column of the corresponding matrix G which has the same position in the corresponding matrix G which the raw image column has in the corresponding matrix X.       
 
         [0065]      FIG. 6  shows the result when step  3  is performed using the second variant for step  2  (i.e. method 2), modelling X as X=L+S+G.
       (i) a B-scan of the original data (labelled the “raw image”),   (ii) the recovered image (labelled the “clean part”). Each column has been obtained from a respective performance of method 1. That is, for a given column of the raw image, a corresponding matrix X is formed. From each X, corresponding matrices L, S and G are formed by method 2. For each column of the raw image, the corresponding column of the “clean part” image is the column of the corresponding matrix L which has the same position in the corresponding matrix L which the raw image column has in the corresponding matrix X.   (iii) a “spare part” image. For each column of the raw image, the corresponding column of the “spare part” image is the column of the corresponding matrix S which has the same position in the corresponding matrix S which the raw image column has in the corresponding matrix X.   (iv) a “noise part” image. For each column of the raw image, the corresponding column of the “noise part” image is the column of the corresponding matrix G which has the same position in the corresponding matrix G which the raw image column has in the corresponding matrix X.       
 
         [0070]    In both cases, the image L is much sharper than the original image X. Visually, the two results from the two variants of step 3 are very close without much visible difference. 
         [0071]    To evaluate the image quality, the contrast to noise ratio (CNR) metric [6] is used. It measures the contrast between a set of regions of interest and a background region. 
         [0000]    
       
         
           
             CNR 
             = 
             
               
                 ( 
                 
                   1 
                   / 
                   R 
                 
                 ) 
               
                
               
                 
                   ∑ 
                   l 
                   R 
                 
                  
                 
                   
                     ( 
                     
                       
                         μ 
                         r 
                       
                       - 
                       
                         μ 
                         b 
                       
                     
                     ) 
                   
                   / 
                   
                     
                       
                         σ 
                         r 
                         2 
                       
                       + 
                       
                         σ 
                         b 
                         2 
                       
                     
                   
                 
               
             
           
         
       
     
         [0000]    where μ r  and σ r  are the mean and variance of all the region of interest, μ b  and σ b  are the mean and variance of the background region. Ten regions of interest from different retinal layers and one background region from each B-scan image were used to compute CNR. 
         [0072]    Two typical OCT volumes with 256 B-scan 992×512 images are used for testing. Table 1 shows the comparison between (i) the raw volume data, (ii) a conventional method using a moving algorithm, and (iii) the embodiment using method 2. As we can observe, the embodiment has a significantly higher CNR.  FIG. 7  uses box plot to show the variation of CNRs from different frames. 
         [0000]    
       
         
               
             
               
               
               
               
             
               
               
               
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 Comparison of CNR between the raw data, the conventional 
               
               
                 moving average speckle reduction algorithm, and 
               
               
                 an embodiment of the invention 
               
             
          
           
               
                   
                 Raw Volume 
                 Moving Average 
                 Embodiment 
               
               
                   
                   
               
             
          
           
               
                   
                 CNR 
                 1.30 
                 2.73 
                 5.26 
               
               
                   
                   
               
             
          
         
       
     
         [0073]      FIG. 8  shows visual difference between the proposed and baseline methods using two examples of raw data ( FIGS. 8( a ) and 8( d ) ). The images produced by the moving average method are shown in  FIGS. 8( b ) and 8( e ) , while the images produced by an embodiment of the present invention using method 2 are shown in  FIGS. 8( c ) and 8( d ) . 
         [0074]    Compared to the raw frames and their moving average, the embodiment provides much better volume quality for structure examination. Many more details of the retinal layers and structures such as lamina cribrosa can be examined more comfortably. 
         [0075]    Furthermore, the case of performing step 3 by low rank recovery using bilateral random projection is about 20 times faster than traditional algorithms such as robust PCA [8]. 
         [0076]    The computational process may be implemented using a computer system having a processor and a data storage device which stores program instructions for implementation by a processor, to cause the processor to carry out the method above substantially automatically (that is, without human involvement, except optionally for initiation of the method). The computer system may further comprise a display device having a screen for displaying the result of the method, and/or a printing device for generating a printed form of the result of the method, and/or an interface for transmitting the result of the method electronically. The computer system may be a general purpose computer, which receives the raw images from an interface. Alternatively, it may be part of an OCT imaging device which first captures the images and then processes them using the embodiment. 
         [0077]    The resulting images may be used by medical personnel as one tool to perform a diagnosis that a patient is suffering from a condition, and/or to select a medical treatment, such as a surgical procedure, to be carried out on the subject. 
       REFERENCES 
       [0078]    The disclosure of the following references is incorporated herein by reference:
   [1] J. S. Lee, “Speckle analysis and smoothing of synthetic aperture radar images,”  Computer Graphics Image Processing , vol. 17, pp. 24-32, 1981.   [2] D. T. Kuan, A. A. Sawchuk, T. C. Strand, and P. Chavel, “Adaptive noise smoothing filter for images with signal dependent noise,”  IEEE Trans. Pat. Anal. Mach. Intell ., vol. 7, pp. 165-177, 1985.   [3] A. Lopes, R. Touzi, and E. Nesby, “Adaptive speckle filter and scene heterogeneity,”  IEEE Trans. Geosci. Remote Sens ., vol. 28, pp. 992-1000, 1990.   [4] P. Perona and J. Malik, Scale-space and edge detection using anisotropic diffusion, IEEE Trans. Patt. Ana. Mach. Intell., vol. 12, pp. 629-639, 1990.   [5] Y. Yu and S. T. Acton, “Speckle reducing anisotropic diffusion,”  IEEE Trans. Image Processing , vol. 11, pp. 1260-1270, 2002.   [6] S. Aja-Fernandez and C. Alberola-López, “On the estimation of the coefficient of variation for anisotropic diffusion speckle filtering,”  IEEE Trans. Image Processing , vol. 15, no. 9, 2006.   [7] K. Krissian, C. F. Westin, R. Kikinis, and K. G. Vosburgh, “Oriented speckle reducing anisotropic diffusion,”  IEEE Trans. Image Processing , vol. 16(5), pp. 1412-1424, 2007.   [8] S. Zhu and K. Ma, “A new diamond search algorithm for fast block-matching motion estimation,”  IEEE Trans. Image Processing,  vol. 9, pp. 287-290, 2000.   [9] T. Zhou and D. Tao, “GoDec: Randomized Low-rank &amp; Sparse Matrix Decomposition in Noisy Case”, International Conference on Machine Learning, pp. 33-40, 2011