JP4089728B2 - Multidimensional interpolator - Google Patents

Description

  The present invention relates to a multidimensional interpolation apparatus.

  In a color image printing apparatus or the like, in order to improve visual characteristics of a printed image, color conversion is performed on the read color image data to convert it into another color system. As this color conversion apparatus, there is an apparatus using an LUT (Look Up Table) and an interpolation calculation apparatus. This device accesses the LUT using the input image data as an address and outputs converted image data. For image data that is not stored in the LUT, a weighting coefficient that is an interpolation operation device is added to the output of the LUT at the grid point position. Interpolation is performed by performing a multiplication process.

Examples of conventional color conversion devices include the following (see, for example, Patent Document 1).
(A) Cubic interpolation (8-point interpolation, British Patent No. 1369702)
FIG. 6 is an explanatory diagram of cube interpolation. (A) is the original space, and (b) is the conversion destination space. The original space is R, G, B space, and the conversion destination space is Y, M, C space. First, as shown in the figure, an arbitrary one point P in the cube shown in FIG. Let the volume of each divided space be Vi (i = 0-7). At this time, the interpolation value of the point P ′ mapped to the space to be converted is given by the following equation.

Here, Pi is the value of the original space that has already been obtained, Vi is the volume of the eight rectangular parallelepipeds constituting the cube V divided by the point P, and V is the volume of the original rectangular parallelepiped.
Moreover, there exist the following (for example, refer patent document 2).
(B) Triangular pyramid interpolation (4-point interpolation; Japanese Patent Laid-Open No. 53-123201)
FIG. 7 is an explanatory diagram of triangular pyramid interpolation. Triangular pyramid interpolation is a method in which a cube constituting the memory space address is converted into a plurality of triangles when obtaining conversion data by inputting image data to a memory space in which data corresponding to three-dimensional image data input is stored. Divide into cones, determine which of the divided triangular pyramids contains the point corresponding to the input value for image data input, and then determine the values at each vertex of the triangular pyramid (4) Is used to find the internal points by interpolation.

7A shows a state in which a cube having a length L of one side is divided into six triangular pyramids by an axis connecting each vertex from the origin a, and FIG. 7B is an exploded view thereof. At this time, an interpolation value P ′ of a point in an arbitrary triangular pyramid is given by the following equation.
P ′ = (LA) × P1 + (AB) × P2 + (BC) × P3 + C (2)
Here, A, B, and C indicate the lower digits of the input data, and it is assumed that A>B> C, and Pi is the value (three-dimensional coordinate value) of the partner already obtained.

Moreover, there exist the following (for example, patent document 1).
(C) Triangular prism interpolation (6-point interpolation. Literatures K. Kanamori, H. Kotera, O. Yamada, H. Motorura, R. Ikawa, T. Fumoto, Fast color with IMM. Imaging, 2 (3), 213-224 (1993))
In this interpolation method, three triangular pyramids shown in (b) are combined into a triangular prism, and interpolation is performed from a total of six points of data.

Moreover, there exist the following (for example, patent document 1).
(D) Interpolation by parallel processing (US Pat. No. 4,837,722)
When the color LUTs are arranged in parallel, the LUTs are held in positions that are alternately necessary for each LUT, and the total LUT size is the same as that of a single LUT. Further, all the weight coefficients are stored and held in the ROM.
British patent 1369702 JP-A-53-123201 U.S. Pat. No. 4,837,722 K. Kanamori, H .; Kotera, O .; Yamada, H .; Motomura, R.A. Iikawa, T .; (Fumoto, Fast color processor with programmable information by small memory (PRISM), Journal of Electronic Imaging, 2 (3), 213-224 (1993))

In the case of the cubic interpolation, since the volume of the rectangular parallelepiped opposite to the point where the point for which the weight coefficient is to be obtained is used, it is necessary to generate the weight coefficient calculated in M ³ when the maximum interpolation interval is M. For example, in the case of M = 17, 4913, which is constituted by hardware, requires 13-bit data lines, and the bit width of the multiplier has to be widened. It was disadvantageous. Further, in the case of interpolation calculation, if one color is 8 bits, (8 + 13) bits are required, and a 64-bit CPU cannot calculate 4 colors simultaneously.

In the case of the triangular pyramid interpolation, the maximum value of the weighting coefficient is M (interpolation interval), and the number of data lines can be greatly saved. However, when the calculation is performed purely for calculation of the interpolation coefficient, it is necessary to make a determination for dividing the unit cube into 5 to 6 parts, and this determination becomes complicated. In order to avoid such a problem, there is a method of calculating and storing in the form of LUT in advance, but in this case, M ³ is obtained when the interpolation interval is M, for example, 4913 words when M = 17. It was necessary to memorize the data. Further, since the number of interpolation points is small (four points), there is a problem in accuracy.

In the case of the triangular prism interpolation, there is a problem that the anisotropy is high and the error increases depending on the interpolation direction.
In the case of the parallel processing interpolation, since the weighting coefficient is provided as an LUT, there is a problem that the LUT size increases when the lattice interval M increases.

  Further, as a problem common to these conventional techniques, when the interpolation interval M is a power of 2, a bit shift can be used instead of the division in the final stage, but when M is not a power of 2, Shifting is not possible, and division must be performed at the final stage, which increases the circuit scale and the calculation time.

  The present invention has been made in view of such a problem, and an object of the present invention is to provide a multidimensional interpolation apparatus capable of saving hardware resources and increasing the calculation speed.

(1) The invention described in claim 1 uses a color LUT in which output values for N (N ≧ 3) -dimensional input data for each interpolation interval M are held, and outputs output values for input values to be interpolated, In a multidimensional interpolation apparatus that obtains an output value from a color LUT with respect to N-dimensional input data for each interpolation interval M in the vicinity of an input value to be interpolated by weighting, an arithmetic means for executing the following steps is provided. It is characterized by doing.
(S1) A step of assuming a unit hypercube having an input value to be interpolated therein and having N-dimensional input data for each interpolation interval M as a vertex .
(S 2 ) This unit hypercube is divided into a plurality of hypersolids sharing a certain diagonal line, and the hypersolid having the input value to be interpolated therein is specified from among the divided supersolids. and, a weighting factor based on the relationship between the input value and each vertex serving as the interpolation target, Ru determined for each vertex of the identified super-solid steps.
(S 3) all rows of the Hare steps for diagonal of remaining step S 2 the unit hypercube.
(S 4) steps for each vertex of the unit hypercube, adding the weighting coefficient obtained in the step S 2 and S 3, Ru determined by a weighting factor summed.
(S 5 ) Each output value for input data corresponding to each vertex of the unit hypercube is obtained from the color LUT, and each obtained output value and the sum obtained in step S 4 for each vertex are added. Multiplying each of the combined weighting factors .
(S 6 ) A step of adding the results multiplied in step S 5 .
(S 7 ) A step of obtaining an interpolated value for the input value to be interpolated by dividing the summation result obtained in step S 6 by M × 2 ^N−1 .
(2) The invention according to claim 2 exists in a unit hypercube of 1/2 ^N of the unit hypercube, wherein the input value to be interpolated is composed of half sides of each side of the unit hypercube. If the input value to be interpolated does not exist in the 1/2 ^N unit hypercube, the weight coefficient is stored in advance based on the symmetry of the unit hypercube. It is characterized by using a weighting factor .
(3) The invention described in claim 3 is characterized in that a plurality of input data among the values of three to four colors of the color LUT are simultaneously multiplied by a weight coefficient .

(1) According to the first aspect of the present invention, it is possible to provide a multidimensional interpolation device capable of saving hardware resources and increasing the calculation speed.
(2) According to the second aspect of the present invention, since interpolation can be performed based on a weight coefficient held in advance, memory can be saved .
(3) According to the invention described in claim 3 , when performing the interpolation operation of the N-dimensional LUT, the means for simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by the weight coefficient By providing the hardware resources can be saved and the interpolation operation can be speeded up .

[Operation of the present invention]
In the first embodiment of the present invention, the maximum value of the weighting factor for interpolation is given by M × 2 ^N-1 at the interpolation interval M, so that the maximum value of the weighting factor is suppressed. As a result, it is possible to save hardware resources and increase the calculation time.

Here, M × 2 ^N-1 was determined as follows.
The present invention is an extension of the triangular pyramid interpolation. In FIG. 7A, the cube is divided into six triangular pyramids with the diagonal of the cube as an axis, and all combinations are made for this axis. That is, when all the weighting coefficients in the triangular pyramid interpolation when the axes of ag, bh, ce, and df in the figure are changed and taken are averaged, the above M × 2 ^{N -1} is obtained. According to the present invention, as a result of obtaining and averaging the weighting coefficients for the axes in all directions, the influence of the directionality of the axes is eliminated.

  In this case, when performing the interpolation operation of the N-dimensional LUT, hardware resources are saved by simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by a weight coefficient, Interpolation calculation can be speeded up.

  In the second embodiment of the present invention, when N-dimensional interpolation is performed, a weighting factor is generated for an address of (M + 1) / 2 with respect to the interpolation interval M, and weighting is performed by performing multidimensional interpolation. The memory capacity for coefficient generation can be reduced, and hardware resources can be saved.

  The weighting factor has the property of being line symmetric in any direction with respect to the lattice points in the small space. This will be described with reference to the drawings. FIG. 8 is an explanatory diagram of the nature of the weighting factor (one-dimensional case). The vertical axis represents the weight coefficient, and the horizontal axis represents the distance between the lattice points Q1 and Q2. In the figure, f1 is a weight characteristic for Q1, and f2 is a weight characteristic for Q2. This distance is defined as an interpolation interval M. Considering the axis S passing through the center of M (M / 2), the weighting factor is line symmetric with respect to the axis S.

  That is, the right half of the characteristic f1 overlaps with the left half of the characteristic f2 when folded about the axis S, and the right half of the characteristic f2 overlaps with the left half of the characteristic f1 when folded with respect to the axis S. For example, the right half weighting factors W1, W2 and W3 of the characteristic f1 are equal to the left half weighting factors W1 ′, W2 ′ and W3 ′ of the characteristic f2, respectively, and the right half weighting factors W4 and W5 of the characteristic f2 are respectively It becomes equal to the weighting factors W4 ′ and W5 ′ in the left half of the characteristic f1. The address reaches M as shown in the figure, but when it exceeds S, Q1 and Q2 are switched. For example, the weighting coefficient of the characteristic f1 is sequentially generated according to the address, and when the address exceeds M / 2, the characteristic is switched from the previous f1 to f2, and the weighting coefficient of the left half of f2 is used.

  Therefore, it is only necessary to have data on the left side of the axis S as weight coefficient data, and it is not necessary to have data on the right side of the axis S. In this way, the number of weight coefficient generations can be reduced. The data amount of the necessary weight coefficient is 1/2 in the case of one dimension, 1/4 in the case of two dimensions, and 1/8 in the case of three dimensions. In this way, it is possible to reduce the amount of data smaller than the originally required weight coefficient data.

It should be noted that the generated address needs to include the value W0 on the axis S, so that the address up to (M + 1) / 2 is taken into consideration when M is an even number.
According to the present invention, the number of weighting factors can be reduced, and hardware resources can be saved.

  In this case, when performing the interpolation operation of the N-dimensional LUT, hardware resources are saved by simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by a weight coefficient, Interpolation calculation can be speeded up.

In a third embodiment of the present invention, when the maximum weighting factor is not a power of 2, previously dividing the data to be stored in the color LUT, was due that stores second exponentiation to Unishi. As a result, the division by the weighting coefficient performed at the end of the interpolation calculation can be performed simply by shifting the data (right shift), thereby speeding up the calculation time.

In the fourth embodiment of the present invention, means for giving the maximum value of the weighting coefficient for interpolation as M × 2 ^N-1 at the interpolation interval M is provided to suppress the maximum value of the weighting coefficient. As a result, it is possible to save hardware resources and increase the calculation time.

  In this case, when performing the interpolation operation of the N-dimensional LUT, by providing means for simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by a weighting coefficient, hardware resources are reduced. It is possible to save and speed up the interpolation operation.

  In the fifth aspect of the present invention, means for generating a weighting factor for an address of (M + 1) / 2 with respect to the interpolation interval M is provided when performing N-dimensional interpolation. The reason is the same as in the case of the second invention. Thereby, the number of weighting factors can be reduced, and hardware resources can be saved.

  In this case, when performing the interpolation operation of the N-dimensional LUT, by providing means for simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by a weighting coefficient, hardware resources are reduced. It is possible to save and speed up the interpolation operation.

  In the sixth aspect of the present invention, there is provided means for preliminarily dividing the data stored in the color LUT and multiplying by a power of 2 when the maximum weight coefficient is not a power of 2. The reason is the same as in the case of the third invention. As a result, the division by the weighting coefficient performed at the end of the interpolation calculation can be performed simply by shifting the data (right shift), thereby speeding up the calculation time.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a block diagram showing a configuration of an embodiment of the present invention, where N = 3, that is, three-dimensional interpolation. In this embodiment, R, G, and B data are received and converted into new Rnew, Gnew, and Bnew data. The numbers in the data lines in the figure indicate the number of bits.

  In the figure, 1 is an R address generator that receives R (Red) data and a counter output and generates a corresponding address, and 2 is a G address generator that receives G (Green) data and a counter output and generates a corresponding address. Reference numeral 3 denotes a B address generator that receives B (Blue) data and generates a corresponding address. Reference numeral 4 denotes a 4-bit output quaternary counter for counting the clock CLK. If the upper bit of the output of the counter 4 is C1, and the lower bit is C0, C0 is input to the R address generator 1 and C1 is input to the G address generator 2. Since the R address generator 1 and the G address generator 2 generate an 8-bit output, and the B address generator 3 performs parallel processing with respect to the B axis, two types of 4-bit addresses are generated as upper addresses. The other R and G axes are calculated in time series.

5 is a neighborhood that generates a 7-bit weight coefficient by receiving the output of the lower 4 bits of the R address generator 1, the lower 4 bits of the G address generator 2, the lower 4 bits of the B address generator 3, and the quaternary counter 4. Similarly, the weight generator 6 receives the output of the lower 4 bits of the R address generator 1, the lower 4 bits of the G address generator 2, the lower 4 bits of the B address generator 3, and the output of the quaternary counter 4. This is a far weight generator that generates bit weight coefficients. For near and far, the weighting coefficient space is divided into two, one for the near and the other for the far. In the present invention, as a result of using the line symmetry in the space region of the weight coefficient, in this embodiment, since it is a three-dimensional space, the necessary weight generator is 1 / (2 ³ ) = the original capacity. 1/8 is enough. Therefore, the memory capacity is greatly reduced, and hardware resources can be saved.

  10 receives the upper 4 bits of the R address generator 1, the upper 4 bits of the G address generator 2, the two upper 4 bits of the B address generator 3, and the outputs of the weight generators 5 and 6, and receives new R data Rnew. The R processing unit 20 generates the upper 4 bits of the R address generator 1, the upper 4 bits of the G address generator 2, the two upper 4 bits of the B address generator 3, and the outputs of the weight generators 5 and 6. G processing unit for generating new G data Gnew in response to the above, 30 is the upper 4 bits of the R address generator 1, the upper 4 bits of the G address generator 2, the two upper 4 bits of the B address generator 3 and the weight A B processing unit that receives the outputs of the generators 5 and 6 and generates new B data Bnew. The configurations of the G processing unit 20 and the B processing unit 30 are not shown, but are the same as the configuration of the R processing unit 10 except that the data stored in the color LUT is different.

  In the R processing unit 10, 11 is a color LUT for the B neighborhood that receives the upper 4 bits of the R address generator 1, the upper 4 bits of the G address generator 2, and the upper 4 bits of one of the B address generator 3, It is a color LUT for B far that receives the upper 4 bits of the R address generator 1, the upper 4 bits of the G address generator 2, and the other upper 4 bits of the B address generator 3. These color LUTs 11 and 12 are composed of, for example, memories in which the same data is stored both above and below. For example, a dual port RAM that can read two pieces of data at the same time is used. These LUTs 11 and 12 store 16 × 16 × 16 × 10 pieces of data corresponding to combinations of R, G, B data inputs 0, 17, 34,. Of the 10 bits of output, 1 bit indicates a code and 1 bit indicates a value exceeding 255.

  Reference numeral 13 denotes a multiplier that multiplies the output of the color LUT 11 and the output of the weight generator 5, and reference numeral 14 denotes a multiplier that multiplies the output of the color LUT 12 and the output of the weight generator 6. These multipliers 13 and 14 receive the 10-bit output of the color LUTs 11 and 12 and the 7-bit output of the weight generators 5 and 6, and have a 16-bit output (of which 1 bit is a sign). An adder 15 adds the outputs of the multipliers 13 and 14. The adder 15 receives 16 bits from the multipliers 13 and 14 and outputs 16-bit data (1 bit of which is a sign).

  Reference numeral 16 denotes an integrator that integrates the output of the adder 15. This accumulator 16 accumulates only the value of the output of the quaternary counter, that is, four calculation results. Reference numeral 17 denotes a divider for dividing the output of the integrator 16 by a weighting factor. The divider 17 receives the 16 bits output from the integrator 16 and outputs 8-bit data. The output of the divider 17 becomes new converted R data Rnew. The operation of the circuit thus configured will be described as follows.

The image data R, G, and B are input to the respective address generators 1, 2, and 3, and each of the address generators 1 to 3 generates address data according to the following algorithm.
1) R address generator The input is A (0 to 255), the upper digit of the output is X (0 to 15), the lower digit is Y (0 to 8), and the upper bit of the counter 4 is C0 (0, 1) The lower order is C1 (0, 1). The algorithm expressed in C language is as follows. Li (i = 1 to 8) indicates a line number.
if (A% 17 <= 8) {L1
Y = A% 17; L2
X = A / 17 + C0; L3
if (X> 15) X = 15; L4
} Else {L5
Y = 17-A% 17; L6
X = A / 17 + (1-C0); L7
if (X> 15) X = 15; L8
}
In the above algorithm,
L1: When the remainder when A is divided by 17 (A% 17) is 8 or less,
L2: Let Y be the remainder when A is divided by 17.
L3: The value obtained by adding C0 to the quotient when A is divided by 17 is the value of X.
L4: At this time, when X becomes larger than 15, the value of X is fixed to 15.
L5: When the condition of L1 is not satisfied, that is, when the remainder when A is divided by 17 is 9 or more,
The value of Y is obtained by subtracting the remainder when A is divided by 17 from L6: 17.
L7: A value obtained by dividing the input A by 17 and adding (1-C0) is the value of X.
L8: At this time, when X becomes larger than 15, the value of X is fixed to 15.

With this algorithm, every time R data is input, the X value is output from the upper 4 bits of the R address generator 1, and the Y value is output from the lower 4 bits.
2) G address generator The operation is the same as that of the R address generator 1. In other words, the input is A (0 to 255), the upper digit of the output is X (0 to 15), the lower digit is Y (0 to 8), the upper input of the counter 4 is C0 (0, 1), and the lower digit Is C1 (0,1). The algorithm expressed in C language is as follows.
if (A% 17 <= 8) {
Y = A% 17;
X = A / 17 + C1;
if (X> 15) X = 15;
} Else {
Y = 17-A% 17;
X = A / 17 + (1-C1);
if (X> 15) X = 15;
}
3) B address generator In this case, since parallel processing is performed for B, two higher-order 4 bits of addresses are output at a time. In addition, since there is no need for separation, the output of the quaternary counter 4 is not input. The address generation algorithm is as follows, where X0 is the upper digit vicinity and X1 is the upper digit distance.
if (A% 17 <= 8) {L1
Y = A% 17; L2
X0 = A / 17; L3
X1 = A / 17 + 1; L4
if (X0> 15) X0 = 15; L5
if (X1> 15) X1 = 15; L6
} Else {L7
Y = 17-A% 17; L8
X0 = A / 17 + 1; L9
X1 = A / 17; L10
if (X0> 15) X0 = 15; L11
if (X1> 15) X1 = 15; L12
}
In the above algorithm,
L1: When the remainder when the input A is divided by 17 (A% 17) is 8 or less,
L2: Let Y be the remainder when input A is divided by 17.
L3: The quotient when the input A is divided by 17 is X0.
L4: A value obtained by dividing input A by 17 and adding 1 is X1.
L5: At this time, when X0 becomes larger than 15, the value of X0 is fixed to 15.
L6: At this time, when X1 becomes larger than 15, the value of X1 is fixed to 15.
L7: When the condition of L1 is not satisfied, that is, when the remainder when A is divided by 17 is 9 or more,
The value obtained by subtracting the remainder when A is divided by 17 from L8: 17 is taken as the value of Y.
L9: The value obtained by adding 1 to the quotient obtained by dividing the input A by 17 is the value of X0.
L10: A value obtained by dividing input A by 17 is set to a value of X1.
L11: At this time, when X0 becomes larger than 15, the value of X0 is fixed to 15.
L12: At this time, when X1 becomes larger than 15, the value of X1 is fixed to 15.

  With such an algorithm, every time B data is input, two values X0 and X1 are output from the upper 4 bits of the B address generator 3, and a Y value is output from the lower 4 bits.

  Of the outputs of the address generators 1 to 3 generated in this way, the upper data enters the color LUTs 11 and 12, and the lower data enters the weight generators 5 and 6. Among these, one upper data of the B address generator 3 enters the color LUT 11, and the other upper data enters the color LUT 12.

  Here, the operation of the weight generators 5 and 6 will be described in detail. The weight generators 5 and 6 store only the original 1/8 capacity data due to the line symmetry of the weighting coefficient, and the entire range is covered with the 1/8 capacity data. For this purpose, each address generator 1 generates an address as follows.

For example, when the weight interval M = 17, the original lower data is generated as 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16. On the other hand, in the present invention, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1 occur. That is, when an address is generated up to the middle point of the interval M, the address is returned from the middle point. As a result, the lower order data generated from the address generator is of (M + 1) / 2 types. For example, when M = 17,
It has (17 + 1) / 2 = 9 values and has data in the range of 0 to 8. By the way, when M = 16, (16 + 1) /2=8.5, but the decimal point is ignored and has eight values.

  At the same time, if the lower data is larger than the midpoint of the grid interval, the output of the higher data is generated in reverse so that it is in the order of +1, +0, not + 0, + 1 with respect to the reference grid point. As a result, a neighboring weighting factor is given to the neighboring grid points, and a farning weighting factor is given to the far grid points. Note that the address generator 3 for B has a fixed built-in two types of addresses for far and near, and generates an address corresponding to the input.

  The weight generators 5 and 6 receiving such addresses generate the weight coefficients calculated in Tables 1 and 2 according to the converted addresses (lower data). Table 1 shows coefficients for weight calculation (for neighborhood), and Table 2 shows coefficients for weight calculation (for distance).

  In these tables, r, g and b are lower addresses (lower data generated from the address generators 1 to 3, r is an R address generator, g is a G address generator, and b is a B address generator. And takes a value of 0-8. C, R, G, and B are coefficients for calculating weighting coefficients. These coefficients C, R, G, and B take values as shown in the table according to the value of the quaternary counter 4 according to the magnitude relationship between r, g, and b. FIG. 2 shows a triangular pyramid applied according to the magnitude relationship between r, g, and b (see FIG. 7). The weighting factor to be generated is expressed by the following equation.

W = M × C + r × R + g × G + b × B (3)
For example, in the first combination r>g> b in Table 1, when the counter value = [00], the weighting factor to be generated is W = 4 × 17 + (− 4) × r + (− 2) from the equation (3). ) × g + (− 1) × b
Calculated by As can be seen from this, the weighting factor W takes an integer value of 0 to 68, and the sum of the weighting factors in the case of eight multiplications (to obtain the value of one point in the space by interpolation at 8 points) is 68.

  The color LUTs 11 and 12 receive the outputs from the address generators 1 to 3 as addresses and output values corresponding to the addresses. The output of the color LUT 11 enters the multiplier 13, and the output of the color LUT 12 enters the multiplier 14. On the other hand, the other inputs of the multipliers 13 and 14 contain the outputs of the weight generators 5 and 6, respectively. These multipliers 13 and 14 simultaneously multiply the output of the color LUT and the output of the weight generator. According to the present invention, since the sum of weighting coefficients becomes 255 or less by simultaneous multiplication, it is possible to perform three-color simultaneous processing by 8-point interpolation, which is not possible with a 64-bit CPU with a conventional rectangular weighting coefficient. Become. As a result, the calculation speed can be greatly increased.

  The outputs of the multipliers 13 and 14 enter an adder 15 and are added. The output of the adder 15 enters the integrator 16 and is integrated. The above operation is repeated four times, 00, 01, 10, and 11, which are the outputs of the counter 4, and eight-point interpolation is performed. The accumulator 16 calculates the total sum of these eight interpolation operations. Since the value accumulated by the accumulator 16 is (result × sum of weighting coefficients), the subsequent divider 17 divides by the weighting coefficient (68 in this case). The divider 17 outputs new R data Rnew converted by interpolation.

  In this case, when the weighting factor of the divider 17 is not a power of 2 (as in the case of 68 described above), division by a divider is necessary. However, when the weighting factor is a power of 2, it is only necessary to shift right by a power, so that a divider is substantially unnecessary. Therefore, if the data to be stored in the color LUTs 11 and 12 is divided in advance by the weighting factor 68 and stored by multiplying by a power of 2, the divider 17 becomes unnecessary. If linear data is held in the color LUT, there is no difference between the final result using the divider and the final result by the above operation.

The case of obtaining R data has been described above, but the same applies to the case of obtaining G data and B data.
Various methods can be considered for the method of generating the weight coefficient by the weight generator. Whether all of the above formulas (3) are performed in advance and the result is stored in the form of ROM, or whether the actual calculation is performed each time, or an intermediate method is used depends on the hardware configuration. Some implementation methods are shown below.
(A) Method for making all ROMs As shown in FIG. 3, a 16 KB ROM for each color is used as an input address. The ROM stores weight coefficients calculated in advance. The 4-bit address of r, g, and b and the 2-bit output of the counter are received, and the 7-bit weight coefficient data stored in the corresponding address is output.
(B) Method of Using Encoder FIG. 4 is a diagram for generating a weighting factor using an encoder. Paying attention to the range of the lower digits from 0 to 8, the first encoder 41 with 8 bits input and 7 bits output outputs the data corresponding to the input of r and g and combines them into one 7 bit data. . For example, an LUT is used as the first encoder 41. The output of the first encoder 41 takes a value from 0 to 80. Next, the data is encoded by a second encoder 42 that receives the output of the first encoder 41 and the b input as input, and is combined into one piece of data. Finally, the output of the second encoder 42 and the counter output are input to the ROM 43 to output 7-bit weight coefficient data. As described above, the encoding is performed in two stages and the value of 0 to 728 is set as the output range, so that the encoding output in the second stage is 10 bits, so that the ROM 43 can be 4 KB in size. By using the encoder, in the example shown in FIG. 3, the ROM capacity can be ¼ compared to the ROM capacity of 16 KB.
(C) Method of obtaining by calculation This method is to calculate equation (3) each time. Instead of eliminating the need for ROM, computation time is required, which is not suitable for speeding up.

  FIG. 5 is a block diagram showing another embodiment of the present invention, in which interpolation is performed using a central processing unit. Again, three-dimensional interpolation is shown. In response to the R, G, B data, the address generating means 50 generates a three-dimensional color LUT address as shown at 60. The color LUT stores four types of data Y, M, C, and K as shown in 61. Here, since division, which is the last sequence in the interpolation calculation, is performed only by shifting, the data stored in the color LUT is stored after being multiplied by 64/68. Accordingly, the maximum value at this time is 240 instead of 255.

The maximum value of the volume of the rectangular parallelepiped is about 13 bits (when M = 17, 17 ³ ). If 13 bits are added to 8 bits of the original data, a calculation width of 21 bits is required. In this case, if four colors are to be calculated simultaneously, a CPU having an extremely large number of bits is required. In the case of the present invention, since the maximum is 7 bits, multiplication of 8 bits and 7 bits does not exceed 16 bits. Therefore, it is 16 × 3 (in the case of three colors), and if a 64-bit CPU is used, simultaneous three-color interpolation with 8-point interpolation is sufficiently possible.

  When R, G, B image data is input to the address generating means 50, the address generating means 50 calculates and outputs the upper and lower digits as in the case of the above embodiment. The upper digit selects the color LUT, and the lower digit enters the weighting factor generating means 51 to generate the weighting factor. The Y, M, C, and K data read from the color LUT are rearranged in the 64-bit register 52 as shown in the figure.

  The color LUT data required for 8 multiplication accumulations is loaded into the register 52, while the corresponding weight coefficient data is given. The calculation of the weighting coefficient is given by Tables 1 and 2, and the position of the required color LUT depends on the lower bits and changes depending on the output of the address generation means 50.

  The i-th LUT data and the i-th weight coefficient Wi are multiplied by an accumulator (or ALU) 53. The multiplication result is sent to the integrating register 54. This calculation is performed 8 times and integrated by the integration register 54. When 8 accumulations are completed, shift 6 bits to the right. This is equivalently 1/64 times. The shifted converted data is rearranged in order to correct it to a predetermined image format.

Next, modifications and applications of the present invention will be described.
1) As a weight generation means, the volume of a rectangular parallelepiped on the opposite side that divides a conventional lattice point can be used. However, in this case, strictly speaking, the number of bits for generating the weighting coefficient is increased from 7 bits in the embodiment to 13 bits, and at the same time, multipliers, adders, etc., which are expensive and have a wide bit width must be used. Disappear.
2) A method that does not save by using the fact that the weighting factor is symmetric with respect to the lattice point is also possible. However, in this case, since no counter input is required for the address generator, there is an advantage that the memory capacity is halved (from 512 bytes in the embodiment to 256 bytes) and the calculation is simplified in the case of the ROM. However, when the weight generator is created in ROM, the total memory capacity increases since 2916 (= 93.times.4) words increase from 19916 (= 173.times.4) words in the embodiment.
3) Although the embodiment is configured by a combination of parallel processing and serial processing (time-series processing), complete parallel processing and serial processing (example of FIG. 5) are also possible.
4) In the embodiment, N = 3, that is, the case of three-dimensional interpolation is shown. However, the present invention can be easily extended to the case of four or more dimensions. In the case of four dimensions, there are 24 cases of weighting factors. However, when the weight coefficient is composed of ROM, it can be reduced to 1/16.
5) When simultaneously performing the interpolation operation in the central processing unit, it is possible not to use 64 bits at a time but to use a 32-bit register twice.

As described above in detail, according to the present invention, the maximum value of the weighting coefficient for interpolation is given by M × 2 ^N-1 at the interpolation interval M, thereby suppressing the maximum value of the weighting coefficient. I did it. As a result, it is possible to save hardware resources and increase the calculation time.

  In this case, when the maximum weight coefficient is not a power of 2, the data stored in the color LUT is divided in advance and stored by multiplying by a power of 2. As a result, the division by the weighting coefficient performed at the end of the interpolation calculation can be performed simply by shifting the data (right shift), thereby speeding up the calculation time. .

  Further, according to the present invention, when performing N-dimensional interpolation, a weighting factor is generated for an address of (M + 1) / 2 with respect to the interpolation interval M, and the weighting factor is obtained by performing multidimensional interpolation. The memory capacity for generation can be reduced, and hardware resources can be saved.

  In this case, when performing the interpolation operation of the N-dimensional LUT, hardware resources are saved by simultaneously multiplying a plurality of color data among the values of three to four colors of the LUT by a weight coefficient, Interpolation calculation can be speeded up.

  As described above, according to the present invention, it is possible to provide a multidimensional interpolation apparatus that can save hardware resources and increase the calculation speed, and has a great practical effect.

1 is a configuration block diagram illustrating an embodiment of the present invention. It is a figure which shows the triangular pyramid applied according to the magnitude relationship of r, g, and b. It is a block diagram when ROM is used as a weight generator. It is a block diagram when using an encoder as a weight generator. It is a block diagram which shows the other Example of this invention. It is explanatory drawing of cube interpolation. It is explanatory drawing of a triangular pyramid interpolation. It is explanatory drawing of the property of a weighting coefficient.

Explanation of symbols

1 R Address Generator 2 G Address Generator 3 B Address Generator 4 Quaternary Counter 5 Weight Generator 6 Weight Generator 10 R Processing Unit 11 Color LUT
12 color LUT
13 Multiplier 14 Multiplier 15 Adder 16 Accumulator 17 Divider 20 G Processing Unit 30 B Processing Unit

Claims (3)

Using a color LUT in which output values for N (N ≧ 3) -dimensional input data for each interpolation interval M are held, output values for the input values to be interpolated are calculated for each interpolation interval M in the vicinity of the input values to be interpolated. A multi-dimensional interpolation apparatus, comprising: a calculation means for executing the following steps in a multi-dimensional interpolation apparatus that is obtained by weighting an output value from a color LUT for N-dimensional input data:
(S1) A step of assuming a unit hypercube having an input value to be interpolated therein and having N-dimensional input data for each interpolation interval M as a vertex .
(S 2 ) This unit hypercube is divided into a plurality of hypersolids sharing a certain diagonal line, and the hypersolid having the input value to be interpolated therein is specified from among the divided supersolids. and, a weighting factor based on the relationship between the input value and each vertex serving as the interpolation target, Ru determined for each vertex of the identified super-solid steps.
(S 3) all rows of the Hare steps for diagonal of remaining step S 2 the unit hypercube.
(S 4) steps for each vertex of the unit hypercube, adding the weighting coefficient obtained in the step S 2 and S 3, Ru determined by a weighting factor summed.
(S 5 ) Each output value for input data corresponding to each vertex of the unit hypercube is obtained from the color LUT, and each obtained output value and the sum obtained in step S 4 for each vertex are added. Multiplying each of the combined weighting factors .
(S 6 ) A step of adding the results multiplied in step S 5 .
(S 7 ) A step of obtaining an interpolated value for the input value to be interpolated by dividing the summation result obtained in step S 6 by M × 2 ^N−1 . A weighting factor is stored in advance when the input value to be interpolated exists in a unit hypercube of 1/2 ^N of the unit hypercube, which is composed of half sides of each side of the unit hypercube. When the input value to be interpolated does not exist in the 1/2 ^N unit hypercube, the weight coefficient held in advance is used based on the symmetry of the unit hypercube. The multidimensional interpolation apparatus according to claim 1, wherein The multidimensional interpolation apparatus according to claim 1 or 2 , wherein among the values of the three colors to four colors of the color LUT, a plurality of input data are simultaneously multiplied by a weighting coefficient .

Images