Abstract:
Provided is a printing system comprising a printing mechanism for applying ink to a substrate using a plurality of print colors. Also included is a computer readable media storing an image and instructions for generating entries in a variable resolution lookup table for use in performing accelerated color conversion of the image. Also included is a lookup table generator configured to divide the lookup table into a plurality of areas, and set a density of lookup table entries in each of the plurality of areas based on overprint combinations of the print colors. The density of entries is varied from one area to another. Also included is a color conversion controller configured to utilize a lookup function to retrieve one or more lookup table entries and to provide printing color space coordinates based upon the one or more lookup table entries to the printing mechanism.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application claims priority to U.S. Provisional Patent Application No. 62/303,642, filed Mar. 4, 2016, the contents of such application being incorporated by reference herein. 
     
    
     FIELD 
       [0002]    This invention relates generally to a lookup table used for color conversion of images from one color space to another color space. The invention seeks to develop a lookup table that is accurate and efficient to use even for large color spaces. 
       BACKGROUND 
       [0003]    Conventional color conversion of large images from a source color space to a destination color space is typically performed by caching a large amount of conversions in a lookup table. For a given color value it is then easy and fast to look up surrounding values and interpolate a conversion for unknown values. Because the number of dimensions of the lookup table is equivalent to the number of inks in the source color space, this approach works well for a small number of inks (e.g. 4 inks (CMYK)) because there are only a small number of combinations of possible overprints. However, this technique rapidly becomes untenable for systems that use a higher number of inks (e.g. expanded gamut printing or spot color proofing). Developing a lookup table for all possible overprints of say 12 inks, would require a lookup table of massive proportions that would not fit into memory of a PC or printer. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0004]    The drawing figures depict one or more implementations in accord with the present teachings, by way of example only, not by way of limitation. In the figures, like reference numerals refer to the same or similar elements. 
           [0005]      FIG. 1  shows a printer system for implementing a lookup table for accelerated color conversion between color spaces. 
           [0006]      FIG. 2  shows a uniform resolution lookup table structure having uniformly distributed overprint values. 
           [0007]      FIG. 3  shows how the uniform resolution lookup table overprint values are stored in memory. 
           [0008]      FIG. 4  shows interpolation between four overprint values in the uniform resolution lookup table. 
           [0009]      FIG. 5  shows a flowchart describing the uniform resolution lookup table implementation. 
           [0010]      FIG. 6A  shows the uniform resolution lookup table structure having uniformly distributed overprint values. 
           [0011]      FIG. 6B  shows a variable resolution lookup table having a variable distribution of overprint values. 
           [0012]      FIG. 7  shows interpolation between the variable distribution of overprint values in the variable resolution lookup table. 
           [0013]      FIG. 8  shows a flowchart describing the variable resolution lookup table implementation. 
           [0014]      FIG. 9  shows interpolation between the variable distribution of overprint values in the variable resolution lookup table. 
           [0015]      FIG. 10  shows a data plot comparing table sizes for set numbers of inks in both the uniform resolution lookup table and the variable resolution lookup table. 
           [0016]      FIG. 11  shows another data plot comparing table sizes for set numbers of inks in both the uniform resolution lookup table and the variable resolution lookup table. 
       
    
    
     SUMMARY 
       [0017]    Provided is a printing system comprising a printing mechanism for applying ink to a substrate. The printing mechanism operable to print using a plurality of print colors such that each unit of a printed output has a color expressed as a set of coordinates in a printing color space, including some coordinates corresponding to ink overprint combinations. Also included is a computer readable media storing digital information including instructions for reading an input image file comprising information defining an image in which each unit of the image has a color defined by a combination of image colors expressed as a set of coordinates in an image color space, and instructions for generating entries in a variable resolution lookup table for use in performing accelerated color conversion of the image from the image color space to the printing color space using a color conversion function. Also included is a lookup table generator configured to divide the lookup table into a plurality of areas, each area corresponding to a printing color subspace, set a density of lookup table entries in each of the plurality of areas based on overprint combinations of the print colors, wherein the density of entries is varied from one area to another, store the lookup table entries according to the varied density, such that the lookup table includes a varied grid of color values corresponding to the printing color space, and generate a lookup function for accessing the lookup table entries when performing accelerated color conversion from the image space to the substrate. Also included is a color conversion controller configured to utilize the lookup function to retrieve one or more lookup table entries and to provide printing color space coordinates based upon the one or more lookup table entries to the printing mechanism for applying the ink to a substrate. 
         [0018]    Provided is a printing system comprising a printing mechanism for applying ink to a substrate, the printing mechanism operable to print using a plurality of print colors such that each unit of a printed output has a color expressed as a set of coordinates in a printing color space. Also included is a computer readable media storing digital information including instructions for reading an input image file comprising information defining an image in which each unit of the image has a color defined by a combination of image colors expressed as a set of coordinates in an image color space. Also included is a lookup table including a plurality of areas having a varied density of lookup table entries for use in performing accelerated color conversion of the image from the image color space to the printing color space using a color conversion function, wherein the density in each of the plurality of areas is based on likelihood of the printing mechanism using the overprints corresponding to the printing space coordinates represented by the lookup table entries, and instructions for implementing a lookup function for the printing mechanism to access the lookup table entries when performing accelerated color conversion of the image. Also included is a color conversion controller configured to access the stored digital information corresponding to the image, determine image color space coordinates of selected pixels in the image, retrieve entries from the lookup table when the lookup table includes entries that correspond to the printing space coordinates corresponding to the image color space coordinates of the selected pixels, interpolate entries from the lookup table when the lookup table does not include entries that correspond to the image color space coordinates, and control the printing mechanism to apply the ink to the substrate based on the retrieved and interpolated entries. 
         [0019]    Provided is an image output method comprising accessing, by a color conversion controller, digital information stored on a computer readable media to implement a lookup function. The stored digital information including a variable density lookup table comprising a plurality of lookup table entries for converting coordinates in an input color space to coordinates in an output color space using a color conversion function, the lookup table including a plurality of areas, the plurality of areas having a plurality of densities of lookup table entries, wherein the density in each of the plurality of areas is based upon likelihood of color combinations represented by the areas being utilized by an output device, and instructions for implementing the lookup function to access the lookup table entries when performing accelerated color conversion from the input color space to the output color space for providing coordinates in the output color space to the output device. Also included is a determining, by the color conversion controller, of input color space coordinates corresponding to selected pixels in an input image, retrieving, by the color conversion controller, of entries from the lookup table when the lookup table is populated with entries that correspond to the output color space coordinates of the selected pixels, the retrieved entries the output color space coordinates that correspond to input color space coordinates converted using the color conversion function, interpolating, by the color conversion controller, of output color space coordinates using neighboring entries from the lookup table when the lookup table is not populated with entries that correspond to the output color space coordinates of the selected colors, and controlling, by the color conversion controller, of the output device to apply the retrieved and interpolated entries to create a representation of the input image in the output color space using the output device. 
       DETAILED DESCRIPTION 
       [0020]    In the following detailed description, numerous specific details are set forth by way of examples in order to provide a thorough understanding of the relevant teachings. However, it should be apparent that the present teachings may be practiced without such details. In other instances, well known methods, procedures, components, and/or circuitry have been described at a relatively high-level, without detail, in order to avoid unnecessarily obscuring aspects of the present teachings. 
         [0021]    This invention is aimed at the multicolour market in the context of devices that have a large number of inks (e.g. most proofers, digital presses, conventional presses using an expanded gamut system). In the context of proofing, it occurs very frequently that the source color space is higher dimensional. 
         [0022]    The invention includes a lookup table (e.g. a single lookup table) that is no longer a regular grid in the (source) color space. The lookup table includes a higher density of entries in color critical areas of the table and a lower density of entries in areas of the table that normally see less color conversions. By choosing an appropriate mathematical structure an efficient lookup table based on the number of inks is formed. For areas of the table with a lower density of entries, an efficient interpolation algorithm is utilized to estimate overprint values. This approach scales much better which makes it practical for most real world applications (e.g. systems with 15 inks). 
         [0023]    In general, the invention is particularly suitable for color transitions between areas within an image having different resolutions, and for use in systems in which it is desirable to process one or more inks differently than others (e.g. by looking at whether they are a process or spot color). Flexibility in determining resolutions within the table makes the exemplary embodiments of the invention particularly applicable to the printing market. 
         [0024]    In addition to these benefits, embodiments of the invention also exhibit good performance with respect to both processing time and memory utilization due in part to a data structure that comprises both externally and internally a single lookup table. This means embodiments of the invention may be particularly useful for implementation in any system configured for use of a lookup table. Storing the points in a single table results in simpler and more efficient operation than if the points were distributed among smaller uniform tables. 
       Introduction: Accelerated Color Transformations 
       [0025]    In general, colors are represented by coordinates in various vector spaces. Grassman&#39;s law states that for human color perception 3 dimensional spaces are sufficient and the standard ways of describing color are 3-dimensional. For a device producing color, the natural way of describing the produced color is as a combination of source colors (Red-Green-Blue RGB as in monitors) or source inks (Cyan-Magenta-Yellow-Key CMYK for office printers). 
         [0026]    For the printing industry there are often many source inks (large presses often have space for up to 8 inks to be printed). On top of that it is common for artwork to contain spot colors. These are colors whose value is specified by some industry standard (like Pantone) or that are typical for a brand (like Coca Cola red). The result is that many files in the printing industry that have artwork described in high-dimensional color spaces. A file containing 10 different inks is not uncommon, especially in the packaging industry where brand colors are important. 
         [0027]    A central problem in color management is that there are two different devices. There is a device (e.g. computer  102  in  FIG. 1 ) for viewing an image in source color space C Input  and a device (e.g. printer  100  having memory  106  in  FIG. 1 ) that prints in a destination color space C output  (e.g. using inkjet heads  104 ). The image must therefore be converted from C Input  to C output  before printing. 
         [0028]    All color spaces have a minimum and maximum value for each dimension (e.g. no ink or maximum amount of ink for a press). After normalizing, it can be said that every dimension has values from 0% to 100% (e.g. 5% Cyan ink and 20% Yellow ink will be the point (5,20) in the CY color space). 
         [0029]    With sufficient information about C Input  and C output  it is possible to make a color transformation function (F: C input -&gt;C output ) that will give a good match for the human eye (i.e. the human eye won&#39;t be able to tell a difference between the source and destination image). In the packaging industry, however, files contain complex artwork that is printed at a very high resolution. This means that millions upon millions of pixels need to be converted for every file. In practice the conversion of a typical file should take under a minute. Implementing conventional transformation functions F as computer algorithms, however, results in a slow conversion process. 
         [0030]    Luckily the following property of color transformations holds true: For the color spaces of output devices, small changes in coordinates make small changes (a couple percent) in the resulting color. Moreover, if for a pixel x transformation F(x) is not known, but points {x 1 , x 2  . . . } that are close to x are known and their functions {F(x 1 ), F(x 2 ) . . . } are also known, F(x) can be estimated by interpolating between pixels {x 1 , x 2  . . . }. 
         [0031]    This estimation is the basis of accelerated color conversion. The idea is to save {F(x)|x in X} for enough points X so that no matter what pixel p is contained in the file, there are always enough points in X that are close to p so an approximation of F(p) can be interpolated. 
         [0032]    Because X is much smaller than the amount of pixels in a typical file and interpolation is quite fast, the conversion speed is increased significantly. Also, if it is known that the same color spaces C Input  and C output  will be repeatedly used, {F(x)|x in X} may be calculated in advance and saved on the hard drive of the computer. This removes the implementation of F completely from the conversion time. 
         [0033]    The method described above to accelerate color conversions can be divided into various parts. A description of these parts are described below. 
         [0034]    The following are identified: 1) A definition of the set X, depending on the color space C Input . This determines how many points need to be calculated with F. 2) An ordering O on X. This allows the storage of the results of {F(x)|x in X}. 3) A fast way of determining O(x) for all x in X. This allows a quick look up of F(x) values in the cache; 4) A function N that for a given pixel c in C gives a set N(c) of points in X close to c. This gives the set of points that can be used in the interpolation. 5) An interpolation function I that for a given pixel c in C approximates F(c) using the cached values for N(c). Together these five parts give a complete approach to approximate F for every pixel. 
         [0035]    In order to clearly describe the lookup process,  FIGS. 2-4  show an example of a simple lookup table and process for two inks with a finite number of points. It should be noted that although  FIGS. 2-4  only shows two inks being utilized and only nine values, that N ink values (where N is an integer number greater than 1) may be utilized storing thousands if not millions of values in the lookup table. 
         [0036]      FIG. 2  shows the structure for a uniform resolution look-up table. For simplicity, the look-up table is shown with overprints for only two inks (ink 1 and ink 2). As shown in  FIG. 2 , the overprint values for different combinations of inks, ink 1 and ink 2, are distributed uniformly throughout the table. Therefore, for any given value of ink 1 and ink 2, there is a resulting overprint value stored in the look-up table. 
         [0037]      FIG. 3  shows the same uniform resolution look-up table structure from  FIG. 2 . During operation, each of the overprint values of the table must be cached in memory in a particular order for easy retrieval during conversion. An example of this caching process is shown in  FIG. 3  where the overprint values are broken up into rows  300 ,  302  and  304 . These overprint values are then stored in a particular order in cache memory  306  (of the PC or the Printer device). 
         [0038]    When utilizing an overprint value look-up table, certain values for combinations of inks will not be stored (i.e., the look-up table will only have a finite number of cached values). Thus, when performing accelerated color conversion utilizing look-up tables, interpolation is typically performed to determine values that are not stored in the look-up table. 
         [0039]    An illustration of interpolation is shown in  FIG. 4  where points  402 ,  404 ,  406  and  408  are stored in the look-up table. However, point  400  is not stored in the look-up table, and therefore must be interpolated. In order to perform interpolation to determine the overprint value  400 , the system (e.g. PC or Printer) typically utilizes the values of neighboring overprint values (e.g., values  402 ,  404 ,  406  and  408 ) in order to estimate value  400 . 
         [0040]    The estimation of point  400  may be performed based on the values of the neighboring pixels as well as their relative distance point  400 . For example, if all four points  402 ,  404 ,  406  and  408  are equidistance to interpolation point  400 , then all of their values may all be weighted equally. However, if, for example, points  402  and  404  were closer to point  400  then were points  406  and  408 , then the value of interpolation point  400  would be more dependent on the overprint values of closer values  402  and  404 , respectively. It should be noted that although in the interpolation shown in  FIG. 4  shows interpolation being performed based on the four neighboring values, that more than four values can be utilized. The number of values and the position/weight of values selected for the interpolation is up to the designer of the system. 
       Uniform Resolution Table Implementation 
       [0041]      FIG. 5  shows a flowchart for a uniform resolution lookup table for performing color conversion. The example described below with respect to  FIG. 5  is called a regular n-grid table. Pseudocode is given to further describe the operations. 
         [0042]    In a first part of the process, the lookup table is generated based on the number of inks utilized and then stored in a specific order in memory. This is shown in  FIG. 5  as steps  500  (DETERMINE NUMBER (N) OF INKS USED BY PRINTER) and  502  (GENERATE (N) DIMENSIONAL LOOKUP TABLE WITH OVERPRINT VALUES UNIFORMLY SPACED APART). Below is a detailed description of these steps. 
         [0043]    As the name suggests, X is a regular n-grid in C Input . For a fixed number n each axis is divided in n equidistant parts. This gives a resolution of n+1 in each direction. The space r between each part is 100/n. It is easy to find out what the points of X are since: A point c=(c 1 , c 2  . . . ) in C Input  is a member of X if and only if all coordinates c i  are a multiple of r (e.g. in 3 dimensions with n=100 X is the set of points with natural numbers as coordinates). 
         [0044]    One type of ordering O on the values of X is lexicographic (i.e. if x and y are elements of X then x&lt;y if and only if x i &lt;y i  where i is the smallest number where x i  and y i  are different). For example, with X as in the previous example: (0,0,1)&lt;(0,0,2) and (0,2,2)&lt;(0,3,1) so the ordering of the set is (0,0,0)&lt;(0,0,1)&lt;(0,0,2), . . . (100,100,99)&lt;(100,100,100). 
         [0045]    In a second part of the process, the lookup function is generated based on for accessing the values stored in lookup table. Generating and performing lookup is shown in  FIG. 5  as steps  504  (GENERATE LOOKUP FUNCTION),  506  (PERFORM LOOKUP FUNCTION TO DETERMINE OVERPRINT VALUE),  508  (IS OVERPRINT VALUE STORED IN LOOKUP TABLE?) and  510  (OUTPUT OVERPRINT VALUE). Below is a detailed description of these steps. 
         [0046]    Say F(x) is calculated for all x in X and stored in a list L that is ordered according to O. Say that C Input  has dimension d input . Then for a given x in X index Ind(x) of F(x) can be found in L as the following: 
         [0000]    
       
         
           
             
               Ind 
                
               
                 ( 
                 x 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 
                   d 
                   input 
                 
               
                
               
                   
               
                
               
                 
                   ( 
                   
                     
                       x 
                       i 
                     
                     / 
                     r 
                   
                   ) 
                 
                 · 
                 
                   n 
                   
                     i 
                     - 
                     1 
                   
                 
               
             
           
         
       
     
         [0047]    Algorithmically this is a quickly calculated function that only depends on x and n (e.g. with X as in the previous example in which n=100: Point (15,0,8) will have a cached value on index (15×100 2 )×(0×100)+8=150008 in the list of cached values). 
         [0048]    In a third part of the process, the an interpolation algorithm is generated so that interpolation may take place in step  512  (INTERPOLATE OVERPRINT VALUE) of  FIG. 5 . Below is a detailed description of generating the interpolation function. 
         [0049]    Before performing interpolation, a neighboring function must be generated. This is performed using hypercubes, which are essentially cubes generalized to higher dimensions. The hypercubes described herein consider cubes where each edge is parallel to one of the axes of the vector space. It should also be noted that not all edges have to be the same length, but all edges that are in the same direction have the same length (Cfr. rectangle). 
         [0050]    It is seen that the set X divides the color space C Input  into a set H of hypercubes with corner points in X and edge length r. N is a function that for every point c in C Input  returns the surrounding hypercube. 
         [0051]    Origin o of the hypercube h in H is defined as the vertex of h that is the closest to the point (0,0, . . . , 0). It is seen that every hypercube in H has a unique origin point and every point in X is the origin point of at the most one hypercube in H. N is then reduced to a function O that for a given c in C Input  returns the origin of the surrounding hypercube. O can then be defined as: Orig(c)=(o 1 , o 2  . . . ) where o i ===floor(c i /r).r (e.g. with X as in the previous example: pixel (15.3,0,8.34) is contained in the cube of length  1  and origin in (15,0,8)). 
         [0052]    Once a hypercube is defined for a surrounding a point many different interpolation formula may be used. For example, an n-simplex interpolation may be used: For a given c in C Input  and surrounding hypercube h in H, call c h  a new set of normalized coordinates for c relative to h, specifically: 
         [0000]    
       
         
           
             
               c 
               l 
               h 
             
             = 
             
               
                 ( 
                 
                   
                     c 
                     i 
                   
                   - 
                   
                     floor 
                      
                     
                         
                     
                      
                     
                       
                         ( 
                         
                           
                             c 
                             i 
                           
                           r 
                         
                         ) 
                       
                       · 
                       r 
                     
                   
                 
                 ) 
               
               / 
               r 
             
           
         
       
     
         [0053]    Call G the function that maps a point c h  in h back to its equivalent point c in C Input . Let O c,h  be an ordering on c h  such that O c,h (i)&lt;O c,h (j)&lt;=&gt;c i   h &lt;c j   h  then n-simplex interpolation can be performed with the following pseudocode: 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 FUNCTION interpolateSimplex(c, hypercube h, cache F){ 
               
               
                   
                   result = (0,0,...,0) 
               
               
                   
                   weightSum = 0 
               
               
                   
                   remainingCoordinates = c h   
               
               
                   
                   currentVertex = (0,0,...,0) 
               
               
                   
                   FOR(a in 1...d input ){ 
               
               
                   
                     weight = remainingCoordinates [O c,h (a)] 
               
               
                   
                     currentVertex[O c,h (a)] = 1 
               
               
                   
                     IF(weight&gt;0){ 
               
               
                   
                       result += F(G(currentVertex)). weight 
               
               
                   
                       remainingCoordinates −= (1,1,...,1) .weight 
               
               
                   
                       weightSum+=weight 
               
               
                   
                   }  } 
               
               
                   
                   result += F(G((0,0,...,0))). (1−weightSum) 
               
               
                   
                   return result 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
         [0054]    It should be noted that in general, n-simplex interpolation doesn&#39;t need to start at (0, 0, . . . , 0) but for color conversion this may be beneficial since then the axis (0, 0, . . . , 0) to (1, 1, . . . , 1) which corresponds to the neutral grey colors, is calculated with the best accuracy. 
         [0055]    During implementation of the algorithm in  FIG. 5 , an n between 10 and 20 would be used to perform color conversions. The value n is chosen depending on the accuracy required and the extent to which the involved color spaces match the linear behavior of the interpolation formula. Typically this approach works well if C Input  is of a low dimension, like RGB or CMYK. It should be noted, however, even n  10  will generate 11 d     input    points in the grid. For example, if a packaging file with 9 colors is used, about 2,400,000,000 points need to be generated in the table. However, it may be impractical to calculate F(x) for all of these points or even to reserve enough RAM memory to cache all of these values. 
         [0056]    There are ways around this problem (e.g. by cutting up C Input  in smaller color spaces through which are converted separately, after which results of all the conversions are combined). However, this combination is done in C output  and cannot take into account the information about how these smaller color spaces interact. As a result color accuracy is lost for all combinations that fall in multiple subdivisions of C Input  and the transitions from one subdivision to another sometimes suffer from sharp changes in behavior, resulting in unwanted artifacts in the final result. 
         [0057]    As described with respect to  FIG. 2 , uniform resolution look-up tables include uniform entries of ink overprint values. On a somewhat larger scale, this uniform table is shown in  FIG. 6A  for ink 1 and ink 2. It can be seen that the number of values in the look-up table increases dramatically as the size of a look-up table increases. This is further amplified by the use of more than two inks (not shown). 
         [0058]    Rather than creating a uniform resolution look-up table with uniform entries, the present system (as shown in  FIG. 6B ) generates a variable resolution look-up table. This variable resolution look-up table shown in  FIG. 6B  is a single lookup table that includes a high resolution of overprint values in certain areas of the table (e.g., single color areas, CMYK areas), and a lower resolution of overprint values in other areas of the table (e.g. areas where the combination of inks is unlikely). 
         [0059]    For example, as shown in  FIG. 6B , the single ink areas (along the X and Y axis) have a high resolution of overprint values. However, the remainder of the table only includes four other overprint values  600 ,  602 ,  604  and  606 . Thus, during operation the printer will be able to easily determine the overprint values for the single ink values along the X and Y axis simply by retrieving the values from the look-up table. However, any other value in the table aside from values  600 ,  602 ,  604  and  606  must be interpolated. For example, points  608  and  610  shown in the table must be interpolated based on the relative values of the neighboring points (e.g. points along the X and Y axis as well as points  600 ,  602 ,  604  and  606 ). 
         [0060]    The interpolation of values in the table of  FIG. 6B  is shown in more detail in  FIG. 7 . For example, as shown in  FIG. 7 , the variable resolution table includes the high resolution overprint values along the X and Y axis as well as additional values  600 ,  602 ,  604  and  606 . However, values  700 ,  702 ,  704 ,  706 ,  708 ,  710 ,  712 ,  714 ,  716 ,  718 ,  720 ,  722  and  724  are not stored in the table and therefore must be interpolated. The lines in  FIG. 7  show the relative distance between interpolation points  700 - 724  and the other points (e.g. points along the X and Y axis as well as points  600 ,  602 ,  604  and  606 ) actually stored in the look-up table. During operation, if value  700  in the look-up table is requested, then the system determines (i.e., estimates) value  700  based on these neighboring values stored in the table. 
       Variable Resolution Table Implementation 
       [0061]      FIG. 8  shows a flowchart for a variable resolution lookup table for performing color conversion. The flowchart is divided into five parts. A description of each of the parts of the process for generating and implementing the variable resolution lookup table is described below. 
         [0062]    In a first part of variable resolution lookup table process, the variable resolution lookup table is generated based on the number of inks utilized and then stored in a specific order in memory. This is shown in  FIG. 8  as step  800  (DETERMINE DEFINITION OF LOOKUP TABLE BASED ON NUMBER (N) OF INKS USED BY PRINTER). Below is a detailed description of this step. 
         [0063]    The central idea of the variable resolution lookup table is to make X sparser in areas which include: 1) Areas where there is little information about the behavior of colors (mainly areas that have a significant amount of spot colors). 2) Areas where a lot of colors are present (e.g. customers use a lot of colors in one file, but almost never all on top of each other). This is also an area where even a more time consuming method F will not result in perfect matching. Higher density in this area is therefore both unnecessary and impractical. 
         [0064]    Another central idea of the variable resolution lookup table is to boost the amount of points in X in color critical areas: 1) The CMYK part of C Input , if present, often corresponds to images in the file that should be converted at high accuracy. 2) Areas where one spot color is dominant. Practically speaking, this is because this spot color represents the brand of the customer, and is critical to the quality of the final customer product. In one example, the density of points in X may correspond to a regular 30-grid. 
         [0065]    The density in a certain areas therefore depend on which colors are present. For this reason a function is defined that for the pixels c in C Input  indicates which colors are present: Hash(c)=(h 1 , h 2  . . . ) where h i =0 if c i =0 and h i =1, else call H input  the set of possible hash values in C Input . C Input  can be divided into areas of equal Hash value that are called regular subspaces. H input  can then be used to indicate the set of regular subspaces. 
         [0066]    The general idea is to give each regular subspace a different resolution, depending on how color critical that area is. For this a Reduction function is defined on the possible hashes: Reduction: H input →         . This reduction formula is used in the following examples: Reduction(h)=0 if h i =0 for all dimensions i that correspond to a spot color=P/2+S−1 where P is the number of process colors that are present in h and S is the number of spot colors present in h. The reduction pixels c in H input  is extended by saying Reduction(c)=Reduction(Hash(c)). With a reduction formula X can be defined as: 
         [0000]    
       
         
           
             ∀ 
             
               c 
               ∈ 
               
                 
                   C 
                   input 
                 
                 : 
                 
                   c 
                   ∈ 
                   
                     X 
                      
                     
                         
                     
                      
                     
                       ≤&gt; 
                     
                      
                     
                         
                     
                      
                     
                       ∀ 
                       
                         0 
                         &lt; 
                         i 
                         ≤ 
                         
                           
                             d 
                             input 
                           
                           : 
                           
                             ( 
                             
                               
                                 ∃ 
                                 
                                   k 
                                   ∈ 
                                   
                                     ℕ 
                                     : 
                                     
                                       100 
                                       - 
                                       
                                         c 
                                         i 
                                       
                                     
                                   
                                 
                               
                               = 
                               
                                 k 
                                 · 
                                 
                                   100 
                                   n 
                                 
                                 · 
                                 
                                   2 
                                   
                                     Reduction 
                                      
                                     
                                         
                                     
                                      
                                     
                                       ( 
                                       c 
                                       ) 
                                     
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           OR 
         
       
       
         
           
             
               c 
               i 
             
             = 
             0 
           
         
       
     
         [0067]    Where nε          it can be seen as a maximum resolution. Reduction(c)=0 reduces to roughly the simple implementation (one exception being that the gaps are not equidistant). Two aspects of this definition are highlighted: 100-c i  is used since that way the smallest gap is the one closest to 0. This is because for color conversion the area of low ink percentage is the most critical so the smaller gap will be most useful there. For a given regular subspace h in H input  this corresponds to a regular grid of resolution 
         [0000]    
       
         
           
             
               n 
               
                 2 
                 
                   Reduction 
                    
                   
                       
                   
                    
                   
                     ( 
                     h 
                     ) 
                   
                 
               
             
             . 
           
         
       
     
         [0000]    This grid becomes sparser exponentially with increasing values for the reduction. To finish this part the following pseudocode is used to find out whether a pixel is a member of X: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 Function is InX(vector c, int n){ 
               
               
                         Int stepsize = 100/n.2{circumflex over ( )}Reduction(c) 
               
               
                         FOR(i in 1...dinput){ 
               
               
                           IF(ci ≠ 0 AND floor(c_i/stepsize).stepsize≠c_i) 
               
               
                           { 
               
               
                           Return false 
               
               
                         }  } 
               
               
                         Return true 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0068]    For example, with a 3-dimensional input space consisting of 2 process colors and spot process color, a resolution of 100 and the reduction formula as defined above the following may result: The area of points (x,y,0) where x and y are natural numbers 1 . . . 100 is a regular grid. All points (0,0,x) with x a natural number from 1 to 100 are also contained. All points (2x,0,2y) and (0,2x,2y) are contained for x and y a natural number from 1 to 50. All points (4x,4y,4z) with x,y,z natural numbers from 1 to 25. The only point missing is (0,0,0). This example also shows the split into regular subspaces (i.e. there are 6 of them in this example). In a second part of the variable resolution lookup table process, the values of the variable resolution lookup table are stored in memory in a specific order. This is shown in  FIG. 8  as step  802  (DETERMINE ORDERING OF LOOKUP TABLE OVERPRINT VALUES IN MEMORY). Below is a detailed description of this step. 
         [0069]    The ordering O that defined for X is double lexicographically, taking advantage of the definition of H input . Let x 1  and x 2  be elements of X and let &lt; lex   x  and &lt; lex   H  be the lexicographic orderings on X respectively H, then: x 1 &lt;x 2           x 1 &lt; lex   x  x 2 . If Reduction(x 1 )=Reduction(x 2 ) x 1 &lt;x 2           Hash(x 1 )&lt; lex   H  Hash(x 2 ) else. In other words, the elements of X are grouped according to hash, with the elements of the group and the groups themselves ordered lexicographically. 
         [0070]    In general, this ordering provides a quick way to calculate the number of elements for buffering. Remark that the size of H is easily seen to be 2 d     input    and that every regular subspace hεH is a grid with resolution 
         [0000]    
       
         
           
             max 
              
             
               ( 
               
                 
                   floor 
                    
                   
                       
                   
                    
                   
                     ( 
                     
                       n 
                       
                         2 
                         
                           Reduction 
                            
                           
                               
                           
                            
                           
                             ( 
                             h 
                             ) 
                           
                         
                       
                     
                     ) 
                   
                 
                 , 
                 1 
               
               ) 
             
           
         
       
     
         [0000]    and as many dimensions as there are nonzero elements in the hash h. For reasons that will become clear later the process keeps track of where in the cache each hash starts. This gives the following function shown in pseudo-code: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 FUNCTION getBufferSizeAndSubspaceStartPoints(int n, int d input ){ 
               
               
                   Int bufferSize = 0 
               
               
                   vector currentHash = (0,0,...,0) 
               
               
                   Int hashIndex = 0 
               
               
                   vector subspaceStartPoints(2 d     input   , 0) 
               
               
                   REPEAT{ 
               
               
                    Int nrNonZeroPoints = 0 
               
               
                    FOR(I in 1... d input ){ 
               
               
                     IF(currentHash[i]) nrNonZeroPoints++ 
               
               
                    } 
               
               
                    subspaceStartPoints[hashIndex] = bufferSize 
               
               
                   
               
               
                    
       bufferSize   +=         max   (       floor   (     n     2     Reduction        (   currentHash   )           )     ,   1     )     nrNonZeroPoints        v         
 
               
               
                   
               
               
                    IF(currentHash=(1,1,...,1)){ 
               
               
                     RETURN bufferSize, subspaceStartPoints 
               
               
                    } 
               
               
                    currentHash++ 
               
               
                    hashIndex++ 
               
               
                 }   } 
               
               
                   
               
             
          
         
       
     
         [0071]    Using the definitions from the previous examples, hashes are ordered as following: (0,0,0)&lt;(0,0,x)&lt;(0,x,0)&lt;(0,2x,2y)&lt;(x,0,0)&lt;(2x,0,2y)&lt;(4x,4y,4z). The start indices for the 6 hashes are (0, 1, 101, 201, 451, 551, 801) and the entire buffer is 16426 points large. That is, hashes (0,0,x), (0,x,0), and (x,0,0) each have 100 values corresponding thereto, and hashes (0,2x,2y) and (2x,0,2y) each have 200 values corresponding thereto. 
         [0072]    In a third part of variable resolution lookup table process, a lookup function is generated for retrieving values from the variable resolution lookup table. This is shown in  FIG. 8  as steps  804  (GENERATE LOOKUP FUNCTION),  810  (PERFORM LOOKUP FUNCTION TO DETERMINE OVERPRINT VALUE),  812  (IS OVERPRINT VALUE STORED IN LOOKUP TABLE?) and  814  (OUTPUT OVERPRINT VALUE). Below is a detailed description of these steps. 
         [0073]    Both for filling up the variable resolution lookup table and for using it in the interpolation, a fast lookup function is beneficial. The breakup into regular subspaces and the fact that the start points of the buffers for each regular subspace are cached may be taken advantage of such that the problem of looking up the value for x in X reduces to calculating the index of Hash(x) in H and calculating the index of x in Hash(x). 
         [0074]    Calculating the index of a hash  11  in H is straightforward as shown in the following pseudo-code: 
         [0000]                                        FUNCTION calculateHashIndex(vector h){            Int index = 0            int increasingSize = 1            FOR(i in d input ... 1){             IF(h[i]){              Index+= increasingSize             }             increasingSize = increasingSize.2            }            RETURN index           }           As is calculating the index of a point x in Hash(x):           FUNCTION calculateIndexInHash(vector x){            Int index            int increasingSize = 1                    
         int                 resolution     =     max   (       floor   (     n     2     Reduction        (   h   )           )     ,   1     )         
                    FOR(i in d input ... 1){             IF(h[i]){              Index+= (h[i]-1).increasingSize              increasingSize = increasingSize.resolution            }  }            RETURN index           }                    
The general lookup is then a combination of these with the cached starting points:
 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 FUNCTION lookup(vector x) 
               
               
                    RETURN subspaceStartPoins [calculateHashIndex(Hash(x))] + 
               
               
                 calculateIndexInHash(x) 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0075]    Point (4,0,14) is in hash (1,0,1) [(2x,0,2y)], which has starting point  551 , as explained above. Inside this hash it has index 57 (x=2, y 7; 2*50+7 57) so its index in the buffer is 608. This lookup function can be used to quickly retrieve overprint values stored in the variable resolution lookup table. 
         [0076]    In a fourth part of variable resolution lookup table process, neighboring function is generated for aiding in the interpolation variable resolution lookup table. This is shown in  FIG. 8  as step  806  (DETERMINE NEIGHBORING FUNCTION TO DESCRIBE NEIGHBORING OVERPRINT VALUES OF ANY GIVEN OVERPRINT VALUE STORED IN THE LOOKUP TABLE). Below is a detailed description of this step. 
         [0077]    While X is divided into regular grids H, the general space is not regular. This complicates finding neighboring points for a given pixel c in C input . In general two hypercubes are used to describe the neighbors of c: The surrounding region (Region(c)) is the smallest hypercube in C input  that contains c and for which all vertices are contained in X. The surrounding sector Sector(c) is a hypercube in C input  that is contained inside of Region(c). Most interpolation formulas in a hypercube (like n-simplex interpolation) usually take only the vertices into account. 
         [0078]    Region(c) allows n-simplex interpolation, but would not always take into account the cached points closest to c, lowering accuracy. Furthermore, adding even a small percent of a color may drastically lower the resolution, which might result in unacceptable color conversion. Accordingly, a smaller hypercube Sector(c) may be beneficial. Generally, any point in X close enough to c to affect its interpolation is a vertex in Sector(c) or Region(c). 
         [0079]    The points in X that are contained in the Region of a pixel c are on the faces of the hypercube Region(c). This follows from the observation that any point x not on a face of Region(c) will be part of the same subspace Hash(c) as c. In this subspace X forms a regular grid, so x must be a vertex of Region(c). Otherwise there would be a smaller hypercube in this subspace that contains c. 
         [0080]    Knowing this Region(x) is divided in parts depending on which points in X have to be taken into account. The idea is that along the edges of Region(x) the system takes into account any other elements of X that might be close. Further away from the edges the system cares less about the other elements of X. 
         [0081]    For a given hypercube Region(c) and dimension i, call the face F(c,i) orthogonal to i in Region (c) the set {α|αεC input ̂αεRegion(c)̂α i =O(c) i }. For any dimension i there is an edge going through the origin Orig(c) of Region(c) along that dimension. The reduction along that dimension is denoted by Reduction(c,i). Call c close in dimension i if: 
         [0000]    
       
         
           
             
               floor 
                
               
                   
               
                
               
                 ( 
                 
                   
                     100 
                     - 
                     
                       c 
                       i 
                     
                   
                   
                     Reduction 
                      
                     
                       ( 
                       
                         c 
                         , 
                         i 
                       
                       ) 
                     
                   
                 
                 ) 
               
             
             = 
             
               floor 
                
               
                   
               
                
               
                 ( 
                 
                   
                     100 
                     - 
                     
                       0 
                        
                       
                         
                           ( 
                           c 
                           ) 
                         
                         i 
                       
                     
                     - 
                     1 
                   
                   
                     Reduction 
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         c 
                         , 
                         i 
                       
                       ) 
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0082]    This can be seen to mean that if only looking at dimension i, the space is divided in areas according to Reduction(c,i). c is then close in dimension i if it is in the same area as the origin of Region(c). What this means is that it is close enough to the face F(c,i) that will let elements of X in that F(c,i) have an effect in the final interpolations. 
         [0083]    In general the system defines the Sector of c as follows. If c is not close to any dimension, then Sector(c)=Region(c). If there is a dimension i to which c is close, then c is projected onto F(c,i). Call the projection p, then Sector(c) is equal to Sector(p), except in dimension i where Sector(c) has edge length Reduction(c,i) instead of 0. If c is close to multiple dimensions it doesn&#39;t matter which one is used (since all calculations are only about one dimension at a time). In pseudocode it is represented as: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                   
                 FUNCTION Reduction(vector c, int i){ 
               
               
                   
                  Vector RegionOrigin, RegionLengths = Region(c) 
               
               
                   
                  Vector SectorOrigin = RegionOrigin 
               
               
                   
                  Vector SectorLengths = RegionLengths 
               
               
                   
                  Vector edgeHash = Hash(RegionOrigin) 
               
               
                   
                  edgeHash[i] = 1 
               
               
                   
               
               
                   
                  
       RETURN                     100   n     ·     2     Reduction        (   edgeHash   )               
 
               
               
                   
               
               
                   
                 } 
               
               
                   
                 FUNCTION CloseInDimension(vector c, vector origin,int i){ 
               
               
                   
                  int reduction = Reduction(c,i) 
               
               
                   
                  int pixelArea = (100-c[i])/(reduction) 
               
               
                   
                  int originArea = (99-origin[i]/reduction) 
               
               
                   
                  return pixelArea==originArea 
               
               
                   
                 } 
               
               
                   
                 FUNCTION Sector(vector c){ 
               
               
                   
                  Vector RegionOrigin, RegionLengths = Region(c) 
               
               
                   
                  Vector SectorOrigin 
               
               
                   
                  Vector SectorLengths 
               
               
                   
                  boolean closeDimensionFound=false 
               
               
                   
                  FOR(i in 1..d index ){ 
               
               
                   
                   If(CloseInDimension(c, RegionOrigin, i)) 
               
               
                   
                   { 
               
               
                   
                    Vector p = c 
               
               
                   
                    p[i] = RegionOrigin[i] 
               
               
                   
                    closeDimensionFound = true 
               
               
                   
                    SectorOrigin, SectorLengths = Sector(p) 
               
               
                   
                    SectorLengths[i] = Reduction(c,i) 
               
               
                   
                   } 
               
               
                   
                  } 
               
               
                   
                  If(!closeDimensionFound) 
               
               
                   
                  { 
               
               
                   
                   SectorOrigin = RegionOrigin 
               
               
                   
                   SectorLengths = RegionLengths 
               
               
                   
                  } 
               
               
                   
                  RETURN SectorOrigin, SectorLengths 
               
               
                   
                 } 
               
               
                   
               
             
          
         
       
     
         [0084]    In a fifth part of variable resolution lookup table process, the neighboring function is used to perform interpolation variable resolution lookup table. This is shown in  FIG. 8  as step  816 . Below is a detailed description of this step. 
         [0085]    By definition, Sector(c) is contained in Region(c) and the missing sector points of c are calculated by interpolation in Region(c). This process is described in the following pseudo-code: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 FUNCTION interpolate(vector c, Cache F){ 
               
               
                   Cache sectorValuesCache 
               
               
                   FOR(s in Sector(c)){ 
               
               
                     IF( isInX(s) ){ 
               
               
                       sectorValuesCache.add(F(lookup(s))) 
               
               
                     }ELSE{ 
               
               
                       sectorValuesCache.add(interpolateSimplex(s, Region(c),F)) 
               
               
                   }  } 
               
               
                   RETURN interpolateSimplex(c, Sector(s), sectorValuesCache) 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0086]    In general, this process combines the consistency of interpolating in adjacent hypercubes with the accuracy of using the closest cached points. Importantly, the Reduction function on H can be adjusted at will, allowing the adaption of the lookup table to different situations. 
         [0087]    One major advantage of the variable resolution lookup table implementation is that it is more efficient (less data points are needed), and therefore more practical than the uniform resolution lookup table implementation. For example, as remarked before, a regular 10-grid will have 11 d     input    points. In general all the edges of the color space are used to make a conversion, giving a lower bound of 2 d     input    for any approach. 
         [0088]    The following is further detail about why the space was divided into sectors in a particular manner. For example, take two points c and d in C input  that are almost equal except for a small difference in one dimension i. For convenience assume that c i &lt;c i . The following are evaluations of all the possible cases: 
         [0089]    When c and d are in different Hashes: This happens if c i =0. In this case they will have different regions, but when calculating Sector(d) it is found that d is close to dimension i. Because the projection of d along dimension i is exactly c it follows that Sector(d) is Sector(c) extended along dimension i by Reduction(d,i). Since d is so close to Sector(c) the interpolation assigns a high weight to the vertices of Sector(c) relative to the other vertices of Sector(d). This means that a transition from c to d behaves smoothly. 
         [0090]    When c and d have the same hash but different regions: Since Region(c) and Region(d) are adjacent in a regular grid they share a face F. The points c and d are on either side of this face but very close to it. This means that the points in F have a very high weight in the interpolation and a transition from c to d is smooth. 
         [0091]    When c and d have the same sector: This results in a smooth transition from c to d since the same points are used in the interpolation and the interpolation formula is assumed smooth. 
         [0092]    When c and d have the same region but different sectors (i.e. c is close to i while d is not): It follows that c and d are in different parts of the partition (see  FIG. 9 ) of their shared region along Reduction(c,i)=Reduction(d,i). Specifically c is in the partition containing Orig(c)=Orig(d) while d is in the one adjacent to that one. If they are close they must be close to the transition between the two partitions. This means that c is close to the face F of Sector(c) that is in this transition. 
         [0093]    If there is a point x in X that is also in F (see  902  in  FIG. 9 ), it means that c is close to another dimension j. It follows that d is also close to that dimension j and that x is also part of Sector(d). Because the order is chosen for projecting along dimensions a point is close to, the system can project along any dimension j like this first and it follows that F is also a face of Sector(d). In this case the points of F have a very high weight in both the interpolation of c and d and the transition from c to d is smooth. 
         [0094]    If there is no point from X in F (see  904  in  FIG. 9 ), this means that all vertices in F are missing and interpolated from Region(c)=Region(d). This means that the points in Region(c) have very high weight in the interpolation of both c and d and the transition between them is smooth. 
         [0095]      FIG. 10  shows a data plot of the comparison of size in stored data points between both variable and uniform look-up table entries. It can be clearly seen from  FIG. 10  that as the number of inks increases (see the X axis), the number of look-up table entries increases very rapidly. This increase in the size of look-up tables is amplified, especially for the uniform resolution look-up table. By utilizing the variable resolution look-up tables, the values somewhat level off at a realistic size that can be stored in memory of the PC and/or printing device. 
         [0096]      FIG. 11  also shows graph comparing the regular 10-grid with the lower bound and a variable resolution table with maximal resolution 15 or 20, reduction formula as in the examples with the first 4 inks being process colors and the other inks being spot colors. To be realistic in industrial uses, 1,000,000 cached points is a good cutoff. The simple uniform resolution implementation in  FIG. 11  reaches this cutoff at only 6 input inks, where the lower bound ensures that this can be reached for 20 inks. The variable resolution lookup tables reaches this cutoff, depending on the maximal resolution, for 10 or 15 input inks, which is more than high enough to capture almost all use cases in industrial applications. Thus, the variable resolution lookup tables have a much higher density in the process colors, orders of magnitude above what the simple uniform implementation reaches, while still converging to the lower bound once spot colors get added. 
         [0097]    In general, the variable resolution lookup table described herein solves the scalability problem of the simple uniform implementation in a flexible way. By adjusting the Reduction formula it can be tailored to specific needs and even higher accuracy in color critical areas can be achieved than is possible with the simple implementation. Asymptotically it is possible to converge to the lower bound of what is possible and this approach remains practically feasible even for a file containing 15 inks. 
         [0098]    Calculating the sector is recursive but many of the calculation can be cached between different recursions. What is still needed is calculating the region in every iteration and O(d input ) to look for a new dimension that a point is close to. Worst case scenario these operations need to happen d input  times, if the system has to iterate for every dimension. This gives looking for the sector O(d 2     input   ) complexity. In reality the number of iterations is almost always much less than d input . 
         [0099]    There are no problems with the presented algorithms in terms of scaling with increasing dimensions. In real life examples the O(d input   3 ) worst case scenario doesn&#39;t happen often enough to make both implementations scale differently. Thus, the actual implementation can be made sufficiently fast for industrial use. In real life jobs there is a fixed overhead that is added when using the variable resolution table compared to the simple implementation. 
         [0100]    There are several aspects in which the design of this table was done with color conversion in mind. It often happens that existing files are tweaked by adding in some new design element or some new colors. These changes can trigger an extension of the color space associated with the file. When converting the file, this should not affect the conversion of the elements in the file that were not changed. 
         [0101]    For accelerated color conversion this means that by adding another ink to the input color space, none of the resolutions should be changed in the areas that only contain the original inks. Ensuring this is a further restriction on the choice for Reduction(x). 
         [0102]    A further benefit of this is the fact that the entire cache does not have to be recalculated if an ink is added. Only the parts of the cache containing this new ink will need to be updated, though the regular subspaces need to be rearranged. Inks are typically chosen so they behave quite linearly. Amongst other things, this makes interpolation formula is more accurate. 
         [0103]    It is however often the case for mechanical reasons that inks behave quite non-linearly when the ink percentages are very low. The reason being mechanical constraints on the printing device. It is therefore recommended to have a high density of cached points in these areas. 
         [0104]    The simple uniform implementation is not able to have this density once more than 4 inks come into play. With the variable resolution table, for low ink percentages, the effective resolution will be close to the maximal resolution, which is generally higher than in the simple uniform implementation. This is the main drawback to other methods for handling high-dimensional input color spaces. Because the entire color space is contained in one data structure and our interpolation method ensures that the closest cached points are all taken into account, the variable resolution table is able to guarantee smooth behavior in these situations. 
         [0105]    While the foregoing has described what are considered to be the best mode and/or other examples, it is understood that various modifications may be made therein and that the subject matter disclosed herein may be implemented in various forms and examples, and that the teachings may be applied in numerous applications, only some of which have been described herein. It is intended by the following claims to claim any and all applications, modifications and variations that fall within the true scope of the present teachings. 
         [0106]    Unless otherwise stated, all measurements, values, ratings, positions, magnitudes, sizes, and other specifications that are set forth in this specification, including in the claims that follow, are approximate, not exact. They are intended to have a reasonable range that is consistent with the functions to which they relate and with what is customary in the art to which they pertain. 
         [0107]    It will be understood that the terms and expressions used herein have the ordinary meaning as is accorded to such terms and expressions with respect to their corresponding respective areas of inquiry and study except where specific meanings have otherwise been set forth herein. Relational terms such as first and second and the like may be used solely to distinguish one entity or action from another without necessarily requiring or implying any actual such relationship or order between such entities or actions. The terms “comprises,” “comprising,” or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. An element proceeded by “a” or “an” does not, without further constraints, preclude the existence of additional identical elements in the process, method, article, or apparatus that comprises the element. 
         [0108]    The Abstract of the Disclosure is provided to allow the reader to quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, it can be seen that various features are grouped together in various embodiments for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed embodiments require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in fewer than all features of a single disclosed embodiment. Thus the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separately claimed subject matter.