Abstract:
Low spatial frequencies of an original image and an upscaled filtered image are analyzed. Differences will be observed in the low frequency components of the two images in the general case since the pixel art upscaler filter as a side effect introduces low frequency changes. A modification to images produced by the PAU is applied to attempt to match the brightness of the original images in the low frequency spectrum. From a viewer perspective (e.g., based on typical blurring visual effects), the original image and the modified filtered image will look the same—demonstrating that there is no low frequency brightness creep or resulting increased photosensitivity concerns.

Description:
FIELD 
       [0001]    The technology herein relates to filtering to improve the visual quality on higher resolution display images. In example embodiments, images are digitally scaled to a higher resolution and then compensated for brightness changes to avoid photosensitivity. 
       BACKGROUND AND SUMMARY 
       [0002]    Just as the ancients constructed mosaics from squares of colored glass or stone, a pixel art graphics artist selects the color of each pixel in a pixel art image from a color palette. The video game and computer hardware of the 1980&#39;s and 1990&#39;s imposed limitations that channeled graphics designers toward pixel art. Some of the best loved video game characters and graphics of all time were created using pixel art. While modern graphics artists generally have more flexibility, some have chosen to use pixel art for aesthetic or other reasons. 
         [0003]    Display resolution has increased dramatically over the last twenty years. Early home video game systems had display resolutions on the order of about 250×250 pixels or less. Currently, high definition televisions have display resolutions of 1920×1080 pixels, and some modern computer displays have even higher display resolution. When one attempts to use higher resolution displays to display lower resolution pixel art, the result can be unsatisfactory. Whereas early lower resolution displays might have tended to blur pixels together to create an aesthetically pleasing effect, higher resolution displays tend to bring out the blocky (pixelated) constitution of pixel art. The resulting images are not aesthetically pleasing. 
         [0004]    A common solution is to “upscale” the pixel art images for rendering on modern displays. This often means replacing each pixel in the original image with a block of higher resolution pixels, and performing some type of filtering to smooth the resulting image. Various techniques are known for performing such upscaling. See for example Kopf et al, “Depixelizing Pixel Art” (Microsoft Research 2011). 
         [0005]    One example non-limiting Pixel Art Upscaler (“PAU”) is a process that creates, from an input picture, a picture with a 2×2 resolution increase. This algorithm works well on images that contain pixel art, namely hand-made low resolution images using palletized colors, that are characterized by flat colors and outlines. The purpose of such a PAU algorithm is to upscale the original picture, while trying to keep the flat colors and the intended hard edges and reducing or removing the staircase effect of the original picture. In particular, the goal of the PAU is to modify high frequencies in the image to make edges sharper. 
         [0006]    This process is successful but has been identified to have a side effect of potentially modifying the brightness of certain areas compared to the original image for example, to modify low frequency spatial components in a way that causes the upscaled image to exhibit local brightness changes. Such modified brightness can cause concerns regarding photosensitivity. Work has been done in the past to analyze video for photosensitivity (see for example HardingFPA software available from Cambridge Research Systems, Ltd.) but further improvements are possible and desirable. 
         [0007]    The example non-limiting technology herein provides a filtering algorithm that compensates for brightness modification so that moving images including but not limited to video games that are already compliant with photosensitivity guidelines can benefit from PAU without losing their compliance. One advantage provided by the example non-limiting technology herein is that in the context of a brightness-compensated real time pixel upscaler, image streams tested for photosensitivity before upscaling do not need to be retested after upscaling. Meanwhile, the example non-limiting technology herein can be used in any context where real time or other flash or brightness compensation is desired irrespective of previous testing and/or image source. 
         [0008]    In one example non-limiting implementation, the system analyzes the low spatial frequencies of the original image and of the upscaled filtered image. Differences will be observed in the low frequency components of the two images in the general case since the PAU filter as a side effect introduces low frequency changes. The example non-limiting implementation applies a modification to images produced by the PAU to attempt to match the brightness of the original images in the low frequency spectrum. Such matching can be accomplished for example by simple brightness subtraction on a pixel by pixel or other localized basis. From a viewer perspective (e.g., based on typical blurring visual effects), the original image and the modified filtered image will look the same demonstrating that there is no low frequency brightness creep. 
         [0009]    The example non-limiting technology herein uses a concept that could be called filter band limiting. It modifies any filter into a filter that will correctly preserve low spatial frequencies (i.e., the source and destination images will appear identical or nearly identical when blurred). This process can effectively be used to improve, or make photosensitive-safe, any image filter such as denoising filters, deblocking filters, deblurring filters or other filters. 
         [0010]    The example non-limiting technology herein thus provides systems and methods that guarantee that, whatever artifacts are introduced by pixel art or other upscaling, they do not incur any global brightness modifications. The resulting images are very close to being as safe as the original images in terms of photosensitivity. 
         [0011]    Furthermore, the example non-limiting safe filter can be implemented on a central processing unit, a graphics processing unit, using embedded logic, or using any other specific, specialized or general purpose hardware. Additionally, television sets or any other display devices could benefit from the example non-limiting safe filter after applying their own filters, such as for example upscaling, deinterlacing, and/or noise reduction. Such a filter can also be inserted in broadcast TV company production systems, or movie post production systems. Many other applications are possible. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0012]    These and other features and advantages may be better and more completely understood by referring to the following detailed description of example non-limiting embodiments and implementations in conjunction with the drawings. The patent or application file contains at least one drawing executed in color. Copies of this patent or patent application publication with color drawing(s) will be provided by the Office upon request and payment of the necessary fee. The drawings include the following: 
           [0013]      FIG. 1  shows applying an example non-limiting pixel art upscaling (PAU) algorithm on a grid of black dots, which can be seen to increase luminance. 
           [0014]      FIG. 2  shows that applying an example non-limiting PAU algorithm on a checkerboard with small variations can reveal underlying patterns. 
           [0015]      FIG. 3  shows comparison between an original image (left), a PAU image (center) and an expected result with brightness compensation (right). Note the differences that occur in the checkerboard pattern. Also, see how some colors were darkened by PAU and brought back by brightness compensation, like in the o of Yoshi, or little details in the character (eyes, hair . . . ). 
           [0016]      FIG. 4  shows an example non-limiting definition of a discrete filter. 
           [0017]      FIG. 5  shows an example non-limiting definition of an ideal downsampling. 
           [0018]      FIG. 6  shows an example non-limiting kernel of the Lanczos2 filter for D=2 (left) and its Fourier transform (right). 
           [0019]      FIG. 7  shows an example non-limiting definition of input image pixel indexes from output pixel coordinates (i,j). Color of the output pixel i, j is computed as a linear combination of input pixels 0 to 3. This linear combination is, in one example non-limiting implementation, chosen from a table using conditions on colors of pixels 0 to 5. 
           [0020]      FIG. 7A  shows an example non-limiting block diagram of a system including a processor and a graphics processor. 
           [0021]      FIG. 8  shows an example non-limiting brightness compensation process. 
           [0022]      FIG. 9  shows an example non-limiting flowchart. 
       
    
    
     DETAILED DESCRIPTION 
       [0023]    Generally speaking, those skilled in the art will understand that there can be two aspects of photosensitivity issues: flashes over a large portion of the screen, and regular patterns over a large portion of the screen. The example non-limiting embodiments focus on ensuring that safe pixel art upscaling (“SPAU”) does not create photosensitivity issues that the original image did not cause. 
         [0024]    When magnified or upscaled by a pixel art upscaler (PAU), most non-linear images will tend to exhibit some kind of brightness change. In particular, repeated patterns in an original image can create local brightness changes that some might say are potentially problematic.  FIGS. 1 and 2  show some examples of effects.  FIG. 1  shows a case where PAU can modify luminance in an area. This can create potentially harmful flashes if consecutive images have their brightness modified in opposite directions. To remove this risk, example non-limiting filtering algorithms will compensate brightness changes to make sure that the original image and the SPAU filtered image have the same brightness when measured over medium to large screen areas. (In fact, a low pass filter of the original image will be identical to a low pass filter of the SPAU filtered image in one example implementation). 
         [0025]      FIG. 2  shows that PAU can reveal patterns when the original image has two characteristics: 
         [0026]    a low frequency pattern that comes from the background, 
         [0027]    a high frequency signal with a high amplitude that does not trigger a failure of the Harding Flash and Pattern Analyzer (“FPA”) test is present in the original image—in this case the checkerboard pattern. 
         [0028]    When this happens, the PAU can reveal the underlying pattern by smoothing out the high frequency signal, thus revealing the low frequency pattern and increasing its contrast by using the energy of the former high frequency signal. The brightness compensation will reduce the contrast of such patterns. 
         [0029]    Moreover, it is expected that, as a positive side effect, SPAU will produce images of better quality regarding their faithfulness to original images as in  FIG. 3 . In particular,  FIG. 3  shows a comparison between an original image (left), a PAU image (center) and an expected result with SPAU (right). Note the differences that occur in the checkerboard pattern. Also, see how some colors were darkened by PAU and brought back by brightness compensation, like in the o of Yoshi, or little details in the character (eyes, hair . . . ). 
         [0030]    Example Non-Limiting Digital Signal Processing Elements 
         [0031]    This section will remind us of some useful results from digital signal processing theory. See Proakis et al,  Digital Signal Processing  (Pearson Prentice Hall, Fourth Edition, 2007) for more details. 
         [0032]    In this section, we will work on one-dimensional signals on a variable, t, which we will call time for simplicity. However, results are transposable to spatial signals, like images (see below). 
         [0033]    Fourier Transform 
         [0034]    The Fourier transform is well known. We will remind here some known properties, without giving proof as they can be found in general reference books about the subject (see e.g., Proakis text). 
         [0035]    Given an analog signal x(t), defined over time, we can compute its Fourier transform X(F), defined over frequencies, as: 
         [0000]    
       
         
           
             
               
                 
                   
                     X 
                      
                     
                       ( 
                       F 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           t 
                           ) 
                         
                       
                        
                       
                          
                         
                           
                             - 
                             j 
                           
                            
                           
                               
                           
                            
                           2 
                            
                           π 
                            
                           
                               
                           
                            
                           Ft 
                         
                       
                        
                       
                          
                         t 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0036]    The Fourier transform is a reversible operation: 
         [0000]    
       
         
           
             
               
                 
                   
                     x 
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         X 
                          
                         
                           ( 
                           F 
                           ) 
                         
                       
                        
                       
                          
                         
                           j2π 
                            
                           
                               
                           
                            
                           Ft 
                         
                       
                        
                       
                          
                         F 
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0037]    We will note: 
         [0000]    
       
         
           
             
               x 
                
               
                 ( 
                 t 
                 ) 
               
             
              
             
                
               ℱ 
             
              
             
               X 
                
               
                 ( 
                 F 
                 ) 
               
             
           
         
       
     
         [0038]    The Fourier transform has some useful properties, among which is the convolution theorem, that states that a convolution of signals in the time domain is equivalent to multiplying their spectra in the frequency domain. 
         [0039]    If: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         x 
                         1 
                       
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                      
                     
                        
                       ℱ 
                     
                      
                     
                       
                         X 
                         1 
                       
                        
                       
                         ( 
                         F 
                         ) 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   and 
                    
                   
                     
 
                   
                    
                   
                     
                       
                         x 
                         2 
                       
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                      
                     
                        
                       ℱ 
                     
                      
                     
                       
                         X 
                         2 
                       
                        
                       
                         ( 
                         F 
                         ) 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       then 
                        
                       
                         
 
                       
                       ( 
                       
                         
                           x 
                           1 
                         
                         * 
                         
                           x 
                           2 
                         
                       
                       ) 
                     
                      
                     
                       
                         ( 
                         t 
                         ) 
                       
                        
                       
                          
                         ℱ 
                       
                        
                       
                         
                           X 
                           1 
                         
                          
                         
                           ( 
                           F 
                           ) 
                         
                       
                     
                      
                     
                       
                         X 
                         2 
                       
                        
                       
                         ( 
                         F 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0040]    The opposite relation is also true: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       1 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                    
                   
                     
                       
                         x 
                         2 
                       
                        
                       
                         ( 
                         t 
                         ) 
                       
                     
                      
                     
                        
                       ℱ 
                     
                      
                     
                       ( 
                       
                         
                           X 
                           1 
                         
                         * 
                         
                           X 
                           2 
                         
                       
                       ) 
                     
                   
                    
                   
                     ( 
                     F 
                     ) 
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0041]    This property will be used in the sections below. 
         [0042]    Sampling Theorem and Ideal Reconstruction 
         [0043]    Sampling is the process of converting an analog signal, say x a (t), into a discrete sequence x(n) by taking samples of x a (t) with a period of T s . F 5 =1/T s  is then the sampling frequency. 
         [0000]        x ( n )= x   a ( nT   s ), nε                 (5)
 
         [0044]    The Nyquist-Shannon sampling theorem states that if x a (t) is bandlimited, i.e., it does not contain any frequency greater than B, it can be uniquely recovered from its samples provided that the sampling frequency F s  verifies: F s ≧2B. 
         [0045]    Then, the analog signal x a (t) could be reconstructed from x(n) by the following formula: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       a 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         
                           - 
                           ∞ 
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                        
                       
                         sinc 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 
                                   
                                     F 
                                     s 
                                   
                                    
                                   t 
                                 
                                 - 
                                 n 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where sinc is the unnormalized sinc function: 
         [0000]    
       
         
           
             
               
                 
                   
                     sinc 
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 sin 
                                  
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                               x 
                             
                             , 
                           
                         
                         
                           
                             x 
                             ≠ 
                             0 
                           
                         
                       
                       
                         
                           1. 
                         
                         
                           
                             x 
                             = 
                             0 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0046]    We should note that, as sinc is the Fourier transform of a gate function, and using the fact that a convolution in temporal space is equivalent to a multiplication in frequency space, this reconstruction can be seen as a low pass filtering of the discrete signal. 
         [0047]    Ideal Filter 
         [0048]    Ideal analog filter: We will define an ideal filter on an analog signal as a filter that removes all frequencies above given frequency F cut , and keeps all lower frequencies as equals. 
         [0049]    Given an analog signal x a (t), we can compute its Fourier transform X a (F) as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       X 
                       a 
                     
                      
                     
                       ( 
                       F 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         
                           x 
                           a 
                         
                          
                         
                           ( 
                           t 
                           ) 
                         
                       
                        
                       
                          
                         
                           
                             - 
                             j 
                           
                            
                           
                               
                           
                            
                           2 
                            
                           π 
                            
                           
                               
                           
                            
                           Ft 
                         
                       
                        
                       
                          
                         t 
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0050]    Multiplying X a (F) by a gate function 
         [0000]    
       
         
           
             
               
                 
                   
                     G 
                      
                     
                       ( 
                       F 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               1 
                               , 
                             
                           
                           
                             
                               
                                  
                                 F 
                                  
                               
                               ≤ 
                               
                                 F 
                                 cut 
                               
                             
                           
                         
                         
                           
                             
                               0 
                               , 
                             
                           
                           
                             
                               
                                  
                                 F 
                                  
                               
                               &gt; 
                               
                                 F 
                                 cut 
                               
                             
                           
                         
                       
                        
                       
                         
 
                       
                        
                       so 
                        
                       
                           
                       
                        
                       that 
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         X 
                         ⋓ 
                       
                       a 
                     
                      
                     
                       ( 
                       F 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         X 
                         a 
                       
                        
                       
                         ( 
                         F 
                         ) 
                       
                     
                      
                     
                       G 
                        
                       
                         ( 
                         F 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0051]    we can then take the inverse Fourier transform of {hacek over (X)}, a (F) to construct a {hacek over (x)}, a (t): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         x 
                         ⋓ 
                       
                       a 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         
                           
                             X 
                             ⋓ 
                           
                           a 
                         
                          
                         
                           ( 
                           F 
                           ) 
                         
                       
                        
                       
                          
                         
                           j2π 
                            
                           
                               
                           
                            
                           Ft 
                         
                       
                        
                       
                          
                         F 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0052]    By construction, {hacek over (x)}, a (t) is the result of applying such ideal filter on x a (t). 
         [0053]    By using the convolution property of the Fourier transform, {hacek over (x)}, a (t) can be computed in time space as 
         [0000]        {hacek over (x)}   a ( t )=( x   a   *g )( t )  (12)
 
         [0054]    where g is the inverse Fourier transform of G: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             t 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             ∫ 
                             
                               - 
                               ∞ 
                             
                             ∞ 
                           
                            
                           
                             
                               G 
                                
                               
                                 ( 
                                 F 
                                 ) 
                               
                             
                              
                             
                                
                               
                                 j2π 
                                  
                                 
                                     
                                 
                                  
                                 Ft 
                               
                             
                              
                             
                                
                               F 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∫ 
                             
                               - 
                               
                                 F 
                                 cut 
                               
                             
                             
                               F 
                               cut 
                             
                           
                            
                           
                             
                                
                               
                                 j2π 
                                  
                                 
                                     
                                 
                                  
                                 Ft 
                               
                             
                              
                             
                                
                               F 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             sinc 
                              
                             
                               ( 
                               
                                 2 
                                  
                                 π 
                                  
                                 
                                     
                                 
                                  
                                 
                                   F 
                                   cut 
                                 
                                  
                                 t 
                               
                               ) 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0055]    Recall that the ideal low pass filter is the convolution with the function sinc (2πF cut t). 
         [0056]    Discrete filter: From an analog filter, we can define a discrete filter on a signal x(n). See  FIG. 4 . This filter should produce the same output as applying the analog filter on signal x a (t), produced by ideal interpolation ( 6 ) of x(n), and then sampling it. 
         [0057]    Let us consider any filter that can be applied on an analog signal as a convolution with a function h(t), called the kernel of the filter: 
         [0000]        {tilde over (x)}   a ( t )=( x   a   *h )( t )  (14)
 
         [0058]    We can then express: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             x 
                             ~ 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               x 
                               ~ 
                             
                             a 
                           
                            
                           
                             ( 
                             
                               nT 
                               s 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ( 
                             
                               
                                 x 
                                 a 
                               
                               * 
                               h 
                             
                             ) 
                           
                            
                           
                             ( 
                             
                               nT 
                               s 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∫ 
                             
                               - 
                               ∞ 
                             
                             ∞ 
                           
                            
                           
                             
                               
                                 x 
                                 a 
                               
                                
                               
                                 ( 
                                 τ 
                                 ) 
                               
                             
                              
                             
                               h 
                                
                               
                                 ( 
                                 
                                   
                                     nT 
                                     s 
                                   
                                   - 
                                   τ 
                                 
                                 ) 
                               
                             
                              
                             
                                
                               τ 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0059]    Using the reconstruction formula (6) for x a , 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 x 
                                 ~ 
                               
                                
                               
                                 ( 
                                 n 
                                 ) 
                               
                             
                             = 
                               
                              
                             
                               
                                 ∫ 
                                 
                                   - 
                                   ∞ 
                                 
                                 ∞ 
                               
                                
                               
                                 
                                   ( 
                                   
                                     
                                       ∑ 
                                       
                                         i 
                                         = 
                                         
                                           - 
                                           ∞ 
                                         
                                       
                                       ∞ 
                                     
                                      
                                     
                                       
                                         x 
                                          
                                         
                                           ( 
                                           i 
                                           ) 
                                         
                                       
                                        
                                       
                                         sinc 
                                          
                                         
                                           ( 
                                           
                                             π 
                                              
                                             
                                               ( 
                                               
                                                 
                                                   
                                                     F 
                                                     s 
                                                   
                                                    
                                                   τ 
                                                 
                                                 - 
                                                 i 
                                               
                                               ) 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   ) 
                                 
                                  
                                 
                                   h 
                                    
                                   
                                     ( 
                                     
                                       
                                         nT 
                                         s 
                                       
                                       - 
                                       τ 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                           ) 
                         
                          
                         
                            
                           τ 
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             
                               = 
                                 
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     
                                       - 
                                       ∞ 
                                     
                                   
                                   ∞ 
                                 
                                  
                                 
                                   
                                     x 
                                      
                                     
                                       ( 
                                       i 
                                       ) 
                                     
                                   
                                    
                                   
                                     
                                       ∫ 
                                       
                                         - 
                                         ∞ 
                                       
                                       ∞ 
                                     
                                      
                                     
                                       
                                         sinc 
                                          
                                         
                                           ( 
                                           
                                             π 
                                              
                                             
                                               ( 
                                               
                                                 
                                                   
                                                     F 
                                                     s 
                                                   
                                                    
                                                   τ 
                                                 
                                                 - 
                                                 i 
                                               
                                               ) 
                                             
                                           
                                           ) 
                                         
                                       
                                        
                                       
                                         h 
                                          
                                         
                                           ( 
                                           
                                             
                                               nT 
                                               s 
                                             
                                             - 
                                             τ 
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             ) 
                           
                            
                           
                              
                             τ 
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
         [0060]    and, with a simple change in variable, 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       ~ 
                     
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         
                           - 
                           ∞ 
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       
                         
                           ∫ 
                           
                             - 
                             ∞ 
                           
                           ∞ 
                         
                          
                         
                           
                             sinc 
                              
                             
                               ( 
                               
                                 π 
                                  
                                 
                                   ( 
                                   
                                     
                                       F 
                                       s 
                                     
                                      
                                     τ 
                                   
                                   ) 
                                 
                               
                               ) 
                             
                           
                            
                           
                             h 
                              
                             
                               ( 
                               
                                 
                                   
                                     ( 
                                     
                                       n 
                                       - 
                                       i 
                                     
                                     ) 
                                   
                                    
                                   
                                     T 
                                     s 
                                   
                                 
                                 - 
                                 τ 
                               
                               ) 
                             
                           
                            
                           
                              
                             τ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0061]    The integral can be identified as a convolution of sinc (π(F s t)) with h(t). We have seen that such convolution is a low pass filter, with F cut =½F s . 
         [0062]    Let {hacek over (h)},(t) be the low-pass filtered version of h(t): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       h 
                       ⋓ 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         sinc 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 
                                   F 
                                   s 
                                 
                                  
                                 τ 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                        
                       
                         h 
                          
                         
                           ( 
                           
                             t 
                             - 
                             τ 
                           
                           ) 
                         
                       
                        
                       
                          
                         τ 
                       
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0063]    Then the filtering of a digital signal can be defined as the convolution with a sampled version of the kernel h(t), previously filtered to contain no frequency greater than ½F s . 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       ~ 
                     
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         
                           - 
                           ∞ 
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       
                         
                           h 
                           ˘ 
                         
                          
                         
                           ( 
                           
                             
                               ( 
                               
                                 n 
                                 - 
                                 i 
                               
                               ) 
                             
                              
                             
                               T 
                               s 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0064]    Ideal discrete filter: Let us now consider an ideal analog filter where 
         [0000]        h ( t )=sinc(2π F   cut   t )  (20)
 
         [0065]    As the Fourier transform of h(t) is a gate function between −F cut  and F cut , and assuming that F cut &lt;½F 5 , the low-pass filtering of h(t) (18) has no effect: 
         [0000]      {hacek over ( h )}( t )= h ( t )  (21)
 
         [0066]    An ideal discrete filter is then a convolution with a discrete sinc: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       ˘ 
                     
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         
                           - 
                           ∞ 
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             2 
                              
                             
                                 
                             
                              
                             π 
                              
                             
                                 
                             
                              
                             
                               
                                 F 
                                 cut 
                               
                               
                                 F 
                                 s 
                               
                             
                              
                             
                               ( 
                               
                                 n 
                                 - 
                                 i 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0067]    This provides a mathematical definition of an ideal discrete filter. As sinc has an infinite support, it cannot be used to derive a computable filter. Nevertheless, it can be approximated very closely by realizable filters. 
         [0068]    Ideal downsampler: Using the sampling theorem, an ideal filtered signal, x, {hacek over ( )}(n), could be resampled at frequency F s =2F cut  without losing any information. 
         [0069]    We will define an ideal downsampling at frequency F s2  of a discrete signal x(n), originally sampled at frequency F s1 , as producing a signal {hacek over (x)},(n), from which a low-pass filtered version of x(n) with F cut =½F s2  can be reconstructed. See  FIG. 5  definition of an ideal downsampling. 
         [0070]    We can define {hacek over (x)},(n) by sampling {hacek over (x)}, a (t): 
         [0000]      {hacek over ( x )}( n )= {hacek over (x)}   a ( nT   s2 )  (23)
 
         [0000]    where {hacek over (x)}, a (t) is a low-pass filtering of x a (t): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         x 
                         ˘ 
                       
                       a 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         
                           x 
                           a 
                         
                          
                         
                           ( 
                           τ 
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             π 
                              
                             
                                 
                             
                              
                             
                               
                                 F 
                                 
                                   s 
                                    
                                   
                                       
                                   
                                    
                                   2 
                                 
                               
                                
                               
                                 ( 
                                 
                                   t 
                                   - 
                                   τ 
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                        
                       
                           
                       
                        
                       
                          
                         τ 
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0071]    Using the reconstruction formula for x a (t) as in (16): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             x 
                             ˇ 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             ∫ 
                             
                               - 
                               ∞ 
                             
                             ∞ 
                           
                            
                           
                             
                               ( 
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     
                                       - 
                                       ∞ 
                                     
                                   
                                   ∞ 
                                 
                                  
                                 
                                   
                                     x 
                                      
                                     
                                       ( 
                                       i 
                                       ) 
                                     
                                   
                                    
                                   sin 
                                    
                                   
                                       
                                   
                                    
                                   
                                     c 
                                      
                                     
                                       ( 
                                       
                                         π 
                                          
                                         
                                           ( 
                                           
                                             
                                               
                                                 F 
                                                 
                                                   s 
                                                    
                                                   
                                                       
                                                   
                                                    
                                                   1 
                                                 
                                               
                                                
                                               τ 
                                             
                                             - 
                                             i 
                                           
                                           ) 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                               ) 
                             
                              
                             sin 
                              
                             
                                 
                             
                              
                             
                               c 
                                
                               
                                 ( 
                                 
                                   π 
                                    
                                   
                                       
                                   
                                    
                                   
                                     F 
                                     
                                       s 
                                        
                                       
                                           
                                       
                                        
                                       2 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         nT 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       - 
                                       τ 
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                              
                             
                                 
                             
                              
                             
                                
                               τ 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               
                                 - 
                                 ∞ 
                               
                             
                             ∞ 
                           
                            
                           
                             
                               x 
                                
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                              
                             
                               
                                 ∫ 
                                 
                                   - 
                                   ∞ 
                                 
                                 ∞ 
                               
                                
                               
                                 sin 
                                  
                                 
                                     
                                 
                                  
                                 c 
                                  
                                 
                                   ( 
                                   
                                     π 
                                      
                                     
                                       ( 
                                       
                                         
                                           
                                             F 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               1 
                                             
                                           
                                            
                                           τ 
                                         
                                         - 
                                         i 
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                                  
                                 sin 
                                  
                                 
                                     
                                 
                                  
                                 
                                   c 
                                    
                                   
                                     ( 
                                     
                                       π 
                                        
                                       
                                           
                                       
                                        
                                       
                                         F 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             nT 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               2 
                                             
                                           
                                           - 
                                           τ 
                                         
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                    
                                   τ 
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               
                                 - 
                                 ∞ 
                               
                             
                             ∞ 
                           
                            
                           
                             
                               x 
                                
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                              
                             
                               
                                 ∫ 
                                 
                                   - 
                                   ∞ 
                                 
                                 ∞ 
                               
                                
                               
                                 sin 
                                  
                                 
                                     
                                 
                                  
                                 
                                   c 
                                    
                                   
                                     ( 
                                     
                                       π 
                                        
                                       
                                         ( 
                                         
                                           
                                             F 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               1 
                                             
                                           
                                            
                                           τ 
                                         
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 sin 
                                  
                                 
                                     
                                 
                                  
                                 
                                   c 
                                    
                                   
                                     ( 
                                     
                                       π 
                                        
                                       
                                           
                                       
                                        
                                       
                                         F 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             nT 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               2 
                                             
                                           
                                           - 
                                           
                                             iT 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               1 
                                             
                                           
                                           - 
                                           τ 
                                         
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                    
                                   τ 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
         [0072]    The integral is the convolution of two sinc. As in the construction of the ideal discrete filter, this simplifies to the lower frequency sinc, in our case, the second one with frequency F s2 : 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             x 
                             ˇ 
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               
                                 - 
                                 ∞ 
                               
                             
                             ∞ 
                           
                            
                           
                             
                               x 
                                
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                              
                             sin 
                              
                             
                                 
                             
                              
                             
                               c 
                                
                               
                                 ( 
                                 
                                   π 
                                    
                                   
                                       
                                   
                                    
                                   
                                     
                                       F 
                                       
                                         s 
                                          
                                         
                                             
                                         
                                          
                                         2 
                                       
                                     
                                      
                                     
                                       ( 
                                       
                                         
                                           nT 
                                           
                                             s 
                                              
                                             
                                                 
                                             
                                              
                                             2 
                                           
                                         
                                         - 
                                         
                                           iT 
                                           
                                             s 
                                              
                                             
                                                 
                                             
                                              
                                             1 
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               
                                 - 
                                 ∞ 
                               
                             
                             ∞ 
                           
                            
                           
                             
                               x 
                                
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                              
                             sin 
                              
                             
                                 
                             
                              
                             
                               c 
                                
                               
                                 ( 
                                 
                                   π 
                                    
                                   
                                     ( 
                                     
                                       n 
                                       - 
                                       
                                         i 
                                          
                                         
                                             
                                         
                                          
                                         
                                           
                                             F 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               2 
                                             
                                           
                                           
                                             F 
                                             
                                               s 
                                                
                                               
                                                   
                                               
                                                
                                               1 
                                             
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0073]    Such an ideal downsampling is useful as it represents an ideal filtered signal with the fewest data needed. 
         [0074]    As for the discrete filter, this mathematical definition cannot be used to derive a computable filter but will be approximated. 
         [0075]    Two-Dimensional Signals 
         [0076]    As we will work on images in the next sections, some results need to be expressed in two dimensions. 
         [0077]    Fourier transform: The two-dimensional Fourier transform of a signal g(x,y) is defined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     G 
                      
                     
                       ( 
                       
                         
                           F 
                           x 
                         
                         , 
                         
                           F 
                           y 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         ∫ 
                         
                           - 
                           ∞ 
                         
                         ∞ 
                       
                        
                       
                         
                           g 
                            
                           
                             ( 
                             
                               x 
                               , 
                               y 
                             
                             ) 
                           
                         
                          
                         
                            
                           
                             
                               - 
                               j2 
                             
                              
                             
                                 
                             
                              
                             
                               π 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       F 
                                       x 
                                     
                                      
                                     x 
                                   
                                   + 
                                   
                                     
                                       F 
                                       y 
                                     
                                      
                                     y 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                          
                         
                             
                         
                          
                         
                            
                           x 
                         
                          
                         
                             
                         
                          
                         
                            
                           y 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0078]    Its inverse transform is: 
         [0000]    
       
         
           
             
               
                 
                   
                     g 
                      
                     
                       ( 
                       
                         x 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∫ 
                       
                         - 
                         ∞ 
                       
                       ∞ 
                     
                      
                     
                       
                         ∫ 
                         
                           - 
                           ∞ 
                         
                         ∞ 
                       
                        
                       
                         
                           G 
                            
                           
                             ( 
                             
                               
                                 F 
                                 x 
                               
                               , 
                               
                                 F 
                                 y 
                               
                             
                             ) 
                           
                         
                          
                         
                            
                           
                             j2 
                              
                             
                                 
                             
                              
                             
                               π 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       F 
                                       x 
                                     
                                      
                                     x 
                                   
                                   + 
                                   
                                     
                                       F 
                                       y 
                                     
                                      
                                     y 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                          
                         
                             
                         
                          
                         
                            
                           
                             F 
                             x 
                           
                         
                          
                         
                             
                         
                          
                         
                            
                           
                             F 
                             y 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   28 
                   ) 
                 
               
             
           
         
       
     
         [0079]    Ideal filter: The ideal discrete filter defined in ( 22 ) can be transposed to two-dimensions as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       ˘ 
                     
                      
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         k 
                         , 
                         
                           l 
                           = 
                           
                             - 
                             ∞ 
                           
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           
                             k 
                             , 
                             l 
                           
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             2 
                              
                             
                                 
                             
                              
                             π 
                              
                             
                                 
                             
                              
                             
                               
                                 F 
                                 
                                   x 
                                   cut 
                                 
                               
                               
                                 F 
                                 
                                   x 
                                   s 
                                 
                               
                             
                              
                             
                               ( 
                               
                                 i 
                                 - 
                                 k 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             2 
                              
                             
                                 
                             
                              
                             π 
                              
                             
                               
                                 F 
                                 
                                   y 
                                   cut 
                                 
                               
                               
                                 F 
                                 
                                   y 
                                   s 
                                 
                               
                             
                              
                             
                               ( 
                               
                                 j 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   29 
                   ) 
                 
               
             
           
         
       
     
         [0080]    Ideal downsampler: The ideal downsampler defined in ( 26 ) can be transposed to two-dimensions as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       x 
                       ˇ 
                     
                      
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         k 
                         , 
                         
                           l 
                           = 
                           
                             - 
                             ∞ 
                           
                         
                       
                       ∞ 
                     
                      
                     
                       
                         x 
                          
                         
                           ( 
                           
                             k 
                             , 
                             l 
                           
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 i 
                                 - 
                                 
                                   k 
                                    
                                   
                                     
                                       F 
                                       
                                         x 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                     
                                     
                                       F 
                                       
                                         x 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           1 
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 j 
                                 - 
                                 
                                   l 
                                    
                                   
                                     
                                       F 
                                       
                                         y 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                     
                                     
                                       F 
                                       
                                         y 
                                         
                                           s 
                                            
                                           
                                               
                                           
                                            
                                           1 
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   30 
                   ) 
                 
               
             
           
         
       
     
         [0081]    Example Non-Limiting Pixel Art Upscaler Model 
         [0082]    The example non-limiting Pixel Art Upscaler computes each pixel of the output image as a linear combination of the 4 pixels of the input image that are nearest from the output pixel. This linear combination is chosen from a table based on conditions on the 9 nearest pixels of the input image. 
         [0000]    
       
         
           
             
               
                 
                   
                     C 
                     
                       PAU 
                       ij 
                     
                   
                   = 
                   
                     
                       ∑ 
                       k 
                     
                      
                     
                       
                         α 
                         k 
                       
                        
                       
                         C 
                         
                           0 
                           
                             
                               i 
                               k 
                             
                              
                             
                               j 
                               k 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   31 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where
 
0≦k≦3, i k , j k  span the four pixels nearest to pixel i, j. We will use the convention i 0  j 0 =ij. α k  are the four coefficients of the linear combination of input colors.
 
         [0083]    This linear combination is, in one example non-limiting implementation, chosen from a table based on conditions on 6 of the 9 nearest pixels of the input image. See  FIG. 7 , which shows an example non-limiting definition of input image pixel indexes from output pixel coordinates (i,j). Color of the output pixel i, j is computed as a linear combination of input pixels 0 to 3. This linear combination is, in one example non-limiting implementation, chosen from a table using conditions on colors of pixels 0 to 5. 
         [0084]    Moreover, this process currently guarantees: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       k 
                     
                      
                     
                       α 
                       k 
                     
                   
                   = 
                   1 
                 
               
               
                 
                   ( 
                   
                     32 
                      
                     a 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     
                       α 
                       k 
                     
                     ≥ 
                     
                       
                         1 
                         / 
                         2 
                       
                        
                       
                           
                       
                        
                       if 
                        
                       
                           
                       
                        
                       k 
                     
                   
                   = 
                   
                     0 
                      
                     
                       ( 
                       
                         
                           ie 
                            
                           
                               
                           
                            
                           
                             i 
                             k 
                           
                            
                           
                             j 
                             k 
                           
                         
                         = 
                         ij 
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   
                     32 
                      
                     b 
                   
                   ) 
                 
               
             
             
               
                 
                   
                     α 
                     k 
                   
                   ≤ 
                   
                     
                       1 
                       / 
                       4 
                     
                      
                     
                         
                     
                      
                     if 
                      
                     
                         
                     
                      
                     k 
                   
                   ≠ 
                   
                     0 
                      
                     
                       ( 
                       
                         
                           ie 
                            
                           
                               
                           
                            
                           
                             i 
                             k 
                           
                            
                           
                             j 
                             k 
                           
                         
                         ≠ 
                         ij 
                       
                       ) 
                     
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0085]    The PAU algorithm also ensures symmetry properties. Given any two blocks of 9 pixels such that one is the symmetric of the other along axis x, y or both, or by a rotation of π or −π, the resulting 4 pixels at the center of the block in the output image will present the same symmetry. 
         [0086]    Example Non-Limiting Brightness Compensation Algorithm 
         [0087]      FIG. 7A  shows an example non-limiting block diagram of an overall graphics display system including a processor  100  that executes stored program instructions  102 ; and a graphics processor  200 , that generates an image for display on a display  300 . In the example shown, the program instructions  102  when executed by processor  100  control the processor to generate commands to graphics processor  200 . Those commands control the graphics processor  200  to generate images using conventional graphics processes (e.g., a video game emulator) (block  202 ), process generated images with a pixel art upscaler PAU described above (block  204 ), and perform brightness compensation (block  206 ). These blocks  202 ,  204  and/or  206  can be performed by the graphics processor  200  and/or the processor  100  with or without additional specialized filtering hardware support. In one example implementation, the PAU and brightness compensation is implemented by instructions stored in a non-transitory storage device that are executed in whole or in part by the graphics processor  200 . In other example implementations, the PAU and brightness compensation is implemented by such stored instructions executed in whole or in part by the processor  100 . In still other implementations, some or all of the PAU and/or brightness compensation may be performed by specialized hardware. All such implementations are referred to herein as “computer processors”. 
         [0088]    The example non-limiting implementation adds, after the PAU  204 , another process  206  that compensates low frequencies brightness changes due to PAU. This way, the original image and the SPAU filtered image are equal when low pass filtered. 
         [0089]    Example Non-Limiting Brightness Compensation Algorithm 
         [0090]    Let A be the input image and B be the PAU version of A (i.e., B is the PAU filtered image in this particular example embodiment). B&#39;s pixel count in this particular case is 2×2 times that of A. 
         [0091]    The example non-limiting brightness compensation  206  algorithm includes the following steps (see  FIGS. 8 &amp; 9 ): 
         [0092]    1. Downsampler computes and stores in a memory {hacek over (A)} as a downsampling of original image A (D=2) (block  206   a ). 
         [0093]    2. Downsampler computes and stores in a memory {hacek over (B)}, as a downsampling of PAU-filtered image B (D=4) (block  206   b ). 
         [0094]    3. Comparator computes and stores in a memory Δ as {hacek over (B)},−{hacek over (A)} (block  206   c ). 
         [0095]    4. Upsampler computes and stores in a memory {circumflex over (Δ)}, as an upsampling of Δ (D=4) (block  206   d ). 
         [0096]    5. Subtractor computes C as B−{circumflex over (Δ)}; (block  206   e ) for display. 
         [0000]    Here, note that Δ and {circumflex over (Δ)}; are each two-dimensional arrays, and C is computed by subtracting the appropriate value in {circumflex over (Δ)}; from B. Also observe that {hacek over (A)} and {hacek over (B)}, are low-frequency versions of A and B, and that {hacek over (A)} and {hacek over (B)}, are the same size in this particular example in order to simplify the differencing operation of block  206   c.    
         [0097]    By construction, this example non-limiting process guarantees that the frequency spectrum of C is very close to that of A for low frequencies. A validity check can be done by computing (as an ideal downsampling of C and comparing it to {hacek over (A)}. Such calculation can be performed efficiently in real time on a stream of images generated periodically (e.g., 30 or 60 times per second) in real time in the context of real time image generation, or it could be performed in a batch mode to produce one or a stream of images for storage and later display. 
         [0098]    Using the brightness compensation after the PAU, we can then guarantee that there will be no low frequency luminance change. 
         [0099]    Example Non-Limiting Downsampler 
         [0100]    As seen above, an ideal downsampler of factor D can be mathematically defined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       A 
                       ˇ 
                     
                     ij 
                   
                   = 
                   
                     
                       ∑ 
                       kl 
                     
                      
                     
                       
                         A 
                         kl 
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 i 
                                 - 
                                 
                                   k 
                                   D 
                                 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                        
                       sin 
                        
                       
                           
                       
                        
                       
                         c 
                          
                         
                           ( 
                           
                             π 
                              
                             
                               ( 
                               
                                 j 
                                 - 
                                 
                                   l 
                                   D 
                                 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   33 
                   ) 
                 
               
             
           
         
       
     
         [0000]    As already seen, such filter is not computable but can be approximated with a finite support filter. 
         [0101]    The example non-limiting algorithm uses an approximation of an ideal downsampler of factor D, that is, a process which resamples an image A, producing an image {hacek over (A)} of lower resolution whose spatial frequency spectrum is exactly the same as A for frequencies up to a maximum frequency F max , and with no frequency greater than F max . 
         [0102]    The example non-limiting embodiment will use a Lanczos2 filter, which is known to perform well. See e.g., Ken Turkowski, Filters for common resampling tasks (April 1990). This filter is defined by the kernel: 
         [0000]    
       
         
           
             
               
                 
                   
                     Lanczos 
                      
                     
                         
                     
                      
                     2 
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               sin 
                                
                               
                                   
                               
                                
                               
                                 c 
                                  
                                 
                                   ( 
                                   
                                     π 
                                      
                                     
                                         
                                     
                                      
                                     x 
                                   
                                   ) 
                                 
                               
                                
                               sin 
                                
                               
                                   
                               
                                
                               
                                 c 
                                  
                                 
                                   ( 
                                   
                                     π 
                                      
                                     
                                         
                                     
                                      
                                     
                                       x 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                             , 
                           
                         
                         
                           
                             
                                
                               x 
                                
                             
                             &lt; 
                             2 
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           
                             
                                
                               x 
                                
                             
                             ≥ 
                             2 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
         [0103]    The resulting image is computed by an ideal downsampler of factor D that can be mathematically defined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       A 
                       ˇ 
                     
                     ij 
                   
                   = 
                   
                     
                       ∑ 
                       
                         kl 
                         ∈ 
                          
                       
                     
                      
                     
                       
                         A 
                         kl 
                       
                        
                       Lanczos 
                        
                       
                           
                       
                        
                       2 
                        
                       
                         ( 
                         
                           i 
                           - 
                           
                             k 
                             D 
                           
                         
                         ) 
                       
                        
                       Lanczos 
                        
                       
                           
                       
                        
                       2 
                        
                       
                         ( 
                         
                           j 
                           - 
                           
                             l 
                             D 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   35 
                   ) 
                 
               
             
           
         
       
     
         [0104]    Such filter introduces an error that is localized around the cutoff frequency. However, the result for lower frequencies is very close to an ideal subsampling. See  FIG. 6  which shows a kernel of the Lanczos2 filter for D=2 (left) and its Fourier transform (right). 
         [0105]    As can be seen in  FIG. 6 , the Fourier transform is very flat in the low frequencies domain, 0.5 F cut  where this frequency can be attenuated to ˜95% of its original value. It is also very near to 0 for high frequencies, greater than 1.5 F cut . We can also note that no frequency is amplified, which is a good feature for an eye-pleasing filter (the contrary would generate little wavelets around hard edges in the picture). 
         [0106]    Working on 8-bits image, we can assume that there is no difference with an ideal filter for frequencies up to ˜0.5 F cut , and that any high frequency greater than ˜1.5 F cut  will be effectively removed (their amplitude being about the quantification step). See Ken Turkowski,  Filters for common resampling tasks , April 1990. 
         [0107]    Example Non-Limiting Upsampler 
         [0108]    The example non-limiting embodiment also uses an approximation of an ideal upsampler of factor D which produces a higher resolution image, A, from an image, A. 
         [0109]    This upsampler is, in one non-limiting embodiment, defined using the Lanczos2 kernel: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       A 
                       ^ 
                     
                     ij 
                   
                   = 
                   
                     
                       ∑ 
                       kl 
                     
                      
                     
                       
                         A 
                         kl 
                       
                        
                       Lanczos 
                        
                       
                           
                       
                        
                       2 
                        
                       
                         ( 
                         
                           
                             ( 
                             
                               k 
                               + 
                               iD 
                             
                             ) 
                           
                            
                           Lanczos 
                            
                           
                               
                           
                            
                           2 
                            
                           
                             ( 
                             
                               ( 
                               
                                 l 
                                 + 
                                 jD 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   36 
                   ) 
                 
               
             
           
         
       
     
         [0110]    Other filters could be used instead of Lanczos2. It is desired that such upsample filters do not themselves create any artifacts or exhibit unpredictable behavior. 
         [0111]    Flash Compliance 
         [0112]    A potentially harmful flash is defined by most of the international guidelines as a pair of opposing transitions in luminance of more than 20 cd·m 2 , covering more than one-fourth of the screen. See e.g., International Telecommunication Union,  Guidance for the reduction of photosensitive epileptic seizures caused by television , 2005; Ofcom,  Ofcom Guidance Note on Flashing Images and Regular Patterns in Television  (2012). These and other standards define potentially harmful flashes as involving saturated red and saturated red transitions. For example, a working definition for a “pair of opposing transitions involving a saturated red” can be found in W3C,  Web Content Accessibility Guidelines  ( WCAG ) 2.0, 2008. It involves a linear combination of the three color channels, and can be measured similarly as luminance flashes. 
         [0113]    The international guidelines do not specify exactly how luminance measurements must be done. However, ITU suggests that a unified specification for measurements should be studied, and suggest that such specification should include a spatial filtering of frames (see ITU,  Guidance for the reduction of photosensitive epileptic seizures caused by television , 2005, appendix 3]). 
         [0114]    The example non-limiting disclosed algorithm guarantees an output image equal to the raw image when considering only the low spatial frequencies (with period T≧8 px in output image). For example, assuming a raw image size of 256 pixels×224 pixels viewed with about 30° angle, this means that no brightness difference can be seen of 0.5° angle or more. The disclosed non-limiting SPAU algorithm discussed above is then conservative considering flashes. 
         [0115]    Pattern Compliance 
         [0116]    Some sources define a potentially harmful regular pattern as containing clearly discernible stripes when there are more than five light-dark pairs of stripes. Although pattern recognition algorithms can work with this definition, it does not give a practical mathematical definition. However, a regular pattern has a specific frequency footprint, with a high amplitude at the main frequency of the pattern. 
         [0117]    The example non-limiting SPAU algorithm, by producing images that have a frequency spectrum as close as possible as the original images, guarantees that, if no regular pattern is present in the original image, no regular pattern with low frequency (T≧8 px) will be present in the output image. 
         [0118]    However, high frequencies will be introduced by the example non-limiting PAU, and are intentional as they are needed to produce the intended hard edges of pixel art images. Nevertheless, such frequencies are expected to remain in very local areas of the image (edges). 
         [0119]    Recall from equations (31) and (32) that an example non-limiting pixel value is bounded by the extrema of the four surrounding pixels. Moreover, its original value contributes to at least half of its new value. This guarantees that no high frequency could appear in flat color areas of an input image. Any high amplitude, high frequency pattern in output image would then require higher color variations at the pixel level in the input image. It may be possible that irregular patterns can generate higher frequency regular pattern. However, using the example non-limiting SPAU, no harmful flashes can be introduced in a flash-free material. There remains a low risk of induced low amplitude regular patterns. 
         [0120]    Meanwhile, the brightness compensation techniques disclosed herein will restore low frequency components that were removed as a side effect of high frequency filtering. Thus, the technology herein is particularly advantageous for filters that target high frequencies, and can be used to ensure that such filters do not affect the low frequencies too. Such filters can include the disclosed PAU filtering, mosaic filtering, noise reduction filtering. The non-limiting example technology is particularly useful when the prefiltered image (or brightness parameters of same) are available for comparison with the postfiltered image irrespective of the type of filtering and the image source. 
         [0121]    While the invention has been described in connection with what is presently considered to be the most practical and preferred embodiment, it is to be understood that the invention is not to be limited to the disclosed embodiment. For example, the brightness compensation techniques described herein can work with any filter or other technique, not just with the PAU techniques described herein. In particular, the brightness compensation techniques can be applied to any images irrespective of source. Thus, the invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.