Abstract:
A method for determining a blob-like structure in a target image includes receiving an input target image is received, determining a mean curvature of the input target image, smoothing the mean curvature is smoothed using a scale that determines a size of the blobs to be found, finding a blob-like structure in the input target image as a portion of the input target image where a smoothed curvature is higher than a threshold value, and outputting a result including an indication of the blob-like structure.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
       [0001]    This application claims priority to U.S. Provisional Application Ser. Nos. 60/839,289, filed on Aug. 22, 2006, and 60/839,290, filed on Aug. 22, 2006, which are herein incorporated by reference in their entirety. 
     
     BACKGROUND OF THE INVENTION 
       [0002]    1. Technical Field 
         [0003]    The present invention relates to computer aided detection, and more particularly to a system and method for finding blob-like structures. 
         [0004]    2. Discussion of Related Art 
         [0005]    In the field of automatic detection systems, suppose that a bright solid sphere is sought in a given image having a given radius in a larger target image. One approach to detect objects in an image is to use template matching, in which a template of the object to be detected is first chosen or generated, and a correlation between the template and the target image for all possible valid shifts of the template within the target is computed. Then the peals of the correlation are selected as candidate positions of the object within the target image. In the case of locating a solid sphere of a given radius, a template solid sphere of the given radius is generated, and the template matching can be performed. However, high correlation peaks could be obtained even by objects within the target that are not spherical; for example, a solid box with sides larger than the radius of the sphere. One proposed solution to this problem is to use the edges (for example, the magnitude of the gradient) instead. That is, instead of detecting solid spheres, the edges in the image can be determined, and then search for a hollow sphere (or shell). 
         [0006]    Therefore, a need exists for a system and method for determining blob-like structures. 
       SUMMARY OF THE INVENTION 
       [0007]    According to an embodiment of the present disclosure, a method for determining a blob-like structure in a target image includes receiving an input target image is received, determining a mean curvature of the input target image, smoothing the mean curvature is smoothed using a scale that determines a size of the blobs to be found, finding a blob-like structure in the input target image as a portion of the input target image where a smoothed curvature is higher than a threshold value, and outputting a result including an indication of the blob-like structure. 
         [0008]    According to an embodiment of the present disclosure, a system for determining a blob-like structure in a target image includes a memory device storing an input target image and a plurality of instructions embodying a computer aided blob-like structure detection system, and a processor for receiving the input target image and executing the plurality of instructions. The processor performing a method including determining a mean curvature of the input target image, smoothing the mean curvature is smoothed using a scale that determines a size of the blobs to be found, finding a blob-like structure in the input target image as a portion of the input target image where a smoothed curvature is higher than a threshold value, and outputting a result including an indication of the blob-like structure. 
         [0009]    According to an embodiment of the present disclosure, a method for determining a blob-like structure in a target image includes receiving the target image as input, determining a diverging gradient field response function, wherein the diverging gradient field response includes a vector correlation of the field and a normalized gradient field of the target image, and determining the blob-like structure in the target image according to the vector correlation and a threshold. 
     
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0010]    Preferred embodiments of the present invention will be described below in more detail, with reference to the accompanying drawings: 
           [0011]      FIG. 1A  is a 2-D diverging gradient field according to an embodiment of the present disclosure; 
           [0012]      FIGS. 1B-C  show the x- and y-magnitude components of the gradient field, respectively, according to an embodiment of the present disclosure; 
           [0013]      FIG. 2  is a flow chart of a method for determining a blob-like structure using diverging gradient field components according to an embodiment of the present disclosure; 
           [0014]      FIG. 3  Is a flow chart of a method for determining a blob-like structure using a mean curvature according to an embodiment of the present disclosure; and 
           [0015]      FIG. 4  is a diagram of a system according to an embodiment of the present disclosure. 
       
    
    
     DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS 
       [0016]    According to an embodiment of the present disclosure, a diverging gradient field response (DFGR) can be used to detect blob-like structures in medical images. Such blobs may be indicative of abnormal structures such as lung nodules. Semi-spherical structures such as colon polyps may also be detected. Examples of medial images include Computer Tomography (CT), Magnetic Resonance (MR), Positron Emission Tomography (PET), Single Positron Emission Tomography (SPECT), and X-rays. 
         [0017]    According to an embodiment of the present disclosure, a set of separable filter banks are used to determine the DGFR. The DGFR looks for the sphere directly in the gradient domain, instead of the edges or magnitude of the gradient. Observe that the gradients of the spherical structure would appear to be diverging in the case of a sphere. 
         [0018]    To detect this diverging field in the derivations of the target image, a template diverging field may be used. In order to be less sensitive to size, a set of concentric diverging fields may be used as shown in  FIGS. 1A-B . 
         [0019]      FIG. 1A  shows a diverging gradient field in 2-D.  FIGS. 1B-C  show the x- and y-magnitude components of the diverging gradient field, respectively. 
         [0020]    Referring to  FIG. 2 , to determine a DGFR response for a given target image  200  a function is determined whose gradients are diverging. For example, consider the following equation of the radius of a sphere: 
         [0000]        s ( x,y,z )=√{square root over (x 2   +y   2   +z   2 )} 
         [0000]    The gradient of the sphere S is given by: 
         [0000]      {right arrow over (∇)} s=s   x   {right arrow over (i)}+s   z   {right arrow over (k)}   
         [0000]    Where the components s x (x,y,z), s y (x,y,z) and s z (x,y,z) are defined as: 
         [0000]    
       
         
           
             
               
                 
                   s 
                   x 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 x 
                 
                   
                     
                       x 
                       2 
                     
                     + 
                     
                       y 
                       2 
                     
                     + 
                     
                       z 
                       2 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 
                   s 
                   y 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 y 
                 
                   
                     
                       x 
                       2 
                     
                     + 
                     
                       y 
                       2 
                     
                     + 
                     
                       z 
                       2 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 
                   s 
                   z 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 
                   z 
                   
                     
                       
                         x 
                         2 
                       
                       + 
                       
                         y 
                         2 
                       
                       + 
                       
                         z 
                         2 
                       
                     
                   
                 
                 . 
               
             
           
         
       
     
         [0000]    The field {right arrow over (∇)}s is a diverging field. The DGFR includes the vector correlation of the field {right arrow over (∇)}s with the normalized gradient field of the target image  201 , and is given by: 
         [0000]    
       
         
           
             
               dgfr 
                
               
                 ( 
                 f 
                 ) 
               
             
             = 
             
               
                 
                   ( 
                   
                     
                       
                         ∇ 
                         → 
                       
                        
                       f 
                     
                     
                        
                       
                         
                           ∇ 
                           → 
                         
                          
                         f 
                       
                        
                     
                   
                   ) 
                 
                 * 
                 
                   ( 
                   
                     
                       ∇ 
                       → 
                     
                      
                     s 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     ( 
                     
                       
                         f 
                         x 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     s 
                     x 
                   
                 
                 + 
                 
                   
                     ( 
                     
                       
                         f 
                         y 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     s 
                     
                       y 
                        
                       
                           
                       
                     
                   
                 
                 + 
                 
                   
                     ( 
                     
                       
                         f 
                         z 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     s 
                     z 
                   
                 
               
             
           
         
       
     
         [0000]    where f x , f y , f z  are the x-, y-, z-image gradients respectively, and s x , s y , s z  are the diverging gradient field components defined in a template region Ω provided by the user. The normalization of the image gradients  201  makes the response insensitive to differing contrasts across different images, and across different regions in the image. 
         [0021]    To determine dgfr three 3-D convolutions are performed, one per dimension of the image  203 . In practice, this is expensive in terms of time. A separable version of the filters s x , s y  and s z  may be determined  202  to mitigate the time needed to determine dgfr. 
         [0022]    Referring to the set of separable filters  202 , and more particularly to the Gaussian function; The function g σ  may be used, which is a Gaussian, and whose gradient field is diverging. 
         [0000]    
       
         
           
             
               
                 g 
                 σ 
               
                
               
                 ( 
                 
                   x 
                   , 
                   y 
                   , 
                   z 
                 
                 ) 
               
             
             = 
             
               
                 
                   1 
                   
                     
                       ( 
                       
                         2 
                          
                         
                             
                         
                          
                         π 
                          
                         
                             
                         
                          
                         
                           σ 
                           2 
                         
                       
                       ) 
                     
                     
                       3 
                       2 
                     
                   
                 
                  
                 
                   
                      
                     
                       - 
                       
                         ( 
                         
                           
                             
                               x 
                               2 
                             
                             + 
                             
                               y 
                               2 
                             
                             + 
                             
                               z 
                               2 
                             
                           
                           
                             2 
                              
                             
                                 
                             
                              
                             
                               σ 
                               2 
                             
                           
                         
                         ) 
                       
                     
                   
                   . 
                   
                     
 
                   
                    
                   
                     dgfr 
                      
                     
                       ( 
                       f 
                       ) 
                     
                   
                 
               
               = 
               
                 
                   
                     ( 
                     
                       
                         
                           ∇ 
                           → 
                         
                          
                         f 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     ( 
                     
                       
                         ∇ 
                         → 
                       
                        
                       g 
                     
                     ) 
                   
                 
                 = 
                 
                   
                     
                       ( 
                       
                         
                           f 
                           x 
                         
                         
                            
                           
                             
                               ∇ 
                               → 
                             
                              
                             f 
                           
                            
                         
                       
                       ) 
                     
                     * 
                     
                       g 
                       x 
                     
                   
                   + 
                   
                     
                       ( 
                       
                         
                           f 
                           y 
                         
                         
                            
                           
                             
                               ∇ 
                               → 
                             
                              
                             f 
                           
                            
                         
                       
                       ) 
                     
                     * 
                     
                       g 
                       
                         y 
                          
                         
                             
                         
                       
                     
                   
                   + 
                   
                     
                       ( 
                       
                         
                           f 
                           z 
                         
                         
                            
                           
                             
                               ∇ 
                               → 
                             
                              
                             f 
                           
                            
                         
                       
                       ) 
                     
                     * 
                     
                       g 
                       z 
                     
                   
                 
               
             
           
         
       
     
         [0000]    which can be determined using the separable filters g x , g y , g z : 
         [0000]    
       
         
           
             
               
                 
                   g 
                   x 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     - 
                     x 
                   
                   
                     σ 
                     2 
                   
                 
                  
                 
                   
                     g 
                     σ 
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                       , 
                       z 
                     
                     ) 
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 
                   g 
                   y 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     - 
                     y 
                   
                   
                     σ 
                     2 
                   
                 
                  
                 
                   
                     g 
                     σ 
                   
                    
                   
                     ( 
                     
                       x 
                       , 
                       y 
                       , 
                       z 
                     
                     ) 
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 
                   g 
                   z 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     - 
                     z 
                   
                   
                     σ 
                     2 
                   
                 
                  
                 
                   
                     
                       g 
                       σ 
                     
                      
                     
                       ( 
                       
                         x 
                         , 
                         y 
                         , 
                         z 
                       
                       ) 
                     
                   
                   . 
                 
               
             
           
         
       
     
         [0023]    A correlation of the two vector fields is determined through on convolution per dimension  203  and these derivative Gaussian filters are used for the determination of the DGFR to find blob-like structures in the input image  204 . Using a determination of the correlation of the two vector fields can be expensive in terms of time, processing power, etc. 
         [0024]    The speed of the determination of the DGFR for a given image may be increased using a scale space of mean curvature. Determining DGFR at a particular σ is exactly equivalent to determining the mean curvature followed by smoothing with a Gaussian with parameter σ. This equivalence allows for faster determination of the DGFR by determining the curvature and applying a Gaussian filter. 
         [0025]    Referring to  FIG. 3 , an input target image is input/received  300  and a mean curvature of the input target image is determined  301 . The mean curvature is smoothed using a scale that determines the size of the blobs to be found  302  and blob-like structures are found in the input target image as places where the smoothed curvature is high  303 , for example, as compared to a threshold value set by a user or as compared to surrounding portions of the input target image. An output  304  may include an image (e.g., shown on a display) wherein the blob-like structure is extracted or highlighted from the input target image, a set of coordinates of the blob-like structure stored to memory, etc. 
         [0026]    Without loss of generality, 3-D images are used as the input target image in the follow exemplary implementation for showing that dgfr σ  is the scale-space of curvature. The methods may be extended to N-D applications (where N is a natural number). 
         [0027]    Gradient of a scalar f: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∇ 
                       → 
                     
                      
                     f 
                   
                   = 
                     
                    
                   
                     
                       
                         
                           ∂ 
                           f 
                         
                         
                           ∂ 
                           x 
                         
                       
                        
                       
                         i 
                         → 
                       
                     
                     + 
                     
                       
                         
                           ∂ 
                           f 
                         
                         
                           ∂ 
                           y 
                         
                       
                        
                       
                         j 
                         → 
                       
                     
                     + 
                     
                       
                         
                           ∂ 
                           f 
                         
                         
                           ∂ 
                           z 
                         
                       
                        
                       
                         k 
                         → 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         f 
                         x 
                       
                        
                       
                         i 
                         → 
                       
                     
                     + 
                     
                       
                         f 
                         y 
                       
                        
                       
                         i 
                         → 
                       
                     
                     + 
                     
                       
                         f 
                         x 
                       
                        
                       
                         k 
                         → 
                       
                     
                   
                 
               
             
           
         
       
     
         [0028]    Magnitude of gradient field: 
         [0000]      ∥{right arrow over (∇)} f∥=√ {square root over ( f   x   2   +f   y   2   +f   z   2 )} 
         [0029]    Convolution of vector {right arrow over (F)}=p{right arrow over (i)}+q{right arrow over (j)}+r{right arrow over (k)} with scalar s: 
         [0000]        {right arrow over (G)}={right arrow over (F)}*s +( p*s ) {right arrow over (i)} +( q*s ) {right arrow over (j)} +( r*s ) {right arrow over (k)}   
         [0030]    Divergence of a vector filed {right arrow over (F)}=p{right arrow over (i)}+q{right arrow over (j)}+r{right arrow over (k)}, also denoted as ∇·{right arrow over (F)}: 
         [0000]    
       
         
           
             
               
                 
                   
                     div 
                      
                     
                       ( 
                       
                         F 
                         → 
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         ∂ 
                         
                           ∂ 
                           x 
                         
                       
                        
                       p 
                     
                     + 
                     
                       
                         ∂ 
                         
                           ∂ 
                           y 
                         
                       
                        
                       q 
                     
                     + 
                     
                       
                         ∂ 
                         
                           ∂ 
                           z 
                         
                       
                        
                       r 
                     
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                      
                     
                       p 
                       x 
                     
                   
                   , 
                   
                     q 
                     y 
                   
                   , 
                   
                     r 
                     z 
                   
                 
               
             
           
         
       
     
         [0031]    Referring to the diverging gradient field response: 
       Given a Gaussian 
       [0032]    
       
         
           
             
               
                 
                   g 
                   σ 
                 
                  
                 
                   ( 
                   
                     x 
                     , 
                     y 
                     , 
                     z 
                   
                   ) 
                 
               
               = 
               
                 
                   1 
                   
                     
                       ( 
                       
                         2 
                          
                         
                             
                         
                          
                         π 
                          
                         
                             
                         
                          
                         
                           σ 
                           2 
                         
                       
                       ) 
                     
                     
                       3 
                       2 
                     
                   
                 
                  
                 
                    
                   
                     - 
                     
                       ( 
                       
                         
                           
                             x 
                             2 
                           
                           + 
                           
                             y 
                             2 
                           
                           + 
                           
                             z 
                             2 
                           
                         
                         
                           2 
                            
                           
                               
                           
                            
                           
                             σ 
                             2 
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
           
         
       
     
         [0000]    the diverging gradient field response may be written as: 
         [0000]    
       
         
           
             
               dgfr 
                
               
                 ( 
                 f 
                 ) 
               
             
             = 
             
               
                 
                   ( 
                   
                     
                       
                         ∇ 
                         → 
                       
                        
                       f 
                     
                     
                        
                       
                         
                           ∇ 
                           → 
                         
                          
                         f 
                       
                        
                     
                   
                   ) 
                 
                 * 
                 
                   ( 
                   
                     
                       ∇ 
                       → 
                     
                      
                     g 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     ( 
                     
                       
                         f 
                         x 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     g 
                     x 
                   
                 
                 + 
                 
                   
                     ( 
                     
                       
                         f 
                         y 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     g 
                     
                       y 
                        
                       
                           
                       
                     
                   
                 
                 + 
                 
                   
                     ( 
                     
                       
                         f 
                         z 
                       
                       
                          
                         
                           
                             ∇ 
                             → 
                           
                            
                           f 
                         
                          
                       
                     
                     ) 
                   
                   * 
                   
                     
                       g 
                       z 
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0000]    where g x , g y , g z  are the x-, y- and z-derivatives of the Gaussian g σ . 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             div 
                              
                             
                               ( 
                               
                                 
                                   F 
                                   → 
                                 
                                 * 
                                 s 
                               
                               ) 
                             
                           
                           = 
                             
                            
                           
                             
                               
                                 ∂ 
                                 
                                   ∂ 
                                   x 
                                 
                               
                                
                               
                                 ( 
                                 
                                   p 
                                   * 
                                   s 
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 ∂ 
                                 
                                   ∂ 
                                   y 
                                 
                               
                                
                               
                                 ( 
                                 
                                   q 
                                   * 
                                   s 
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 ∂ 
                                 
                                   ∂ 
                                   z 
                                 
                               
                                
                               
                                 ( 
                                 
                                   r 
                                   * 
                                   s 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 p 
                                 x 
                               
                               * 
                               s 
                             
                             + 
                             
                               
                                 q 
                                 y 
                               
                               * 
                               s 
                             
                             + 
                             
                               
                                 r 
                                 z 
                               
                               * 
                               s 
                             
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               ( 
                               
                                 
                                   p 
                                   x 
                                 
                                 + 
                                 
                                   
                                     q 
                                     y 
                                   
                                   * 
                                   s 
                                 
                                 + 
                                 
                                   r 
                                   z 
                                 
                               
                               ) 
                             
                             * 
                             s 
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               div 
                                
                               
                                 ( 
                                 
                                   F 
                                   → 
                                 
                                 ) 
                               
                             
                             * 
                             s 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     also 
                      
                     
                       : 
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           div 
                            
                           
                             ( 
                             
                               
                                 F 
                                 → 
                               
                               * 
                               s 
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               ∂ 
                               
                                 ∂ 
                                 x 
                               
                             
                              
                             
                               ( 
                               
                                 p 
                                 * 
                                 s 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               ∂ 
                               
                                 ∂ 
                                 y 
                               
                             
                              
                             
                               ( 
                               
                                 q 
                                 * 
                                 s 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               ∂ 
                               
                                 ∂ 
                                 z 
                               
                             
                              
                             
                               ( 
                               
                                 r 
                                 * 
                                 s 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               p 
                               x 
                             
                             * 
                             s 
                           
                           + 
                           
                             
                               q 
                               y 
                             
                             * 
                             s 
                           
                           + 
                           
                             
                               r 
                               z 
                             
                             * 
                             s 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             p 
                             * 
                             
                               s 
                               x 
                             
                           
                           + 
                           
                             q 
                             * 
                             
                               s 
                               y 
                             
                           
                           + 
                           
                             r 
                             * 
                             
                               s 
                               z 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0033]    Here, the DGFR is the scale-space of curvature. Consider: 
         [0000]    
       
         
           
             
               
                 
                   
                     dgfr 
                      
                     
                       ( 
                       f 
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         ( 
                         
                           
                             f 
                             x 
                           
                           
                              
                             
                               
                                 ∇ 
                                 → 
                               
                                
                               f 
                             
                              
                           
                         
                         ) 
                       
                       * 
                       
                         g 
                         x 
                       
                     
                     + 
                     
                       
                         ( 
                         
                           
                             f 
                             y 
                           
                           
                              
                             
                               
                                 ∇ 
                                 → 
                               
                                
                               f 
                             
                              
                           
                         
                         ) 
                       
                       * 
                       
                         g 
                         
                           y 
                            
                           
                               
                           
                         
                       
                     
                     + 
                     
                       
                         ( 
                         
                           
                             f 
                             z 
                           
                           
                              
                             
                               
                                 ∇ 
                                 → 
                               
                                
                               f 
                             
                              
                           
                         
                         ) 
                       
                       * 
                       
                         g 
                         z 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       div 
                       ( 
                       
                         
                           ( 
                           
                             f 
                             
                                
                               
                                 
                                   ∇ 
                                   → 
                                 
                                  
                                 f 
                               
                                
                             
                           
                           ) 
                         
                         * 
                         g 
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     from 
                      
                     
                         
                     
                      
                     
                       Eq 
                       . 
                       
                           
                       
                        
                       
                         ( 
                         2 
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       div 
                       ( 
                       
                         f 
                         
                            
                           
                             
                               ∇ 
                               → 
                             
                              
                             f 
                           
                            
                         
                       
                       ) 
                     
                     * 
                     g 
                      
                     
                         
                     
                      
                     from 
                      
                     
                         
                     
                      
                     
                       Eq 
                       . 
                       
                           
                       
                        
                       
                         ( 
                         1 
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             Thus 
             , 
             
               
 
             
              
             
               
                 dgfr 
                 σ 
               
               = 
               
                 
                   ( 
                   
                     
                       
                         ∇ 
                         → 
                       
                        
                       f 
                     
                     
                        
                       
                         
                           ∇ 
                           → 
                         
                          
                         f 
                       
                        
                     
                   
                   ) 
                 
                 * 
                 
                   g 
                   σ 
                 
               
             
           
         
       
     
         [0034]    Note that 
         [0000]    
       
         
           
             div 
             ( 
             
               
                 
                   ∇ 
                   → 
                 
                  
                 f 
               
               
                  
                 
                   
                     ∇ 
                     → 
                   
                    
                   f 
                 
                  
               
             
             ) 
           
         
       
     
         [0000]    is the definition of a mean curvature. Thus, dgfr σ  is the scale-space of curvature. 
         [0035]    It is to be understood that the present invention may be implemented in various forms of hardware, software, firmware, special purpose processors, or a combination thereof. In one embodiment, the present invention may be implemented in software as an application program tangibly embodied on a program storage device. The application program may be uploaded to, and executed by, a machine comprising any suitable architecture. 
         [0036]    Referring to  FIG. 4 , according to an embodiment of the present invention, a computer system  401  for determining a blob-like structure in a target image can comprise, inter alia, a central processing unit (CPU)  402 , a memory  403  and an input/output (I/O) interface  404 . The computer system  401  is generally coupled through the I/O interface  404  to a display  405  for displaying, inter alia, an output image, and various input devices  406  such as a mouse and keyboard. The support circuits can include circuits such as cache, power supplies, clock circuits, and a communications bus. The memory  403  can include random access memory (RAM), read only memory (ROM), disk drive, tape drive, etc., or a combination thereof. The present invention can be implemented as a routine  407  that is stored in memory  403  and executed by the CPU  402  to process a signal, e.g., an input target image, from the signal source  408 . As such, the computer system  401  is a general purpose computer system that becomes a specific purpose computer system when executing the routine  407  of the present invention. The computer system  401  may further include a GPU  409  for processing certain operations. 
         [0037]    The computer platform  401  also includes an operating system and micro instruction code. The various processes and functions described herein may either be part of the micro instruction code or part of the application program (or a combination thereof) which is executed via the operating system. In addition, various other peripheral devices may be connected to the computer platform such as an additional data storage device and a printing device. 
         [0038]    It is to be further understood that, because some of the constituent system components and method steps depicted in the accompanying figures may be implemented in software, the actual connections between the system 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. 
         [0039]    Having described embodiments for a system and method for determining a blob-like structure in a target image, it is noted that modifications and variations can be made by persons skilled in the art in light of the above teachings. It is therefore to be understood that changes may be made in the particular embodiments of the invention disclosed which are within the scope and spirit of the invention as defined by the appended claims. Having thus described the invention with the details and particularity required by the patent laws, what is claimed and desired protected by Letters Patent is set forth in the appended claims.