JPH10150578A - Color image conversion method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve the accuracy of color conversion, without increasing a capacity of a memory. SOLUTION: The color image conversion method coverts an image dot group in an input color space into a group in an output color space, and 1st control point group (p0, p1, p2, p3, p4, p5, p6, p7) is provided in an input color space. The 1st control point group is placed to each apex of a cube in the input color space, and a 2nd control point group (p8) is provided to the input color space. The 2nd control point group is placed in the inside of the cube and each the 1st and 2nd control point group has a corresponding output value group in the output color space to interpolate an image point, based on the 1st and 2nd control point group.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates generally to the processing of color images, and more particularly to processing images (such as a color CRT monitor).
It relates to a method for converting from an input color space to an output color space (such as a color printer).

[0002]

2. Description of the Related Art The color perception by the human eye is theoretically represented by three color vectors in a three-dimensional space called a tristimulus space or a color space. See John Wiley & Sons, NY, for the basis of such three-dimensional structures.
Inc., Billmeyer and Saltzman, "Prin
ciples of Color Technology ”(copyright 1981, 2nd edition) and Wys published by John Wiley & Sons, Inc.
"Color Science; Concepts and M", co-authored by zecki and Stiles
ethods, Quantative Data and Formulae ”(copyright 1982
(2nd edition) (especially pages 119-130).

[0003] Various three-color model systems have been developed, including a red-green-blue (RGB) model and a cyan-color model.
Magenta-yellow (and black) (CMY (K)) model, hue-saturation-value (HSV) model, hue-brightness-saturation (HLS) model, luminance-red / green scale-yellow / blue scale (L * a * b) Models and YIQ used for commercial color television broadcasting
Model etc. are included. Addison-Wesley Publishing Comp
"Fundamentals of Inter," co-authored by Foley and Van Dam
Various ternary color models are described in documents such as "Active Computer Graphics" (specifically, pages 606-621).

[0004] Color input and output devices, such as scanners, cathode ray tube (CRT) video monitors and printers, provide color images in a device dependent manner. For example, a CRT electron gun is driven by an RGB value (a voltage level or other input signal function, referred to herein as a data triplet) stored in a frame buffer. The colors that the CRT generates for a particular RGB triplet value on one pixel of the screen will be unique to each video monitor device. The same RGB triplet produces significantly different colors or hues when displayed on different CRT models, and produces different colors on a print medium (such as paper) when printed on a color printer.

[0005]

There are many problems with color conversion (also referred to in the art as color correction and cross-rendering) between model systems in digital data processing. Conversion of data from one device to another is difficult because the color matching relationships between such systems are generally non-linear. Therefore, (color scanner,
Color preservation between original images from input devices (such as CRT monitors, digital cameras, computer software / firmware generation, etc.) and converted copies on output devices (such as color laser printers, color inkjet printers, etc.) Is a very important issue.

As described in the above references, the color must be created as a rendering of the additive primary, red, green and blue (RGB) or subtractive primary, cyan, magenta, yellow and black (CMYK). Can be. Conversion is RGB
CMYK from color space (eg computer video monitor)
A transition to a color space (eg, a color inkjet printer) may be required. Conversion from one color space to another requires complex, non-linear calculations in multiple dimensions. A very large look-up table (e.g., 50 megabytes) containing data to approximate the conversion is typically used to perform the conversion from an RGB system to a CMYK system to correlate a wide hue spectrum. (Note: To maintain black purity in CMYK printing, usually instead of printing all three colors cyan, magenta and yellow as composite black, another black ink or toner is provided and the disclosure of the present invention This is based on the premise that such a separate black expression mechanism is used). A look-up table of input data versus output data can be generated for any combination of devices. There are various ways to build a device-dependent lookup table for a particular device. One example is shown in U.S. Pat. No. 3,893,166 (Pugsley). However, memories are relatively expensive in the current market, especially in view of the low cost of current color printers.

Therefore, there is a need for a process for converting color values from a particular device color space to another device color space in a fast and economical manner.

[0008] The data bytes correlated in three dimensions can be represented as a cubic lattice structure, with each apex angle of the cube representing a data point. For an RGB or other model color space structure, the entire look-up table is composed of a number of such cubes as shown in FIG. But,
To store a typical printer color conversion data point for each monitor RGB value in the lookup table, about 50
It requires megabytes of memory, which is currently too costly. Therefore, it is more economical to store only a limited number of data points and use interpolation to generate intermediate data points in the grid.

The conversion of RGB triplets on a CRT video monitor to printer RGB (or CMY or CMYK) values can be performed using a color adjustment tool and a device independent color space. Device independent colors allow for accurate color matching based on absolute color standards, such as what is called the CIE * a * b color space developed by the International Commission on Illumination (CIE).

A device independent color space provides a way to describe the appearance of a color independent of the mechanism that generated the color. First, the RGB data points are converted from the monitor color space (ie, the input / output correlation table) to a device independent color space, for example, CI.
A function to convert to E * a * b color space is constructed. Second, a function is built to convert the color data points from the device independent space (CIE * a * b color space) to the color space of the particular printer. These two
Converts monitor RGB data values to L * a * b data triplets, converts L * a * b data triplets to printer data triplets using one of the three functions, and matches the original output as viewed on the CRT monitor. You can get the output.

However, in addition to the data storage and access issues described below, if the mapping of monitor RGB values to printer RGB values is performed for each colored pixel in an image, the image will not be completely printed. It takes a lot of time to complete. Therefore, it is low to calculate and store the printer output RGB values for a subset of the monitor input RGB values in advance, and then use a fast interpolation algorithm to approximate the conversion function of the intermediate RGB values, that is, the RGB values that have not been calculated and stored in advance. It is a cost method.

Although printers usually print in subtractive color CMY (K), it must be noted that the output printer color space is RGB. First, convert the input monitor RGB color space to the printer RGB color space, then convert the output RGB values to the subtractive CMY
(K) It has been found that the method of converting to the color space is algorithmically easy.

After the output RGB color space values are obtained, these values are "halftoned" to produce CMY (K) "binary" values that can be used by the printer. Halftoning is necessary because color printers are usually binary devices. That is, for each pixel, such a device can only perform two levels of printing: printing a dot on that pixel or not printing it. On the other hand, the output RGB values typically have 256 levels potentially for each pixel. The halftoning algorithm uses dithering to print binary dots to give the appearance of a continuous tone image. The necessity of halftone processing of an image in this way contributes to the graininess sometimes seen in a dot printer.

The conversion of one tristimulus system to another has used three- or four-line interpolation techniques well known to those skilled in the art. One of the devices that perform algorithmic interpolation using the L * a * b model is Electronic Eng
Junko, ineering Times, November 9, 1992, page 35
Yoshida “High-speed processor transforms colors”
Briefly described. However, Yoshida's "new algorithm" itself is not disclosed. The commonality of such interpolation algorithm-based methods is that to achieve maximum speed, the data of three or more variables must be accessed simultaneously, ie, in parallel, and redundant data tables or complex storage access. It requires a mechanism. Moreover, such interpolation requires multiplication and division, and requires complex and expensive hardware.

"Method For Multi-Variable Digital Da
July 20, 1995 entitled “Ta Storage and Interpolation”
The applicant's patent application Ser. No. 08 / 504,406 discloses a color interpolation cube having 729 (9 × 9 × 9) control points for each axis of the input color space. These control points are stored in a table, and the output value of any point in the input color cube is then obtained using a fast interpolation method. For the following reasons, this number of control points is obtained from the color (2m + 1) n. Here, n is the number of axes in the input color space (usually three), and the variable m determines the number of control points on each axis. The number 729 is the result of selecting m = 3.

However, if m is increased by 1, (m =
4) The number of control points increases to 4913 (17 × 17 × 17). With this number of control points, the color accuracy of the color conversion is improved, but the required memory storage capacity is also increased about seven times. In the current market for low cost printers, this additional cost of memory storage is a significant problem. There is a need for a color image conversion method that can improve the accuracy of color conversion without increasing the memory required to store control points.

[0017]

SUMMARY OF THE INVENTION The present invention provides a method for converting a set of image points from an input color space to an output color space.
A first group of control points is provided in the input color space, and the first group of control points is located at the apex of a cube in the first color space. In addition, a second group of control points is provided in the first color space, and the second group of control points is arranged in the cube. Each of the first and second control point groups has a corresponding output value group in the output color space. Output values in the output color space for these image points are interpolated based on the first and second control point groups.

In one embodiment, the second group of control points is located at the center of the cube. The input color space is preferably an RGB color space for displaying on a computer monitor, and the output color space is preferably a printer color space. In this case, the output values are preferably converted to a color space that includes at least CMY colors.

In one embodiment, the step of interpolating includes subdividing the cube into a first-level secondary cube, wherein the apex points of the first-level partial cube are first and second control points. Interpolated from the group. Preferably, the method further comprises subdividing each sub-cube of the first-level sub-cubes into a second-level sub-cubes, wherein the vertex angle of the second-level sub-cubes is Interpolated from the apex angle of the one level sub-cube. In a particularly preferred embodiment, the method further comprises subdividing such a partial cube into the next level until a predetermined level of partial cube is obtained, and the final level of the partial cube where the image points are present. Providing the output value of the image point based on the apex angle of The output value of the image point can be obtained as one output value of the vertex point of the partial cube at the final level where the image point exists.

The present invention provides a color image conversion method for improving the accuracy of color conversion without increasing the memory required for storing control points.

[0021]

BEST MODE FOR CARRYING OUT THE INVENTION In the following, specific examples of the present invention showing the presently preferred embodiments of the present invention considered by the inventors will be described in detail. Also, alternative embodiments will be briefly described as appropriate. Here, the present invention is applied to the first RGB space (CRT).
The conversion from the monitor to the second RGB space (printer) will be described as an example, but the scope of the present invention is not limited to this. The general methods and apparatus described herein are applicable to the interpolation of any type of non-linear data that can be represented as a multidimensional structure.

As described above, as a solution to the problem in color space conversion, a printer output RGB value is converted to a monitor input RGB value.
There is a method in which a subset of values is calculated in advance, and a conversion function for intermediate RGB values, that is, RGB values not calculated and stored in advance, is approximated using a high-speed interpolation algorithm. The present invention provides a fast and accurate method of interpolating this pre-computed color conversion function using data storage and numerical segmentation techniques that do not require complex multiplication and division circuits.

When each N × N × N color table is used, an index from 0 to N−1 is provided in each direction, and the RGB values change from 0 to 255. Read from this table,
The eight data points to be interpolated are: (R * (N-1) / 255), (G * (N-1) / 255), (B * (N-1) / 255) (R * (N-1) / 255), (G * (N-1) / 255), (B * (N-1) / 255) +1 (R * (N-1) / 255), (G * (N-1) / 255) +1, (B * (N-1) / 255) (R * (N-1) / 255), (G * (N-1) / 255) +1, (B * (N-1) / 255) +1 (R * (N-1) / 255) +1, (G * (N-1) / 255) +1, (B * (N-1) / 255) (R * (N-1) / 255), ( G * (N-1) / 255), (B * (N-1) / 255) +1 (R * (N-1) / 255) +1, (G * (N-1) / 255), +1 (B * (N-1) / 255) (R * (N-1) / 255) +1, (G * (N-1) / 255) +1, (B * (N-1) / 255) +1

Unfortunately, multiplication and division are slow for real-time processing. Conventionally, the size of a table is limited to 2m + 1 in each dimension in order to quickly calculate a table position to be searched for performing interpolation, and as a result, a size such as 9 × 9 × 9 or 17 × 17 × 17 is obtained. Color map was obtained. With such a restriction, the table can be indexed by taking the most significant bit group of the input RGB and performing some simple addition thereto. In the case of the above example, if the table size is (2m + 1) 3, the table is a 9 × 9 × 9 table, but the above calculation is as follows. (R >> (8-m)), (G >> (8-m)), (B >> (8-m)) (R >> (8-m)), (G >> (8-m m)), (B >> (8-m)) + 1 (R >> (8-m)), (G >> (8-m)) + 1, (B >> (8-m)) (R >> (8-m)), (G >> (8-m)) + 1, (B >> (8-m)) + 1 (R >> (8-m)) + 1, ( G >> (8-m)), (B >> (8-m)) (R >> (8-m)) + 1, (G >> (8-m)), (B >> (8 -m)) + 1 (R >> (8-m)) + 1, (G >> (8-m)) + 1, (B >> (8-m)) (R >> (8-m )) + 1, (G >> (8-m)) + 1, (B >> (8-m)) + 1 where >> is a bitwise right shift operator.

FIG. 1 shows a series of three axes, the X-axis (green), the Y-axis (red) and the Z-axis (blue), formulated as a grid structure of color data defining data points in the tristimulus space. Indicates color data. Each apex angle of each cube in the grid represents a stored data point. Usually, an 8-bit (1 byte) digital data value is used. Therefore, in the embodiment of the present invention, that is, in the conversion from the CRT monitor to the RGB of the printer, 729 equally spaced 729 pixels are arranged in the color space of the monitor.
Data points are pre-computed for the RGB values (obtained from (23 + 1) 3). That is, the data on this spectrum is stored in nine equal steps (0 to 8) in each of the red, green and blue directions of the CRT. The method of the present invention is applicable to any (2m + 1) n data set, where (2m + 1) n
Is the density of stored data points, that is, the number of samples per dimension in a particular embodiment, and "n" is the number of variables in the first data structure. Tristimulus color space,
That is, in the example of the data set of three variables, n = 3.
In this embodiment, m = 3, and there are nine levels of data per one-dimensional axis. Therefore, in total
729 data points are provided.

The data points form the three-dimensional grid shown in FIG. Generally, a database of this structure will comprise a predetermined number of output data values of an output device (such as an inkjet pen controller) that are correlated with a particular input data value for that particular output device.

In FIG. 2, one cube is extracted from the lattice. In the present invention, the bottom left bottom (LLB) vertex angle, p0, represents the minimum RGB value in that particular color space, and the top right front (URF) vertex angle, p7, represents the maximum RGB value in that particular color space. Is set. In another way,
It can also be expressed as: p0 = Rmin, Gmin, Bmin, p7 = Rmax, Gmax, Bmax For a pixel to be printed, an RGB input value is received (see step 601 in FIG. 6). For any pixel to be printed on a device capable of producing millions of color changes, the color to be printed may fall within the boundaries of a cube of eight of the stored 729 RGB values. Is high, that is, the color is likely to be in one of these stored memory cube structures rather than in one of the stored specific hues.

Using the upper three bits of each 8-bit RGB value, a color map data structure grid is searched to extract eight data points surrounding the RGB values to be generated by interpolation (FIG. 6, step 603). ).

For example, assume that the input values to this grid are as follows. (1) R = 00101100 (= 44) G = 10100110 (= 165) B = 01111011 (= 123) The three upper bits of each of these values are as follows. (2) R = 001 (= 1) G = 101 (= 5) B = 011 (= 3) Then, a specific cube can be obtained from the entire grid (or even if you understand that it is "searched"). Good), that is, the cube of FIG. 1 is extracted from FIG.
LLB data point p0 is “up” by 1 from the origin on the red axis, “left” by 5 from the origin on the green axis, and 3 from the origin on the blue axis.
Only "outside." Basically, the upper three bits provide the "address" in the grid for obtaining the eight data points surrounding the desired value, and the desired output RGB value is described by these eight data points p0-p7. Is guaranteed to be contained within the cube. If the input to be searched is one of the stored data points, that data point is output (FIG. 6, step 605).

An approximate value for the conversion can be generated as an output value by using one of these eight points or the average value of these points (the "center" of the extracted cube). This generates a mapping that supplies 1241 output values (each apex angle and each center) in the example where this 729 value is stored. However, this approximation is not yet sufficient for many applications.

In accordance with the method of the present invention, iterative subdivision (which is important without the need for complex mathematical calculations and associated hardware) is used to calculate more accurate results. Means are provided.

FIG. 3 shows the original cube of FIG.
Figure 4 shows the mapping of bittriplets to 8-part subcubes. In other words, the bits of the lower left front 8-divided partial cube
0, 0, 1 are displaced by "0" in the red direction, "0" in the green direction, and "1" in the blue direction. All "addresses" of the eight 8-part sub-cubes are obtained in a similar manner (FIG. 6,
Step 607).

The upper (1) shows the five lower bits of the RGB value, which are used to form the eight data points extracted using the upper three bits of (2). The required conversion color interpolation is executed by controlling the subdivision of the cube shown in FIG. 2 (step 609 in FIG. 6). That is, the bits serving as references for this subdivision routine are as follows. (3) R = 01100 G = 00101 B = 11011

The first subdivision is determined by the most significant bit of each of the five bits of each color axis of each data triplet. (4) R = 0G = 0B = 1 From these three bits, eight new data points are calculated from the original data points by segmentation. These data points also
For convenience of explanation, it is assumed that the apex angle is the lower left front divided eight-part cube as shown in FIG. (5) s0 = (p1-p0) / 2 s1 = p1 s2 = (p3-p0) / 2 s3 = (p3-p1) / 2s4 = (p5-p0) / 2 s5 = (p5-p1) / 2 s6 = (p7-p0) / 2 (= the center of the data cube in Fig. 3) s7 = (p7-p1) / 2

The midpoint between cube apex angles calculated to allow for subdivision can be calculated in many different ways to simulate various interpolation methods. For example, as shown in FIG. 5, it is possible to simulate tetrahedral interpolation as shown in Table 1 by calculating data values of intermediate points shown as i0,... I18. As is well known in the art, such simple algorithms can be provided to perform trilinear interpolation or other interpolation methods as needed.

In practice, by using such a simulation, division by 2 is simply a binary right shift, and expensive division operation hardware is not required.
Further, it is not necessary to calculate all the intermediate points every time the subdivision is performed, and only the seven points need to be calculated. This is because one is always redundant (see s1 above), and only the data point determined from the next upper bit of the bit string of the next octant cube determined to contain the data point of interest is used That is because

In practice, these eight new data points s0
-s7 defines one-eighth of the original cube, and the desired output value is in this eight-part cube. This achieves the accuracy level at which the 4096 output values are mapped to the input values, given the "center" or average of the eight new data points as the result of the conversion. To perform more accurate interpolation, it is necessary to further subdivide.

In the second subdivision, each second bit of the bit string shown in (3) above is used. (6) R = 1 G = 0 B = 1 As a result, as shown in FIG. 4, the original cube p0-p
Same as the subdivision of 7, the first subdivision 8 division cube (s0-s7)
From the second subdivision into eight divided cubes. Again, the desired output data points are within a cube containing the desired output RGB output color values. Because the eight newly obtained data points are relatively close in value, the new cube containing that data point reliably is more desirable than the first partial cube (points s0-s7). Are interpolated closer to the output value of.

This action is the third bit, the fourth bit,
Proceeding on the fifth bit further, the original RG
Three more subdivisions (five times in total) are performed from the 8-bit string of the B triplet (FIG. 6, step 611).
See below). Therefore, when such subdivision is performed five times, 16,777,21 each corresponding to a certain output RGB value.
Six interpolated output values have been mapped from the original 729 stored values. In this example, the fifth subdivision is the final subdivision level. Either the value of the vertex angle of the "minimum" (of the fifth subdivision) sub-cube, or any average of these eight converged data points, is the correct output for that particular input function, R'G'B ' (FIG. 6, step 619).

It is also pointed out that according to the method of the present invention, accuracy and speed can be selected for each image. Reducing the segmentation reduces the required data processing time. For example, reducing the subdivision results in an effective color space mapping, albeit with lower accuracy, which may be sufficient for simple business graphs and other business graphics. Those who work in computer art, where speed is less of an issue than reproduction quality, will use all five repetitive subdivisions. This function can also be adapted for real-time, time-constrained applications to convert large images with lower accuracy than small images. By sacrificing some accuracy, the speed of high-speed image preview and draft image printing can be increased.

Further, the level of subdivision can be made variable within a specific color data group. The number of times of subdivision can be increased in a portion where high accuracy is required in the color map and reduced in a portion where accuracy is not required. For example, there are more subtle color changes near the neutral axis than for highly saturated colors, and therefore less precise calculations are needed for saturated color regions. This provides an optimal solution to the trade-off between accuracy and throughput. To do this, the required subdivision level is calculated in advance in each "cube" of the color map based on eye measurements, and the value is stored with the color data. During real-time execution, the level of segmentation can be determined based on this data.

The problem with the interpolation method disclosed here is that (2m + 1)
From the table size of n, to increase the accuracy of the color data, the number of control points on each axis of the color cube must be almost doubled. For example, 9x9x9
17 × 17 × 17 if the accuracy of the color map is not sufficient
, Which requires approximately seven times the memory storage. For example, 9x9x
It is not practical to replace the 9 color map with an 11 × 11 × 11 color map. This is because the cost required for calculating the table position based on RGB increases.

FIG. 7 shows a cube similar to the cube shown in FIG. 2 except that it has an additional control point p8 precisely located at its center. In the grid described with reference to FIG.
Each of the 512 cubes has such a central control point p8. Note that this center point p8 is the same as the interpolated point s6 shown in FIG. In the algorithm described above, the value of s6 was interpolated using a fast interpolation algorithm. However, in this improved method, such a center point p8
Are established control points stored in memory in another table having a size of 2m.

The memory storage format of these center points is basically a grid within a grid. In addition to the search for the eight vertex points for interpolation as described above, the midpoint p8 is searched. An additional search to find this waypoint is simply the waypoint = (R >> (8-m)), (G >> (8-m)), (B >> (8-m)) Performed by searching in the midpoint table.

This interpolation method increases the color accuracy by obtaining additional control points inside each cube shown as an example in FIG. This improvement in accuracy is 512 (8 × 8 × 8)
This is achieved by simply adding an additional data point, which is added to the existing 729 (9 × 9 × 9), for a total of 1241 data points. This is significantly less than the 4913 data points present in the 17 × 17 × 17 grid, obtained by searching m from 3 to 4 in equation (2m + 1) n with n = 3.

FIG. 8 shows a flowchart similar to FIG. However, the flowchart shows that the apex angle of the cube is 9
A method is shown that uses both a × 9 × 9 control point and an additional 8 × 8 × 8 control point at the center of the cube as shown in FIG. In this algorithm, in step 803,
In this manner, based on the most significant bits, the appropriate cube (from a 9 × 9 × 9 table) eight cube apex angles and (8
Both of its centers are read out (from a x8x8 table). In step 805, the method determines whether the image point of interest is actually on these nine control points of interest (ie, whether that point is on one of points p0 through p8 in FIG. 7). Is done.

In step 809, if the algorithm has performed a first subdivision into sub-cubes, the algorithm sets the center point p8 to the appropriate sub-cube vertex point at 8
Determined from a × 8 × 8 table. After the first subdivision,
There is no need to extract more control points from the 8 × 8 × 8 table. In step 809, it is not necessary to perform interpolation to obtain already existing apex points (already taken from the table or interpolated).

This 9 × 9 × 9 + 8 × 8 × 8 system is
Although the number of control points is much smaller than a 17 × 17 × 17 table, it has the same color resolution on the important “gray” axis (the axis from white to black in the color cube). 9 with a point 17 at ³ +8 ³ Both table and 173 table on the gray axis. Accurate representation of this neutral axis is one of the most important aspects of color reproduction.

Further, the center of each cube in the grid representation is the point furthest from any of the original 9 × 9 × 9 control points. If data must be added to an existing color table, such an intermediate point is the optimal location from the standpoint of device input color space spacing.

Further, when used in conjunction with the interpolation algorithm described herein, this data format does not reduce the throughput of the printer (the number of printed pages per minute). If the central control point is not on the table,
The interpolation algorithm must calculate these points. Retrieving these control points from a table in memory is performed at least as fast, if not faster, than calculating them.

Thus, the improved method described herein improves color accuracy and achieves improved color accuracy without increasing the amount of memory.

The embodiments of the present invention will be summarized below.

1. A color image conversion method for converting an image point group from an input color space to an output color space, wherein a first control point group (p0, p1, p2, p3, p4, p5, p6,
p7), the first group of control points is arranged at the apex angle of a cube in the input color space, a second group of control points (p8) is provided in the input color space, and the second group of control points A group is arranged inside the cube, and the first and second control point groups each have a corresponding output value group in the output color space, and are based on the first and second control point groups. A color image conversion method for interpolating output values of the image points.

2. The color image conversion method according to claim 1, wherein the second group of control points (p8) is arranged at the center of the cube.

3. The color image conversion method according to claim 1 or 2, wherein the first color space is an RGB color space for expression on a computer monitor.

4. 4. The color image conversion method according to claim 1, wherein the output color space is adapted to print on a color printer.

5. 5. The color image conversion method according to claim 1, wherein the output value is converted into a color space including at least a color CMY.

6. The interpolating step includes:
Subdividing into sub-cubes of the first level (809), wherein the vertex points of the first-level sub-cubes are the first and second control points (p0, p1, p2, p3, p4, p5, p
6. The color image conversion method according to any one of 1 to 5, wherein the color image conversion method is interpolated from (6, p7, p8).

7. Subdividing each of the first level sub-cubes into second level sub-cubes (809), wherein the vertex angle of the second level sub-cube is the first level sub-cube 7. The color image conversion method according to any one of the above items 1 to 6, wherein the color image conversion method is interpolated from a vertex point of the color image.

8. Continuing subdivision of said partial cube into higher level partial cubes until a predetermined final level of partial cube is obtained, and said image based on said final level partial cube where said image points are located 1 to 7 including the step of providing an output value of a point.
The color image conversion method according to claim 1.

9. The color image conversion method according to any one of claims 1 to 8, wherein the output value of the image point is obtained as one output value of a vertex angle point of the partial cube at the final level where the image point exists.

[0062]

As described above, according to the present invention,
By providing the second control point inside the grid as an additional control point, it is possible to improve the accuracy of color conversion without increasing the memory for storing the control points.

[Brief description of the drawings]

FIG. 1 is a spatial representation of a general lattice memory configuration according to the present invention.

FIG. 2 is a “data cube” extracted from the data structure of the lattice memory configuration shown in FIG. 1;

FIG. 3 illustrates a first level of subdivision of the extracted data cube shown in FIG. 2 into octant space regions.

FIG. 4 is a diagram showing a second example of the spatial region of the extracted data cube shown in FIG. 3;
Shows the level of subdivision.

FIG. 5 shows intermediate data points used in the subdivision step shown in FIGS. 3 and 4;

FIG. 6 is a flowchart of an interpolation method using 9 × 9 × 9 control points.

FIG. 7 shows the extracted “data cube” of FIG. 2 with an additional control point p8 in the center.

FIG. 8 is a flowchart of an interpolation method using both 9 × 9 × 9 control points and 8 × 8 × 8 control points.

[Explanation of symbols]

 p0-p8, s0-s7 control point

Claims (1)

[Claims] 1. A color image conversion method for converting an image point group from an input color space to an output color space, comprising: a first control point group (p0, p1, p2, p3,
p4, p5, p6, p7), the first control point group is arranged at the apex angle of a cube in the input color space, and a second control point group (p8) is provided in the input color space. The second control point group is disposed inside the cube; the first and second control point groups each have a corresponding output value group in the output color space; A color image conversion method, wherein output values of the image points are interpolated based on a control point group.