Patent Publication Number: US-7710432-B2

Title: Color correction techniques for correcting color profiles or a device-independent color space

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
   This application claims the benefit of: (a) U.S. Provisional Application No. 60/652,998, filed Feb. 15, 2005, the entire disclosure of which is hereby incorporated herein by reference, and (b) U.S. Provisional Application No. 60/653,011, filed Feb. 15, 2005, the entire disclosure of which is hereby incorporated herein by reference. 

   This application also is related to U.S. Non-Provisional patent application Ser. No. 11/303,071, titled “System and Method for Profiling Digital-Image Input Devices,” filed Dec. 14, 2005, by Christopher Edge, and associated with the entire disclosure of which is hereby incorporated herein by reference. 
   FIELD OF THE INVENTION 
   This invention relates to correcting device-independent color data in a color management profile in a manner that allows selective adjustment of one or more regions of color with substantially no risk of introducing artifacts or unwanted corruption of subsequently generated images. This invention is useful for, among other things, improving a color profile of a digital-image input device, such as a digital camera or a scanner. 
   BACKGROUND OF THE INVENTION 
   A digital-image input device, such as a digital camera or a scanner, converts light reflected from an object into digital data representing an image of the object. Typically, the digital data is divided into units, each unit describing the color of a portion, or pixel, of the image. Accordingly, the image may be described as a two-dimensional array of pixels (x, y). Further, each unit of digital data typically describes the color of a pixel by describing the amount, or intensity, of each primary color red, green, and blue, present in the pixel. For example, the digital data may indicate that the pixel at x=0 and y=0 has a red intensity of 200, a green intensity of 134, and a blue intensity of 100, where the intensity of each primary color is represented by eight bits. (Eight bits allows 256 combinations, so each primary color may have a value of 0-255, in this example, where 255 indicates the highest level of intensity and zero indicates no intensity, or black.) The digital data produced by a digital-image input device is referred to herein as “device dependent data,” because different digital-image input devices typically produce different digital data representing the same image acquired under the same conditions. For example, a first digital camera may indicate that a first pixel of an image has a red component of 200, whereas a second digital camera may indicate that the same pixel of an equivalent image taken under the same conditions has a red component of  202 . For another example, the first digital camera may record the red in an apple as  200 , and the second digital camera may record the red in the same part of the apple (as imaged under the same conditions) as  202 . Because the device-dependent data generated by a digital-image input device typically specifies the red, green, and blue color components associated with each pixel, it is often referred to as “RGB” data. 
   The differences between device-dependent data from two different devices arise from minute differences in the imaging components in each device. These differences create problems when the images are output by a digital-image output device, such as a color ink-jet printer, a CRT monitor, or an LCD monitor. For example, the image of the apple taken by the first digital camera discussed above will appear differently than the image of the apple taken by the second digital camera when output to the same color ink-jet printer. 
   To further complicate matters, digital-image output devices also have the same types of discrepancies between each other that digital-image input devices have. For example, a user may want to view an image of a red square on one CRT monitor while a customer simultaneously views the same image on another CRT monitor. Assume that the digital-image input device used to image the red square recorded all pixels of the red square as red=200, green=0, and blue=0. Commonly, when the two monitors display the same image, each monitor displays a slightly different red color even though they have received the same digital data from the input device. 
   The same differences commonly exist when printing the same image to two different printers. However, it should be noted that the digital image data processed by printers typically describes each pixel in an image according to the amount, or intensity, of each secondary color cyan, magenta, and yellow, as well as black present in the pixel. Accordingly, the device-dependent digital image data processed by printers is referred to as “CMYK” data (as opposed to RGB device-dependent data associated with digital-image input devices.) (Monitors, on the other hand, display data in RGB format). 
   Color profiles provide a solution to the color discrepancies between devices discussed above. Each digital-image input device typically has its own color profile that maps its device-dependent data into device-independent data. Correspondingly, each digital-image output device typically has its own color profile that converts device-independent data into device-dependent data usable by the output device to print colors representative of the device-independent data. Device-independent data describes the color of pixels in an image in a universal manner, i.e., a device-independent color space. A device-independent color space assigns a unique value to every color, where the unique value for each color is determined using calibrated instruments and lighting conditions. Examples of device-independent color spaces are CIEXYZ, CIELAB, CIE Yxy, and CIE LCH, known in the art. Device-independent data is sometimes referred to herein as “device-independent coordinates.” Device-independent data in the CIEXYZ color space is referred to herein as “XYZ data,” or just “XYZ.” Device-independent in the CIELAB color space is referred to herein as “LAB data,” “CIELAB” or just “LAB.” 
   Theoretically, color profiles allow a user to acquire an image of an object using any digital-image input device and to output an accurate representation of the object from a digital-image output device. With reference to  FIG. 1 , for example, an image of an object  101  is acquired using a digital-image input device  102 . The image is represented in  FIG. 1  as RGB  103 . Then, the image RGB  103  is converted into device-independent data (XYZ  105 , for example) using the digital-image input device&#39;s color profile  104 . The device-independent data XYZ  105  is then converted using the output device&#39;s color profile  106  into device-dependent data (CMYK  107 , for example) specific to the output device  108 . The output device  108  uses its device-dependent data CMYK  107  to generate an accurate representation  109  of the object  101 . 
   The usefulness of color profiles is limited by how accurately they convert device-dependent data to device-independent data, or vice versa. Currently, there is no way of generating a color profile that perfectly translates device-dependent data to device-independent data, or vice-versa. Errors in color profiles become apparent when comparing a displayed image, such as an image displayed on a CRT or LCD monitor, and a hard-copy printout of the image. 
   Conventional methods exist that improve color profiles by correcting device-independent data associated with device-dependent data. However, these methods, while improving color profiles, still leave small but significant color errors on the order of 2-3 delta E in certain regions of color space. (The unit of 1 delta E, known in the art, refers to one unit of Euclidean distance in the CIELAB color space.) In other words, the translations or corrections performed by the conventional methods still introduce irregularities in the corrected color gamut and, particularly for large corrections, are not truly linear in all areas of color space. 
   Accordingly, a need in the art exists for a method for correcting color profiles or a device-independent color space with reduced errors. 
   SUMMARY OF THE INVENTION 
   The above-described problems are addressed and a technical solution is achieved in the art by a system and a method for correcting color profiles or a device-independent color space that allow selective adjustment of one or more regions of color with substantially no risk of introducing artifacts or unwanted corruption of subsequently generated images. According to an embodiment of the present invention, selective tristimulus corrections to device-independent coordinates are applied using a piecewise linear correction function. The piecewise linear correction function is defined such that a maximum of the piecewise linear correction function occurs at a boundary condition of a corresponding device-dependent color space and the piecewise linear correction function is linearly reduced to zero or approximately zero as values in the corresponding device-dependent color space approach either a different boundary condition or a neutral axis. By having the piecewise linear correction function reduce linearly to zero or approximately zero, corrections to one region of color smoothly diminish and blend into the other regions of color, thereby substantially preventing the introduction of artifacts or image corruption due to the corrections. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The present invention will be more readily understood from the detailed description of preferred embodiments presented below considered in conjunction with the attached drawings, of which: 
       FIG. 1  illustrates a conventional arrangement for acquiring and outputting an image; 
       FIG. 2  illustrates a system for generating a color profile for a digital-image input device, according to an embodiment of the present invention; 
       FIG. 3  illustrates a method for generating a color profile for a digital-image input device, according to an embodiment of the present invention; 
       FIG. 4  illustrates a method for calculating a parameter list used to calculate final device independent coordinates of the profile, which may be used as step  314  in  FIG. 3 , according to an embodiment of the present invention; and 
       FIG. 5  illustrates a method for performing selective adjustments to the device independent color space, which may be used independently or as part of step  406  in  FIG. 4 , according to an embodiment of the present invention. 
   

   It is to be understood that the attached drawings are for purposes of illustrating the concepts of the invention and may not be to scale. 
   DETAILED DESCRIPTION OF THE INVENTION 
   The present invention corrects one or more selected regions of color in a device-independent color space, such that the magnitude of the corrections diminish as colors in the color space move away from the selected region being corrected. Accordingly, adjustments to regions of color in a device-independent color space may be made, such that the adjustments pose substantially no risk of introducing artifacts or unwanted corruption of subsequently generated images. The present invention has been shown to be useful in correcting both small color discrepancies, i.e., on the order of 2-3 delta E, or large color discrepancies, i.e., on the order of 20-30 delta E. 
     FIG. 2  illustrates a system  200  for generating a color profile for a digital-image input device, according to an embodiment of the present invention. The system  200  may include a digital-image input device  202  communicatively connected to a computer system  204 , which is communicatively connected to a data storage system  206 . The computer system  204  may include one or more computers communicatively connected and may or may not require the assistance of an operator  208 . The digital-image input device  202  acquires a test image of a color chart and optionally a scene outside of the color chart. Examples of the digital-image input device  202  include a digital camera or a scanner. The digital-image input device  202  transmits the test image to the computer system  204 , which generates a color profile for the digital-image input device  202  based upon the test image and an estimated illumination of the color chart as discussed in more detail with reference to  FIGS. 3 and 4 . The color profile may be stored in the data storage system  206 , output to other optional devices  210 , or otherwise output from the computer system  204 . It should be noted that the information needed by the computer system  204 , such as the test image and information pertaining to the color chart, may be provided to the computer system  204  by any means, and not necessarily by the digital-image input device  202 . 
   The data storage system  206  may include one or more computer-accessible memories. The data storage system  206  may be a distributed data-storage system including multiple computer-accessible memories communicatively connected via a plurality of computers, devices, or both. On the other hand, the data storage system  206  need not be a distributed data-storage system and, consequently, may include one or more computer-accessible memories located within a single computer or device. 
   The term “computer” is intended to include any data processing device, such as a desktop computer, a laptop computer, a mainframe computer, a personal digital assistant, a Blackberry, and/or any other device for processing data, and/or managing data, and/or handling data, whether implemented with electrical and/or magnetic and/or optical and/or biological components, and/or otherwise. 
   The phrase “computer-accessible memory” is intended to include any computer-accessible data storage device, whether volatile or nonvolatile, electronic, and/or magnetic, and/or optical, and/or otherwise, including but not limited to, floppy disks, hard disks, Compact Discs, DVDs, flash memories, ROMs, and RAMs. 
   The phrase “communicatively connected” is intended to include any type of connection, whether wired, wireless, or both, between devices, and/or computers, and/or programs in which data may be communicated. Further, the phrase “communicatively connected” is intended to include a connection between devices and/or programs within a single computer, a connection between devices and/or programs located in different computers, and a connection between devices not located in computers at all. In this regard, although the data storage system  206  is shown separately from the computer system  204 , one skilled in the art will appreciate that the data storage system  206  may be stored completely or partially within the computer system  204 . 
     FIG. 3  illustrates a method  300  for generating a color profile for the digital-image input device  202 , according to an embodiment of the present invention. The method  300  is executed as hardware, software, and/or firmware by the computer system  204 , according to an embodiment of the present invention. 
   At step  302 , the computer system  204  receives device-dependent data from the digital-image input device  202  or from some other source. The device-dependent data received at step  302  is RGB data, according to an embodiment of the present invention. The device-dependent data represents a test image of at least a color chart. It should be noted that although this application is described in the context of using a color chart, any object that has known device-independent values associated with its colors may be used. It should also be noted that the device-dependent data received at step  302  need not include data pertaining to a scene outside of the color chart in the test image. 
   The operator  208 , who also may operate the digital-image input device  202 , may specify the location and orientation of the color chart in the test image. Alternatively, the orientation of the color chart may be determined automatically by the computer system  204 . The average of the device-dependent RGB values received at step  302 , for each color patch in the color chart may be determined, such that a single device-dependent RGB value for each color patch is output from step  302 . Collectively, the device-dependent RGB values, each associated with a color patch, are referred to as an array of device-dependent RGB values represented as RGB  303 . 
   At step  304 , the array of RGB values, RGB  303 , is associated with device-independent data XYZ  301  previously measured for the color chart used for the test image. The association of the device dependent data RGB  303  with the corresponding device-independent data XYZ  301  may be stored as a two-dimensional array, represented as “RGB-XYZ”  305  in  FIG. 3 . The array may include two columns, one for the device-dependent data and one for the device-independent data, where each row contains associated data for a single color patch in the color chart. For example, the following software code could be used to define such an array: 
   RGB rgbChartValue[i] 
   Lab labMeasuredValue[i], where 0&lt;i&lt;numPatches 
   rgbChartValue represents RGB  303  in  FIG. 3 . labMeasuredValue represents the previously measured device-independent data XYZ  301  associated with the color chart, converted and stored as Lab data. numPatches represents the number of patches in the color chart. One skilled in the art will appreciate that any manner of representing the association of the device-dependent data RGB  303  and the device-independent data XYZ  301  may be used. 
   Although the device-independent data XYZ  301  is illustrated as being in the CIEXYZ device-independent color space, any device-independent color space may be used. Further, although  FIGS. 3 ,  4 , and  5  illustrate device-independent data as XYZ data, particular steps in  FIGS. 3 ,  4 , and  5  may operate on the device-independent data in other color spaces. Accordingly, conversions of XYZ data into other color spaces are implied by these steps and are not illustrated in the figures, because such conversions are well known to one of ordinary skill in the art. 
   At step  306 , the gray patches in the device-independent data XYZ  301  are identified. The gray patches may be identified using the device-independent data XYZ stored in the array RGB-XYZ  305 . The identified gray patches output at step  306  are represented as GrayPatches  307 . RGB-XYZ  305  may pass through step  306  to step  308  unmodified. Although not required, it may be advantageous to identify gray patches in the LAB color space as opposed to the XYZ color space. In particular, in the LAB color space, gray colors are associated with the coordinates “a” and “b” approximately equal to zero, thereby providing for a simple calculation. Accordingly, the device-independent data XYZ in the array RGB-XYZ  305  may be converted to LAB prior to performing step  306 . The following software code illustrates a way of identifying the GrayPatches  307 , as well as the benefits of operating in the LAB color space. 
                                          grayIndex=0;           For (i=0; i&lt;numPatches; i++)           {             If (labMeasuredValue[i].a( )&lt;GrayRange &amp;&amp;               labMeasuredValue[i].b( )&lt;GrayRange)             {               LabGrayValue.lab[grayIndex]=                 labMeasuredValue[i];               rgbGrayValues[grayIndex] = rgbChartValues[i];               grayIndex++;             }           }           numGrayPatches=grayIndex;                        
labMeasuredValue[i].a( ) is the “a” value (in LAB) of the current patch i. Similarly, labMeasuredValue[i].b( ) is the “b” value (in LAB) of the current patch i. GrayRange is the value used to determine if a color is gray. According to an embodiment of the present invention, GrayRange is 5 delta E. LabGrayValue.lab[ ], when output, contains the array of gray patches  307  in the CIELAB device-independent color space. rgbGrayValues[ ] represents the device dependent gray values extracted from the RGB image of the color chart. numGrayPatches is the total number of identified gray patches.
 
   According to an embodiment of the present invention, GrayPatches  307  includes both the device-independent measured data array (referred to as LabGrayValue[ ] in the software code, above) as well as the corresponding device dependent gray values extracted from the RGB image of the chart (referred to as rgbGrayValues[ ] in the software code, above). It may be convenient to sort the array of LabGrayValue[i] and rgbGrayValues[i] where index i=0, . . . , numGrayPatches maps to lightest-&gt;darkest, unless it is known in advance that the chart data is already sorted in this manner. 
   At step  308 , the brightest within-range gray patch in GrayPatches  307  is identified and output as Brightest Patch  309 . According to an embodiment of the present invention, the brightest within-range gray patch is the gray patch (in device-independent coordinates) that has associated device-dependent data of R&lt;255, G&lt;255, and B&lt;255. Stated differently, the brightest gray patch having associated non-overexposed device-dependent data is identified. The device-independent data and the device-dependent data necessary for performing step  308  may be obtained from the array RGB-XYZ  305 . GrayPatches  307  and RGB-XYZ  305  may be passed through step  308  unchanged to step  310 . The following software code illustrates a way to accomplish step  308 , which assumes that the input GrayPatches  307 , as well as the array RGB-XYZ  305 , have been sorted in order of intensity (coordinate “L” in LAB) (from brightest to darkest): 
                              int maxGrayPatchIndex = 0;       float maxL=0.0;       For (i=0;i&lt;numGrayPatches;i++)       {       if (LabGrayValue.lab[i]&gt;maxL &amp;&amp; rgbGrayValues[i].r( ) &lt; 255&amp;&amp;         rgbGrayValues [i].g( ) &lt; 255&amp;&amp; rgbGrayValues [i].b( )         &lt; 255)         {           maxL=LabgrayValue[i];           maxGrayPatchIndex =i;         }       }                    
maxGrayPatchIndex, upon completion of the above-code, is the location in the array labGrayValue.lab[ ] (GrayPatches  307 ) that stores the brightest in-range gray patch. maxL, upon completion of the above-code, is the L* value of the brightest in-range gray patch from labGrayValue.lab[ ] (GrayPatches  307 ). maxL is subsequently converted to Y measured , discussed below. rbgChartValues[ ] represents the device-dependent data from the array RGB-XYZ  305 , such that rgbChartValues[i].r( ) is the red component, rgbChartValues[i].g( ) is the green component, and rgbChartValues[i].b( ) is the blue component.
 
   At steps  310  and  312 , in order to compensate for the effects of over-illumination or under-illumination of the color chart, the device-independent data of the color chart (stored in the array RGB-XYZ  305 ) is scaled by an illumination-correction factor α ILLCORR . α ILLCORR , according to an embodiment of the present invention, is generated by comparing the illumination of the BrightestPatch  309  in device-independent coordinates and the illumination of the same patch as indicated by the associated device-dependent coordinates. In other words, the measured illumination of the BrightestPatch  309  is compared against the illumination of the same patch as recorded by the digital-image input device in the RGB data  303 . According to an embodiment of the present invention, α ILLCORR  is generated as follows.
 
α ILLCORR =(Y estimated )/(Y measured )
 
Y estimated  is an estimated illumination of the RGB data  303  for the brightest in-range gray patch. Y estimated  may be represented as follows.
 
Y estimated =f Y (R i     0   ,G i     0   ,B i     0   )
 
where the index “i 0 ” refers to maxGrayPatchIndex. Y measured  is the illumination of the XYZ data  301  as identified by BrightestPatch  309 .
 
   At step  312 , according to an embodiment of the present invention, illumination-corrected device-independent data is generated by linearly scaling the device-independent data XYZ  301  by α ILLCORR . Such illumination-corrected device-independent data is represented in  FIG. 3  as XYZ ILLCORR . The one-to-one color-patch association between XYZ ILLCORR  and the RGB data  303  is represented as RGB-XYZ ILLCORR    313 . According to an embodiment of the present invention, XYZ ILLCORR  is generated by multiplying all values of the XYZ data  301  by α ILLCORR , as illustrated below. 
               (         X           Y           Z         )     ILLCORR     =       α   Illcorr     ⁡     (         X           Y           Z         )             
The vector on the right represents the XYZ data  301  and the vector on the left represents XYZ ILLCORR . This correction assures that the brightest in-range gray patch continues to have a value that corresponds to the original RGB value for that patch assuming an initial camera gamma of 2.2. According to this embodiment of the present invention, it is assumed that values of gamma and RGB chromaticites have been initialized to the default digital-image input device profile settings, e.g., sRGB or Adobe RGB, known in the art.
 
   At step  314 , an optimized list of parameters  315  used to generate final device independent coordinates of the digital-image input device profile is calculated.  FIG. 4 , discussed below, illustrates an inventive method for generating such parameters, according to an embodiment of the present invention. However, any method for calculating these parameters, known in the art, may be used. The parameter list  315  is used at step  316 , as well as RGB  303  and XYZ  301 , to generate a profile  317  for the digital-image input device  202 . 
     FIG. 4  illustrates an exploded view of the substeps that may be performed at step  314 , according to an embodiment of the present invention. The input to step  402  is the RGB-XYZ ILLCORR  array  313  of associated device-dependent data RGB and illumination-corrected device-independent data XYZ ILLCORR . At step  402 , optimal parameters α TC    403  that describe the 1-dimensional tone curves R, G, and B of the device-dependent data RGB (in RGB-XYZ ILLCORR ) are generated. RGB-XYZ ILLCORR    313  is passed unmodified through step  402  to step  404 . 
   The process of generating optimized α TC    403  may be performed by selecting initial parameters for α TC , according to an embodiment of the present invention, and applying the initially selected parameters for α TC  to the device-dependent data RGB to generate predicted device-independent coordinate values. Then, an error between the generated predicted device-independent coordinate values and the measured device-independent coordinate values (XYZ ILLCORR ) is calculated. The process is repeated with newly selected parameters for α TC  until the calculated error is minimized. The parameters for α TC    403  that produce the minimum error are output at step  402  as the optimal parameters α TC    403 . The process of step  402 , according to an embodiment of the present invention, may be represented as follows. 
             Err   ⁡     (     α   TC     )       =       ∑     i   =     i   0         i   =     n   -   1         ⁢                (           L   ILLCORR   *               a   ILLCORR   *               b   ILLCORR   *           )     i     -     (             F     L   *       ⁡     (       RGB   i     ,     α   TC       )                   F     a   *       ⁡     (       RGB   i     ,     α   TC       )                   F     b   *       ⁡     (       RGB   i     ,     α   TC       )             )            2             
The index “i” refers to the “n” gray patches on the color chart, where the index “i 0 ” refers to makGrayPatchIndex, which is the location in the array labGrayValue.lab[ ] (GrayPatches  307 ) that stores the brightest in-range gray patch. The (L*a*b* ILLCORR ) vector represents the LAB coordinate values corresponding to XYZ ILLCORR . The (F LAB (RGB i , α TC )) vector represents the function used to calculate the predicted device-independent coordinates corresponding to the device-dependent data RGB  303 . Any function, known in the art, may be used for F LAB (RGB i , α TC ). Using well-known methods, such as Newton&#39;s method or Powell&#39;s method, the parameters α TC  may be varied automatically in such a manner as to minimize the value of the least squared error function Err(α TC ). The resulting values of α TC  may, in some cases, be optimal values for use in predicting device independent coordinates from RGB  303 .
 
   According to an embodiment of the present invention, the following expression may be used as F LAB (R i , α TC ) for the red tone channel.
 
ƒ R ( R,R   Max ,R bias ,γ R ,β C )=R Max (1.0− R   bias )[ƒ c ( R,β   C )] γR   +R   bias  
 
f R  is a function that defines the one-dimensional response of the red tone channel, such that R Max , R bias , γ R , and β c  represent α TC  in the case where the digital-image input device is a digital camera. The above expression may be used similarly for the green and blue tone channels, where β c =0 in the contrast function f c (R) defined by:
 
ƒ c ( x,β   C )= x+β   C (0.5+0.5(2( x− 0.5)) 3   −x ).
 
Note that for β c =0, the contrast function f c (x)=x. R Max  is a linear scaling factor and indicates the maximum red color recorded by the digital-image input device. R bias , a black bias offset, indicates the darkest red color recorded by the digital-image input device  202 . γ R  is the gamma, known in the art, of the digital-image input device associated with the red color. Alternatively, γ R  may equal γ G  and γ B , which all may equal the overall gamma of the device  202 . β c  is a parameter for adjusting contrast, i.e., a means for reducing the output of the function f c ( ) for values 0.0&lt;x&lt;0.5 and increasing the output of function f c ( ) for 0.5&lt;x&lt;1.0. Many mathematical functions exist that can perform such an adjustment, e.g., 3 rd  order polynomials, splines, etc. The concept of performing such an adjustment is well-known in the art (c.f. the “auto-contrast” feature in applications such as Adobe® PhotoShop®) although it is often in the context of an aesthetic improvement to an image rather than attempting to characterize a device with regard to color data.
 
   The following software code illustrates how step  402  may be performed, according to an embodiment of the present invention. It is assumed in this software code that all GrayPatches represented in RGB-XYZ ILLCORR    313  are sorted in order of brightest to darkest. 
                                          MinimizeError(sumSquareGrayDeltaE, parameterList,             NumParameters)                        
where
 
   sumSquareGrayDeltaE( ) 
   is defined as: 
                                            for (i=brightestValidGray; i&lt;nGray; i++)           {             xyzPred=evaluateModel(grayRGB[i]);             labPred=mColMetric-&gt;XYZToLab(xyzPred);             labMeas=grayLab[i];             xyzMeas=mColMetric-&gt;LabToXYZ(labMeas);             xyzMeas*=Y_IlluminationCorr;             labMeas=mColMetric-&gt;XYZtoLab(xyzMeas);             errSq=distanceSquaredLab(labPred, labMeas);             sumSq+=errSq;           }           return(sumSq);                        
parameterList represents α TC    403  output by step  402 , and NumParameters represents the number of parameters in α TC    403 . brightestValidGray represents the location of the brightest in-range gray patch in XYZ ILLCORR . nGray represents the total number of gray patches. xyzPred is a predicted device independent value corresponding to a device-dependent value in RGB  303 . evaluateModel( ) is a function that generates the predicted device independent value xyzPred, and is akin to F LAB (RGB i , α TC ), discussed above. labPred represents the LAB version of xyzPred, such that xyzPred is converted to LAB space using the function mColMetric-&gt;XYZToLab( ). labMeas represents the LAB device-independent values of the current gray patch (grayLab[ ]). xyzMeas represents the XYZ version of labMeas. xyzMeas* represents xyzMeas corrected by Y_IlluminationCorr, which represents α ILLCORR . errSq is an individual squared error and sumSq is the total squared error.
 
   The values of α TC    403  should be adjusted to minimize the sum of the calculated squared errors (sumSq, for example). The mathematical model (evaluateModel( ), for example) used to predict the device-independent coordinates associated with RGB (in RGB-XYZ ILLCORR ) may be any model known in the art. However, it is important that a selected model provide smoothness (i.e., low values of second order derivatives and/or no unwanted visual banding or artifacts when the profile is used for characterizing images) and as few parameters as possible, while achieving accurate predictions. The following software code illustrates a mathematical model (evalGammaModel( ) used as F LAB (RGB i , α TC ), discussed above) that predicts device-independent coordinates for the device dependent data RGB, according to an embodiment of the present invention. 
                                          double evalGammaModel (double *RGBMax, double *gamma,             double *blackBias, double filmContrastCorr, int rgbIndex,             const double&amp; cVal)           {             double val, corrVal, result=0.0;             corrVal=0.5+0.5*pow(2.0*(cVal−0.5),3.0)−cVal;             val=cVal+filmContrastCorr*corrVal;             if (rgbIndex != iFixedMaxRGB)               result=RGBMax[rgbIndex]*(1.0−                 blackBias[rgbIndex])*                 pow(val, gamma[rgbIndex]) +                 blackBias[rgbIndex];             else               result=(1.0−blackBias[rgbIndex])*                 pow(val, gamma[rgbIndex]) +                 blackBias[rgbIndex];             if (cVal&lt;0.0)               result=0.0;             return(result);           }                        
In this example, α TC    403  includes RGBMax, gamma, blackBias, and filmContrastCorr. RGBMax corresponds to the linear scaling factor R Max , described above, as well as the G MAX  and B MAX  counterparts. Gamma corresponds to γ R , described above, as well as the γ G  and γ B  counterparts. blackBias corresponds to R bias , described above, as well as the G bias  and B bias  counterparts. filmContrastCorr corresponds to β c . Note that rgbIndex indicates which channel is being calculated (rgbIndex=0,1,2=&gt;R,G,B) and cVal is the input color value (R, G, or B) which is being converted to the corresponding output color value modified by the evalGammaModel( ) function. The value “result” is calculated to obtain R,G,B (out) for input index rgbIndex=0,1,2. The resultingRGB vector is multiplied by the RGB-&gt;XYZ matrix described below to obtain the calculated values of XYZ. The above calculation of the sum square error is repeated after methodically adjusting parameters α TC    403  in the RGB-&gt;XYZ calculation until the sum square error is minimized.
 
   Note that the above tone curve calculation begins with a contrast adjustment applied to the RGB input values. This contrast adjustment is a 3 rd  order polynomial with constraints that no correction is applied to values RGB=0, 0.50, or 1.0 (assume RGB normalized to 1.0). The correction is multiplied by filmContrastCorr, default=0.0, which can be positive or negative (decreasing or increasing contrast, respectively) and added to the RGB value. The modified values are used to calculate a standard gamma function with a black bias offset (defined by blackBias[ ]), a linear scaling factor for each R, G, B channel (RGBMax[ ]) and a value of Gamma for each RGB channel (gamma[ ]). In this example, the total number of adjustable parameters α TC    403  is ten: RGBMax, gamma for R, G, and B, blackBias for R, G, and B, and a single value of filmContrastCorr for all three channels. Note that if the number of data values for the color chart is 6 gray patches, there are 18 data points to calculate on (6 times 3 (for L*,a*,b*)=18). In the event that the first two patches are overexposed, the number of data points is reduced to 4×3=12. One can optionally assume that gamma is identical for each of the three RGB channels and reduce the number of parameters α TC    403  to 8. This approach is helpful for lower quality images that have noisy RGB data extracted from the color chart. 
   Having determined optimal parameters α TC    403  at step  402 , step  404  generates optimal parameters α C    405  that describe the RGB chromaticites of the device profile. α TC    403  and RGB-XYZ ILLCORR    313  are passed unmodified through step  404  to step  406 . In step  404 , standard Matrix/TRC formalism, as indicated in the description below, may be used to calculate the values of XYZ for R, G, and B for all the color chart values using tone response calculated in step  402 . The error function is similar to that described above with respect to step  402 . However, all data points may be used, and all squared errors added to the sum may be reduced by a predefined weighting factor if values of R, G, or B are equal to 0 or 255, implying that the image data was clipped and that the actual R, G, or B value is not known accurately. 
   In step  404 , the adjusted parameter list ac  405  is the chromaticity value (xy, known in the art) for R, G, and B. According to an embodiment of the present invention, the mathematical description of the matrix portion of the XYZ function of RGB is as follows. Note that it is assumed that device-dependent data RGB (in RGB-XYZ ILLCORR    313 ) has already been processed by the RGB tone curve functions defined above with respect to step  402 . In other words, the new values of RGB are in linear RGB space. Thus, they can easily be converted to XYZ using a simple matrix: 
             (         X           Y           Z         )     =     M   ⁡     (         R           G           B         )                   M   =     (           X   r           X   g           X   b               Y   r           Y   g           Y   b               Z   r           Z   g           Z   b           )           
The M matrix is uniquely determined by the (x,y) chromaticities of the RGB channels and the white point for the system, i.e., the (x,y) chromaticities resulting from the value of the XYZ at RGB=max.
 
             M   ⁡     (       x     r   1       ,     y     r   1       ,     x     g   1       ,     y     g   1       ,     x     b   1       ,     y     b   1       ,     x   wp     ,     y   wp       )       =         M   c     ⁡     (       x     r   1       ,     y     r   1       ,     x     g   1       ,     y     g   1       ,     x     b   1       ,     y     b   1         )       ⁢     (             Y     r   1       ⁡     (       x   wp     ,     y   wp       )           0       0           0           Y     g   1       ⁡     (       x   wp     ,     y   wp       )           0           0       0           Y     b   1       ⁡     (       x   wp     ,     y   wp       )             )                       M   c     ⁡     (       x     r   1       ,     y     r   1       ,     z     r   1       ,     x     g   1       ,     y     g   1       ,     z     g   1       ,     x     b   1       ,     y     b   1       ,     z     b   1         )       =     (             x     r   1       /     y     r   1                 x     g   1       /     y   g               x   b     /     y     b   1                     y     r   1       /     y     r   1                 y     g   1       /     y     g   1                 y     b   1       /     y     b   1                     z     r   1       /     y     r   1                 z     g   1       /     y     g   1                 z     b   1       /     y     b   1               )                   (             Y     r   1       ⁡     (       x   wp     ,     y   wp       )                   Y     g   1       ⁡     (       x   wp     ,     y   wp       )                   Y     b   1       ⁡     (       x   wp     ,     y   wp       )             )     =       M   c     -   1       ⁡     (             x   wp     /     y   wp               1               (     1   -     x   wp     -     y   wp       )     /     y   wp             )             
In this case, the formalism for defining the error function is identical to process of defining the tone curve described above with respect to step  402 , with the differences that a) all color chart values can be used (as opposed to only the gray chart patches) and b) the parameters ac defined are the values of x and y for the R, G, B channels. The white point of model (x wp ,y wp ) should correspond to the white point used for the measured data of the chart, typically D50, known in the art.
 
   At step  406 , which is optional, optimal parameters α SA    407  that describe selective adjustments to the resulting device-independent color space values XYZ of the device profile. Parameters α SA    407  may be optimized using the error minimization routines described above with respect to steps  402  and/or  404 . According to an embodiment of the present invention, the selective adjustments performed by parameters α SA    407  at step  406  are made to one or more colors such that there is substantially no risk of introducing artifacts or unwanted corruption to images converted or rendered with profiles that have been modified with this approach. Although any method may be used at step  406 , an inventive process of performing selective adjustments to a device-independent color space as part of step  406  is described below with respect to  FIG. 5 . The embodiment illustrated with  FIG. 5  may be used to generate parameters α SA    407  that comprise a list of corrections ΔXYZ i  for i=0, . . . , 5 corresponding to R, G, B, C, M, Y. Such parameters may be optimized using the error minimization processes described above such that an adjusted device-independent color space XYZ adj    505  is generated that minimizes sum squared error. 
   At step  408 , also an optional step, a final optimization of some or all of the parameters in α TC    403 , α C    405 , and α SA    407  may be performed. These parameters may be optimized individually by repeating steps  402  and/or  404  and/or  406  and/or by optimizing most of the parameters as a group using the error minimization techniques mentioned above, such as Powell. For images that are not over-exposed, the total number of data points is 24×3=72. The total number of adjustable parameters is 10 for the tone curves (α TC    403 ), 6 for the chromaticities (α C    405 ), and 18 for the selective XYZ adjustments (α SA    407 ). Since there is a strong correlation of the chromaticity values and the selective XYZ adjustments, it may be beneficial to perform a global optimization of the tone curve and selective chromaticities simultaneously, leaving the chromaticities fixed. The output of step  408  may include adjusted α C  parameters α c ′  409 , adjusted α TC  parameters α TC ′  410 , and adjusted α SA  parameters α SA ′  411 . α C ′  409 , α TC ′  410  and α SA ′  411  are output from step  408  and included in ParameterList  315 . RGB-XYZ ILLCORR    313  need not be output from step  408 , and, instead, α ILLCORR    311  may be output from step  408  and added to the ParameterList  315  used to generate the profile  317  at step  316 . In this regard, it should be noted that step  312  could be performed as part of step  316 . In this scenario, α ILLCORR    311  and RGB-XYZ  305 , output from step  310 , would be passed directly as input to step  314 , instead of RGB-XYZ ILLCORR    313 . Anytime illumination-corrected device-independent data is needed to be operated on in step  314 , α ILLCORR    311  could be applied to XYZ  301  (stored in RGB-XYZ  305 ) to generate XYZ ILLCORR . 
   The above method of  FIGS. 3 and 4  has been shown to provide good results on image with color checker, known in the art, that are either over-exposed or less well-illuminated than the rest of a scene. In all cases, the extreme colors and overall white balance is improved. If desired, the measured chart values XYZ  301  can be modified to achieve the equivalent of a “look profile”, i.e., images can be made more saturated or otherwise modified. 
   Turning now to  FIG. 5 , a method  500 , according to an embodiment of the present invention, for performing selective adjustments to a device independent color space is illustrated. The method  500  ensures an excellent visual match between an image displayed for viewing and the same image printed out in hard-copy form. The method  500  is useful for characterizing image data coming from input devices, rendering images to display devices, and converting images to output devices. The method  500  also is useful for improving the accuracy of a color profile for a digital-image input device, such as a digital camera or a scanner. Accordingly, the method  500  may be used as part of step  406  in  FIG. 4 . However, one skilled in the art will appreciate that the method  500  may be used completely independently of the method  300  illustrated with  FIGS. 3 and 4 . 
   The method  500  applies corrections in a linear manner in all or selected areas of device-independent data derived from device-dependent data with substantially no possibility of introducing artifacts. Selective adjustments may be made to the device-independent data to improve color in selected color regions, such as in the vicinity of red (“R”), green (“G”), blue (“B”), cyan (“C”), magenta (“M”), or yellow (“Y”), without degrading color in the unmodified color areas. 
   Inputs used by the method  500  include device-dependent data “RGB”  501 , device-independent data “XYZ”  502 , other parameters  503 , and changes to selected regions of color “ΔXYZ i ”  504  in device-independent coordinates, where “i” represents a local region of color. When the method  500  is used as part of step  406  in  FIG. 4 , ΔXYZ i    504  represents α SA    407 . The device-dependent data RGB  501  and the device-independent data XYZ  502  correspond, such that each piece of device-dependent data in RGB  501  corresponds to a piece of device-independent data in XYZ  502 . For example, if the method  500  is used as step  406  in  FIG. 4 , the RGB data in RGB-XYZ ILLCORR    313  may be input as RGB data  501 , and the associated device-independent data XYZ ILLCORR  in RGB-XYZ ILLCORR    313  may be input as XYZ data  502 . 
   When attempting to improve a profile for RGB device-dependent data, such as RGB data  501 , it is desirable to perform a correction in a device-independent color space that is similar to the output of the mathematical expression characterizing the device associated with the RGB data. A common mathematical expression characterizing RGB-data-generating devices, such as digital cameras and scanners, is a modified version of the Matrix/TRC formalism described above, for example, in regard to step  402  in  FIG. 4 . This Matrix/TRC formalism inherently converts RGB to XYZ. Hence, for most devices, XYZ tristimulus space is the preferred space in which to perform corrections. Therefore, the device-independent data  502  is shown as XYZ data, and the output of the method  500  is adjusted XYZ coordinates, illustrated as XYZ adj    505 . However, similar linear corrections to those described with reference to the method  500  may be performed with some degree of success for visually uniform color spaces, such as CIELAB, and the various CIECAM models such as CIECAM 98, known in the art. 
   ΔXYZ i    504  represents changes (e.g., to saturation, hue, and brightness) to selected regions “i” of color in the device-independent color space. According to an embodiment of the present invention, 0≦i≦5, such that the values zero to five are associated with the colors red, green, blue, cyan, magenta, and yellow, respectively (referred to as R 0 , G 0 , B 0 , C 0 , M 0 , and Y 0 , respectively). One skilled in the art will appreciate, however, that changes to different color regions may be used. The value R 0  is defined as R=R max , G=0, B=0, C=0, M=0, and Y=0. The values of G 0 , B 0 , C 0 , M 0 , and Y 0  follow similarly. ΔXYZ i    504  may be generated manually or automatically. An example of manually generating ΔXYZ i    504  is having an operator view a displayed image (such as on a CRT) or a hard copy print out of an image generated from the device-independent data XYZ  502  and then make changes to select colors of the displayed or printed image. For instance, if red in a displayed image looks too bright, the operator may specify a negative brightness value for ΔXYZ 0    504  to reduce the brightness of the red in the image. Alternatively, ΔXYZ i  data  504  may be generated automatically through the use of an error minimization routine, such as that described with respect to steps  402  and/or  404  above. For example, if the method  500  is used as part of step  406  in  FIG. 4 , initial values for ΔXYZ i  data  504  may be automatically generated. Then, the method  500  may be performed iteratively, such that different values of ΔXYZ i  data  504  are used in an effort to minimize the sum squared error between the resulting device-independent color space XYZadj  505  and a predicted device-independent color space. The values of ΔXYZ i  data  504  that result in the least sum squared error may be output at step  406  as α SA    407 . 
   Step  506  of method  500  takes as input RGB  501  and other parameters  503  and generates linear RGB values (RGB)′  507 . Alternatively, step  506  may take directly as input the linear values (RGB)′ without the need for the other parameters  503  and step  506 . Although any procedure for generating (RGB)′  507  may be used, (RGB)′  507  typically is calculated to be the corrected values of RGB  501  that achieve optimized predictions of XYZ  502  when multiplied by the appropriate RGB-&gt;XYZ matrix as described in the optimization processes above. In the case of a CRT, (RGB)′ may be calculated by a form of gamma curve associated with the CRT, e.g., R γ . In this case, the other parameters  503  are the parameters describing the gamma curve. More complex functions, beyond just using the gamma curve, may be required for greater accuracy or for LCD systems. In the case where the method  500  is used as step  406  in  FIG. 4 , the other parameters  503  may include one or more of the parameters in α TC    403 . For example, if the device-independent coordinates of a digital camera profile are to be adjusted, the camera&#39;s tone channel expressions f R , f G , f B  (and associated α TC    403  parameters as described with respect to step  402 ) may be used at step  506  to generate (RGB)′  507 . 
   At step  508 , correction factors β  509  are generated for each color i corresponding to ΔXYZ i    504 . According to an embodiment of the present invention, the correction factors β  509  are calculated using piecewise linear correction functions, such that a maximum of each of the piecewise linear correction functions occurs at a boundary condition of a corresponding device-dependent color space (RGB  501 ) and each piecewise linear correction function is linearly reduced to zero or approximately zero as values in the corresponding device-dependent color space approach either a different boundary condition or a neutral axis. Stated differently, the correction factors β  509  are calculated, according to an embodiment of the present invention, such that (a) the piecewise linear correction function for a correction factor (β) and a color i is at a maximum when the current device-dependent color being evaluated is at a maximum distance from all other colors capable of being associated with i and the neutral axis, and (b) the piecewise linear correction function for a correction factor correction factor (β) and a color i scales linearly to zero as the device-dependent colors being evaluated approach another color capable of being associated with i or the neutral axis. For an illustration of what is meant by “associated,” consider a color at the boundary condition R b G b B b . Assume, for example, that a boundary condition is defined as all values of R b G b B b  being either 0 or 1.0. An “adjacent” or “associated” color would be one in which only one of the colors is switched from 0 to 1 or from 1 to 0 from the current color. Thus, adjacent colors to R b G b B b =(1,0,0) are (1,1,0) and (1,0,1). Adjacent colors to R b G b B b =(1,1,0) are (1,0,0) and (0,1,0) 
   According to an embodiment of the present invention, β i    509  for i=0 to i=5 (i.e., for R 0 , G 0 , B 0 , C 0 , M 0 , and Y 0 ) for values ΔXYZ i    504  are calculated as follows. According to this embodiment, R, G, and B are assumed to be normalized to 1.0 so that β is between zero and one, with maximum correction occurring at β=1. 
                           RGB min  = min(R, G, B)                                        β 0 (R, G, B) = R − max(G, B)   for i = 0(R), R &gt; G, R &gt; B       β 0 (R, G, B) = 0   for i = 0(R), R &lt; G or R &lt; B       β 1 (R, G, B) = G − max(R, B)   for i = 1(G), G &gt; R, G &gt; B       β 1 (R, G, B) = 0   for i = 1(G), G &lt; R or G &lt; B       β 2 (R, G, B) = B − max(R, G)   for i = 2(B), B &gt; G, B &gt; R       β 2 (R, G, B) = 0   for i = 2(B), B &lt; G or B &lt; R       β 3 (R, G, B) = min(G, B) − RGB min     for i = 3(C), R &lt; G, R &lt; B       β 3 (R, G, B) = 0   for i = 3(C), R &gt; G or R &gt; B       β 4 (R, G, B) = min(R, B) − RGB min     for i = 4(M), G &lt; R, G &lt; B       β 4 (R, G, B) = 0   for i = 4(M), G &gt; R or G &gt; B       β 5 (R, G, B) = min(R, G) − RGB min     for i = 5(Y), B &lt; G, B &lt; R       β 5 (R, G, B) = 0   for i = 5(Y), B &gt; G or B &gt; R                    
For example, when i=0 (associated with red), β 0  is at a maximum when the current device-dependent color being evaluated (from (RGB)′  507 ) is at a maximum distance from all other colors capable of being associated with i (that is, green, blue, cyan, magenta, and yellow) and the neutral axis. In other words, β 0  is at a maximum when the green and blue components of the current device-dependent color (from (RGB)′  507 ) being evaluated are zero. The piecewise linear correction function for β 0  linearly scales to zero as the device-dependent colors being evaluated (from (RGB)′  507 ) approach green, blue, cyan, magenta, yellow, or the neutral axis. In other words, the linear correction function associated with β 0  linearly scales to zero as the green and blue components of the current device-dependent color (from (RGB)′  507 ) being evaluated increase.
 
   At step  510 , each of the individual device-independent changes ΔXYZ i    504  is corrected by its corresponding correction factors β i    509 . A total adjustment to be made to the device-independent data XYZ  502  is calculated as ΔXYZ total    511 . ΔXYZ total    511  is calculated by summing each of the individually corrected device-independent changes ΔXYZ i    504 . According to an embodiment of the present invention, ΔXYZ total    511  is calculated as follows. 
   
     
       
         
           
             Δ 
             ⁢ 
             
                 
             
             ⁢ 
             
               
                 XYZ 
                 total 
               
               ⁡ 
               
                 ( 
                 
                   R 
                   , 
                   G 
                   , 
                   B 
                 
                 ) 
               
             
           
           = 
           
             
               ∑ 
               
                 i 
                 = 
                 0 
               
               
                 i 
                 = 
                 5 
               
             
             ⁢ 
             
               
                 
                   β 
                   i 
                 
                 ⁡ 
                 
                   ( 
                   
                     R 
                     , 
                     G 
                     , 
                     B 
                   
                   ) 
                 
               
               ⁢ 
               Δ 
               ⁢ 
               
                   
               
               ⁢ 
               
                 XYZ 
                 i 
               
             
           
         
       
     
   
   At step  512 , the device-independent data XYZ  502  is adjusted by ΔXYZ total    511 , thereby generating XYZ adj    505 . According to an embodiment of the present invention, XYZ adj    505  is calculated as follows.
 
 XYZ   adj   =XYZ+ΔXYZ   total  
 
   The following software code illustrates an implementation of the method  500 , according to an embodiment of the present invention. 
   
     
       
         
             
             
           
             
                 
                 
             
           
          
             
                 
               #define nRGBCMY 6 
             
             
                 
               int iColor; 
             
             
                 
               deltaXYZ=XYZ(0.0,0.0,0.0); 
             
             
                 
               for (iColor=0; iColor&lt;nRGBCMY; iColor++) 
             
             
                 
               { 
             
             
                 
                 corrFactor=calcCorrFactor (rgbLinear, iColor); 
             
             
                 
                 deltaX=corrFactor*mDeltaX[iColor]; 
             
             
                 
                 deltaY=corrFactor*mDeltaY[iColor]; 
             
             
                 
                 deltaZ=corrFactor*mDeltaZ[iColor]; 
             
             
                 
                 deltaXYZtemp.x(deltaX); deltaXYZtemp.y(deltaY); 
             
             
                 
                 deltaXYZtemp.z(deltaZ); 
             
             
                 
                 deltaXYZ+=deltaXYZtemp; 
             
             
                 
               } 
             
             
                 
               xyzResult+=deltaXYZ; 
             
             
                 
               double Camera_Model::calcCorrFactor(const 
             
             
                 
               vRGB&lt;double&gt;&amp;rgbVal, int corrColor) 
             
             
                 
               { 
             
             
                 
                 double corrFactor, minRGB; 
             
             
                 
                 corrFactor=0.0; 
             
             
                 
                 minRGB=min(rgbVal.r( ), min(rgbVal.g( ), rgbVal.b( ))); 
             
             
                 
                 if (corrColor==iRED) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.r( )&gt;rgbVal.g( ) &amp;&amp; 
             
             
                 
                     rgbVal.r( )&gt;rgbVal.b( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=rgbVal.r( ) − max(rgbVal.g( ), 
             
             
                 
                       rgbVal.b( )); 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 else if (corrColor==iGRE) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.g( )&gt;rgbVal.r( ) &amp;&amp; 
             
             
                 
                     rgbVal.g( )&gt;rgbVal.b( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=rgbVal.g( ) − max(rgbVal.r( ), 
             
             
                 
                       rgbVal.b( )); 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 else if (corrColor==iBLU) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.b( )&gt;rgbVal.g( ) &amp;&amp; 
             
             
                 
                     rgbVal.b( )&gt;rgbVal.r( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=rgbVal.b( ) − max(rgbVal.r( ), 
             
             
                 
                       rgbVal.g( )); 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 else if (corrColor==iCYAN) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.g( )&gt;rgbVal.r( ) &amp;&amp; 
             
             
                 
                     rgbVal.b( )&gt;rgbVal.r( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=min(rgbVal.g( ), rgbVal.b( )) − 
             
             
                 
                       minRGB; 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 else if (corrColor==iMAG) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.r( )&gt;rgbVal.g( ) &amp;&amp; 
             
             
                 
                     rgbVal.b( )&gt;rgbVal.g( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=min(rgbVal.r( ), rgbVal.b( )) − 
             
             
                 
                       minRGB; 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 else if (corrColor==iYELL) 
             
             
                 
                 { 
             
             
                 
                   if (rgbVal.r( )&gt;rgbVal.b( ) &amp;&amp; 
             
             
                 
                     rgbVal.g( )&gt;rgbVal.b( )); 
             
             
                 
                   { 
             
             
                 
                     corrFactor=min(rgbVal.r( ), rgbVal.g( )) − 
             
             
                 
                       minRGB; 
             
             
                 
                   } 
             
             
                 
                   else 
             
             
                 
                     corrFactor=0.0 
             
             
                 
                 } 
             
             
                 
                 return(corrFactor); 
             
             
                 
               } 
             
             
                 
                 
             
          
         
       
     
   
   The method  500  may be used to improve the process of soft proofing on a display. In order to determine the desired corrections for achieving such improved soft proofing, the magnitude and direction of the corrections can be estimated by correcting a display profile A-&gt;display profile A′ in the desired direction of improvement and then converting colors from the corrected display profile A′-&gt;display profile A. For example, if an operator desires to shift the hue of yellow in a displayed image towards red, a value of Δ(XYZ) 5  (yellow), which equates to a hue shift of 3 delta E towards red for saturated yellow, can be used. If the operator confirms that the desired result has occurred, the RGB profile of the display may now be corrected in an inverse manner to ensure that images rendered to the screen will have the desired red shift in the yellows. This may be accomplished to reasonable accuracy by adjusting the display profile A with a value of Δ(XYZ) 5  (yellow), which is the negative of the above correction. 
   Similarly, the method  500  may be used to perform device independent color space correction. For instance, an original RGB profile (profile A1) may be modified according to the method  500  to generate a new profile (profile A2). XYZ corrections may be performed by following the standard color management path of XYZ-&gt;RGB(profileA1)-&gt;RGB(profileA2)-&gt;(XYZ)′. Combining multiple conversions into a single conversion is well-known in the art and is called concatenation of profiles. The XYZ-&gt;(XYZ)′ result is known as an abstract profile. 
   Another application for the method  500 , as discussed above with reference to  FIGS. 3 and 4  is for digital-image input device (such as a scanner or a digital camera) profiling. The method  500  may permit adequate correction to be applied to a generic RGB profile for a digital camera or scanner in order to preserve gray balance and good overall image integrity, but also improvement to the predictive conversion of RGB-&gt;XYZ or L*a*b* for a specific object in an image having intense color. The values of the corrections to the angle, saturation, and luminance for RGBCMY may be automatically calculated by an error minimizing routine. 
   Unlike other techniques, the method  500  uses piecewise linear functions that may be used to correct both small color discrepancies, i.e., on the order of 2-3 delta E, or large color discrepancies, i.e., on the order of 20-30 delta E. 
   It is to be understood that the exemplary embodiments are merely illustrative of the present invention and that many variations of the above-described embodiments can be devised by one skilled in the art without departing from the scope of the invention. It is therefore intended that all such variations be included within the scope of the following claims and their equivalents. 
   
     
       
         
             
           
             
                 
             
             
               PARTS LIST 
             
             
                 
             
           
          
             
                 
             
          
         
         
             
             
             
          
             
                 
               101 
               object 
             
             
                 
               102 
               input device 
             
             
                 
               103 
               device-dependent data RGB 
             
             
                 
               104 
               color profile 
             
             
                 
               105 
               device-independent data XYZ 
             
             
                 
               106 
               output device color profile 
             
             
                 
               107 
               device-independent data CMYK 
             
             
                 
               108 
               output device 
             
             
                 
               109 
               representation of object 101 
             
             
                 
               200 
               system 
             
             
                 
               202 
               input device 
             
             
                 
               204 
               computer system 
             
             
                 
               206 
               data storage system 
             
             
                 
               208 
               operator 
             
             
                 
               210 
               optional devices/computers 
             
             
                 
               300 
               method 
             
             
                 
               301 
               XYZ data 
             
             
                 
               302 
               step 
             
             
                 
               303 
               RGB data 
             
             
                 
               304 
               step 
             
             
                 
               305 
               RGB-XYZ 
             
             
                 
               306 
               step 
             
             
                 
               307 
               GrayPatches 
             
             
                 
               308 
               step 
             
             
                 
               309 
               Brightest Patch 
             
             
                 
               310 
               step 
             
             
                 
               311 
               α ILLCORR   
             
             
                 
               312 
               step 
             
             
                 
               313 
               RGB-XYZ ILLCORR   
             
             
                 
               314 
               step 
             
             
                 
               315 
               parameters 
             
             
                 
               316 
               step 
             
             
                 
               317 
               profile 
             
             
                 
               402 
               step 
             
             
                 
               403 
               parameters α TC   
             
             
                 
               404 
               step 
             
             
                 
               405 
               parameters α C   
             
             
                 
               406 
               step 
             
             
                 
               407 
               parameters α SA   
             
             
                 
               408 
               step 
             
             
                 
               409 
               adjusted α C  parameters α C ′ 
             
             
                 
               410 
               adjusted α TC  parameters α TC ′ 
             
             
                 
               411 
               adjusted α SA  parameters α SA ′ 
             
             
                 
               500 
               method 
             
             
                 
               501 
               device-dependent data “RGB” 
             
             
                 
               502 
               device-independent data “XYZ” 
             
             
                 
               503 
               other parameters 
             
             
                 
               504 
               changes to selected regions of color “ΔXYZ i ” 
             
             
                 
               505 
               adjusted device-independent data XYZ adj   
             
             
                 
               506 
               step 
             
             
                 
               507 
               adjusted device-dependent data (RGB)′ 
             
             
                 
               508 
               step 
             
             
                 
               509 
               correction factors β 
             
             
                 
               510 
               step 
             
             
                 
               511 
               total changes to device-independent data ΔXYZ total   
             
             
                 
               512 
               step