Method and system for removal of flash artifacts from digital images

[0002] The present invention relates to removal of red-eye and other flash-based artifacts from digital images.

[0003] When photographs are taken of people using a digital or traditional film camera with a flash, a common artifact that can appear in the picture is referred to as “red-eye.” This artifact manifests itself as a red coloration within the pupils of eyes, instead of the natural black or dark gray color, and is referred to as a “flash effect.”

[0004] Red-eye is caused by the reflection of light from a flash off of the blood vessels of the retinas of a subject's eyes. One can try to reduce the red-eye by increasing the light level in the room by turning on all the lights. Alternatively, one can have a subject look at a bright light, such as a room lamp, just before taking the flash picture. Both methods of red-eye reduction described above cause the subject's pupils to contract, thereby reducing the amount of reflective surface.

[0005] Interestingly, this flash effect appears as red eyes in humans, but as yellow eyes in dogs and cats, and green eyes in some other animals. Photographers and image compositors commonly touch up their images and remove the flash effects from the eyes.

[0006] Adobe's PhotoDeluxe™ 2.0 and Microsoft's PictureIt!™ 2.0 are digital photo-editing software applications that offer semi-automatic red-eye removal as a feature. Such software applications require a user to select a region surrounding a group of pixels that are corrupted by red-eye. In operating PhotoDeluxe 2.0, for example, a user selects a red-eye area, clicks a button and then the eyes return to their natural color.

[0007] There is provided in accordance with a preferred embodiment of the present invention a method for removal of flash artifacts from a digital image containing pixels therein, including using a database of reference flash-corrupted images for identifying corrupted pixels within the digital image that have been corrupted by a flash, and modifying the color values of each corrupted pixel of the digital image, to correct the corrupted pixel color values.

[0008] There is also provided in accordance with a preferred embodiment of the present invention a method for detecting flash artifacts in a digital image containing pixels therein, including analyzing pixel color values for a group of pixels in the digital image, to determine a likelihood that each pixel of the group of pixels would be classified as flash-corrupted, based on a database of reference flash-corrupted images, and employing the likelihoods for identifying corrupted pixels within the digital image that have been corrupted by a flash.

[0009] There is also provided in accordance with a preferred embodiment of the present invention a method for removal of flash artifacts from a digital image containing pixels therein, including automatically identifying corrupted pixels within the digital image that have been corrupted by a flash, and modifying the color values of each corrupted pixel of the digital image, to correct the corrupted pixel color values.

[0010] There is also provided in accordance with a preferred embodiment of the present invention a system for removal of flash artifacts from a digital image containing pixels therein, including a pixel processor identifying corrupted pixels within the digital image that have been corrupted by a flash, based on a database of reference flash-corrupted images, and a color processor modifying the color values of each corrupted pixel of the digital image, to correct the corrupted pixel color values.

[0011] There is also provided in accordance with a preferred embodiment of the present invention a system for detecting flash artifacts in a digital image containing pixels therein, including a pixel analyzer analyzing pixel color values for a group of pixels in the digital image, to determine a likelihood that each pixel of the group of pixels would be classified as flash-corrupted, based on a database of reference flash-corrupted images, and a pixel processor employing the likelihoods for identifying corrupted pixels within the digital image that have been corrupted by a flash.

[0012] There is also provided in accordance with a preferred embodiment of the present invention a system for removal of flash artifacts from a digital image containing pixels therein, including a pixel processor automatically identifying corrupted pixels within the digital image that have been corrupted by a flash, and a color processor modifying the color values of each corrupted pixel of the digital image, to correct the corrupted pixel color values.

[0013] There is also provided in accordance with a preferred embodiment of the present invention a photo kiosk including a touch-sensitive screen, red-eye correction apparatus, and a photo printer unit.

[0014] The present invention will be more fully understood and appreciated from the following detailed description, taken in conjunction with the drawings in which:

[0015] FIG. 1 is a simplified illustration of a red-eye removal feature of a photo kiosk, in accordance with a preferred embodiment of the present invention;

[0016] FIG. 2 is a simplified flow chart illustrating how parameters for each reference image are estimated in a preferred embodiment of the present invention;

[0017] FIG. 3 is a simplified flow chart of a photo kiosk application that identifies flash-corrupted pixels in a digital image, based on a database of reference images, in accordance with a preferred embodiment of the present invention; and

[0018] FIG. 4 is an illustration of a touch-sensitive screen presented to a user of a preferred embodiment of the present invention.

[0019] FIG. 5 is a block diagram of a processing system that can be used to perform processing operations used in embodiments of the present invention.

[0020] In accordance with a preferred embodiment of the present invention, removal of flash effects is effected by two essential steps. First, the pixels that have been corrupted by the flash are identified, either (i) semi-automatically using a database of reference flash-corrupted images, or (ii) fully automatically. Second, the color values of the corrupted pixels are corrected.

[0021] The term “pixel” is used herein to denote a picture element of a digital image. A pixel has both a location, referred to as the pixel location, and a color, referred to as the pixel color. The pixel color is characterized by a pixel color value, which is typically a triplet of three individual color channel values, such as red (R), green (G) and blue (B). The R, G and B values may be 8-bit integer values ranging from 0 to 255. Many other well-known color spaces may also be used, and color channels may also have precisions other than 8 bits.

[0022] Identifying the pixels that have been corrupted by the flash is complicated by the fact that non-corrupted pixels in the vicinity of those that have been corrupted may have a similar color to that of the flash artifact. For example, in the case of humans, pink skin color near an eye may have a similar color to the red-eye portion of the eye, but must be distinguished from red flash-corrupted pixels. If one were only to use the red color component in identifying the “red-eye” pixels, pixel locations where natural pink skin color is present might also be identified, and then improperly “corrected.”

[0023] One possible approach is to manually select each flash-corrupted pixel, but since the user of the application must carry this out for each image processed, this is far too time consuming for practical use. Clearly a fully or near-fully automated method is preferred. The method used by the present invention in carrying out the identification of corrupted pixels is such an automated method, and is described in detail hereinbelow.

[0024] In accordance with a preferred embodiment of the present invention, correcting the color values of the corrupted pixels is carried out by converting the flash-corrupted pattern to a natural textural pattern. The eye's outer surface consists of three concentric areas: the white, the iris and the pupil. The white is the outer area, the iris is the colored middle area commonly used to determine the “color” of one's eyes, and the pupil is the black or dark gray inner area. The flash effect occurs in the pupil. The present invention corrects the flash effect by converting the color values of the corrupted pixels to an appropriate gray-scale monochrome color value.

[0025] For color values specified using the familiar triplet of red (R), green (G) and blue (B) color channels, the correction proceeds by modifying a color value of (R, G, B) to a color value of (Y, Y, Y). In a preferred embodiment of the present invention, the monochrome Y channel values are a function of the green and blue channel values alone. Some exemplary choices are

[0026] Y=max(G, B), Y=min(G, B), Y=_(G+B). It should be pointed out that the G and B values are typically both very small within the pupil, even for flash-corrupted pixels, and as such, the exemplary choices indicated above tend to produce similar values of Y, corresponding to a dark gray or black color.

[0027] Reference is now made to FIG. 1, which is a simplified illustration of a red-eye removal feature of a photo kiosk 10, in accordance with a preferred embodiment of the present invention. The kiosk 10 illustrated in FIG. 1 contains a reader 12 for inputting a photo 14, and a printing device 16 for outputting a photo product 22, such as a poster, personalized stationary, business cards, an invitation or a calendar. It also provides features that enable a user 18 to edit the photo 14.

[0028] The user 18 inputs the photo 14 into the kiosk 10. If the photo is corrupted by red-eye, the user can correct this by positioning a circular cursor 20 around pixels corrupted by red-eye, and instructing the kiosk 10 to remove the red-eye. Upon such instruction, the kiosk 10 runs a software application that carries out red-eye removal in accordance with a preferred embodiment of the present invention, as described with reference to FIG. 3 below. After the red-eye is corrected, the user 18 can further edit the photo 14. Upon completion of the editing, the user can print the photo product 22 by means of the printer device 16 that forms part of the photo kiosk 10.

[0029] Pre-processing the reference images

[0030] The present invention uses a database of digital images with flash effects to identify those pixels of any subject digital image that are flash-corrupted. The database is constructed from a collection of images used as references.

[0031] For each reference image, the flash-corrupted pixels are identified either manually or automatically, or by a combination of both. Alternatively, the reference images can be set up initially so that all of the pixels contained therein are part of a flash-corrupted effect, obviating the need for manual or automatic identification. Because, in at least one embodiment, the reference images are processed by the application developer, rather than the user, a manual approach, although more time-consuming and less desirable than an automatic approach, is nevertheless possible.

[0032] For each reference image, once the flash-corrupted pixels have been identified, the pixel color values (r_n, g_n, b_n) of those pixels are used as samples for statistical estimation of a probability distribution function for the flash effect. The subscript n above is used to index the flash-corrupted pixels of a reference image. In a preferred embodiment of the present invention, a model is assumed for a probability density function f(r, g, b; p), where p is a vector of unknown parameters of the distribution to be estimated from the sample data {(r_n, g_n, b_n)}. In one embodiment of the present invention, the probability density function f(r, g, b; p) is taken to be tri-variate Gaussian, and its vector of means and matrix of covariances are estimated from the sample data. A general reference for statistical estimation procedures is Hogg and Tanis, “Probability and Statistical Inference,” ISBN: 0132546086, published by Prentice-Hall.

[0033] The following source code listing, written in the C++ programming language, carries out the calculations for the means and covariances in accordance with a preferred embodiment of the present invention. In the listing, Image24BMP is a data structure for a 24-bit color image, and the pixel color values are stored in the array itsData[ ]. Specifically, itsData[i] contains the red, green and blue color values for pixel number i, where i runs serially from 0 to the total number of pixels in the image, which is itsNCols*itsNRows. As can be seen in the listing, the red, green and blue averages are calculated by averaging the red, green and blue values of the pixels. The covariances are calculated by averaging the products of the red, green and blue values of the pixels with their respective averages subtracted off. The array XminusMU[ ] is used to store the pixel color data with the appropriate average subtracted off.

[0034] double Image24BMP::GetRedAverage( ) const

[0035] {

[0036] double aRedAverage=0.0;

[0037] for (int i=0; i<itsNCols*itsNRows; i++)

[0038] RedAverage=aRedAverage+

[0039] (double)itsData[i].GetRed( );

[0040] aRedAverage=aRedAverage/(itsNCols*itsNRows);

[0041] return(aRedAverage);

[0042] }

[0043] double Image24BMP::GetGreenAverage( ) const

[0044] {

[0045] double aGreenAverage=0.0;

[0046] for (int i=0; i<itsNCols*itsNRows; i++)

[0047] aGreenAverage=aGreenAverage+

[0048] (double)itsData[i] .GetGreen( );

[0049] aGreenAverage=aGreenAverage/(itsNCols*itsNRows);

[0050] return(aGreenAverage);

[0051] }

[0052] double Image24BMP: :GetBlueAverageo const

[0053] {

[0054] double aBlueAverage=0.0;

[0055] for (int i=0; i<itsNCols*itsNRows; i++)

[0056] aBlueAverage=aBlueAverage+

[0057] (double)itsData[i].GetBlue( );

[0058] aBlueAverage=aBlueAverage/(itsNCols*itsNRows);

[0059] return(aBlueAverage);

[0060] }

[0061] MatrixSquare3 Image24BMP::

[0062] GetSigma(const Image24BMP& theImage)

[0063] {

[0064] MatrixSquare3 SigmaMatrix;

[0065] double *XMinusMu, BufSigma;

[0066] double RedAverage, GreenAverage,

[0067] BlueAverage;

[0068] int i,j;

[0069] XMinusMu=new double[3*itsNCols*itsNRows];

[0070] RedAverage=thehmage.GetRedAverage( );

[0071] GreenAverage=theImage.GetGreenAverage( );

[0072] BlueAverage=theImage.GetBlueAverage( );

[0073] for (i=0;

[0074] i<(theImage.GetNCols( )*thelnage.GetNRows( )); i++)

[0075] {

[0076] XMinusMu[i]=theImage[i].GetRed( )—RedAverage;

[0077] XMinusMu[i+itsNCols*itsNRows]=theImage[i].GetGreeno—GreenAverage;

[0078] XMinusMu[i+2*itsNCols*itsNRows]=theImage[i].GetBlue( )—BlueAverage;

[0079] }

[0080] for (i=0; i<3; i++)

[0081] {

[0082] for j=0; j<3; j++)

[0083] {

[0084] BufSigma=0; for (int k=0; k<itsNCols*itsNRows; k++)

[0085] BufSigma=BufSigma+XMinusMuk[+i*itsNCols*itsNRows]*

[0086] XMinusMu[k+j*itsNCols*itsNRows];

[0087] SigmaMatrix[j+i*3]=BufSigma/(float)(itsNCols*itsNRows −1);

[0088] }

[0089] }

[0090] delete [ ] XMinusMu; return(SigmaMatrix);

[0091] }

[0092] For color spaces such as CMYK, with more or fewer color channels, a multi-variate Gaussian of a different dimensionality can be used instead of the tri-variate Gaussian. Similarly, non-Gaussian distributions may also be used instead.

[0093] Reference is now made to FIG. 2, which is a simplified flow chart illustrating how the above-described estimation of parameters is performed for each reference image. Initially, at step 200, all reference images are marked as unprocessed. At step 210 a check is made whether a reference image has not yet been processed. If so, at step 220 an unprocessed reference image is selected. Otherwise, at step 230 execution terminates. At step 240 the flash-corrupted pixels within the selected reference image are identified. At step 250 the color values of those pixels identified at step 240 are used to estimate the parameters of a Gaussian probability distribution. At step 260 the estimated parameters are then recorded for each such image. At step 270 the reference image is marked as processed, and control returns to step 210. By recording the estimated parameters, the estimated probability distributions corresponding to each reference image are effectively recorded. These probability distributions are henceforth referred to as the reference probability distributions. The probability density function for reference image I is denoted by f_Iin what follows.

[0094] Identifying the Flash-corrupted pixels based on the reference images

[0095] After the estimated parameters are recorded, an application using the present invention can be used to identify flash-corrupted pixels in arbitrary digital images. In a preferred embodiment of the present invention, when a subject digital image is given, each pixel color value is used as an argument in each reference probability distribution, to determine a likelihood value. Specifically, each pixel color value (r_n, g_n, b_n) is substituted as an argument into each reference probability density function of each reference image I, to determine a likelihood

[0096] L_n(I)=f_I(r_n, g_n, b_n; p).

[0097] This likelihood L_n(I) represents the likelihood that color value (r_n, g_n, b_n) would be classified as a flash-corrupted pixel within the reference image I. The subscript n is used to index the pixels in the subject digital image.

[0098] In a preferred embodiment of the present invention, a threshold likelihood L_ThRESHOLD is prescribed, and the pixel location with color value (r_n, g_n, b_n) is classified as being flash-corrupted if its likelihood L_n(I) exceeds L_ThRESHOID for any of the reference images I.

[0099] It is clear that calculation of the likelihood values for each pixel in a subject image and for each reference image, can be demanding. To make this more efficient, only a small subset of pixels within the subject image within a vicinity of the flash-corrupted pixel locations, is tested. In a preferred embodiment of the present invention, this subset is chosen by first having a user select a region surrounding a group of flash-corrupted pixels, by means of a user interface, and then pre-filtering the pixels within the user-selected region by means of the pixel color saturation levels.

[0100] User selection of a region surrounding a group of flash-corrupted pixels can be accomplished by enabling a user to position a closed curve, such as a circle or an ellipse or a square, around a group of flash-corrupted pixels. For example, a user could position a circle around the red-eye pixels in one eye. This would limit the number of likelihood calculations to those pixels within the circle.

[0101] Pre-filtering by color saturation further reduces the number of likelihood calculations by eliminating those pixels for which the color saturation level is below a prescribed saturation threshold. The rationale for this is that flash-corrupted pixels, such as red-eye, tend to have highly saturated color values. In at least one embodiment, saturation is determined as the S color component within the hue (H), saturation (S) and value (V) three-channel color system. A general reference for color spaces is Foley, van Dam, Feiner and Hughes, “Computer Graphics: Principles and Practice,” ISBN: 0201848406, published by Addison Wesley.

[0102] The following source code listing, written in the C++ programming language, carries out the calculations for saturation in accordance with a preferred embodiment of the present invention.

[0103] double ERedEyeTool::

[0104] RGB2Saturation(Pixel& theRGBPixel)

[0105] {

[0106] float aRed, aGreen, aBlue, aMin, aMax, delta;

[0107] double aSaturation;

[0108] aRed=(float)theRGBPixel.red/255.0;

[0109] aGreen=(float)theRGBPixel.green/255.0;

[0110] aBlue=(float)theRGBPixel.blue/255.0;

[0111] aMax=max3(aRed,aGreen,aBlue);

[0112] aMin=min3(aRed,aGreen,aBlue);

[0113] if (aMax==0)

[0114] aSaturation=0;

[0115] else

[0116] {

[0117] delta=aMax—aMin;

[0118] aSaturation=(delta/aMax) * 100.0;

[0119] }

[0120] return(aSaturation);

[0121] }

[0122] Reference is now made to FIG. 3, which is a simplified flow chart for a photo kiosk application that identifies flash-corrupted pixels in a subject digital image, by means of a database of reference images, in accordance with a preferred embodiment of the present invention. At step 300, a user delineates a subset P of pixels within the subject digital image by means of a user interface, such as the one described below in reference to FIG. 4. At step 310 all pixels within the subset P are marked as unprocessed and not flash-corrupted.

[0123] At step 320 a check is made whether there are any unprocessed pixels within the subset P. If so, at step 330 an unprocessed pixel is selected and its color value (r_n, g_n, b_n) is read. If not, execution terminates at step 340. At step 350 the saturation level s_nof the pixel color is calculated. At step 360 a check is made whether the saturation level s_nis below a prescribed threshold SAT_LEVEL. If so, at step 370 the pixel is marked a s processed, and control returns to step 320. Otherwise, a t step 380 the reference images are all marked as unprocessed.

[0124] At step 390, a check is made whether there are any unprocessed reference images. If so, at step 400 an unprocessed reference image I is selected. At step 410 the likelihood L_n(I)=f_I(r_n, g_n, b_n; p) is calculated using the estimated parameters p for the reference probability density corresponding to the reference image I. At step 420 a check is made whether the likelihood L_n(I) is below a prescribed threshold confidence level L_THRESHOLD. If so, control returns to step 400. Otherwise, at step 430 the pixel is marked as being flash-corrupted and control returns to step 370. Step 430 points out that it is not necessary to exhaustively test all of the reference images. As soon as one reference image gives rise to a likelihood above L_ThRESHOLD, the decision is conclusive, and the pixel is marked as flash-corrupted. In an alternate embodiment, a threshold number of likelihoods above L_THRESHOLD may be required before a pixel is marked as flash corrupted.

[0125] When execution terminates the flash-corrupted pixels are then identifiable as those pixels that have been marked as flash-corrupted.

[0126] The following source code listing, written i n the C++ programming language, carries out the calculations for deciding whether or not a pixel is flash-corrupted in accordance with a preferred embodiment of the present invention. The array aCircleBrush[ ] is used to denote those pixels that are within a circular cursor, as described below with reference to FIG. 4. The method ComputeMaximumLikelihood calculates the multi-variate Gaussian probability density function. The double for loop calculates the quadratic form aUnderExp that forms the exponent in the exponential term, and the parameters aPdf is the normalizing constant that pre-multiplies the exponential term. The parameters NB_COLOR_CHANNELS denotes the number of color channels, which is typically three. The method IsPixelToBeCorrected checks whether the maximum likelihood exceeds the threshold confidence level L_THRESHOLD. It returns the value 255 if the pixel is corrupted and needs to be corrected, and it returns the value 0 otherwise. The methods GetlnverseSigma and GetDeterminant calculate the inverse matrix and the determinant of the covariance matrix, respectively.

[0127] if ((RGB2Saturation(aPixelTable[i]))>SAT_LEVEL)

[0128] {

[0129] anOpacityValue=IsPixelToBeCorrected(aPixelTable[i]);

[0130] if ((anOpacityValue==255) &&

[0131] (aCircleBrush[i]==255))

[0132] //correct the corrupt pixel

[0133] }

[0134] unsigned char ERedEyeTool::

[0135] IsPixelToBeCorrected(const Pixel& thePixel)

[0136] {

[0137] double *aProbaBuf;

[0138] aProbaBuf=NEW double [itsNbOfStat];

[0139] double aMaxProba=0.0;

[0140] for (int j=0;j<itsNbOfStat;j++)

[0141] aProbaBuf[j]=ComputeMaximumLikelihood(thePixel,

[0142] itsRedEyeList[j]);

[0143] aMaxProba=MAXI(aMaxProba,aProbaBuf[j]);

[0144] }

[0145] if (aMaxProba>L_THRESHOLD)

[0146] {

[0147] delete[ ] aProbaBuf; return((unsigned char)255);

[0148] }

[0149] else

[0150] {

[0151] delete[ ] aProbaBuf;

[0152] return((unsigned char)0);

[0153] }

[0154] double ERedEyeTool::

[0155] ComputeMaximumLikelihood(const Pixel& thepixel,

[0156] ERedEyeStat theRedEyeStat)

[0157] {

[0158] double aPdf, aUnderExp(0.0);

[0159] double aBufX[NB_COLOR_CHANNELS+1],

[0160] anInverseSigmaData;

[0161] aPdf=

[0162] sqrt(pow(2*PI,NBCOLORCHANNELS) * theRedEyeStat.GetDeterminant( ));

[0163] aPdf=(double) 1.0/aPdf;

[0164] aBufX[1]=thePixel.rouge—theRedEyeStat.GetRedMean( );

[0165] aBufX[2]=thepixel.vert—theRedEyeStat.GetGreenMean( );

[0166] aBufX[3]=thepixel.bleu—theRedEyeStat.GetBlueMean( );

[0167] for (int i=1; i<=NB_COLOR_CHANNELS; i++)

[0168] {

[0169] for (intj=1; j<=NB_COLOR_CHANNELS; j++)

[0170] {

[0171] anInverseSigmaData=theRedEyeStat.GetlnverseSigma( (i-1)*NB_COLOR_CHANNELS+j);

[0172] aUnderExp=aUnderExp+anInverseSigmaData*aBufX[i]*aBufX[j];

[0173] }

[0174] }

[0175] aUnderExp=(double)aUnderExp/2.0;

[0176] aPdf=aPdf*exp(-aUnderExp);

[0177] return(aPdf);

[0178] }

[0179] Reference is now made to FIG. 4, which illustrates a touch-sensitive screen 440 presented to a user in a preferred embodiment of the present invention. The screen illustrated is part of a photo kiosk system, such as the system of FIG. 1. Such a system allows only limited user interaction. A user arrives at this screen by having instructed the kiosk to launch a “REMOVE RED EYE” screen from a previous menu. When this screen is initially launched, a target circular cursor (not shown) is positioned in the center of an image 450 appearing on the screen. The cursor is preferably bi-colored so as to avoid hidden contrast with the photo. A slider bar 460 is initially at the center, corresponding to a medium-sized circular cursor.

[0180] A region 470, corresponding to the step labeled “1”, enables a user to position the circular cursor within image 450, and move it around by pressing on the four directional arrows 480. An image portion 485 within the four arrows is a magnified preview of the portion of image 450 in the vicinity of the circular cursor. The circular cursor can also be moved around by moving circle 488 within image portion 485 using the tip of a finger.

[0181] A region 490, corresponding to the step labeled “2”, enables a user to reduce or enlarge the size of the circular cursor by pressing on “SMALLER” and “LARGER” buttons, 493 and 496, respectively, at the ends of slider bar 460, respectively. Pressing on buttons 493 and 496 serves to decrease or increase the radius of the circle, respectively, keeping its center fixed. When the size of the circular cursor is adjusted, the portion and magnification factor of image portion 485 in the preview box above changes correspondingly. Specifically, as the size of the circular cursor decreases, the magnification factor of previewed image portion 485 increases. The objective of steps 1 and 2 is to position the circular cursor around the red-eye portion of a first eye, so as to completely encircle the red-eye pixel locations.

[0182] A region 500, corresponding to the step labeled “3”, provides the operational step, in which a user presses on a “REMOVE RED EYE” button 510 to instruct the application to run through the algorithm described above in reference to FIG. 3. Once “REMOVE RED EYE” button 510 is pressed, image 450 will be modified to correct for the red eye in the selected eye within the circular cursor. In addition, preview image portion 485 is also modified in accordance with the red-eye removal.

[0183] The user interface in FIG. 4 also provides a button 520 labeled “UNDO” to remove the red-eye correction and return image 450 to its original form, in case the user is not satisfied and wants to re-position the circle. “UNDO” button 520 undoes all of the remove actions performed within the current remove edit session.

[0184] Once the user is satisfied and accepts the red-eye correction, another button 530 labeled “NEXT EYE” is used to process the second eye. When “NEXT EYE” button 530 is pressed, the circular cursor goes back to the center of image 450 and is restored to its original size. In an alternate embodiment, the circular cursor may be moved to a different location on the image or keep its current size when the “NEXT EYE” button 530 is pressed. When both eyes have been processed, image 450 has been corrected, and the flash effects have been removed.

[0185] FIG. 5 is a block diagram of a processing system 600 that can be used to perform processing operations used in embodiments of the present invention. The processing system 600 includes a processing unit 610, memory 620, display device 630, user-input device 640, communications device 650, reader 10 and printing device 16 each coupled to a bus structure 660. In the case of the photo kiosk 10 of FIG. 1, the display device 630 and the user-input device 640 may be implemented by a touch-sensitive screen described above in reference to FIG. 4. In alternate embodiments, the user-input device 640 may be a mouse, trackball, stylus, or any other device for manipulating elements displayed on display device 630. Moreover, user-input device 640 may include a keypad or keyboard to allow a user to input alphanumeric data into the processing system 600.

[0186] The processing unit 610 may include one or more general purpose processors, one or more digital signal processors or any other devices capable of executing a sequence of instructions. When programmed with appropriate instructions, the processing unit may be used to implement a number of different types of machines including, but not limited to, a pixel processor, pixel analyzer, color processor, statistical processor, computational unit and so forth.

[0187] The communications device 650 may be a modem, area network card or any other device for coupling the processing system 600 to a computer network. The communications device may be used to generate or receive a carrier wave modulated with a data signal, for example, for obtaining images or text from a server computer on the World Wide Web or other network, or for receiving updated program code or function-extending program code that can be executed by the processing unit to implement embodiments of the present invention.

[0188] The memory 620 may include both system memory and non-volatile storage devices such as magnetic tape, magnetic disk, optical disk, electrically erasable programmable read only memory (EEPROM), or any other computer-readable medium. As shown in FIG. 5, the memory 620 may be used to store program code 622 for performing the above-described processing operations, framing images and other documents 624 that can be combined with user-supplied images, and the above-described database of reference flash-corrupted images 626. In one embodiment, when power is applied to the processing system 600, operating system program code is loaded from non-volatile storage into system memory by the processing unit 610 or another device, such as a direct memory access controller (not shown). Sequences of instructions comprised by the operating system are then executed by processing unit 610 to load other sequences of instructions, including the above-described application programs, from non-volatile storage into system memory. Thus, embodiments of the present invention may be implemented by obtaining sequences of instructions from a computer-readable medium, including the above-described carrier wave, and executing the sequences of instructions in the processing unit 610.

[0189] Having described a processing system for implementing embodiments of the present invention, it should be noted that the individual processing operations described above may also be performed by specific hardware components that contain hard-wired logic to carry out the recited operations or by any combination of programmed processing components and hard-wired logic. Nothing disclosed herein should be construed as limiting the present invention to a single embodiment wherein the recited operations are performed by a specific combination of hardware components.

[0190] It will be appreciated by persons skilled in the art that the present invention is not limited by what has been particularly shown and described hereinabove. Rather the present invention includes combinations and sub-combinations of the various features described hereinabove as well as modifications and extensions thereof which would occur to a person skilled in the art and which do not fall within the prior art.