Abstract:
Provided are a digital video rescaling system, a method of rescaling video images, and a chip comprising a computer executable medium embedded therein computer executable instructions for rescaling video images.

Description:
CROSS-REFERENCE TO RELATED APPLICATION(S) AND CLAIM OF PRIORITY 
       [0001]    This application claims the benefit under 35 U.S.C. §119(a) to a Singapore patent application filed in the Intellectual Property Office of Singapore on Dec. 31, 2008 and assigned Serial No. 200809685-1, the entire disclosure of which is hereby incorporated by reference. 
       TECHNICAL FIELD OF THE INVENTION 
       [0002]    The present invention generally relates to the field of digital image processing, and more particularly to a system and process for rescaling digital images using adaptive interpolation kernel with sharpness and overshoot control. 
       BACKGROUND OF THE INVENTION 
       [0003]    Digital images have become more popular in the field of image display because they offer clarity and less distortion during processing. Furthermore, a wider range of image processing algorithms can be applied to digital images. Interpolation is a common stage in image processing to improve the appearance of the processed image on the output imaging medium. Interpolation is often performed during rescaling or resizing of digital images. 
         [0004]    Rescaling or resizing of digital images includes magnification or reduction of image. For example, large screen displays have a native resolution that reaches or exceeds the well-known high-definition TV (HDTV) standard. In order to display a low-resolution digital image on a large screen display, it is desirable to rescale the image to a full screen resolution. 
         [0005]    Traditionally, linear interpolation techniques such as bilinear or bicubic interpolation are used to rescale digital images. However, these linear interpolation techniques have certain drawbacks. For example, the interpolated image may suffer from blurred edges, resulting in a loss in image quality. Furthermore, artifacts such as overshoot and undershoot may be introduced around the edge areas. Therefore, many techniques have been proposed to improve the subjective quality of the interpolated images by using adaptive (interpolation) algorithms. These adaptive algorithms minimize loss in image quality by adapting the interpolation coefficients in the algorithms to better match the local structures around the edges of the image. 
         [0006]    One approach/method for adaptive interpolation of image data is by selecting an appropriate interpolation kernel function from a plurality of different interpolation kernel functions based on one or more factors. The factors can be the input image format, the output imaging media, or the appearance characteristic of the interpolated image data. 
         [0007]    Another approach/method (to provide a representation of image data) is by using a scaled kernel. The scaled kernel is constructed by transforming a kernel from a first range to a second range, where the second range is smaller than the first range. This method can improve the sharpness of the image data without any overshoot problem. However, transforming a kernel from one range to another range creates a dead-zone in the transformed range, which may result in an un-natural edge effect in the interpolated image. 
         [0008]    Yet another approach/method (for digital image interpolation and sharpness enhancement) is by combining two interpolated images with sharpness level control. The two interpolated images are generated by two interpolation filters with different cut-off frequencies. This method will lead to overshoot and undershoot artifacts near the edge areas when using large sharpness control parameters. 
         [0009]    Generally, the three methods as discussed above address the issues of loss in image quality by applying effective global sharpness control. In global sharpness control, the control parameter is fixed for all the pixels. However, the effect of local sharpness control for different characteristics of the image content has not been adequately addressed. For example, while the three methods enhance the sharpness of the edge components, they also tend to amplify the noise in the signal. Furthermore, the three methods are unable to control the sharpness level locally through local sharpness control, thereby causing the weak edges to be enhanced without over-enhancing the strong edges. In local sharpness control, the control parameter is different for each individual pixel. As a result, the methods produce artificial-looking images. 
         [0010]    One approach for local sharpness control is to apply an adaptive enhancement process on different edge magnitudes to achieve good edge enhancement. However, the soft edges can add depth perceptibility to the digital image, and therefore this approach is not suitable for steepening. Furthermore, the hard edges are already steep enough to demand further enhancement. 
         [0011]    As described above, conventional linear interpolation techniques and the existing adaptive techniques suffer from blurred edges or artifacts introduced around edge areas, such as overshoot and undershoot. The conventional techniques generally address the effectiveness of global sharpness control which is based only on different formats of input image data or different types of the output display media. They are not concerned about the local image content. Hence, they are noise sensitive. 
         [0012]    In the case of downscaling, a number of input pixels in the original image are transformed to a single output pixel in the down-sampled image. The frequency sampling interval must be chosen very short based on Nyquist sampling theory in order to transform the entire data from input to output image, which is not feasible in most cases, and aliasing artifacts can be introduced. 
         [0013]    As shown in  FIG. 11 , a conventional image size changing apparatus  1  includes a combination of the horizontal interpolator  2  and the vertical interpolator  5  for interpolating an input image signal SI in both the horizontal and vertical directions using the horizontal and vertical interpolation factors received from the horizontal interpolator factor generator  3  and the vertical interpolator factor generator  6 , respectively. Using the horizontal size change rate received from the horizontal magnification storage  4  and the sync signal timed with the input image signal SI, the horizontal interpolator factor generator  3  produces three horizontal interpolation factors hw 1 , hw 2 , and hw 3 , each having a ratio between a horizontal component of the visual area determined by image data of an original image and a horizontal component of the visual area determined by image data of its size-changed image. The horizontal interpolation factors hw 1 , hw 2 , and hw 3  are timed with a clock signal of which the frequency is two times greater than the pixel clock signal of the input image signal SI. Also produced by the horizontal interpolator factor generator  3  is a horizontal pixel enable signal indicative of effective ones of the pixel data from the horizontal interpolator  2  to be received by the vertical interpolator  5  and a read/write controller  9 . Using the vertical size change rate received from the vertical magnification storage  7  and the syn signal timed with the input image signal SI, the vertical interpolator factor generator  6  produces three vertical interpolation factors vw 1 , vw 2 , and vw 3 , each having a ratio between a vertical component of the visual area determined by image data of an original image and a vertical component of the visual area determined by image data of its size-changed image. The vertical interpolation factors vw 1 , vw 2 , and vw 3  are timed with the horizontal sync signal of the input image signal SI. Also produced by the vertical interpolator factor generator  6  is a vertical pixel enable signal indicative of effective ones of the pixel data from the vertical interpolator  5  to be received by the read/write controller  9 . The read/write controller  9  is responsive to the horizontal pixel enable signal from the horizontal interpolator factor generator  3 , the vertical pixel enable signal from the vertical interpolator factor generator  6 , and the sync signal of the input image SI for controlling the writing of the pixel data received from the vertical interpolator  5  into the field memory  8 . Each interpolator may comprise a group of latch circuits for delaying the input image signal by one pixel period or line memories for delaying the input image signal by one horizontal period, multipliers, and an adder. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0014]    Preferred embodiments according to the present invention will now be described with reference to the Figures, in which like reference numerals denote like elements. 
           [0015]      FIG. 1  illustrates a block diagram of a digital video rescaling system in accordance with one embodiment of the present invention. 
           [0016]      FIG. 2  illustrates a block diagram of the adaptive spline interpolation kernel in accordance with one embodiment of the present invention. 
           [0017]      FIG. 3  illustrates the spline interpolation using four support pixels. 
           [0018]      FIG. 4  illustrates the interpolation curves with different sharpness control parameter values. 
           [0019]      FIG. 5  illustrates the interpolation curves with different overshoot control parameter values. 
           [0020]      FIG. 6  illustrates a block diagram of the adaptive spline interpolation kernel in accordance with one alternative embodiment of the present invention. 
           [0021]      FIG. 7  illustrates neighbourhood pixels for local gradient estimation. 
           [0022]      FIG. 8  illustrates the graphical relationship between the local sharpness control parameter and local gradient values. 
           [0023]      FIG. 9  illustrates a block diagram of the anti-aliasing filter in accordance with one embodiment of the present invention. 
           [0024]      FIG. 10  illustrates the list of coefficients of eight anti-aliasing low pass 7-tap filters according to the predetermined range of downscaling factors. 
           [0025]      FIG. 11  shows a conventional image size changing apparatus. 
       
    
    
     DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS 
       [0026]    The present invention may be understood more readily by reference to the following detailed description of certain embodiments of the invention. 
         [0027]    The present invention provides an effective process of video image rescaling. This process uses a controllable interpolation kernel to generate the interpolated outputs ranging from relatively sharp at one end to relatively soft at the other end. The levels of sharpness and overshoot can be either selected by users using a set of control parameters or adaptively steered by the image contents. In addition, a downscaling process with anti-aliasing low pass filtering is used to generate the downsampled images without aliasing artifacts. 
         [0028]    The present invention provides a system for video image rescaling using a controllable interpolation kernel. The system comprises a global and local sharpness control functionality to generate the interpolated images with the visual qualities ranging from relative sharpness to softness. Furthermore, the system comprises an overshoot control functionality to adjust the levels of overshoot/undershoot effects along the edges in the interpolated images. In addition, a set of anti-aliasing low pass filters are designed and conducted according to a certain range of downscaling factors. 
         [0029]    Now referring to  FIG. 1 , the rescaling system comprises an adaptive spline interpolation kernel  101 , a sharpness control module  102 , an overshoot control module  103 , a local sharpness control module  109 , an anti-aliasing filter  106 , and an input module  108 . The adaptive spline interpolation kernel  101  is coupled to the input module  108  to receive input image data and generate interpolated pixels. The sharpness control module  102  and overshoot control module  103  are configured to generate control parameters for the adaptive spline interpolation kernel  101  to improve the sharpness, and reduce overshoot/undershoot artifacts in edge areas of the image. The local sharpness control module  109  is provided to make the sharpness control module  102  adaptive to the local image content. In addition, the anti-aliasing filter  106  is coupled between the input module  108  and the adaptive spline interpolation kernel  101 , wherein the anti-aliasing filter  106  comprises a set of low pass filters to reduce aliasing artifacts during image downscaling. The interpolation phase calculation  110  is used to calculate the phase value (S) of the pixel to be interpolated in the interpolation processing. 
         [0030]    The adaptive spline interpolation kernel  101  uses a controllable third order polynomial function based on four input support pixels received from the input image data to generate an interpolated pixel. One embodiment of the implementation of the adaptive spline interpolation kernel  101  is shown in  FIG. 2 , wherein the adaptive spline interpolation kernel  101  calculates the interpolated pixel y 1 (x) using a third order polynomial function with sharpness control parameter Kshp. The calculation is performed according to the following Equation 1: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         y 
                         1 
                       
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           
                             n 
                             = 
                             A 
                           
                           , 
                           B 
                           , 
                           C 
                           , 
                           D 
                         
                       
                        
                       
                         
                           y 
                           n 
                         
                         * 
                         
                           
                             f 
                             n 
                           
                            
                           
                             ( 
                             
                               s 
                               , 
                               Kshp 
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     1 
                   
                   ] 
                 
               
             
           
         
       
     
         [0031]    where y A , y B , y C  and y D  are four support pixels from input image data; s is the distance from interpolation position to the position of the support pixel y b  as shown in  FIG. 3 ; and f n (s,Kshp) (n=A, B, C, D) are four control synthesis functions which can be expressed by the following Equations 2-5: 
         [0000]        f   A ( s,Kshp )= Kshp *(− s   3 +2 *s   2   −s )/2,  [Eqn. 2] 
         [0000]        f   B ( s,Kshp )=(3 *Kshp*s   3 −5 *Kshp*s   2 +2*( Kshp− 1)* s+ 2)/2,  [Eqn. 3] 
         [0000]        f   C ( s,Kshp )=(−3 *Kshp*s   3 +4 *Kshp*s   2 +(2−( Kshp )* s )/2, and  [Eqn. 4] 
         [0000]        f   D ( s,Kshp )= Kshp *( s   3   −s   2 )/2.  [Eqn. 5] 
         [0032]    Kshp is the global sharpness control parameter generated from the sharpness control module  102 , wherein Kshp is used to adjust the sharpness of the rescaled image. Kshp has a predetermined range of negative to positive values to control the visual quality of the rescaled images from soft to sharp, wherein a negative Kshp produces a softer rescaled image and a positive Kshp produces a sharper rescaled image.  FIG. 4  illustrates some examples of the interpolation curves driven by different values of the global sharpness control parameter Kshp, wherein the values of Kshp are set at 0.0, 1.0 and 5.0. A larger Kshp value (e.g., Kshp=5.0) produces a steeper interpolation curve as compared to a smaller Kshp value (e.g, Kshp=1.0), and the steeper interpolation curve gives a sharper rescaled image. Therefore, the setting of Kshp value can effectively control the sharpness of the interpolation curve. The value of Kshp can be determined by the user of the system or by the micro-controller (not shown) in the system. 
         [0033]    From  FIG. 4 , it can be observed that large values of Kshp produce overshoot  401  and undershoot  402  effects. Strong overshoot and undershoot effects might result in an artificial-looking rescaled image. Hence, an overshoot/undershoot control parameter Kovs is provided to control the overshoot and undershoot effects. 
         [0034]    Referring back to  FIG. 2 , the adaptive spline interpolation kernel  101  comprises a max-min calculation module  202 , a comparator  203 , and a multiplier  204 . The max-min calculation module  202  is used to calculate the maximum value and the minimum value of the support pixels y B  and y C . The outputs of the max-min calculation module  202  are then compared with the output y 1 (x) of the kernel  201  in comparator  203  to generate the output y 2 (x) according to the following Equation 6: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       y 
                       2 
                     
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             max 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   B 
                                 
                                 , 
                                 
                                   y 
                                   C 
                                 
                               
                               ) 
                             
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     y 
                                     1 
                                   
                                    
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                                 &gt; 
                                 
                                   max 
                                    
                                   
                                     ( 
                                     
                                       
                                         y 
                                         B 
                                       
                                       , 
                                       
                                         y 
                                         C 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             min 
                              
                             
                               ( 
                               
                                 
                                   y 
                                   B 
                                 
                                 , 
                                 
                                   y 
                                   C 
                                 
                               
                               ) 
                             
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     y 
                                     1 
                                   
                                    
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                                 &lt; 
                                 
                                   min 
                                    
                                   
                                     ( 
                                     
                                       
                                         y 
                                         B 
                                       
                                       , 
                                       
                                         y 
                                         C 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             
                               y 
                               1 
                             
                              
                             
                               ( 
                               x 
                               ) 
                             
                           
                         
                         
                           
                             else 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     6 
                   
                   ] 
                 
               
             
           
         
       
     
         [0035]    The outputs y 1 (x) and y 2 (x) are then subtracted to produce an output (y 1 (x)−y 2 (x)). The multiplier  204  multiplies the output (y 1 (x)−y 2 (x)) by the overshoot control parameter Kovs to produce the output Kovs*(y 1 (x)−y 2 (x)). Thereafter, Kovs*(y 1 (x)−y 2 (x)) is added to y 2 (x) to generate the final output y(x) with sharpness and overshoot control according to the following Equation 7: 
         [0000]        y ( x )= Kovs *( y   1 ( x )− y   2 ( x ))+ y   2 ( x ).  [Eqn. 7] 
         [0036]      FIG. 5  illustrates some examples of the interpolation curves having the same Kshp=5.0 but driven by different values of Kovs, wherein the values of Kovs are set at 0.01, 0.5 and 1.0. A smaller Kovs value (e.g., Kovs=0.01) creates a larger reduction of the overshoot  401  and undershoot  402  effects. Therefore, the setting of the Kovs value can effectively control the overshoot and undershoot of the interpolation curve, thereby allowing the rescaling system to produce a more natural-looking image. 
         [0037]    An alternative embodiment of the adaptive spline interpolation kernel with sharpness control  201  is shown in  FIG. 6 , wherein the adaptive spline interpolation kernel with sharpness control  201  comprises a kernel look up table (KernelLUT)  601 , a spline interpolation module  602 , and a linear interpolation module  603 . The adaptive spline interpolation kernel with sharpness control  201  uses the KernelLUT  601  to reduce the complexity of the interpolation process. KernelLUT  601  is a look up table which stores the values of four control synthesis functions. The contents of a look up table can be calculated by the following Equations 8-11: 
         [0000]        f   A ( s )=(− s   3 +2 *s   2   −s )/2,  [Eqn. 8] 
         [0000]        f   B ( s )=(3 *s   3 −5 *s   2 +2)/2,  [Eqn. 9] 
         [0000]        f   C =(−3 *s   3 +4 *s   2   +s )/2, and  [Eqn. 10] 
         [0000]        f   D ( s )=( s   3   −s   2 )/2.  [Eqn. 11] 
         [0038]    The size of this look up table is dependent on the resolution of interpolation, which is initialized at the beginning of the rescaling process. The spline interpolation module  602  is used to calculate the interpolated pixel value y c (X) using the KernelLUT  601 . The interpolation can be obtained according to the following Equation 12: 
         [0000]        y   c ( x )= y ( A )* f   A ( s )+ y ( B )* f   B ( s )+ y ( C )* f   C ( s )+ y ( D )* f   D ( s ).  [Eqn. 12] 
         [0039]    The linear interpolation  603  is used to calculate the interpolated pixel value y t (x) which can be obtained according to the following Equation 13: 
         [0000]        y   t ( x )=(1 −s )* y ( B )+ s*y ( C ).  [Eqn. 13] 
         [0040]    The outputs y c  and y t (x) are then subtracted to produce an output (y c (x)−y t (x)). The multiplier  604  multiplies the output (y c (x)−y t (x)) by the sharpness control parameter Kshp to produce the output Kshp*(y c (x)−y t (x)). Thereafter, Kshp*(y c (x)−y t (x)) is added to y t (x) to generate the final output y 1 (x) with sharpness control according to the following Equation 14: 
         [0000]        y   1 ( x )= Kshp* ( y   c ( x )− y   t ( x ))+ y   t ( x ).  [Eqn. 14] 
         [0041]    Referring back to  FIG. 1 , the rescaling system comprises a local sharpness control module  109  to make the sharpness control module  102  adaptive to the local image content. Generally, the sharpness control is applied according to the local gradient magnitude (Gn) and the noise level (Sigma) estimated from the digital picture or video sequence. The local sharpness control module  109  comprises a local gradient estimation module  104 , a noise level estimator module  107 , and a local sharpness control parameter function module  105 . 
         [0042]    The local gradient estimation module  104  is coupled to the input module  108  to estimate the local gradient magnitude Gn based on a 3×3 neighbourhood window (shown in  FIG. 7 ) from the input image data. The local gradient estimation module  104  calculates the local gradient magnitude Gn according to the following Equation 15: 
         [0000]        G   n =( abs ( X 0+2 *X 1+ X 2−( X 6+2 *X 7 +X 8))+ abs ( X 0+2 *X 3 +X 6−( X 2+2 *X 5 +X 8)))/8.  [Eqn. 15] 
         [0043]    The noise level estimator module  107  is coupled to the input module  108  to estimate the noise level Sigma from the input image or video. An example of a suitable noise level estimator or detector is disclosed in U.S. Pat. No. 5,657,401, the content of which is incorporated herein by reference. Alternatively, the noise level can be predetermined before transmitting it to the system so as to simplify the implementation of the system. 
         [0044]    The local gradient estimation module  104  and the noise level estimator module  107  are both coupled to the local sharpness control parameter function module  105 , wherein the local gradient estimation module  104  transmits the local gradient magnitude Gn to the local sharpness control parameter function module  105 , and wherein the noise level estimator module  107  transmits the noise level Sigma to the local sharpness control parameter function module  105 . The local sharpness control parameter function module  105  is configured to control the sharpness control module  102  using a transfer function, wherein the transfer function indicates the relationship between the control parameter Kshp and the local image content.  FIG. 8  illustrates an example of the transfer function Kshp(Gn), wherein the transfer function Kshp(Gn) can be defined according to the following Equation 16: 
         [0000]        Kshp ( Gn )= AKshp ( Gn )+ GKshp.   [Eqn. 16] 
         [0045]    GKshp is a fixed value that is defined by the global sharpness control parameter Kshp. AKshp(Gn) is a variable value that is defined by the control parameters max K, min K, K 1 , K 2 , K 3 , and Sigma. The AKshp(Gn) can be expressed by a transfer function according to the following Equation 17: 
         [0000]    
       
         
           
             
               
                 
                   
                     AKshp 
                      
                     
                       ( 
                       
                         G 
                         n 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 
                                    
                                   
                                     min 
                                      
                                     
                                         
                                     
                                      
                                     K 
                                   
                                    
                                 
                                 * 
                                 
                                   G 
                                   n 
                                 
                               
                               Sigma 
                             
                             + 
                             
                               min 
                                
                               
                                   
                               
                                
                               K 
                             
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   G 
                                   n 
                                 
                                 ≤ 
                                 Sigma 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             
                               max 
                                
                               
                                   
                               
                                
                               K 
                               * 
                               
                                 ( 
                                 
                                   
                                     G 
                                     n 
                                   
                                   - 
                                   Sigma 
                                 
                                 ) 
                               
                             
                             
                               
                                 K 
                                  
                                 
                                     
                                 
                                  
                                 1 
                               
                               - 
                               Sigma 
                             
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 Sigma 
                                 &lt; 
                                 
                                   G 
                                   n 
                                 
                                 ≤ 
                                 
                                   K 
                                    
                                   
                                       
                                   
                                    
                                   1 
                                 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             max 
                              
                             
                                 
                             
                              
                             K 
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   K 
                                    
                                   
                                       
                                   
                                    
                                   1 
                                 
                                 &lt; 
                                 
                                   G 
                                   n 
                                 
                                 ≤ 
                                 
                                   K 
                                    
                                   
                                       
                                   
                                    
                                   2 
                                 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           
                             
                               max 
                                
                               
                                   
                               
                                
                               K 
                               * 
                               
                                 ( 
                                 
                                   
                                     K 
                                      
                                     
                                         
                                     
                                      
                                     3 
                                   
                                   - 
                                   
                                     G 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             
                               
                                 K 
                                  
                                 
                                     
                                 
                                  
                                 3 
                               
                               - 
                               
                                 K 
                                  
                                 
                                     
                                 
                                  
                                 2 
                               
                             
                           
                         
                         
                           
                             if 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   K 
                                    
                                   
                                       
                                   
                                    
                                   2 
                                 
                                 &lt; 
                                 
                                   G 
                                   n 
                                 
                                 ≤ 
                                 
                                   K 
                                    
                                   
                                       
                                   
                                    
                                   3 
                                 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           0 
                         
                         
                           
                             else 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     17 
                   
                   ] 
                 
               
             
           
         
       
     
         [0046]    When the local gradient magnitude value (Gn) is lower than the noise level Sigma, the pixels are considered as being corrupted by noise. In this case, the sharpness control value will be lower than GKshp and decreases linearly to a minimum value (min K+GKshp), as illustrated by segment  801  in  FIG. 8 . When Gn is between the range of Sigma and K 1 , the sharpness control value increases linearly to achieve the maximum value (max K+GKshp) as illustrated by segment  802 . The sharpness control value is kept at the constant value (maxK+GKshp) until the Gn is larger than K 2 . The pixels with gradient magnitudes Gn falling in the segment  802  and segment  803  are considered as low and middle edges, respectively. Hence, higher sharpness control parameter values are used on these edge pixels. On the other hand, pixels with gradient magnitude Gn that is larger than K 2  are considered as large edge pixels. The sharpness control parameter value then decreases linearly as shown by segment  804 . For gradient magnitude Gn that is larger than K 3 , the sharpness control parameter value is kept constant at GKshp as shown by segment  805 . 
         [0047]    Referring back to  FIG. 1 , the rescaling system further comprises the anti-aliasing filter  106  to reduce any aliasing artifacts during image downscaling. In particular, the input image data is coupled to the anti-aliasing filter  106  via a switch device  111 . The switch device  111  is configured to select or bypass the anti-aliasing filter  106  depending on the rescaling factor. Suppose the rescaling factor is more than 1, the switch device  111  would bypass the anti-aliasing filter  106 . If the rescaling factor is less than 1, the switch device  111  would select the anti-aliasing filter  106 . The anti-aliasing filter  106  then processes the input image data and sends a filtered image data to the adaptive spline interpolation kernel  101 . 
         [0048]    The anti-aliasing filter  106  comprises a plurality of 1 D low pass filters that are activated according to a predetermined range of downscaling factors.  FIG. 9  illustrates a block diagram of the anti-aliasing filter  106 , which comprises a low pass filtering module  901  and a low pass filter bank  902 . During downscaling, one set of filter coefficients, h(m), is selected from the low pass filter bank  902  according to the downscaling factor. The selected set of filter coefficients are then applied on the input image data in the low pass filtering module  901  to produce the filtered image data to the adaptive spline interpolation kernel  101  according to the following Equation 18: 
         [0000]    
       
         
           
             
               
                 
                   
                     y 
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         
                           n 
                           - 
                           
                             m 
                             / 
                             2 
                           
                         
                       
                       
                         n 
                         + 
                         
                           m 
                           / 
                           2 
                         
                       
                     
                      
                     
                       
                         h 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                       * 
                       
                         
                           Y 
                            
                           in 
                         
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     18 
                   
                   ] 
                 
               
             
           
         
       
     
         [0049]    where m is the length of the filter. 
         [0050]    The low pass filter coefficients stored in the low pass filter bank  902  are designed using finite impulse response (FIR) filter design methods based on adjustable Hanning window. The cutoff frequencies used in the filter design depend on the downscaling factors. Therefore, different downscaling factors correspond to different low pass filters. In one embodiment, eight filters are operated according to eight pre-divided ranges of downscaling factors.  FIG. 10  shows an example of eight sets of 7-tap low pass filter coefficients that are stored in the low pass filter bank  901 . Furthermore, the effective range of the downscaling factors is 0.20 to 0.99. 
         [0051]    While this detailed description has set forth some embodiments of the present invention, the appended claims are sufficiently supported to cover and will cover other embodiments of the present invention which differ from the described embodiments according to various modifications and improvements.