BACKGROUND OF THE INVENTION 
       [0001]    The present invention generally relates to imaging technology. More particularly, the present invention relates to computing geometric wavelets representation based on active contours. 
         [0002]    Imaging systems have been developed for a variety of purposes. Some of these are for computer graphics, for video encoding for transferring video files, and for generating computer-enhanced pictures/videos. For example, an imaging system may rely upon an edge detection method for video data compression. Edge detection may also allow generating pictures and/or videos that will allow shape analysis. For example, there are a number of numerical algorithms for computing a near-minimizer of one of the methods of edge detection, Mumford-Shah functional. However, they do not produce an actual segmentation of the image into distinct regions with disjoint interiors. Instead, they classify pixels with an “edge” score, where the score implies the probability that the pixel is an edge pixel. This method may make difficult extraction of true segmentation from this “fuzzy” classification. For example, some computer aided diagnostic procedures for the medical field require that an actual segmentation curve be computed so that shape analysis can be applied to the segmented object for the purpose of detecting abnormalities. 
         [0003]    In the medical field, an imaging system that can provide as much detail as possible from a limited video data may be valuable to a radiologist in his work since the radiologist relies on X-ray pictures, MRI or CAT scans, and other visual rendition of a patient&#39;s body in assessing a patient&#39;s health. However, in some situations, there may not be enough data available for generation of an acceptable video/picture output. For example, in photon-limited images, the random nature of photon emission and detection is the dominant source of noise in the imaging system. In these cases, the relatively small number of detected photons is a factor limiting the signal-to-noise ratio. These applications comprise Positron Emission Tomography (PET), Single Photon Emission Computed Tomography (SPECT), Confocal Microscopy, and Infrared (IR) imaging. 
         [0004]    The data collected by these imaging systems are usually assumed to obey a spatial Poisson distribution involving a two-dimensional intensity image that descries the probability of photon emissions at different locations in space. The mean and variance of a Poisson process are equal to the intensity, where the intensity mean corresponds to the “signal” of interest and the variability of the data about the mean can be interpreted as “noise.” In some sense, it may be said that the noise in photon-limited imaging is signal dependent. Thus, a reconstruction method that removes the Poisson noise while preserving the main feature of the image will be useful. 
       BRIEF SUMMARY OF THE INVENTION 
       [0005]    Certain embodiments of the invention provide systems and methods for image processing. 
         [0006]    Certain embodiments of the invention provide a method for image processing. The method includes computing a segmentation tree for an input image data using active contours; creating a geometric wavelets representation using a segmentation tree; and generating an image based on geometric wavelet sparse representation extracted from the geometric wavelets representation. The method also includes recursively finding sub-domains and low-order multivariate polynomials for at least one domain at each stage in the computing of the segmentation tree, where each sub-domain may be a domain for a succeeding stage in creating the segmentation tree, if the recursive finding is not terminated. The succeeding stage may be the next stage or another stage down the line. 
         [0007]    The low-order multivariate (2D for a single image, 3D for an image sequence, etc) polynomials may be found, for example, using least-squares method. The process of recursively finding sub-domains may be terminated, for example, when each domain at a stage comprises less than a determined number of pixels. The geometric wavelet sparse representation may comprise, for example, M most active geometric wavelets from a set of N geometric wavelets in the geometric wavelets representation, where M is a number less than N. The segmentation tree may be generated, for example, using binary space partition. 
         [0008]    Certain embodiments provide a system for providing geometric wavelets based on active contours. The system may include providing an image processing circuitry that computes a segmentation tree using active contours for an input image data. The image processing circuitry may create a geometric wavelets representation using a segmentation tree. The image processing circuitry may generate an image based on geometric wavelet sparse representation that may be extracted from the geometric wavelets representation. The image processing circuitry may recursively find sub-domains and low-order multivariate polynomials for at least one domain at each stage in the computing of the segmentation tree, if the recursive finding is not terminated. The system may use, for example, a least-squares method to find the low-order multivariate polynomials. 
         [0009]    Each of the sub-domains is a domain for a succeeding stage for the segmentation tree. The recursively finding may be terminated, for example, when each domain at a stage comprises less than a determined number of pixels. The image processing circuitry may generate the geometric wavelet sparse representation comprising M most active geometric wavelets from a set of N geometric wavelets in the geometric wavelets representation, where M is a number less than N. The system may generate, for example, the segmentation tree using binary space partition. 
     
    
     
       BRIEF DESCRIPTION OF SEVERAL VIEWS OF THE DRAWINGS 
         [0010]      FIG. 1  is an exemplary diagram of a portion of an imaging device, which may be utilized with an embodiment of the invention. 
           [0011]      FIG. 2  shows exemplary diagrams of an image being detected using active contours method, which may be utilized with an embodiment of the invention. 
           [0012]      FIG. 3A  shows an exemplary segmentation of an image, which may be utilized with an embodiment of the invention. 
           [0013]      FIG. 3B  shows generation of an exemplary segmentation tree corresponding to  FIG. 3A , which may be utilized with an embodiment of the invention. 
           [0014]      FIG. 4  illustrates an exemplary flow diagram for finding geometric wavelets based on active contours in accordance with an embodiment of the present invention. 
           [0015]      FIG. 5  illustrates an exemplary flow diagram for generating a segmentation tree using active contours in accordance with an embodiment of the present invention. 
       
    
    
       [0016]    The foregoing summary, as well as the following detailed description of certain embodiments of the present invention, will be better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, certain embodiments are shown in the drawings. It should be understood, however, that the present invention is not limited to the arrangements and instrumentality shown in the attached drawings. 
       DETAILED DESCRIPTION OF THE INVENTION 
       [0017]      FIG. 1  is an exemplary diagram of a portion of an imaging device, which may be utilized with an embodiment of the invention. Referring to  FIG. 1 , there is shown an imaging device  100 . The imaging device  100  may comprise an image sensor  110 , an image processor  112 , a processor  114 , and a memory block  116 . The image sensor  110  may comprise suitable circuitry and/or logic that may enable capture of images, which may include, for example, video images and still images. The images captured may be further processed as video and/or still photograph outputs. 
         [0018]    The image processor  112  may comprise suitable circuitry, logic, and/or code that may enable processing of image data. The processor  114  may comprise suitable circuitry, logic, and/or code that may enable general processing. For example, the processor  114  may determine the mode of operation of various portions of the imaging device  100 . For example, the processor  114  may set up data registers in the image processor  112  to allow direct memory access (DMA) transfers of video data to the memory block  116 . The processor may also communicate instructions to the image sensor  110  to initiate capturing of images. The memory block  116  may be used to store image data that may be processed and communicated by the image processor  112 . The memory block  116  may also be used for storing code and/or data that may be used by the processor  114 . The memory block  116  may also be used to store data for other functionalities of the imaging device  100 . For example, the memory block  114  may store data corresponding to voice communication. 
         [0019]    In operation, the processor  114  may initiate image capture by the image sensor  110 . The image sensor  110  may communicate, for example, the YUV data corresponding to the captured images to the image processor  112 . The processor  114  may provide information to the image processor  112  for DMA transfer of processed image data to the memory block  116 . The image data in the memory block  116  may be further processed, for example, by the processor  114 . The processing by the processor  114  may comprise, for example, preparing the image for printing and/or transmission to another network node. 
         [0020]    While an embodiment of the invention may have been described as comprising the image processor  112  and the processor  114 , the invention need not be so limited. For example, the processor  114  may comprise the functionality of the image processor  112 . 
         [0021]      FIG. 2  shows exemplary diagrams of an image being detected using active contours method, which may be utilized with an embodiment of the invention. Referring to  FIG. 2 , there is shown frames  200 ,  202 ,  204 , and  206 , where an initial outline  200   a  in the frame  200  may converge to a final outline in the frame  206 . Same images may be in the frames  200 ,  202 ,  204 , and  206 , and the images may be photon-limited images. Outline  200   a  shown in the frame  200  may be a circle. The image processor  112  may, for example, draw a circle as a default outline  200   a , where the default outline  200   a  may be selected to generally encircle images in the frame  200 . In the frame  202 , the image processor  112  may converge to a more accurate outline  202   a  from the outline  200   a.    
         [0022]    Similarly, in the frame  204 , the image processor  112  may converge to a still more accurate outline  204   a , and start to generate an interior circle outline  204   b . In the frame  206 , the image processor  112  may generate distinct outlines  206   a  and  206   b  for the toroid image on the lower left-hand side of the frame  206 , the outline  206   c  for the image on the right hand side of the frame  206 , and the outline  206   d  for the triangle image on the top left-hand side of the frame  206 . The image processor  112  may, for example, use the active contours method to converge to more accurate outlines. 
         [0023]    For example, given a multivariate real-valued function (image) f defined on a domain such as the d-th dimensional unit cube [0,1] d , one may subdivide the initial domain into two sub-domains. In Binary Space Partition (BSP) applications, the subdivision may be performed by intersecting the domain with a hyper-plane, which may be a line for the case where d=2. The partition is performed so that a given cost function is minimized. This subdivision then proceeds recursively on the sub-domains until some exit criterion is met. At each stage of the BSP process, for a given convex polytope Q, the algorithm finds two sub-domains Ω′, Ω″ and two low-order polynomials Q Ω′ , Q Ω″ , that minimize the quantity 
         [0000]      ∥f−Q Ω′ ∥ L     2     (Ω′)   2 +∥f−Q Ω″∥   L     2     (Ω″)   2   (1.1) 
         [0000]    over all pairs Ω′, Ω″ of polyhedral domains that are the result of an binary space partition of Ω by a hyper-plane, where 
         [0000]    
       
         
           
             
               
                 
                   
                     
                        
                       g 
                        
                     
                     
                       
                         L 
                         2 
                       
                        
                       
                         ( 
                         Ω 
                         ) 
                       
                     
                   
                   := 
                   
                     
                       
                         ( 
                         
                           
                             ∑ 
                             
                               x 
                               ∈ 
                               Ω 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               g 
                                
                               
                                 ( 
                                 x 
                                 ) 
                               
                             
                             2 
                           
                         
                         ) 
                       
                       
                         1 
                         / 
                         2 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   1.2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The quantity in (1.2) is the L 2  norm of a discrete function over a domain Ω. In some embodiments, other ‘energy’ quantifications may be applied. 
         [0024]    To minimize (1.1), candidate partitions of the domain Ω may need to be tested. Once a test partition is fixed, the polynomials Q Ω′ , Q Ω″  can be calculated separately using, for example, the least-squares technique. For example, in an embodiment where d=2, the polynomials are linear and Ω′ is one of the sub-domains, one minimizes 
         [0000]    
       
         
           
             
               min 
               
                 a 
                 , 
                 b 
                 , 
                 c 
               
             
              
             
               
                 ∑ 
                 
                   
                     ( 
                     
                       
                         x 
                         1 
                       
                       , 
                       
                         x 
                         2 
                       
                     
                     ) 
                   
                   ∈ 
                   
                     Ω 
                     ′ 
                   
                 
               
                
               
                   
               
                
               
                 
                   
                     ( 
                     
                       
                         f 
                          
                         
                           ( 
                           
                             
                               x 
                               1 
                             
                             , 
                             
                               x 
                               2 
                             
                           
                           ) 
                         
                       
                       - 
                       
                         ( 
                         
                           
                             ax 
                             1 
                           
                           + 
                           
                             bx 
                             2 
                           
                           + 
                           c 
                         
                         ) 
                       
                     
                     ) 
                   
                   2 
                 
                 . 
               
             
           
         
       
     
         [0025]    The above least square minimization is performed by solving the linear system of three equations: 
         [0000]    
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     1 
                                     2 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     
                                       x 
                                       1 
                                     
                                      
                                     
                                       x 
                                       2 
                                     
                                   
                                 
                                 ) 
                               
                                
                               b 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               c 
                             
                           
                           = 
                           
                             
                               ∑ 
                               
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                                 ∈ 
                                 
                                   Ω 
                                   ′ 
                                 
                               
                             
                              
                             
                               
                                 f 
                                  
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                                
                               
                                 x 
                                 1 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     
                                       x 
                                       1 
                                     
                                      
                                     
                                       x 
                                       2 
                                     
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     2 
                                     2 
                                   
                                 
                                 ) 
                               
                                
                               b 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     2 
                                   
                                 
                                 ) 
                               
                                
                               c 
                             
                           
                           = 
                           
                             
                               ∑ 
                               
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                                 ∈ 
                                 
                                   Ω 
                                   ′ 
                                 
                               
                             
                              
                             
                               
                                 f 
                                  
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                                
                               
                                 x 
                                 2 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     1 
                                   
                                 
                                 ) 
                               
                                
                               a 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   
                                     x 
                                     2 
                                   
                                 
                                 ) 
                               
                                
                               b 
                             
                             + 
                             
                               
                                 ( 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             x 
                                             1 
                                           
                                           , 
                                           
                                             x 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       
                                         Ω 
                                         ′ 
                                       
                                     
                                   
                                    
                                   1 
                                 
                                 ) 
                               
                                
                               c 
                             
                           
                           = 
                           
                             
                               ∑ 
                               
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                                 ∈ 
                                 
                                   Ω 
                                   ′ 
                                 
                               
                             
                              
                             
                               f 
                                
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    We then set 
         [0000]        Q   Ω′ ( x   1   ,x   2 )= ax   1   +bx   2   =c.   (1.4) 
         [0026]    The same calculations can be performed over Ω″, and once the polynomials Q Ω′ , Q Ω″  are computed, one can also compute (1.1) for the tested partition and compare with previously tested partitions. To speed up calculations of the type (1.3), one can pre-compute moment integrals, as a pre-processing step, at all the points of the original domain. Once a domain Ω is partitioned into two ‘optimal’ sub-domains Ω′,Ω″, the process may be applied recursively on the sub-domains. The subdivision process may be terminated, for example, when each sub-domain contains only a few pixels. 
         [0027]    An embodiment of the invention may replace the hyper-plane with a curved partition. The curved partition may be computed, for example, using the active contour paradigm. In one embodiment of the invention, (1.1) may be replaced by 
         [0000]      len(γ)+μ(∥f−Q Ω′ ∥ L     2(Ω′)     2 +∥f−Q Ω′ ∥ L     2     (Ω″)   2 ),  (1.5) 
         [0000]    where γ is the segmentation curve between the sub-regions Ω′, Ω″ and μ&gt;0 is a weight parameter. Regions and sub-regions may also be referred to as, for example, domains and sub-domains. 
         [0028]    Accordingly, the active contour algorithm may find a solution to (1.5) for the frame  200 , where a square domain may be partitioned into four sub-regions in the presence of Poisson ‘noise’. The sub-regions Ω′ and Ω″ need not be connected regions. For example, the toroid image on the lower left-hand side of the frame  206  outlined by the outlines  206   a  and  206   b , the triangle image outlined by the outline  206   d , and the image on the right hand side of the frame  206  outlined by the outline  206   c  are not connected regions. In such a case, sub-regions Ω′ and Ω″ may be further subdivided into their connected components and thus a region Ω may have more than two children in a tree. As in the standard BSP method, the algorithm may proceed recursively on the connected sub-regions to create a segmentation tree. 
         [0029]      FIG. 3A  shows an exemplary segmentation of an image, in accordance with an embodiment of the invention. Referring to  FIG. 3A , there is shown a connected region A that may be divided to create a segmentation tree. The initial region A may be seen in the frame  300 . The initial region A may be divided into sub-regions B and C by the curved partition  302   a  in the frame  302 . The frame  304  shows the sub-region B divided into sub-regions D and E by the curved partition  304   a . The frame  306  shows the sub-region D divided into sub-regions F and G by the curved partition  306   a . The curved partitions  302   a ,  304   a , and  306   a  may be generated using, for example, the active contour algorithm. The partitions  302   a ,  304   a , and  306   a  may be shown as straight lines for ease of presentation. 
         [0030]    Accordingly, a segmentation tree may be generated, where each branch of the segmentation tree may indicate a sub-region of the initial region A. A partial segmentation tree that corresponds to the segmentation shown in the frames  300 ,  302 ,  304 , and  306  is shown in  FIG. 3B . 
         [0031]      FIG. 4  illustrates an exemplary flow diagram for a geometric wavelets algorithm based on active contours in accordance with an embodiment of the present invention. Referring to  FIG. 4 , there is shown steps  400  to  406 . In step  400 , data corresponding to an image frame may be received for image processing. The image frame may comprise, for example, one or more unconnected images. In step  402 , a binary space partition segment tree may be computed as illustrated, for example, with respect to  FIGS. 2 ,  3 A, and  3 B. 
         [0032]    In step  404 , once the segmentation tree is constructed, a geometric wavelets representation that is supported on this tree may be computed. For example, Ω′ may be a child of Ω in a segmentation tree, that is, Ω′⊂Ω and Ω′ was created by the curved partition of Ω. The polynomial approximations Q Ω , Q Ω′  that were found for these domains by a local minimization such as (1.5) may be used, and a geometric wavelet may be defined as: 
         [0000]      ψ Ω′ :=ψ Ω′ ( f ):=1 Ω′ ( Q   Ω′   −Q   Ω ).  (1.6) 
         [0033]    Accordingly, the geometric wavelet may be associated with the sub-region Ω′ and the function f. A reader familiar in the art of Wavelet Theory will notice that ψ Ω′  is a ‘local difference’ component that belongs to the detail space between two levels in the BSP tree, a ‘low resolution’ level associated with Ω and a ‘high resolution’ level associated with Ω′. Also, these wavelets also have the ‘zero moments’ property. That is, if f is locally a polynomial over Ω, then Q Ω′ =Q Ω =f and ψ Ω′ =0. 
         [0034]    Under certain mild conditions on the partition          , the function f may be defined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     f 
                     = 
                     
                       
                         ∑ 
                         
                           Ω 
                           ∈ 
                            
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ψ 
                           Ω 
                         
                          
                         
                           ( 
                           f 
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   ( 
                   1.7 
                   ) 
                 
               
             
             
               
                 
                   
                     ψ 
                     
                       
                         [ 
                         
                           0 
                           , 
                           1 
                         
                         ] 
                       
                       d 
                     
                   
                   := 
                   
                     
                       
                         ψ 
                         
                           
                             [ 
                             
                               0 
                               , 
                               1 
                             
                             ] 
                           
                           d 
                         
                       
                        
                       
                         ( 
                         f 
                         ) 
                       
                     
                     := 
                     
                       
                         Q 
                         
                           
                             [ 
                             
                               0 
                               , 
                               1 
                             
                             ] 
                           
                           d 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   1.8 
                   ) 
                 
               
             
           
         
       
     
         [0035]    The geometric wavelets (1.6) may be computed, and they may be sorted according to their L 2  norm: 
         [0000]      ∥ψ Ω     k   ∥ 2 ≧∥ψ Ω     k   ∥ 2 ≧∥ψ Ω     k   ∥ 2  (1.9) 
         [0000]    As noted earlier, in some embodiments, other ‘energy’ quantifications may be used as a criterion to sort the geometric wavelet contribution/importance. 
         [0036]    In step  406 , given an integer n ε□, a sparse representation or approximation of the input function by the n-term geometric wavelet sum may be extracted: 
         [0000]    
       
         
           
             
               
                 
                   
                     ∑ 
                     
                       j 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                       
                   
                    
                   
                     
                       ψ 
                       
                         Ω 
                         
                           k 
                           j 
                         
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   1.10 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The sum (1.10) may be, in some sense, a generalization of the classical n-term wavelet approximation where the wavelets are constructed over dyadic cubes. As with classical wavelets, the n-term strategy may be used for progressive approximation and rate-distortion control, where more geometric wavelets may be added according to their order in (1.9). 
         [0037]      FIG. 5  illustrates an exemplary flow diagram for generating a segmentation tree using active contours in accordance with an embodiment of the present invention. Referring to  FIG. 5 , there is shown steps  500  to  504  that may be an expansion of the step  402 . In step  500 , a region may be divided into sub-regions, such as, for example, in the frames  302 ,  304 , and  306 . The sub-regions may then be considered to be regions for segmentation purposes. Accordingly, the sub-region B in frame  302  may be considered to be a region B that may be segmented to sub-regions D and E in the frame  304 . 
         [0038]    In step  502 , a determination may be made as to whether any region can be segmented further. This step may be referred to as, for example, a stage. Various algorithms may be suitable for segmenting an image. For example, an algorithm used may be pre-order traversal, or level-order. The criterion or criteria for determining whether a region can be segmented may be design and/or implementation dependent. For example, a criterion may be the number of pixels in the region. If there is at least one region that can be further segmented, the next step may be step  504 . In step  504 , a region may be selected for segmentation. The next step may be step  500 . Otherwise, there may not be any regions that can be segmented further, and the segmentation may be terminated. The next step may then be step  404 . 
         [0039]    Another embodiment of the invention may provide a machine-readable storage, having stored thereon, a computer program having at least one code section executable by a machine, thereby causing the machine to perform the steps as described above for method and system for using geometric wavelets based on active contours for signal processing. 
         [0040]    While the invention has been described with reference to exemplary embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted for elements thereof without departing from the scope of the invention. In addition, many modifications may be made to adapt a particular situation or material to the teachings of the invention without departing from the essential scope thereof. Therefore, it is intended that the invention not be limited to the particular embodiment disclosed as the best mode contemplated for carrying out this invention, but that the invention will include all embodiments falling within the scope of the appended claims. Moreover, the use of the terms first, second, etc. do not denote any order or importance, but rather the terms first, second, etc. are used to distinguish one element from another.
Certain embodiments provide systems and methods for using geometric wavelets based on active contours for signal processing. Certain embodiments may allow image processing. A system includes providing an image processing circuitry that computes a segmentation tree using active contours for an input image data; creates a geometric wavelets representation using the segmentation tree; and then generate an image based on geometric wavelet sparse representation extracted from the geometric wavelets representation. The geometric wavelet sparse representation may comprise M most active geometric wavelets from a set of N geometric wavelets in the geometric wavelets representation. The image processing circuitry may recursively find sub-domains and multivariate polynomials for each domain at each stage in the computing of the segmentation tree. Each of the sub-domains is a domain for a succeeding stage for the segmentation tree. The recursively finding may be terminated, for example, when each domain at a stage comprises less than a determined number of pixels.