Abstract:
A barcode decoding system and method are disclosed that use a data-driven classifier for transforming a potentially degraded barcode signal into a digit sequence. The disclosed implementations are robust to signal degradation through incorporation of a noise model into the classifier construction phase. The run-time computational cost is low, allowing for efficient implementations on portable devices. Implementations are disclosed for intelligent preview scaling, barcode-aware autofocus augmentation and multi-scale signal feature extraction.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a divisional application of U.S. application Ser. No. 13/658,765, entitled “Barcode Recognition Using Data-Driven Classifier,” filed Oct. 23, 2012, which is a continuation-in-part of U.S. application Ser. No. 12/895,751, entitled “Barcode Recognition Using Data-Driven Classifier,” filed Sep. 30, 2010, the entire contents of each of which are incorporated herein by reference. 
    
    
     TECHNICAL FIELD 
     The disclosure generally relates to scanning and decoding barcodes captured in digital images. 
     BACKGROUND 
     The use of one-dimensional barcodes on consumer products and product packaging has become nearly ubiquitous. These barcodes linearly encode a numerical digit sequence that uniquely identifies the product to which the barcode is affixed. The ability to decode accurately and quickly barcodes under a variety of conditions on a variety of devices poses a number of interesting design challenges. For example, a barcode recognition algorithm must be able to extract information encoded in the barcode robustly under a variety of lighting conditions. Furthermore, the computational cost of signal processing and decoding needs to be low enough to allow real-time operation of barcode recognition on low-powered portable computing devices such as smart phones and electronic tablet computers. 
     Some bar code labels are smaller than what is specified in the GS1 GTIN/EAN13 standard. These barcode labels have small leading and trailing quite-zone whitespace allowances and a high symbol-bar linear spatial frequency. These characteristics create stringent requirements on the camera system (lens, signal-processing stack) that has to capture the image of the barcode before information can be extracted from the barcode through signal processing. 
     A first requirement is the ability to resolve the individual lines of the barcode. To resolve the individual lines of the barcode, the spatial sampling frequency needs to be high enough (at least twice as the highest spatial frequency contained in the linear  1 D barcode). This requires the camera to be close enough to the barcode such that enough of the sensor&#39;s photo sites (pixels) cover the barcode. In other words, the camera needs to be close enough to the barcode such that the pixel resolution of the imaged barcode satisfies the Nyquist-Shannon theorem for the barcode spectrum. If this requirement is violated, one would expect a significant amount of signal aliasing to occur which will severely degrade the information content of the captured signal. 
     A second requirement is the ability to focus accurately on the barcode symbol to resolve sharply the individual symbol lines of the barcode. Many cameras have a minimum focal distance imposed by the physical and mechanical constraints of the lens assembly. In particular, many mobile device cameras, such as those found in smart phones, lack the ability to focus on objects very near the lens (&lt;5 cm). Consequently, the minimal focus distance imposes a (device specific) lower bound on the distance from the camera to the barcode. If the camera is closer than this distance to the object being imaged, sharp focus is not possible. 
     Note that the two requirements described above are compatible in a straightforward way—the symbol should be placed as close to the camera lens as the focal mechanism allows, and no closer. The software user interface (or UI) can be designed to encourage proper placement of the symbol in the camera&#39;s field of view. Unfortunately, the straightforward solution suffers from a poor user experience. Any target guide for the barcode appropriately scaled to the field of view to encourage the right distancing of the symbol from the camera is likely to be quite small—especially for the tiny barcodes used by some retail stores. 
     The perceived ease of placement of an object inside a target guide is directly affected by the distance of the object from the camera. There is a direct relationship between the distance of an object from the camera and the relative distance the object travels on screen in a camera image preview for a lateral motion of any given distance. A small adjustment in the position of an object four centimeters from the camera can move the object (in the image and on the screen) a significant distance left, right, up, or down. By contrast, another object several feet away can be similarly repositioned with little or no notable effect in the image. 
     SUMMARY 
     A barcode decoding system and method are disclosed that use a data-driven classifier for transforming a potentially degraded barcode signal into a digit sequence. The disclosed implementations are robust to signal degradation through incorporation of a noise model into the classifier construction phase. The run-time computational cost is low, allowing for efficient implementations on portable devices. Implementations are disclosed for intelligent preview scaling, barcode-aware autofocus augmentation and multi-scale signal feature extraction. 
     Particular implementations disclosed herein relax the requirements on camera systems that capture barcode images. The disclosed implementations enable the camera system to robustly process barcodes of a variety of sizes and spatial scales as captured by the camera sensor. The processing is transparent to the user and can be implemented on a variety of devices with different imaging characteristics (e.g., sensor, lens, focal distance/field of view). More particularly, the disclosed implementations allow a camera system to: 1) be close enough to the barcode such that photo sites (pixels) of the sensor cover the barcode; 2) accurately focus on the barcode symbol to sharply resolve individual symbol lines of the barcode; and 3) provide a target guide that occupies a large portion of the screen. 
     Other implementations directed to methods, systems and computer readable mediums are also disclosed. The details of one or more implementations are set forth in the accompanying drawings and the description below. Other features, aspects, and potential advantages will be apparent from the description, drawings and claims. 
    
    
     
       DESCRIPTION OF DRAWINGS 
         FIG. 1A  illustrates an EAN-13 one-dimensional barcode. 
         FIG. 1B  illustrates a UPC-A one-dimensional barcode. 
         FIG. 2  is an EAN/UPC barcode symbol alphabet. 
         FIGS. 3A-3B  illustrate exemplary EAN/UPC barcode symbol encoding. 
         FIG. 4  is a high-level block diagram of an exemplary barcode decoding system. 
         FIG. 5  illustrates an exemplary process for manual targeting of a barcode using a target guide overlaid on top of a live preview screen. 
         FIG. 6  illustrates a typical area of pixels, which can be vertically integrated to generate a one dimensional intensity profile. 
         FIG. 7  is a plot of an exemplary one dimensional intensity profile generated by integrating the luminance value of the pixels inside the bounding box of  FIG. 6 . 
         FIGS. 8A and 8B  are plots illustrating the determining of left and right cropping points for the barcode intensity profile of  FIG. 7  using a differential spatial signal variance ratio (DSSVR) metric. 
         FIGS. 9A-9C  are plots illustrating extrema location determination. 
         FIGS. 10A and 10B  are plots illustrating positive and negative edge locations of a barcode intensity profile. 
         FIG. 11  is a block diagram of an exemplary data-driven classifier based decoding system that can be trained in a supervised fashion using noisy simulated input feature vectors. 
         FIG. 12  is a plot illustrating neural network output class probabilities for a sequence of input symbol feature vectors. 
         FIG. 13  is an exemplary process for barcode recognition. 
         FIG. 14  is a block diagram of an exemplary system architecture implementing a barcode decoding system according to  FIGS. 1-13 . 
         FIG. 15  illustrates a user interface for an online payment application running on a mobile device. 
         FIG. 16  illustrates a user interface for capturing an image of a barcode provided by the online payment application. 
         FIG. 17  is a graph illustrating a pinhole camera model. 
         FIG. 18  illustrates a typical target image used for camera model calibration. 
         FIGS. 19A-19C  illustrate unfocused signal statistics of an image of a barcode. 
         FIGS. 20A-20C  illustrate focused signal statistics of a barcode image. 
         FIG. 21  is a flow diagram of exemplary process of intelligent preview scaling. 
         FIG. 22  is a flow diagram of an exemplary process of barcode-aware autofocus augmentation. 
         FIG. 23  is a flow diagram of an exemplary process of multi-scale signal feature extraction. 
         FIG. 24  is a plot of integrated barcode signal intensity (normalized and detrended) illustrating upper, lower envelope signals and an adaptive threshold. 
     
    
    
     Like reference symbols in the various drawings indicate like elements. 
     DETAILED DESCRIPTION 
     Barcode Encoding Overview 
     A barcode is an optical machine-readable representation of data about a product to which the barcode is affixed. Barcodes that represent data in the widths of bars and the spacing of parallel bars are referred to as linear or one-dimensional (1D) barcodes or symbologies. One-dimensional barcodes can be read by optical scanners called barcode readers or scanned from a digital image. One-dimensional barcodes have a variety of applications, including but not limited to automating supermarket checkout systems and inventory control. Some software applications allow users to capture digital images of barcodes using a digital image capture device, such as a digital camera or video camera. Conventional applications perform processing on the digital image to isolate the barcode in the image so that it can be decoded. Such applications, however, cannot decode accurately and quickly barcodes under a variety of conditions on a variety of devices. 
     One-dimensional barcodes, such as those barcodes covered by the GS1 General Specifications (Version 10), encode individual numbers of a digit sequence using a linear sequence of parameterized symbols.  FIG. 1A  illustrates an EAN-13 one-dimensional barcode.  FIG. 1B  illustrates a UPC-A one-dimensional barcode, which is a subset of the EAN-13 standard. 
       FIG. 2  is an EAN/UPC barcode symbol alphabet. Three symbol sets are used to encode the numerical digits of the barcode, as described in the GS1 General Specifications. Each symbol is composed of two light and two dark interleaved bars of varying widths. Typically, black is used for the dark bars and white for the light bars, however, any two high contrast ratio colors can be used. The order of the interleaving, white-black-white-black or black-white-black-white depends on the specific symbol set and encoding parity being used for a given numeric digit. 
       FIGS. 3A and 3B  illustrate exemplary EAN/UPC barcode symbol encoding. Barcode digit symbols are parameterized using five salient parameters (L, x 0 , x 1 , x 2 , x 3 ) that encode the distances between key fiducial landmarks in the pictorial representation of the barcode. These parameters are:
         L: Symbol length measures from the leading edge of the first bar (dark or light) of a symbol to the corresponding leading edge of the first bar of the next adjacent symbol.   x 0 : width of the second dark (black) bar.   x 1 : width of the first dark (black) bar.   x 2 : Distance between the trailing edges of the two dark (black) bars.   x 3 : Distance between the leading edges of the two dark (black) bars.       

     Barcode Decoding Overview 
       FIG. 4  is a high-level block diagram of an exemplary barcode decoding system  400 . Decoding a barcode from its pictorial representation is usually a three-step process that includes capture, digital signal processing and decoding. For example, an image of a barcode  402  can be captured by a digital image capture device and converted into an electronic representation ( 404 ). The electronic representation can be digital or analog. The electronic representation (e.g., a  1 D signal) is processed ( 406 ). The processing can include converting the electronic representation into a linear sequence of N symbol feature vectors, {{right arrow over (s)} 0 , {right arrow over (s)} 1 , . . . , {right arrow over (s)} N }, where {right arrow over (s)} i =[L i , x i,0 , x i,1 , x i,2 , x i,3 ] and i=0, 1, . . . , N−1. The sequence of symbol feature vectors is decoded ( 408 ) by mapping the symbol feature vectors into a corresponding digit sequence  410  using the relevant symbol alphabet shown in  FIG. 2 . 
     A hardware digital image capture device, such as a dedicated laser scanner or a digital camera can be used for step  404 . Steps  406 ,  408  can be implemented using digital signal processing (DSP) hardware and/or software running on a general purpose CPU, such as the architecture shown in  FIG. 14 . 
     Exemplary Barcode Capture &amp; Conversion 
     There are is a variety of ways in which a pictorial representation of a 1D barcode can be converted into a 1D electronic signal in step  404  of barcode decoding system  400 . Laser scanners, either hand-held or fixed, have traditionally been the method of choice for barcode entry, and are still widely used in point-of-sell retail venues, such as supermarkets. Now that computationally powerful mobile devices (e.g., smart phones) have become ubiquitous, using the built-in digital camera as a means of barcode capture and entry have become popular. Under a camera-based scenario, one has to differentiate between techniques that operate on low quality (often blurry) photos from older fixed focus mobile phone cameras that have poor macro performance, and those cameras that use high quality macro-focused images originating from auto-focus cameras. A technique for decoding blurry barcodes using a genetic process is disclosed in U.S. patent application Ser. No. 12/360,831, for “Blurring Based Content Recognizer.” 
       FIG. 5  illustrates an exemplary process for manual targeting of a barcode using a target guide overlaid on top of a live preview screen. In some implementations, a barcode  502  is located and cropped from a live video preview screen  500  of an auto-focus camera. The cropping can be performed manually by presenting the user with target guides  504   a - 504   d  overlaid on the live video preview screen  500 . The user aligns the barcode between the target guides  504  and captures a video frame from the live video preview screen  500 . An alternative technique for automated barcode location determination using an automated barcode location determination process is disclosed in U.S. patent application Ser. No. 12/360,831, for “Blurring Based Content Recognizer.” 
     Once the barcode has been located, the pixel values in a horizontal band cutting through the vertical center of the barcode are vertically integrated to generate a one dimensional intensity profile.  FIG. 6  illustrates a typical area of pixels, which can be vertically integrated to generate a one dimensional intensity profile. In the example shown, a barcode  602  on a live video preview screen  600  has a bounding box  604  indicating an area of pixels which is vertically integrated to generate a one dimensional intensity profile 
       FIG. 7  is a plot of an exemplary one dimensional intensity profile generated by integrating the luminance value of the pixels inside the bounding box of  FIG. 6 . In some implementations, the luminance value of the pixels within bounding box  604  (e.g., Y channel of YUV color space) can be integrated. In some implementations, the average gray value can be used, which is the average of the red, green and blue pixel intensities, i.e., gray=(R+G+B)/3. One can also use any other linear or non-linear combination of the three R (red), G (green) and B (blue) channels for each pixel to generate a one dimensional intensity like signal. The number of scan lines that are integrated is a function of the vertical resolution of the input image containing the barcode. Bounding box  604  indicates a typical region of pixels, which is vertically integrated, and  FIG. 7  shows the resulting intensity profile (normalized). The three channel RGB pixel values can be first converted into a single scalar pixel value before vertical integration. This conversion can be done with a linear (or nonlinear) color-space mapping function: RGB→YUV. The luminance intensity profile shown in  FIG. 7  can be calculated by the formula 
                     Y   ⁡     (   x   )       =       ∑     y   =     -     h   2             h   2     -   1       ⁢       P   Y     ⁡     (     x   ,   y     )                 [   1   ]               
where P Y (x, y) is the image Y value (luminance intensity) at pixel coordinates (x, y), and h is the height of the integration slice measured in pixels.
 
     Exemplary Digital Signal Processing 
     In the DSP phase of barcode recognition (step  406  of  FIG. 4 ), the one dimensional intensity profile of the captured barcode is converted into a linear sequence of symbol feature vectors. As such, the DSP step  406  can be general in application and can operate on 1D image intensity profiles captured by any means (e.g., laser scanner, digital camera). 
     In some implementations, the substeps of step  406  are:
         1. Crop left and right edges of intensity profile to barcode guard bars.   2. Identify the position and value of extrema (local maxima and minima) of intensity profile.   3. Filter list of extrema to remove extraneous detections.   4. Calculate locations of edges (positive or negative) of intensity profile using list of extrema.   5. Perform edge consistency checking.   6. Sequentially convert consecutive local edge location measurements into a linear sequence of N symbol feature vectors, {{right arrow over (s)} 0 , {right arrow over (s)} 1 , . . . , {right arrow over (s)} N }, where {right arrow over (s)} i =[L i , x i,0 , x i,1 , x i,2 , x i,3 ] and i=0, 1, . . . , N−1, as described in reference to  FIGS. 3A and 3B .
 
Intensity Profile Cropping
       

     To accurately and robustly convert the intensity profile into a sequence of barcode symbol features vectors, the left and right hand parts of the intensity profile that do not contain barcode relevant information can be removed. This can be achieved by determining the location where the barcode starts and stops. 
     In some implementations, barcode endpoints can be detected using a differential spatial signal variance ratio (DSSVR) metric. The DSSVR metric profiles (left and right) of the intensity profile can be determined over a sliding window of length L v  by calculating the ratios of the signal variance over the left and right half-windows, that is, 
     
       
         
           
             
               
                 
                   
                     D 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     S 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     S 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     V 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         R 
                         L 
                       
                       ⁡ 
                       
                         ( 
                         x 
                         ) 
                       
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     0 
                                   
                                   
                                     
                                       L 
                                       v 
                                     
                                     2 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       
                                         Y 
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             + 
                                             n 
                                           
                                           ) 
                                         
                                       
                                       - 
                                       
                                         
                                           
                                             Y 
                                             _ 
                                           
                                           R 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           x 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                   2 
                                 
                               
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     0 
                                   
                                   
                                     
                                       L 
                                       v 
                                     
                                     2 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       
                                         Y 
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             - 
                                             n 
                                           
                                           ) 
                                         
                                       
                                       - 
                                       
                                         
                                           
                                             Y 
                                             _ 
                                           
                                           L 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           x 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                   2 
                                 
                               
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       Y 
                                       _ 
                                     
                                     L 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                               
                               &gt; 
                               
                                 
                                   
                                     Y 
                                     _ 
                                   
                                   R 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             0 
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       Y 
                                       _ 
                                     
                                     L 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                               
                               ≤ 
                               
                                 
                                   
                                     Y 
                                     _ 
                                   
                                   R 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                             
                           
                         
                       
                       , 
                     
                   
                 
               
               
                 
                   [ 
                   2 
                   ] 
                 
               
             
             
               
                 
                   
                     D 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     S 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     S 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     V 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         R 
                         R 
                       
                       ⁡ 
                       
                         ( 
                         x 
                         ) 
                       
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     0 
                                   
                                   
                                     
                                       L 
                                       v 
                                     
                                     2 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       
                                         Y 
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             - 
                                             n 
                                           
                                           ) 
                                         
                                       
                                       - 
                                       
                                         
                                           
                                             Y 
                                             _ 
                                           
                                           L 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           x 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                   2 
                                 
                               
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     0 
                                   
                                   
                                     
                                       L 
                                       y 
                                     
                                     2 
                                   
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       
                                         Y 
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             + 
                                             n 
                                           
                                           ) 
                                         
                                       
                                       - 
                                       
                                         
                                           
                                             Y 
                                             _ 
                                           
                                           R 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           x 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                   2 
                                 
                               
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       Y 
                                       _ 
                                     
                                     R 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                               
                               &gt; 
                               
                                 
                                   
                                     Y 
                                     _ 
                                   
                                   L 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             0 
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       Y 
                                       _ 
                                     
                                     R 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     x 
                                     ) 
                                   
                                 
                               
                               ≤ 
                               
                                 
                                   
                                     Y 
                                     _ 
                                   
                                   L 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                             
                           
                         
                       
                       , 
                       
                         
 
                       
                       ⁢ 
                       where 
                     
                   
                 
               
               
                 
                   [ 
                   3 
                   ] 
                 
               
             
             
               
                 
                   
                     
                       
                         Y 
                         _ 
                       
                       R 
                     
                     ⁡ 
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         0 
                       
                       
                         
                           L 
                           v 
                         
                         / 
                         2 
                       
                     
                     ⁢ 
                     
                       Y 
                       ⁡ 
                       
                         ( 
                         
                           x 
                           + 
                           n 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   [ 
                   4 
                   ] 
                 
               
             
             
               
                 
                   
                     
                       
                         Y 
                         _ 
                       
                       L 
                     
                     ⁡ 
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         0 
                       
                       
                         
                           L 
                           v 
                         
                         / 
                         2 
                       
                     
                     ⁢ 
                     
                       
                         Y 
                         ⁡ 
                         
                           ( 
                           
                             x 
                             - 
                             n 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   [ 
                   5 
                   ] 
                 
               
             
           
         
       
     
     These two variance ratios of equations [2] and [3] are reciprocals of each other. 
       FIGS. 8A and 8B  are plots illustrating the determining of left and right cropping locations for the barcode intensity profile of  FIG. 7  using the DSSVR metric. The top plot of  FIG. 8  shows the intensity profile using the DSSVR metric and the dots at A and B indicate the optimal left and right cropping locations, respectively, determined from filtered peaks of left and right DSSVR metrics shown in the bottom plot of  FIG. 8 . The maximal peaks of DSSVR L    802  and DSSVR R    804  in the left halve (left edge to middle of profile space) and right halve (right edge to middle of profile space) of the profile space, respectively, can be used to determine the optimal left and right crop locations A and B. 
     The left crop location A can be placed a fixed distance δ to the left of the left local maximal peak of DSSVR L    802 , and likewise, the right crop location B to the right of the local maximal peak of DSSVR R    804 . The value of δ can be set to δ=α*P where P is the nominal pitch of the intensity profile. The nominal pitch can be determined from the dominant frequency peak in the Fourier transform of the intensity profile. 
     Find Extrema of Cropped Intensity Profile 
       FIGS. 9A-9C  are plots illustrating extrema location determination. After the cropping locations are determined, the location and values of the local maxima and minima of the cropped intensity profile can be determined. In some implementations, a preprocessing step can be applied to the cropped profile prior to extrema finding which includes a linear de-trending operation followed by a signal amplitude normalization step. These optional preprocessing steps remove any linear intensity ramp present in the signal due to adverse lighting conditions and keeps the signal amplitude within a known dynamic range, typically [0 . . . 1] or [−1 . . . 1].  FIG. 9A  shows the raw unfiltered output of the extrema detection phase.  FIG. 9B  shows the filtered list of extrema after invalid extrema have been removed.  FIG. 9C  shows the final output of the extrema filtering phase after local multiples were coalesced into a single maximum or minima. 
     In some implementations at least two robust techniques for extrema finding can be used. A first technique uses a linear search (e.g., an argmax operator) over a sliding window to determine local extrema. A second technique uses slope filtering to determine when the signal slope undergoes a polarity change. Since slope filtering uses linear regression over a finite window length to fit a linear FIR model to the data, the slope filtering technique can robustly mitigate the adverse effects of noise in the barcode intensity profile. Accordingly, the slope filtering technique can be used under challenging lighting conditions (e.g., low light, high sensor noise). Slope filtering is describe in C. S. Turner, “Slope filtering: An FIR approach to linear regression,” IEEE Signal Processing Magazine, vol. 25, no. 6, pp. 159-163 (2008). 
     Both techniques operate over a short window of the intensity profile. This window length can be picked as a fixed multiple of the fundamental pitch of the intensity profile. The linear search technique is faster than the slope filtering technique. The linear search technique, however, can produce false detections due to being more sensitive to noise. To reduce false detections, the list of detected extrema can be filtered, as described below. 
     Find Extrema of Cropped Intensity Profile 
     Ideally there should be one maximum per peak (white bar) and one minimum per valley (black bar) of the bar code intensity profile. Unfortunately, the raw output of the extrema detection step ( FIG. 9A ) often have invalid extrema. The invalid extrema can be defined as local minima that occur in the high (peak) areas of the intensity profile and local maxima that occur in the low (valley) areas of the intensity profile. Additionally, there can be multiple extrema present each valley or peak. These invalid and superfluous extrema can be removed through a process called extrema filtering. 
     In some implementations, extrema filtering can include detecting and removing invalid extrema and coalescing multiples of local extrema. First, invalid extrema are removed and then multiple extrema in the same peak or valley of the intensity profile are coalesced into a single maximum or minimum. Invalid extrema are detected using either an adaptive threshold based comparator or an alpha-trimmed outlier detector. 
     Adaptive Threshold Based Extrema Rejection 
     The adaptive threshold based comparator sets the comparison threshold, T(x), to the mid-point between the local signal maximum h(x) and minimum g(x). The comparison threshold T(x) can be determined by calculating the max-min envelope of the intensity profile and then setting the comparison threshold to the middle of this band given by
 
 T ( x )=0.5*( h ( x )+ g ( x )),  [6]
 
with the maxima and minima envelope signals defined as
 
                       h   ⁡     (   x   )       =     max   ⁢     {       Y   ⁡     (     x   +   n     )       ❘     n   ∈     [       -       L   e     2       ,       L   e     2       ]         }         ,           [   7   ]                   g   ⁡     (   x   )       =     min   ⁢     {       Y   ⁡     (     x   +   n     )       ❘     n   ∈     [       -       L   e     2       ,       L   e     2       ]         }         ,           [   8   ]               
where L e  is the width of the window over which the maximum and minimum value is calculated. The extrema can now be compared to this threshold. Maxima that lie below this threshold and minima that lie above this threshold can be rejected.
 
Alpha-Trimmed Outlier Detection Based Extrema Rejection
 
     This technique first builds a second order statistical model for both the maxima and minima dataset using an alpha-trimmed estimate of the mean and covariance. The datasets can be first sorted and then the top and bottom  100 *α percent of the datasets can be excluded for the calculation of the mean and variance of the dataset (μ and σ 2 ). Each entry in the full dataset d i  can then be tested to see if it lies further than k*σ from the mean. If so, it can be rejected as an outlier. This decision rule can be given by
 
( d   i   −μ&gt;k σ)?reject:accept,  [9]
 
where kε[2, 3] is a sensitivity meta parameter.
 
       FIG. 9B  shows what the extrema of the intensity profile looks like after invalid entries are removed. Notice how certain peaks and valleys of the intensity profile now contain multiple maxima (in the peaks) and multiple minima (in the valleys). A simple linear search over the local set of extrema in a peak or valley can be used to determine the extrema with the largest absolute amplitude. This extrema can be kept and the rest of the extrema discarded. 
     Find Edges 
     Given a list of the filtered extrema, the position of the positive and negative edges can be calculated. The edge location can be calculated using a linear interpolation of the pixel x-coordinates of the two intensity profile samples that straddle the mid-value between consecutive maxima and minima. This procedure can include the following steps for each edge between two extrema:
         1. Calculate mid-point value between maxima and minima as follows
 
mid i   v =0.5*(maximum i   v +minimum i   v ),  [10]
   where maximum i   v  is the y-value (normalized intensity) of the ith maximum and minimum i   v  is the y-value (normalized intensity) of the ith minimum.   2. Find the two samples of the intensity profile Y(x) whose amplitude straddles the midpoint value. That is, find k i  such that Y(k)&lt;mid i   v &lt;Y(k+1) for positive edges and Y(k)&gt;mid i   v &gt;Y(k+1) for negative edges.   3. Calculate real valued {tilde over (k)} such that k&lt;{tilde over (k)}&lt;k+1 and {tilde over (Y)}({tilde over (k)})=mid i   v . Here {tilde over (Y)}(x) is a linear interpolation function between Y(k) and Y(k+1).   4. Set the real valued location of the ith edge to {tilde over (k)}.       

       FIGS. 10A and 10B  are plots illustrating the calculated edge locations for a typical barcode intensity profile using the technique just described.  FIG. 10A  shows the intensity profile.  FIG. 10B  shows a plot of the positive and negative edge locations of a barcode intensity profile, calculated from the filtered list of maxima and minima shown overlaid on the intensity profile in  FIG. 10A . 
     Edge List Consistency Checking 
     Once the list of positive and negative edges is calculated, the consistency of the list structure can be checked. The purpose of this step is to determine if the list structure is consistent with one of the types of known barcodes the system can decode. First, we check if the number of negative (high-to-low) and positive (low-to-high) edges of the intensity profile corresponds with the expected number for a given barcode type. Within this implementation, the following number of edges can be expected for the four main consumer product barcode types:
         EAN-13: 30 positive, 30 negative   EAN-8: 22 positive, 22 negative   UPC-A: 30 positive, 30 negative   UPC-E: 17 positive, 17 negative       

     Second, we determine if the list of edges forms a correctly interleaved set. That is, a negative edge should be followed by a positive edge and vice versa. Lastly, the list should start on a negative (high-to-low, white-to-black) edge and end with a positive (low-to-high, black-to-white) edge. Given a consistency check-list of consecutive edges, a linear sequence of symbol feature vectors can be calculated by applying the parameterizations shown in  FIGS. 3A-B . 
     Exemplary Machine Learning Based Decoding 
     In this section, a general approach is disclosed for implementing the final decoding/mapping step (step  408 ) of process  400  described in reference to  FIG. 4 . This step utilizes a data-driven machine learning based classifier. An advantage of this classifier is that the effect of noise and other inaccuracies in the preceding steps of the barcode decoding system are modeled. A noise model is incorporated into the off-line data generation phase which is used to train the classifier-based decoding back-end using supervised learning. This approach significantly increases robustness of the barcode decoder. 
     Due to the inherent presence of noise in the signal capturing front-end and other non-ideal corrupting influences (e.g., bad lighting, focus, optical distortion, non-planar packaging, user motion, etc.), the resulting calculated feature vector for any given symbol can be distorted from the ideal correct underlying representation. This distortion can be modeled as
 
{tilde over ({right arrow over ( s )})} i   =h ({right arrow over ( s )} i   ,{right arrow over (n)}   i ),  [11]
 
where h( ) is some potentially non-linear observation function, {right arrow over (s)} i =[L i , x i,0 , x i,1 , x i,2 , x i,3 ] are the symbol feature vectors as defined in reference to  FIGS. 3A-3B  and {right arrow over (n)} i  is a corrupting noise-like random variable. This distortion causes errors in the decoding process if not mitigated in some robust fashion. A simplification of the distortion can be given by
 
                             s     ⇀   ~       i     =       ⁢         s   ⇀     i     +       n   ⇀     i                   =       ⁢       [       L   i     ,     x     i   ,   0       ,     x     i   ,   1       ,     x     i   ,   2       ,     x     i   ,   3         ]     +       n   ⇀     i                   =       ⁢     [         L   i     +     n     i   ,   L         ,       x     i   ,   0       +     n     i   ,   0         ,       x     i   ,   1       +     n     i   ,   1         ,       x     i   ,   2       +     n     i   ,   2         ,       x     i   ,   3       +     n     i   ,   3           ]                   =       ⁢     [           L   ~     i     +       x   ~       i   ,   0         ,       x   ~       i   ,   1       ,       x   ~       i   ,   2       ,       x   ~       i   ,   3         ]       ,                 [   12   ]               
which states that each component of the symbol feature vector is corrupted by additive noise drawn from some probability density function. Typical noise models that can be used are Gaussian (white or colored) or uniform distributions.
 
Classifier Input Features
 
     To make the classification backend scale invariant, the noisy feature vectors of equation [10] can be transformed into a scale invariant form by normalizing each vector with its first component, the absolute length of each symbol, 
     
       
         
           
             
               
                 
                   
                     
                       y 
                       ⇀ 
                     
                     i 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 
                                   x 
                                   ~ 
                                 
                                 
                                   i 
                                   , 
                                   0 
                                 
                               
                               
                                 
                                   L 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           
                             
                               
                                 
                                   x 
                                   ~ 
                                 
                                 
                                   i 
                                   , 
                                   1 
                                 
                               
                               
                                 
                                   L 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           
                             
                               
                                 
                                   x 
                                   ~ 
                                 
                                 
                                   i 
                                   , 
                                   2 
                                 
                               
                               
                                 
                                   L 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                           
                             
                               
                                 
                                   x 
                                   ~ 
                                 
                                 
                                   i 
                                   , 
                                   3 
                                 
                               
                               
                                 
                                   L 
                                   ~ 
                                 
                                 i 
                               
                             
                           
                         
                       
                       ] 
                     
                     . 
                   
                 
               
               
                 
                   [ 
                   13 
                   ] 
                 
               
             
           
         
       
     
     The 4-dimensional feature vector of equation [13] can be used as input to the classification backend. 
     Classifier Implementation and Training 
       FIG. 11  is a block diagram of an exemplary data-driven classifier based decoding system  1100  that can be trained in a supervised fashion using noisy simulated input feature vectors. System  1100  includes a trainable machine-learning based classifier  1102  that is trained in a supervised fashion on datasets generated using the feature vector noise model given by equations [12] and [13]. Classifier  1102  is trained by a dataset including simulated noisy symbol feature vectors with a known target class. An input symbol feature vector generated by the DSP step  406  is input to classifier  1102 . The output of classifier  1102  is a posterior probability of an output class given the input feature vector. 
     The purpose of the classification backend is to map any input feature vector {right arrow over (y)}εR n  to one of the possible output classes corresponding with possible numerical value and parity of the corresponding input barcode digit. That is, classifier  1102  applies a function ƒ( ) to the input feature vector which maps it onto one of M potential classes
 
ƒ({right arrow over ( y )})→ c   j ,  [14]
 
where c j  is the label of the jth class with j=[0, 1, . . . , M−1]. The function ƒ( ) in equation [14] can be linear or non-linear. This operation can be repeated for each one of the N input feature vectors {right arrow over (y)} i  with i=[0, 1, . . . , N−1] in the linear sequence of symbol feature vectors generated by the DSP step  406  of  FIG. 4 .
 
     Specifically, for classifying the input feature vectors given by equation [13] into the integer digits 0 through 9 (even and odd parity), classifier  1102  maps real valued vectors in R 4  into one of 20 discrete classes. Classifier  1102  can be any known classifier algorithm, provided the algorithm is trainable in a supervised fashion using a representative training set of input feature vectors and known class labels. Some examples of suitable classifiers include but are not limited to multi-layer neural networks (MLP-NN), radial basis function neural networks (RBF), support vector machines (SVM), and classification and regression trees. 
     In some implementations, a three-layer MLP neural network can be used as a classifier. The three layer MLP neural network can have a 4-7-20 architecture (4 input units, 7 hidden units, 20 output units) and use hyperbolic tangent nonlinearities in the input and hidden layers and a one-hot encoded soft-max sigmoid output layer. This allows the real valued outputs of each of the 20 output units to be treated as posterior probabilities of the class conditioned on the input symbol feature vector, p(c j |{right arrow over (y)} i ). 
       FIG. 12  is a plot illustrating neural network output class probabilities for a sequence of input symbol feature vectors. Specifically,  FIG. 12  displays a graphical representation of the probabilistic output of the neural network classifier for the decoding of a 12 digit UPC-A barcode. Each row of the 2D plot displays the posterior probabilities of each of the 20 output classes for that specific symbol feature vector in the input sequence. There are 20 classes since each of the ten digits [0, 1, . . . , 9] can have one of two parities, even or odd, depending on the encoding symbols set. 
     Referring to  FIG. 12 , the y-axis indicates the index of the input symbol feature vector in the digit sequence and the x-axis indicates the index of the respective neural network output units. Since a one-hot encoding scheme is used for the output layer, the output units can be treated as actual posterior probabilities of the class given the input p(c j |{right arrow over (y)} i ), where j is the class index and i is the input symbol index (in the input sequence). The brightest spots per input row indicate the output units with the highest output probability. The input sequence presented to the neural network classifier in this example decodes to [0, 7, 3, 3, 3, 3, 4, 3, 4, 6, 1, 3], where the first 6 digits have odd parity (classes 0 through 9) and the last 6 digits have even parity (classes 10 through 19). 
     Decoding an input symbol feature vector into a barcode digit can be accomplished by applying the input vector to the neural network and picking the output class with the highest posterior probability. Furthermore, an overall confidence score can be computed for the complete decoding of the barcode by averaging the maximum per-symbol output probability for the whole sequence, 
     
       
         
           
             
               
                 
                   γ 
                   = 
                   
                     
                       1 
                       N 
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           0 
                         
                         
                           N 
                           - 
                           1 
                         
                       
                       ⁢ 
                       
                         max 
                         ⁢ 
                         
                           
                             { 
                             
                               
                                 p 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       c 
                                       j 
                                     
                                     ❘ 
                                     
                                       
                                         y 
                                         ⇀ 
                                       
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                               ❘ 
                               
                                 j 
                                 ∈ 
                                 
                                   [ 
                                   
                                     0 
                                     , 
                                     1 
                                     , 
                                     … 
                                     ⁢ 
                                     
                                         
                                     
                                     , 
                                     
                                       M 
                                       - 
                                       1 
                                     
                                   
                                   ] 
                                 
                               
                             
                             } 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   [ 
                   15 
                   ] 
                 
               
             
           
         
       
     
     The score in equation [15] can be compared against a gating threshold to determine if the quality of a barcode decode is high enough or if it should be rejected. 
     Exemplary Classifier Training 
     The neural network classifier  1102  can be trained in a supervised fashion using a regularized scaled conjugate gradient algorithm. For example, cross-validated weight-decay regularization can be used to ensure that the neural network does not over fit the training data. This in turn ensures a robust generalization performance for real-world (post training) use. 
     The training dataset can be synthesized by generating the symbol feature vectors for the full set of output classes using the barcode symbol parameterization shown in  FIGS. 3A-3B  and the encoding alphabet shown in  FIG. 2 . 
     The size and diversity of the training dataset can be increased Q-fold by generating Q independent random variable noise samples {right arrow over (n)} i  for each noiseless input feature vectors {right arrow over (S)} i , and then simulating Q new noisy feature vectors {right arrow over (y)} i  using equations [12] and [13]. 
     This training dataset captures the real distortions, which might be encountered during the imperfect conversion of captured barcode into a symbol feature vector sequence. Training the classifier  1102  on this data with the correct a priori known target classes provides robust real-world performance. 
     Exemplary Barcode Decoding Process 
       FIG. 13  is an exemplary process  1300  for barcode recognition. The process  1300  can begin by converting a barcode image into an electronic representation ( 1302 ). The barcode image can be converted as described in reference to  FIGS. 1-10 . Next, symbol feature vectors are extracted from the electronic representation to form a sequence of symbol feature vectors ( 1304 ), as described in reference to  FIGS. 1-10 . The symbol feature vectors are then mapped into digit sequence using a classifier trained from a dataset of simulated noisy symbol feature vectors with known target classes ( 1306 ), as described in reference to  FIGS. 11 and 12 . 
     Exemplary System Architecture 
       FIG. 14  is a block diagram of an exemplary system architecture implementing the barcode decoding system according to  FIGS. 1-13 . The architecture  1400  can be implemented on any electronic device that runs software applications derived from compiled instructions, including without limitation personal computers, servers, smart phones, media players, electronic tablets, game consoles, digital cameras, video cameras, email devices, etc. In some implementations, the architecture  1400  can include one or more processors  1402 , one or more input devices  1404 , one or more display devices  1406 , image capture device  1408  and one or more computer-readable mediums  1410 . Each of these components can be coupled by bus  1412 . 
     Display device  1406  can be any known display technology, including but not limited to display devices using Liquid Crystal Display (LCD) or Light Emitting Diode (LED) technology. Processor(s)  1402  can use any known processor technology, including but are not limited to graphics processors and multi-core processors. Input device  1404  can be any known input device technology, including but not limited to a keyboard (including a virtual keyboard), mouse, track ball, and touch-sensitive pad or display. Bus  1412  can be any known internal or external bus technology, including but not limited to ISA, EISA, PCI, PCI Express, NuBus, USB, Serial ATA or FireWire. Computer-readable medium  1410  can be any medium that participates in providing instructions to processor(s)  1402  for execution, including without limitation, non-volatile storage media (e.g., optical disks, magnetic disks, flash drives, etc.) or volatile media (e.g., SDRAM, ROM, etc.). 
     Computer-readable medium  1410  can include various instructions  1414  for implementing an operating system (e.g., Mac OS®, Windows®, Linux). The operating system can be multi-user, multiprocessing, multitasking, multithreading, real-time and the like. The operating system performs basic tasks, including but not limited to: recognizing input from input device  1404 ; sending output to display device  1406 ; keeping track of files and directories on computer-readable medium  1410 ; controlling peripheral devices (e.g., disk drives, printers, etc.) which can be controlled directly or through an I/O controller; and managing traffic on bus  1412 . Network communications instructions  1416  can establish and maintain network connections (e.g., software for implementing communication protocols, such as TCP/IP, HTTP, Ethernet, etc.). 
     An image capture application  1418  can include instructions that operate the image capture device  1408 . The image capture device  1408  can be an embedded device or a separate device coupled to system architecture  1400  through a port (e.g., USB, FireWire). 
     Barcode recognition instructions  1420  can be a barcode recognition application that implements the capture, DSP and decoding processes described in reference to  FIGS. 1-13 . The barcode recognition instructions  1420  can also be implemented as part of operating system  1414 . 
     Example Online Payment System 
       FIG. 15  illustrates user interface  1502  for an online payment application running on mobile device  1500 . In some implementations, an online payment application can be opened on mobile device  1500  (e.g., smart phone, e-tablet). The payment application can present user interface  1502 , which allows a user to select various functions related to online payments, including but not limited to scanning barcodes on product packaging, researching products, reading product ratings and reviews, obtaining Q&amp;As and paying for products. An example payment application is EasyPay®, developed by Apple Inc. of Cupertino, Calif., USA. 
     Example Intelligent Preview Scaling 
       FIG. 16  illustrates user interface  1600  for capturing an image of a barcode  1602  provided by the online payment application described in reference to  FIG. 15 . In the example shown, a user can scan barcode  1602  by holding device  1500  over barcode  1602  so that a camera system embedded in mobile device  1500  can capture an image of barcode  1602 . The user can capture an image of barcode  1602  by positioning a camera lens over barcode  1602  such that barcode  1602  is contained within target guide  1604  (e.g., a rectangular bounding box). Target guide  1604  provides a visual aid to the user in lieu of actual instructions and also provides a straightforward way to distinguish among several barcode symbols that may be captured by the camera in a given frame. 
     Note that the placement of target guide  1604  occupies a substantial portion of the screen that does not correspond to a fraction of the image sensor capturing barcode  1602 . Instead of scaling target guide  1604  to fit the size of the image preview of barcode  1602  (a live video feed) as done in conventional systems, the image preview of barcode  1602  is scaled to fit the size of target guide  1604 . Given the size of barcode  1602 , the optimal distance from the camera sensor (CMOS or CCD), and user interface  1600 , the image preview of barcode  1602  is scaled such that barcode  1602  maintains an optimal distance from the camera lens and lies within target guide  1604 , as shown in  FIG. 16 . 
     The optimal scaling can be determined by finding a mapping from physical real world space onto the sensor using a suitable geometric model. The optimal scaling of the image preview of barcode  1602  implicitly encourages the optimal positioning of the camera lens by the user. The optimal scaling can also be used to constrain user interface  1600 , requiring user interface  1600  to use a larger or smaller target guide  1604 , depending on factors such as the optical magnification of barcode  1602  or the total active area of the camera sensor. For example, it may not make sense to scale a preview image of barcode  1602  too far beyond one screen pixel to one image pixel. It also may not make sense to scale down the preview image of barcode  1602  so far that there is substantial image-free space on the screen. 
     Example Geometric Model 
       FIG. 17  is a graph illustrating a pinhole camera model. The pinhole camera model directly relates the distance d of an object of length h from a camera lens (at the origin) to a camera sensor at distance d′. The object&#39;s image on the camera sensor has in some dimension a length h′. The basic trigonometric model illustrated in  FIG. 17  relates these quantities as 
     
       
         
           
             
               
                 
                   
                     h 
                     d 
                   
                   = 
                   
                     
                       h 
                       ′ 
                     
                     
                       d 
                       ′ 
                     
                   
                 
               
               
                 
                   [ 
                   16 
                   ] 
                 
               
             
           
         
       
     
     The optimal values for h, d and d′ are typically measured during manufacture and provided directly by image capture software running on device  1500  or derived from information (e.g., 35 mm equivalent focal length) often provided by the camera system as image metadata. h′ represents a fraction of the total length of the image sensor of some dimension, and this fraction can be scaled to occupy a suitable region of user interface  1600  using Equations [17] given by 
     
       
         
           
             
               
                 
                   
                     
                       s 
                       w 
                     
                     = 
                     
                       
                         h 
                         v 
                       
                       * 
                       
                         
                           w 
                           r 
                         
                         
                           ( 
                           
                             
                               w 
                               view 
                             
                             * 
                             
                               w 
                               o 
                             
                           
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       s 
                       h 
                     
                     = 
                     
                       
                         h 
                         h 
                       
                       * 
                       
                         
                           h 
                           r 
                         
                         
                           ( 
                           
                             
                               h 
                               view 
                             
                             * 
                             
                               h 
                               o 
                             
                           
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                   ⁢ 
                   
                     Scale 
                     = 
                     
                       MIN 
                       ⁡ 
                       
                         ( 
                         
                           
                             s 
                             w 
                           
                           , 
                           
                             s 
                             h 
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   [ 
                   17 
                   ] 
                 
               
             
           
         
       
     
     where h v , h h  represent, respectively, linear dimension h of the field-of-view from the pinhole model (see  FIG. 17 ) along the vertical and horizontal axis. s w , s h  are the scale factors along the width and height axes of the camera sensor. w o , h o  are the width and height of the object (e.g., barcode  1602 ). w r , h r  are the width and height of target guide  1604  in user interface  1600 —the image preview that is to be magnified to fit into target guide  1604 . 
     h v , h h  are the width and height of the screen region or view that contains the image preview of barcode  1602 . These measurements can be in the same coordinate system and units as w r , h r . The underlying assumption is that the scale factor is computed relative to a camera image preview rectangle entirely contained in the screen region (view) in an aspect-preserving manner. 
     In some implementations, a more sophisticated model, taking lens and sensor characteristics as well as macro photographic effects into account, can be used to provide more refined estimates for performing this scaling, when, for example, the object to be identified (e.g., barcode  1602 ) is positioned away from the optical center of the camera lens. In this case, the trigonometric model may not predict the length of the image on the sensor with sufficient accuracy. 
     A parametric extension of the pinhole camera model that takes these effects into account is given by the following homogeneous coordinate formulation: 
                       z   c     =       [         u           v           1         ]     =       A   ⁡     [         R       T         ]       ⁡     [           x   w               y   w               z   w             1         ]           ,           [   18   ]               
where R and T are the camera rotation and translation matrices, respectively, and A is called the camera&#39;s intrinsic matrix, given by
 
     
       
         
           
             
               
                 
                   A 
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               α 
                               x 
                             
                           
                           
                             γ 
                           
                           
                             
                               u 
                               o 
                             
                           
                         
                         
                           
                             0 
                           
                           
                             
                               α 
                               y 
                             
                           
                           
                             
                               v 
                               o 
                             
                           
                         
                         
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                         
                       
                       ] 
                     
                     . 
                   
                 
               
               
                 
                   [ 
                   19 
                   ] 
                 
               
             
           
         
       
     
     The parameters of the intrinsic matrix relates to focal length, sensor aspect ratio and camera principal point. The parameters α x =f·m x  and α y =f·m y  represent focal length in terms of pixels, where m x  and m y  are scale factors relating pixels to physical distance. γ represents the skew coefficient between the x and y-axes, and (u o , v o ) represents the principal point (e.g., the origin) of the image on the camera sensor. This model can be extended further (nonlinearly) to include lens distortion effects, as described in specifications and tutorials for the publicly available Open Source Computer Vision Library (OpenCV) of programming functions for real-time computer vision, developed by Intel Corporation and supported by several open source organizations (e.g., itseez.com, Willow Garage (www.willowgarage.com)). 
     The parameters of these more sophisticated models are commonly estimated through formal camera model calibration. During such a calibration process, several images of a calibration target are captured from a variety of positions with the camera to be calibrated. An example calibration target that includes a checkerboard pattern is shown in  FIG. 18 . These images sample the spatial optical response of the camera-lens system forming an over determined set of measurements which can be used to estimate the unknown model parameters using an optimization algorithm, such as least-squares or related non-linear approaches, such as described in S. S. Rao, “Engineering Optimization: Theory and Practice,” John Wiley &amp; Sons, 1996. 
     Barcode-Aware Autofocus Augmentation 
     Ideally, autofocus cameras should analyze an entire scene, make a global determination about the area of interest in the image, and then focus appropriately. Conventional autofocus processes, however, can be deficient or sub optimal for barcodes with small features (e.g., barcode  1602 ). 
     For barcodes with small features, a custom focus metric is computed. The custom metric is used to detect when a barcode may be out of focus and instruct the camera system to refocus explicitly at a particular target point in the image. This target point may be determined by the user interface, user input or some automatic barcode location process. The custom metric constructs a histogram from a first order differentiation of a linear image scan. In the simplest case, this is just a first order difference signal calculated from a normalized single linear sweep (intensity profile) across the camera sensor at a particular vertical position. This difference signal is then binned using a histogram calculation process (e.g., a one-dimensional (1D) histogram calculation process). 
       FIGS. 19A-19C  and  FIGS. 20A-20C  illustrate, respectively, unfocused an focused signal statistics of an image of a barcode.  FIGS. 19A, 20A  show a normalized scan intensity profile signal.  FIGS. 19B, 20B  shows the first order derivative signal calculated from the normalized intensity profile.  FIGS. 19C, 20C  show the histogram of the derivative signal. 
       FIG. 20C  illustrates that the histogram of the focused signal has significantly longer tails in the histogram distribution than that of the unfocused signal. The custom focus metric calculates the amount of normalized probability mass in the tails of the histogram distribution and compares it with a predetermined threshold value according to Equation [20]: 
                     m   =     (         ∫     -   ∞       -   α       ⁢     p   ⁡     (   x   )         +       ∫   α   ∞     ⁢     p   ⁡     (   x   )           )       ,     
     ⁢     focused   =     {         1             if   ⁢           ⁢   m     &lt;   β     ,             0             if   ⁢           ⁢   m     ≤   β     ,                       [   20   ]               
where p(x) is the normalized histogram approximation of the probability density function of the derivative signal, α defines the tails and β defines the amount of normalized mass needed in the tails for the in-focus hypothesis. In some implementations, a good robust behavior can be found by setting the tail parameter to a nominal value of α≈0.2 and the mass focus threshold to a value β≈0.2. These values can be optimized for robust focus behavior on typical signal profiles for high spatial frequency 1D barcodes (e.g., barcode  1602 ).
 
     Based on the calculated value of the focus metric m and the current state of an autofocus engine in the camera system (e.g., is the camera system already focusing or not), the camera system can explicitly refocus based on the focus metric m. 
     Multi-Scale Feature Extraction 
     One of the stages of barcode decoding includes signal envelope detection, as described above in reference to Equations [6]-[8]. The signal envelope is used by a subsequent filtering stage that is used for calculating robust barcode symbol features, which are fed as input to a machine learning based backend classifier (e.g., multilayer neural network) as described in reference to  FIGS. 11-15 . 
     The signal envelope detection stage is sensitive to the resolution of the barcode signal, which can vary significantly due to user handling of the camera or the desire to decode unusually small (or large) barcode signals. This stage can be made more robust by computing the signal envelope at several different spatial scales, typically near the information-theoretic size of the barcode projected on the camera sensor at the optimal distance, which is often (but not always) the nearest distance to the object at which the camera lens is able to focus. 
     This multi-scale envelope detector can be implemented as an early abort cascade in which the camera system sweeps operation values of critical parameters of the envelope detector and signals an extra filtering process. The nominal operating point and range extent of these parameter windows can be chosen to maximize scanning robustness using a cross validation approach on a large set of typical test cases. 
     In some implementations, the envelope detector calculates the envelope e(x) of an intensity profile signal Y(x) given a spatial parameter L e /2, where L e  is the width of the window over which the maximum and minimum values are calculated or the number of pixels around the intensity profile signal Y(x) which can influence the envelope value computed at the same location. In other words, the envelope signal e(x) is a function of the values the function Y(x) can take on the interval [x−L e /2, x+L e /2], or {Y(T)|x−L e /2&lt;=T&lt;x+L e /2}, where T is the comparison threshold of Equation [6]. 
     Different values for L e /2 will result in different function envelopes, and the envelope that is often (but not always) optimal for the barcode decoding technique described in this document will use a spatial scale parameter, L e /2, which corresponds to the number of image pixels used by a single bar in the barcode. If L e /2 is smaller than this number, the envelope tends to be unduly influenced by noise. If L e /2 is much larger than this number, then the calculated barcode symbol features tend to omit narrower bars and gaps in the barcode. 
       FIG. 24  is a plot of integrated barcode signal intensity (normalized and detrended) illustrating upper (h(x)) and lower (g(x)) envelopes  2402 ,  2404  and an adaptive threshold  2406 . 
     Further, since the camera sensor can measure the quality of a specific barcode decode based on the average output score of the neural network decoder backend, adaptive feedback can be used to guide the multi-scale preprocessing stage. 
     This early abort multi-scale processing cascade can potentially also be exploited to improve runtime performance by reducing the probability of doing unnecessary (and potentially power and CPU costly) signal processing in the nominal case. 
       FIG. 21  is a flow diagram of exemplary process  2100  of intelligent preview scaling. In some implementations, process  2100  can begin by capturing a digital image of an object ( 2102 ). Process  2100  can continue by scaling the image of the object to lie within an image view area of a user interface, while a distance (e.g., an optimal distance) is maintained between the object and the sensor ( 2104 ). The scaling can be on a geometric model, as described in reference to  FIGS. 15-20 . 
       FIG. 22  is a flow diagram of an exemplary process  2200  of barcode-aware autofocus augmentation. In some implementations, process  2200  can begin by capturing a digital image of an object ( 2202 ). Process  2200  can continue by detecting that the object is not in focus using a focus metric ( 2204 ). The focus metric can be determined as described by Equation [20]. Process  2200  can continue by automatically refocusing at a target point in the image ( 2206 ). For example, the focus metric can be used, together with the current state of autofocus (e.g., is the camera system already focusing or not) to trigger the camera system to refocus at a target point in the image. 
       FIG. 23  is a flow diagram of an exemplary process  2300  of multi-scale signal feature extraction. In some implementations, process  2300  can begin by capturing a digital image of an object ( 2302 ). Process  2300  can continue by calculating an envelope signal from an image at different spatial scales ( 2304 ). Process  2300  can continue by filtering the envelope signal to extract object features ( 2306 ). 
     The described features can be implemented advantageously in one or more computer programs that are executable on a programmable system including at least one programmable processor coupled to receive data and instructions from, and to transmit data and instructions to, a data storage system, at least one input device, and at least one output device. A computer program is a set of instructions that can be used, directly or indirectly, in a computer to perform a certain activity or bring about a certain result. A computer program can be written in any form of programming language (e.g., Objective-C, Java), including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. 
     Suitable processors for the execution of a program of instructions include, by way of example, both general and special purpose microprocessors, and the sole processor or one of multiple processors or cores, of any kind of computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memories for storing instructions and data. Generally, a computer will be coupled to one or more mass storage devices for storing data files; such devices include magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and optical disks. Storage devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, including by way of example semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, ASICs (application-specific integrated circuits). 
     To provide for interaction with a user, the features can be implemented on a computer having a display device such as a CRT (cathode ray tube) or LCD (liquid crystal display) monitor for displaying information to the user and a keyboard and a pointing device such as a mouse or a trackball by which the user can provide input to the computer. 
     The features can be implemented in a computer system that includes a back-end component, such as a data server, or a middleware component, such as an application server or an Internet server, or that includes a front-end component, such as a client computer having a graphical user interface or an Internet browser, or any combination of them. The components of the system can be connected by any form or medium of digital data communication such as a communication network. Examples of communication networks, include, e.g., a LAN, a WAN, and the computers and networks forming the Internet. 
     The computer system can include clients and servers. A client and server are generally remote from each other and typically interact through a network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. 
     One or more features or steps of the disclosed embodiments can be implemented using an API. An API can define on or more parameters that are passed between a calling application and other software code (e.g., an operating system, library routine, function) that provides a service, that provides data, or that performs an operation or a computation. 
     The API can be implemented as one or more calls in program code that send or receive one or more parameters through a parameter list or other structure based on a call convention defined in an API specification document. A parameter can be a constant, a key, a data structure, an object, an object class, a variable, a data type, a pointer, an array, a list, or another call. API calls and parameters can be implemented in any programming language. The programming language can define the vocabulary and calling convention that a programmer will employ to access functions supporting the API. 
     In some implementations, an API call can report to an application the capabilities of a device running the application, such as input capability, output capability, processing capability, power capability, communications capability, etc. 
     A number of implementations have been described. Nevertheless, it will be understood that various modifications may be made. For example, other steps may be provided, or steps may be eliminated, from the described flows, and other components may be added to, or removed from, the described systems. Accordingly, other implementations are within the scope of the following claims.