JP2009020617A - Image processor, image processing method, and ink jet recording device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a technology for forming an image of high picture quality while reducing the complexity of processing. <P>SOLUTION: This image processor is provided with a means for converting the respective pixels of data expressed with the total value of the respective pixels of n pieces of i gradation data into the quantized value of n+1 gradation, and for generating the first quantized data; a means for discriminating the n pieces of color components into a first color group in which k pieces of colors are included and a second color group in which residual n-k pieces of colors are included, and for converting the data expressed with difference quantity between the respective pixels of the data expressed with the total value of the respective pixels of the (n-k) pieces of i gradation data and the respective pixels of the first quantized data into the quantized value of the (k+1) gradation, and for generating second quantized data; a means for generating the data expressed with the difference quantity between the respective pixels of the first quantized data and the respective pixels of the second quantized data as third quantized data; and a control means for recursively executing the means, and for controlling the generation of n pieces of two gradation data. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to an image processing technique for generating image data of two gradations for each color based on color image data.

  2. Description of the Related Art As information output devices in word processors, personal computers, facsimiles, and the like, recording devices that record information such as desired characters and images on a sheet-like recording medium such as paper or film are used. Such recording apparatuses include various recording systems, and a system for forming text and images on a recording medium by attaching a recording agent to the recording medium has been widely put into practical use. A typical example of such a system is an ink jet recording apparatus.

  In an ink jet recording apparatus, a recording head having a nozzle group in which a plurality of ink discharge ports (nozzles) capable of discharging ink of the same color and the same density are integrated is used in order to improve the recording speed and improve the image quality. Furthermore, in order to improve the image quality, there may be provided a nozzle group that uses ink of the same hue and different density, or a nozzle group that can control the discharge amount of ink of the same color and the same density per time in a plurality of stages. is there. In such an image forming apparatus, input image data in which one pixel is expressed in multiple values is converted into a binary image (an image having a smaller number of gradations than the number of input gradations) corresponding to a dot recording signal. Record.

As a method for converting to a binary image, R.I. There is an error diffusion method by Floyd et al. In this error diffusion method, pseudo gradation expression is performed by diffusing a binarization error generated in a certain pixel to a plurality of subsequent pixels. Therefore, an image processing technique using an error diffusion method has been proposed in order to control the dot arrangement of inks having the same hue and different densities or inks having different hues. For example, Patent Document 1 discloses a method of arranging dots so that a plurality of types of dots do not overlap.
JP 2004-336570 A R. Floyd et al., “An adaptive algorithm for spatial gray scale”, SID International Symposium Digest of Technical Papers, vol4.3, 1975, pp.36-37

  However, in the method according to Patent Document 1 described above, by using an LUT (LookUp Table), each pseudo gradation output value is determined while restricting the arrangement of a plurality of ink planes. For this reason, magenta dots having a high density are easily visually recognized, but yellow dots having a low density are hardly visually recognized. As a result of the above processing, only the magenta dots that have been struck with restrictions on the dot arrangement are likely to be visually recognized, and the graininess is deteriorated.

  Furthermore, in the method according to Patent Document 1, when the number of ink planes increases, the processing becomes complicated. For example, when targeting four types of ink planes, a four-dimensional LUT is required. In recent inkjet printers, special inks of red (R), green (G), and blue (B) may be added to the basic inks of cyan (C), magenta (M), and yellow (Y). Therefore, considering the dot arrangement control including spot color ink, the method of Patent Document 1 is not practical from the viewpoint of processing complexity.

  The present invention has been made in view of the above-described problems, and an object of the present invention is to provide a technique that enables image formation with higher image quality while reducing processing complexity.

  In order to solve one or more of the problems described above, the image processing apparatus of the present invention has the following configuration. That is, n pieces of two gradation data from n pieces of i gradation (i is a positive integer of 2 or more) data corresponding to each of n (n is a positive integer of 2 or more) color components constituting the image data. Each pixel of data represented by the total value of each pixel of the n i gradation data is converted into a quantized value of n + 1 gradation by error diffusion processing, and n First quantized data generating means for generating first quantized data corresponding to the total n + 1 gradation data, and k color components having relatively high visibility (k <n A first color group containing a positive integer color) and a second color group containing n−k colors having relatively low visibility, and n corresponding to the second color group Each pixel of data represented by the total value of each pixel of k i-gradation data and the first quantization data; The data represented by the difference amount from each pixel of the data is converted into k + 1 grayscale quantization values by error diffusion processing, and the kth grayscale data corresponding to the k total grayscale data corresponding to the first color group is converted. 2nd quantized data generating means for generating 2 quantized data, and data expressed by a difference amount between each pixel of the first quantized data and each pixel of the second quantized data A third quantized data generating means for generating third quantized data corresponding to a total of n−k corresponding to the second color group, and at least one of k or n−k is greater than 1 The first quantized data generating means, the second quantized data generating means, and the third quantized data generating means are recursively for at least one of the first color group and the second color group. In And a control means for controlling to generate the n 2 gradation data by rows.

  In order to solve one or more of the problems described above, the image processing method of the present invention comprises the following arrangement. That is, n pieces of two gradation data from n pieces of i gradation (i is a positive integer of 2 or more) data corresponding to each of n (n is a positive integer of 2 or more) color components constituting the image data. Is generated by converting each pixel of data represented by the total value of each pixel of the n i-gradation data into a quantized value of n + 1 gradations by error diffusion processing. A first quantized data generating step for generating first quantized data corresponding to the total n + 1 gradation data, and k color components having relatively high visibility (k <n A first color group containing a positive integer color) and a second color group containing n−k colors having relatively low visibility, and n corresponding to the second color group Each pixel of data represented by the total value of each pixel of k i-gradation data and the first quantization data; The data represented by the difference amount from each pixel of the data is converted into k + 1 grayscale quantization values by error diffusion processing, and the kth grayscale data corresponding to the k total grayscale data corresponding to the first color group is converted. A second quantized data generating step for generating two quantized data, and data expressed by a difference amount between each pixel of the first quantized data and each pixel of the second quantized data A third quantized data generating step for generating third quantized data corresponding to the total of n−k corresponding to the second color group, and at least one of k or n−k is greater than 1 The first quantized data generating step, the second quantized data generating step, and the third quantized data generating step are recursively performed on at least one of the first color group and the second color group. In And a control step of controlling to generate the n 2 gradation data by rows.

  According to the present invention, it is possible to provide a technique that enables image formation with higher image quality while reducing processing complexity.

  Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the drawings. The following embodiments are merely examples, and are not intended to limit the scope of the present invention.

(First embodiment)
The first embodiment of the image processing apparatus according to the present invention will be described below by taking an image forming system as an example.

<System configuration>
FIG. 1 is a block diagram showing a configuration of an image forming system including an image forming apparatus according to the first embodiment. Reference numeral 1 denotes an image processing apparatus, and 2 denotes a printer. The image processing apparatus 1 can be realized by a printer driver installed in a general personal computer (PC), for example. In this case, each unit of the image processing apparatus 1 described below is realized by executing a program constituting a printer driver by a CPU in the PC. Here, an example in which the image processing apparatus 1 and the printer 2 are separately configured will be described. However, a configuration in which an image processing unit corresponding to the image processing apparatus 1 is included in the printer may be employed.

  The image processing apparatus 1 and the printer 2 are connected by a printer interface or a network interface. The image processing apparatus 1 inputs image data to be printed from the data input unit 101 and stores the input image data in the image buffer 102. The color separation processing unit 103 separates the input color image into ink colors provided in the printer 2. In this color separation process, a color separation lookup table (LUT) 104 is referred to.

  The halftone processing unit 105 converts multi-tone (three or more gradations) image data of each color obtained by the color separation processing unit 103 into binary image data. The obtained binary image data of each color is stored in the halftone image storage memory 106. The binary image data stored in the halftone image storage memory 106 is output from the data output unit 107 to the printer 2.

  The printer 2 forms an image on the recording medium by moving the recording head 201 vertically and horizontally relative to the recording medium 202. As the recording head, a wire dot method, a thermal method, a thermal transfer method, an ink jet method, or the like can be used, and each has one or more recording elements (a nozzle in the case of an ink jet method). The moving unit 203 moves the recording head 201 under the control of the head control unit 204. The transport unit 205 transports the recording medium under the control of the head control unit 204. Further, the ink color and ejection amount selection unit 206 determines the ink color mounted on the recording head 201 and the ink ejection amount that the head can eject based on the binary image data of each color formed by the image processing apparatus 1. Select the ink color and discharge amount from the list.

  FIG. 2 is a diagram illustrating a configuration example of the recording head 201 mounted on the printer 2. Here, in addition to four inks of cyan (C), magenta (M), yellow (Y), and black (K), three colors of red (R), green (G), and blue (B) are included. The case where a total of seven colors of ink are used is illustrated.

  Note that FIG. 2 shows a recording head having a configuration in which nozzles are arranged in a line in the paper transport direction for the sake of simplicity. However, the number and arrangement of nozzles are not limited to this. For example, there may be a plurality of nozzle rows for the same ink color, or a configuration in which a plurality of nozzles are arranged in a zigzag manner for the same ink color. In FIG. 2, the nozzle rows for each ink color are arranged in the moving direction of the head, but may be arranged in a row in the paper transport direction.

<Operation of the device>
In the following, a process for generating print data expressed by 7 colors of CMYKRGB (1 bit of each color) based on input image data expressed by 3 colors of RGB (8 bits of each color) will be described. . It should be noted that the color component can be applied to an arbitrary n that is a positive integer of 2 or more. In other words, the configuration may be such that n pieces of two gradation data are generated from n pieces of i gradation (i is a positive integer of 2 or more) data.

  FIG. 3 is an operation flowchart of the image processing apparatus 1 according to the first embodiment.

  In step S 101, multi-tone color input image data is input from the data input unit 101 and stored in the image buffer 102. Here, it is assumed that the input image data is represented by three color components of red (R_in), green (G_in), and blue (B_in), and each color has 256 gradations (8 bits).

  In step S102, the color separation processing unit 103 performs color separation processing of multi-tone color input image data stored in the image buffer 102 using the LUT of the color separation LUT 104. In this color separation processing, color input image data is color-separated from RGB into CMYK and RGB ink color planes.

  As described above, the recording head 201 forms dots on the recording medium using the nozzle rows corresponding to the seven types of ink colors. Therefore, RGB color input image data input to the image processing apparatus 1 is converted into image data of 7 planes of CMYKRGB planes and output to the printer 2. That is, seven types of plane image data corresponding to the seven types of recording modes are generated. Details of the color separation process will be described later.

  In step S103, the halftone processing unit 105 performs pixel position selection processing for halftone processing.

  In step S104, halftone processing for converting to a small number of gradations is performed. In this embodiment, the color separation processing unit 103 separates each pixel data of the input image into a plane having an 8-bit gradation value. Then, the halftone processing unit 105 converts the plane obtained by the color separation processing unit 103 into two-level gradation value data (binary data). The halftone process according to the first embodiment is a process for converting multi-valued input image data into a binary image (or an image having two or more values and a smaller number of gradations than the number of input gradations). The error diffusion method by Floyd et al. Is used. Details of the halftone processing unit 105 of the present embodiment will be described later.

  In step S <b> 105, the binary image data after the halftone process is stored in the halftone image storage memory 106.

  FIG. 4 is a diagram illustrating a configuration example of each color plane 61 and binary image data 62 input to the halftone processing unit 105. The color separation processing unit 103 has a plane 61 (8 bits) in which multivalued (8 bits) data is arranged in a two-dimensional storage area I (x, y) equal to the number of horizontal pixels W and the number of vertical pixels H of the input image. Multi-valued image data) is generated. The halftone processing unit 105 performs gradation conversion processing on the plane 61 to generate binary data at each pixel position of each color plane. The halftone image storage memory 106 has a two-dimensional storage area O (x, y) equal to the number of horizontal pixels W and the number of vertical pixels H of the input image, and stores binary image data corresponding to each pixel position. Store.

  In the present embodiment, the corresponding pixels of each plane are sequentially input to generate binary image data corresponding to each recording mode. Therefore, it is not necessary to prepare a memory space for holding the entire multi-value image plane 61. Further, the halftone image storage memory 106 may be prepared with a memory space having a size necessary for recording operation in units of bands, for example.

  In step S106, it is determined whether halftone images have been generated for all pixels to be processed.

  In step S107, the data output unit 107 outputs the image data after halftone processing stored in the halftone image storage memory 106 as an output dot pattern.

  In step S108, the printer 2 receives the image data output from the data output unit 107, selects an ink color and an ejection amount according to the image data, and forms an image. In image formation, for example, the printer 2 drives each nozzle at a fixed driving interval (that is, controls on / off of ink ejection) while moving the recording head 201 from the left to the right with respect to the recording medium. Images are recorded on the recording medium. When one scan is completed, the recording head is returned to the left end and the recording medium 202 is conveyed by a certain amount. By repeating the above processing, an image is formed.

<Details of color separation processing>
FIG. 5 is a diagram illustrating a configuration of the color separation processing unit 103 in the image processing apparatus 1. Reference numeral 501 denotes a luminance density conversion unit, and reference numeral 502 denotes a UCR (Under Color removal) / BG (Black Generation) processing unit. Reference numeral 503 denotes a BG amount setting unit, 504 denotes a UCR amount setting unit, 505 denotes a special color ink separation processing unit, and a special color ink separation processing LUT 506.

First, 8-bit luminance information image data R_in, G_in, and B_in input in the luminance density conversion unit 501 are converted into CMY based on the following equation.
C = −αlog (R_in / 255) (1)
M = −αlog (G_in / 255) (2)
Y = −αlog (B_in / 255) (3)
Here, α is an arbitrary real number.

Next, the CMY data is obtained by β (Min (C, M, Y), μ) set in the BG amount setting unit 503 and a value μ set in the UCR amount setting unit 504.
C ′ = C− (μ / 100) × Min (C, M, Y) (4)
M ′ = M− (μ / 100) × Min (C, M, Y) (5)
Y ′ = Y− (μ / 100) × Min (C, M, Y) (6)
K ′ = β (Min (C, M, Y), μ) × (μ / 100) × Min (C, M, Y) (7)
Is converted. Here, β (Min (C, M, Y), μ) is a real number that varies depending on Min (C, M, Y) and μ, and the usage method of K ink can be set by this value.

  Subsequently, for the three colors C′M′Y ′ that are color components constituting the color gamuts of red, green, and blue, the spot color ink separation processing unit 505 refers to the spot color ink separation processing LUT 506, and Carry out spot color ink decomposition according to the formula.

C ″ = Lut (C ′, M ′, Y ′) (8)
M ″ = Lut (C ′, M ′, Y ′) (9)
Y ″ = Lut (C ′, M ′, Y ′) (10)
R ′ = Lut (M ′, Y ′) (11)
G ′ = Lut (C ′, Y ′) (12)
B ′ = Lut (C ′, M ′) (13)
C ″, M ″, Y ″, R ′, G ′, and B ′ indicate output data values of cyan, magenta, yellow, red, green, and blue after the special color ink separation, respectively. ) To the right side of the equation (13) corresponds to the spot color ink separation processing LUT.

  FIG. 6 is a diagram illustrating an example of the spot color ink separation processing LUT. Specifically, RGB and CMY ink decomposition amounts are determined according to CMY input values. When creating this LUT, a color chart composed of a combination of six colors of CMYRGB is printed in advance, and an ink separation amount corresponding to the target color is determined. In the first embodiment, the means for determining the amount of ink separation is provided separately from the image forming apparatus, and only the result is held in the spot color ink separation processing LUT.

<Details of halftone processing>
Next, an error diffusion method used in the halftone processing unit 105 will be described. As described above, each CMYRGB plane image after color separation processing is an 8-bit image from 0 to 255. Generally, it is expressed as i gradation data (i is a positive integer of 2 or more). Here, in order to simplify the description, a pseudo gradation process using an error diffusion process in magenta, red, and yellow dot planes, M ″, R ′, and Y ″ will be described as an example. The following processing is sequentially executed for all pixels with one pixel in the input image data as a target pixel.

  FIG. 7 is a flowchart for explaining the operation of the halftone processing unit 105. However, it is assumed that dot grouping that should be prioritized is set in advance. Here, the grouping means that the dot overlap is controlled in units of groups.

  When Gr1 and Gr2 are set as the hierarchy 1 group, it indicates that dot overlap can be controlled in units of Gr1 and Gr2. In addition, when Grx_1 and Grx_2 are set as the layer 2 group, it indicates that dot overlap can be controlled in units of Grx_1 and Grx_2.

  FIG. 9 is a diagram illustrating an example in which three planes M ″, R ′, and Y ″ are grouped into two groups. The grouping may be determined in advance so that, for example, a color with relatively high visibility (high density) has a higher priority. For example, when the three colors M ″, R ′, and Y ″ are compared, they become M ″, R ′, and Y ″ in descending order of visibility. However, the difference in visibility between M ″ and R ′ is smaller than that between R ′ and Y ″. Therefore, Gr1: M ″ R ′, Gr2: Y ″ are set as the hierarchy 1 group. Furthermore, Gr1_1: M ″ and Gr1_2: R ′ are set as the hierarchy 2 group. FIG. 10 shows an example in which 7 planes of CMYKRGB are grouped into 5 groups. The first color group including k (k <n positive integers) colors with relatively high visibility and the nk colors with relatively low visibility. In order to simplify the description, processing for the three planes M ″, R ′, and Y ″ shown in FIG.

  In step S1, a hierarchical level 1 group and Gr1_data (corresponding to k total data of the first color group) are respectively calculated. Then, Gr2_data (corresponding to nk total data of the second color group) and the hierarchy 2 groups Gr1_1data and Gr1_2data are similarly calculated.

Tier 1 group:
Gr1_data = M ″ + R ′
Gr2_data = Y "(14)
Tier 2 group:
Gr1_1data = M "
Gr1_2data = R ′ (15)
In step S2, it is determined whether Gr2_data is larger or smaller than a value k designated in advance. If Gr2_data> = k, the process proceeds to step S3, and if Gr2_data <k, the process proceeds to step S5.

  In step S3, arrangement control is performed so that dot position overlap is not permitted between the Gr1 and Gr2 planes. Details of the arrangement control will be described below (Process 1).

  In step S4, arrangement control is performed to allow overlapping of dot positions between the Gr1 and Gr2 planes. Details of the placement control will be described below (Process 2).

  In step S5, it is determined whether or not the processing in steps S1 to S4 described above has been completed for all the pixels in the image data. If not completed, the target pixel is moved, and steps S1 to S4 are executed again. If completed, the process is terminated.

<Process 1 (Step S3)>
The process of step S3 is a process of determining an arrangement so as not to allow overlapping of dot positions between the planes as described above. Specifically, first, control is performed so that dots do not overlap between the first layer, that is, Gr1data (magenta, red) and Gr2data (yellow). Subsequently, control is performed so that dots do not overlap between the hierarchical two groups, that is, Gr1_1 data (magenta) and Gr1_2 data (red). In this way, dots are prevented from overlapping between Gr1_1 data (magenta), Gr1_2 data (red), and Gr2 data (yellow). Hereinafter, a method for realizing the processing will be described in detail.

  FIG. 8A is a diagram for explaining the details of the processing in step S3. Note that each functional component shown in FIG. 8A may be realized by hardware, or a part or all of it may be realized by software. FIG. 11 is a detailed flowchart of the process in step S3. The first quantizing unit 601 corresponds to a first quantized data generating unit, and the second quantizing unit 602 corresponds to a second quantized data generating unit and a third quantized data generating unit.

  In the process of step S3, binarization (quantization value is 0 or 255) is performed on the three dot plane data of magenta, red, and yellow (each plane takes a value of 0 to 255). In that case, the first quantization unit 601 receives the total data I_mry of the corresponding pixels of the Gr1_data and Gr2_data data. That is, the sum of the corresponding pixel values in each of the magenta, red, and yellow planes is input to I_mry. More generally, n total data of n color components are input. Then, error diffusion processing is performed on the input I_mry to perform quaternization corresponding to the first quantized data (quantized value is 0, 255, 510, or 765). In general, n + 1 gradation data is generated in the case of n color components.

  More specifically, first, in step S201, Gr1_data + Gr2_data (total data of magenta, red, and yellow dot plane pixel values) I_mry is input to the first quantization unit 601. Here, I_mry is calculated as follows.

I_mry = Gr1_data + Gr2_data (16)
FIG. 12 is a diagram for explaining error diffusion coefficients (four coefficients K1 to K4) around the target pixel in the error diffusion processing. For example, K1 = 7/16, K2 = 3/16, K3 = 5/16, and K4 = 1/16. In order to diffuse and accumulate errors using such error diffusion coefficients, the accumulated error line buffer 604 in the first quantization unit 601 has a storage area shown in FIG. That is, it has one storage area E_mry0 and the same number of storage areas E_mry (x) (x = 1 to W) as the number of horizontal pixels W of the input image, and the quantization error is stored by a method described later. . Note that the accumulated error line buffer 604 may be initialized with an initial value of 0 before starting the process, or may be initialized with a random value.

In step S202, the accumulated error adding unit 605 reads the error E_mry (x) corresponding to the horizontal pixel position x of the target pixel from the accumulated error line buffer 604 and adds it. That is, if the input total data is I_mry and the data after adding the accumulated error is I_mry ′,
I_mry ′ = I_mry + E_mry (x) (17)
It becomes.

Next, in step S203, the threshold selection unit 606 selects a threshold T_mry. The threshold T_mry is, for example, according to the input pixel data I_mry,
T_mry (I_mry) = 128 (0 ≦ I_mry ≦ 255) (18)
T_mry (I_mry) = 384 (255 <I_mry ≦ 510) (19)
T_mry (I_mry) = 640 (510 <I_mry ≦ 765) (20)
Is set. Alternatively, in order to avoid dot generation delay, the threshold T_mry may be finely changed according to the input pixel data I_mry so that the average quantization error is reduced.

  Next, in step S <b> 204, the quantization unit 607 compares the pixel data I_mry ′ after the error addition and the threshold value T (I_mry) to determine an output pixel value Out_mry. The rules are as follows:

Out_mry = 0 (21)
(0 ≦ I_mry ≦ 255, I_mry ′ <T (I_mry))
Out_mry = 255 (22)
(0 ≦ I_mry ≦ 255, I_mry ′ ≧ T (I_mry)) or
(255 <I_mry ≦ 510, I_mry ′ <T (I_mry))
Out_mry = 510 (23)
(255 ≦ I_mry ≦ 510, I_mry ′ ≧ T (I_mry)) or
(510 <I_mry ≦ 765, I_mry ′ <T (I_mry))
Out_mry = 765 (24)
(510 <I_mry ≦ 765, I_mry ′ ≧ T (I_mry))
Here, the meaning of quaternizing Gr1_data + Gr2_data (total data of magenta, red, and yellow dot plane pixel values) I_mry will be described. For example, as shown in Expression (22), Out_mry = 255 means that one of magenta, red, and yellow dots is hit at that location. In other words, Out_mry = 255 does not determine magenta dots at that location, and neither red dots nor yellow dots. What is fixed at this point is that it is not known which dot, magenta, red or yellow, will be hit, but at least one will be hit.

  Similarly, Out_mry = 510 means that two dots of magenta, red, and yellow are hit at the place. What is determined at this point is that it is not known whether magenta dots, red dots, or yellow dots will be hit, but at least any two will be hit. However, only the same dot can be hit at most.

  That is, the following features of each pixel are expressed by Out_mry.

Out_mry = 0... Neither magenta, red nor yellow dots are hit.
Out_mry = 255... One of magenta, red, and yellow dots is hit.
Out_mry = 510... Two of magenta, red, and yellow dots are hit.

        Out_mry = 765... Magenta, red, and yellow dots are shot.

  Next, in step S205, a difference amount Err_mry between the pixel data I_mry ′ after the error is added to the total value I_mry of the target pixel by the error calculation unit 608 and the output pixel value Out_mry is calculated as follows.

Err_mry (x) = I_mry′−Out_mry (25)
In step S206, the error diffusion unit 609 performs the error Err_mry (x) diffusion process in the accumulated error line buffer 604 according to the horizontal pixel position x as follows.

E_mry (x + 1) ← E_mry (x + 1) + Err_mry (x) × 7/16 (x <W)
E_mry (x-1) <-E_mry (x-1) + Err_mry (x) × 3/16 (x> 1)
E_mry (x) ← E_mry0 + Err_mry (x) × 5/16 (1 <x <W)
E_mry (x) ← E_mry0 + Err_mry (x) × 8/16 (x = 1)
E_mry (x) ← E_mry0 + Err_mry (x) × 13/16 (x = W)
E_mry0 ← E_mry × 1/16 (x <W)
E_mry0 ← 0 (x = W)
... (26)
As described above, the four-value quantization corresponding to the first quantized data is completed for the three-plane total data for one pixel of Gr1_data + Gr2_data (total data of pixel values of magenta, red, and yellow dot planes).

  By the quaternarization processing of the total data of the three dot planes obtained in this way, a suitable arrangement is ensured for at least a total of three planes. However, at this time, it is not determined which dot of the three dot planes is hit.

  Next, in the second quantization unit 602, error diffusion processing is performed on Gr1_data (that is, total data of pixel values of the target pixel of the two magenta and red dot planes) I_mr to obtain a ternary value (quantized value 0). , 255, 510).

  First, in step S207, the total data I_mr is input to the second quantization unit 602. I_mr is calculated as follows.

I_mr = Gr1_data (27)
The accumulated error line buffer 610 in the second quantization unit 602 in FIG. 8A has the same configuration as the accumulated error line buffer 604. That is, as shown in FIG. 13B, the cumulative error line buffer 610 has one storage area E_mr0 and the same number of storage areas E_mr (x) (x = 1 to W) as the number of horizontal pixels W of the input image. The quantization error is stored by a method described later. Note that the accumulated error line buffer 610 may be initialized with an initial value of 0 before starting the process, or may be initialized with a random value.

Next, in step S208, the error E_mr (x) corresponding to the horizontal pixel position x of the target pixel is added by the cumulative error addition unit 611. That is, if the total value of the input pixels of interest is I_mr and the data after accumulated error addition is I_mr ′,
I_mr ′ = I_mr + E_mr (x) (28)
It becomes.

Next, in step S209, the threshold selection unit 612 selects a threshold T_mr. In selecting the threshold T_mr,
t_mr = I_mr-I_mr (29)
The threshold T_mr is
T_mr (t_mr) = 128 (0 ≦ t_mr ≦ 255) (30)
Is set. In order to avoid dot generation delay, the threshold T_mr (t_mr) may be finely changed according to t_mr so that the average quantization error is reduced. Here, since I_mry-I_mr is always 255 or less, T_mr (t_mr) = 128 is taken.

  Next, in step S210, the quantization unit 613 compares the pixel data I_mr 'after the error addition with the threshold T (t_mr) and the aforementioned Gr1_data + Gr2_data (3-dot plane multi-value quantization result Out_mry). Then, the output pixel value Out_mr (trinary value) and Gr2_data (that is, the yellow dot final result Out_y) are determined. The rules are as follows:

When Out_mry−I_mr ′ ≧ T (t_mr): (31)
Out_mr = Out_mry-255 (32)
Out_y = 255 (33)
When Out_mry−I_mr ′ <T (t_mr): (34)
Out_mr = Out_mry (35)
Out_y = 0 (36)
For example, when Out_mry = 765, since Out_mry−I_mr ′ ≧ T (t_mr), the condition of Expression (31) is satisfied, and Out_mr = 510. In this way, ternarization (quantization values 0, 255) corresponding to the second quantization data of Gr1_data (that is, the total data of the two dot planes of magenta and red) is expressed by the equations (31) to (36). , 510) is determined. Along with this, binarization (quantization value 0, 255) of Gr1_data (that is, yellow dot plane) (Out_y) is determined. That is, at this time, the binary data of Gr1_data is determined. Expression (33) means that Gr1_data (yellow dot) is shot, and Expression (36) means that yellow dot is not shot.

  Here, the meaning of the ternarization of Gr1_data (total data of two magenta and red dot planes) will be described. For example, Out_mr = 255 means that one dot of magenta or red is hit at that place. In other words, Out_mr = 255 does not determine a magenta dot at that location, and does not determine a red dot. What is fixed at this point is that it is not known which dot, magenta or red, will be hit, but at least one will be hit.

  Further, Out_mry = 510 means that two dots of either magenta or red are hit at the place. This means that both magenta and red can be hit on the premise that only one dot of the same color can be hit at most.

  The above is summarized as follows.

Out_mr = 0 ... Neither magenta nor red dot is hit.
Out_mr = 255 One of magenta and red dots is hit.
Out_mr = 510... Magenta and red dots are hit.

  In step S211, the error calculation unit 614 calculates a difference amount Err_mr between the pixel data I_mr ′ after the error addition to the target pixel I_mr and the output pixel value Out_mr by the following equation (37).

Err_mr (x) = I_mr′−Out_mr (37)
In step S212, similarly to the error diffusion unit 609, the error diffusion unit 615 diffuses the error Err_mr (x) as follows using the accumulated error line buffer 610 according to the horizontal pixel position x of the target pixel.

E_mr (x + 1) ← E_mr (x + 1) + Err_mr (x) × 7/16 (x <W)
E_mr (x−1) ← E_lm (x−1) + Err_lm (x) × 3/16 (x> 1)
E_mr (x) ← E_mr0 + Err_mr (x) × 5/16 (1 <x <W)
E_mr (x) ← E_mr0 + Err_mr (x) × 8/16 (x = 1)
E_mr (x) ← E_mr0 + Err_mr (x) × 13/16 (x = W)
E_mr0 ← E_mr × 1/16 (x <W)
E_mr0 ← 0 (x = W)
... (38)
As described above, Gr1_data for one pixel (total data of two planes of magenta, red dot, M ″, and R ′) is ternary (quantized values 0, 255, 510) corresponding to the second quantized data. At the same time, a binarization (quantized value 0, 255) result corresponding to the third quantized data of Gr2_data (yellow dot Y ″) is determined.

  That is, the ternarization of Gr1_data has the purpose of ensuring a more suitable arrangement with respect to Gr1_data (magenta and red 2 plane total). Then, the binarization result of Gr2_data (yellow dot Y ″) is determined as the remaining arrangement of the reserved arrangement. That is, Gr1_data having a relatively high priority is a more preferable arrangement. The Gr2_data whose priority is set to be relatively low is arranged at a surplus position after the Gr1_data is arranged, thereby realizing a control that does not allow overlapping of dots of Gr1_data and Gr2_data.

  Next, error diffusion processing is performed on Gr1_1data (that is, magenta dot plane data) to perform binarization. First, in step S <b> 213, Gr <b> 1 </ b> _ <b> 1 data (magenta dot target pixel data) I_m is input to the third quantization unit 603. I_m is calculated as follows.

I_m = Gr1_1data (39)
The accumulated error line buffer 616 in the third quantization unit 603 in FIG. 8 has the same configuration as the accumulated error line buffer 604. That is, as shown in FIG. 13C, the cumulative error line buffer 616 has one storage area E_m0 and the same number of storage areas E_m (x) (x = 1 to W) as the number of horizontal pixels W of the input image. The quantization error is stored by a method described later. Note that the accumulated error line buffer 616 may be initialized with an initial value of 0 before starting the process, or may be initialized with a random value.

Next, in step S214, an error E_m (x) corresponding to the horizontal pixel position x of the input pixel data is added by the cumulative error addition unit 617. That is, it is equivalent to being reflected and reflected. That is, if the input pixel-of-interest data is I_m, and the data after adding the cumulative error is I_m ′,
I_m ′ = I_m + E_m (x) (40)
It becomes.

Next, in step S215, the threshold selection unit 618 selects a threshold T_m. In the selection of the threshold T_m, for example,
t_m = I_mr-I_m (41A)
The threshold T_m is
T_m (t_m) = 128 (0 ≦ t_m ≦ 255) (41B)
Is set. Alternatively, in order to avoid dot generation delay, the threshold value T_m may be finely changed according to t_m so that the average quantization error becomes small. Since I_mr-I_m is 255 or less, T_m (t_mr) = 128 is always used in this embodiment.
Next, in step S216, the quantization unit 619 compares the pixel data I_m ′ after the error addition, the threshold T_m (t_m), and Out_mr (quantized values 0, 255, 510). Out_mr (quantized value 0, 255, 510) is a multi-valued result of the aforementioned Gr1_data (total data of two dot planes of magenta and red). Then, the final binarization result Out_r of Gr1_2 data (red dot) and the final binarization result Out_m of Gr1_1 data (magenta dot) are determined. The rules are as follows:

When Out_mr-I_m ′ ≧ T (t_m), (42)
Out_m = Out_mr-255 (43)
Out_r = 255 (44)
When Out_mr-I_m ′ <T (t_m) (45)
Out_m = Out_mr (46)
Out_r = 0 (47)
For example, when Out_mr = 510, since Out_mr−I_m ′ ≧ T (t_m), the condition of Expression (42) is satisfied, and Out_m = 255. For this reason, the binarization of Gr1_1data (magenta data) Out_m is determined at the same time as the binarization of Gr1_2data (red data) Out_r is determined by equations (42) to (47). That is, the final red dot result Out_r and the final magenta dot result Out_m are determined simultaneously. Equation (44) means that a red dot is hit, and equation (47) means that a red dot is not hit.

  Next, in step S217, the error calculation unit 620 calculates the difference amount Err_m between the pixel data I_m ′ after the error addition to the target pixel I_m and the output pixel value Out_m as follows.

Err_m (x) = I_m′−Out_m (47)
Next, in step S218, the error diffusion unit 621 diffuses the error similarly to the error calculation units 608 and 615. That is, using the accumulated error line buffer 616, the error Err_m (x) is diffused as follows according to the horizontal pixel position x.

E_m (x + 1) ← E_m (x + 1) + Err_m (x) × 7/16 (x <W)
E_m (x-1) <-E_m (x-1) + Err_m (x) * 3/16 (x> 1)
E_m (x) ← E_m0 + Err_m (x) × 5/16 (1 <x <W)
E_m (x) ← E_m0 + Err_m (x) × 8/16 (x = 1)
E_m (x) ← E_m0 + Err_m (x) × 13/16 (x = W)
E_m0 ← E_m × 1/16 (x <W)
E_m0 ← 0 (x = W)
... (48)
This completes binarization (quantization value 0, 255) for one pixel of Gr1_1data (magenta data M ″). Simultaneously, binarization (quantization value 0) of Gr1_2data (red data R ′) 255) The result is also confirmed.

  In other words, the binarization of Gr1_1 data (magenta data) has the purpose of ensuring a more favorable arrangement with respect to Gr1_1 data. Then, the binarization result of Gr1_2 data (red data) is determined as the remaining arrangement of the arrangement secured for Gr1_1 data. That is, Gr1_1data (magenta data) set with a relatively high priority is more suitable, and Gr1_2data (red data) set with a relatively low priority is the remaining position after Gr1_1data is arranged. Placed in. Thereby, control which does not permit the overlap of dots of Gr1_data and Gr2_data is realized.

  Further, as described above, in the first embodiment, the binarized data corresponding to the color component here is finally obtained by performing grouping of two hierarchies and performing the same operation recursively for each hierarchy. (2 gradation data) is determined. Similarly, even if it is expressed by a larger number n of color components, two gradation data is determined by performing recursive error diffusion calculation by performing hierarchical grouping. It turns out that it is possible. As a method for recursively determining whether or not an operation has been performed, it is determined whether at least one of the number of color components included in each group (first color group and second color group) is greater than one. What should I do?

<Process 2 (Step S4)>
In the process 1 described above (step S3), the arrangement can be determined so that dot overlap does not occur. However, in the area where the number of dot shots is small (highlight area), the number of yellow dot shots is small. Further, since the yellow dots have low visibility, the image looks as if the dots are missing, and the graininess deteriorates. Therefore, in the following, processing for preventing the appearance of graininess deterioration due to missing yellow dots is performed.

  Hereinafter, details of the processing in step S4 will be described with reference to FIG. The internal configuration of FIG. 8B is the same as that of FIG.

  First, binarization (quantized values 0, 255) is performed on data of three dot planes of magenta, red, and yellow (each plane takes a value of 0 to 255). In that case, the first quantization unit 601 first receives Gr2_data (data I_y of the corresponding pixel of the yellow dot plane). Then, error diffusion processing is performed on the input Gr2_data, and binarization (quantized values 0, 255) is performed.

  More specifically, first, in step S301, Gr2_data (pixel data I_y corresponding to the yellow dot plane) is input to the first quantization unit 601. Here, I_y is calculated as follows.

I_y = Gr2_data (49)
In step S302, the accumulated error adding unit 605 reads the error E_mry (x) corresponding to the horizontal pixel position x of the target pixel from the accumulated error line buffer 604 and adds it. That is, if the input total data is I_y and the data after adding the cumulative error is I_y ′,
I_y ′ = I_y + E_mry (x) (50)
It becomes.

Next, in step S303, the threshold selection unit 606 selects a threshold T_y. The threshold T_y is, for example,
T_y (I_y) = 128 (0 ≦ I_y ≦ 255) (51)
Is set. Alternatively, in order to avoid dot generation delay, the threshold value T_y may be finely changed according to the input pixel data I_y so that the average quantization error is reduced.

  Next, in step S304, the quantization unit 607 compares the pixel data I_y ′ after the error addition and the threshold value T (I_y) to determine the output pixel value Out_y. The rules are as follows:

Out_y = 0 (51)
(0 ≦ I_y ≦ 255, I_y ′ <T (I_y))
Out_y = 255 (52)
(0 ≦ I_y ≦ 255, I_y ′ ≧ T (I_y))
Out_y = 0... Yellow dot is not hit.
Out_y = 255... Yellow dots are hit.
Next, in step S305, a difference amount Err_mry between the pixel data I_y ′ after the error is added to I_y of the target pixel by the error calculation unit 608 and the output pixel value Out_y is calculated as follows.

Err_mry (x) = I_y′−Out_y (53)
In step S306, the error diffusion unit 609 performs diffusion processing of the error Err_mry (x) in the accumulated error line buffer 604 as follows according to the horizontal pixel position x.

E_mry (x + 1) ← E_mry (x + 1) + Err_mry (x) × 7/16 (x <W)
E_mry (x-1) <-E_mry (x-1) + Err_mry (x) × 3/16 (x> 1)
E_mry (x) ← E_mry0 + Err_mry (x) × 5/16 (1 <x <W)
E_mry (x) ← E_mry0 + Err_mry (x) × 8/16 (x = 1)
E_mry (x) ← E_mry0 + Err_mry (x) × 13/16 (x = W)
E_mry0 ← E_mry × 1/16 (x <W)
E_mry0 ← 0 (x = W)
... (54)
This completes binarization of one pixel of Gr2_data (yellow dot Y ″).

  Next, in the second quantizing unit 602, error diffusion processing is performed on Gr1_data (total data of the pixel values of the target pixel of the two magenta and red dot planes) to obtain ternary values (quantized values 0, 255, and 255). 510).

  First, in step S307, Gr1_data is input to the second quantization unit 602. I_mr is calculated as follows.

I_mr = Gr1_data (55)
The accumulated error line buffer 610 in the second quantization unit 602 in FIG. 8B has the same configuration as the accumulated error line buffer 604. That is, as shown in FIG. 13B, the cumulative error line buffer 610 has one storage area E_mr0 and the same number of storage areas E_mr (x) (x = 1 to W) as the number of horizontal pixels W of the input image. The quantization error is stored by a method described later. Note that the accumulated error line buffer 610 may be initialized with an initial value of 0 before starting the process, or may be initialized with a random value.

Next, in step S308, the accumulated error adder 611 adds an error E_mr (x) corresponding to the horizontal pixel position x of the target pixel. That is, if the total value of the input pixels of interest is I_mr and the data after accumulated error addition is I_mr ′,
I_mr ′ = I_mr + E_mr (x) (56)
It becomes.

Next, in step S309, the threshold selection unit 606 selects a threshold T_mry. The threshold T_mry is, for example, according to the input pixel data I_mry,
T_mr (I_mr) = 128 (0 ≦ I_mr ≦ 255) (57)
T_mr (I_mr) = 384 (255 <I_mr ≦ 510) (58)
Is set. Alternatively, in order to avoid dot generation delay, the threshold T_mr may be finely changed according to the input pixel data I_mr so that the average quantization error is reduced.

  Next, in step S310, the quantization unit 607 compares the pixel data I_mr 'after the error addition and the threshold value T (I_mr) to determine the output pixel value Out_mr. The rules are as follows:

Out_mr = 0 (59)
(0 ≦ I_mr ≦ 255, I_mr ′ <T (I_mr))
Out_mr = 255 (60)
(0 ≦ I_mr ≦ 255, I_mr ′ ≧ T (I_mr)) or
(255 <I_mr ≦ 510, I_mr ′ <T (I_mr))
Out_mr = 510 (61)
(255 ≦ I_mr ≦ 510, I_mr ′ ≧ T (I_mr)) or
(510 <I_mr ≦ 765, I_mr ′ <T (I_mr))

Here, the meaning of ternarization (I_mr ′) of Gr1_data (total data of two dot planes of magenta and red) will be described. For example, Out_mr = 255 means that one dot of magenta or red is hit at that place. In other words, Out_mr = 255 does not determine a magenta dot at that location, and does not determine a red dot. What is fixed at this point is that it is not known which dot, magenta or red, will be hit, but at least one will be hit.

  Further, Out_mr = 510 means that two dots of either magenta or red are hit at the place. This means that both magenta and red are hit on the premise that only one dot can be hit at most.

  The above is summarized as follows.

Out_mr = 0 ... Neither magenta nor red dot is hit.
Out_mr = 255 One of magenta and red dots is hit.
Out_mr = 510... Magenta and red dots are hit.

  In step S311, the error calculation unit 614 calculates a difference amount Err_mr between the pixel data I_mr ′ after the error addition to the target pixel I_mr and the output pixel value Out_mr by the following equation (62).

Err_mr (x) = I_mr′−Out_mr (62)
In step S312, similarly to the error diffusion unit 609, the error diffusion unit 615 diffuses the error Err_mr (x) using the accumulated error line buffer 610 according to the horizontal pixel position x of the target pixel as follows.

E_mr (x + 1) ← E_mr (x + 1) + Err_mr (x) × 7/16 (x <W)
E_mr (x−1) ← E_lm (x−1) + Err_lm (x) × 3/16 (x> 1)
E_mr (x) ← E_mr0 + Err_mr (x) × 5/16 (1 <x <W)
E_mr (x) ← E_mr0 + Err_mr (x) × 8/16 (x = 1)
E_mr (x) ← E_mr0 + Err_mr (x) × 13/16 (x = W)
E_mr0 ← E_mr × 1/16 (x <W)
E_mr0 ← 0 (x = W)
... (63)
As described above, ternarization (quantized values 0, 255, 510) is completed for Gr1_data (total data of two planes of magenta, red dot, M ″, and R ′) for one pixel.

  Although ternarization of Gr1_data (total data of two dot planes of magenta and red dots) does not know which dot of the two dot planes will be hit, at least two planes in total ensure a more favorable arrangement. There is a purpose.

  Next, error diffusion processing is performed on Gr1_1data (plane data of magenta dots) to perform binarization. First, in step S 313, the magenta dot target pixel data I_m is input to the third quantization unit 603. I_m is calculated as follows.

I_m = Gr1_1data (64)
The accumulated error line buffer 616 in the third quantization unit 603 in FIG. 8B has the same configuration as the accumulated error line buffer 604. That is, as shown in FIG. 13C, the cumulative error line buffer 616 has one storage area E_m0 and the same number of storage areas E_m (x) (x = 1 to W) as the number of horizontal pixels W of the input image. The quantization error is stored by a method described later. Note that the accumulated error line buffer 616 may be initialized with an initial value of 0 before starting the process, or may be initialized with a random value.

Next, in step S314, the error E_m (x) corresponding to the horizontal pixel position x of the input pixel data is added by the cumulative error addition unit 617. That is, if the input pixel-of-interest data is I_m, and the data after adding the cumulative error is I_m ′,
I_m ′ = I_m + E_m (x) (65)
It becomes.

Next, in step S315, the threshold selection unit 618 selects a threshold T_m. In the selection of the threshold T_m, for example,
t_m = I_mr-I_m (66A)
The threshold T_m is
T_m (t_m) = 128 (0 ≦ t_m ≦ 255) (66B)
Is set. Alternatively, in order to avoid dot generation delay, the threshold value T_m may be finely changed according to t_m so that the average quantization error becomes small. Since I_mr-I_m is 255 or less, T_m (t_mr) = 128 is always used in this embodiment.

  Next, in step S316, the quantization unit 619 compares the pixel data I_m ′ after the error addition, the threshold T_m (t_m), and Out_mr (quantized values 0, 255, 510). Out_mr (quantized value 0, 255, 510) is a multi-valued result of the aforementioned Gr1_data (total data of two dot planes of magenta and red). Then, the final binarization result Out_r of Gr1_2 data (red dot) and the final binarization result Out_m of Gr1_2 data (magenta dot) are determined. The rules are as follows:

When Out_mr-I_m ′ ≧ T (t_m), (67)
Out_m = Out_mr-255 (68)
Out_r = 255 (69)
When Out_mr-I_m ′ <T (t_m) (70)
Out_m = Out_mr (71)
Out_r = 0 (72)
For example, when Out_mr = 510, since Out_mr−I_m ′ ≧ T (t_m), the condition of Expression (69) is satisfied and Out_m = 255. Therefore, the binarization of the red plane data Out_r is determined at the same time as the binarization of the magenta plane data Out_m is determined by the equations (67) to (72). That is, the final red dot result Out_r and the final magenta dot result Out_m are determined simultaneously. Equation (69) means that a red dot is hit, and equation (72) means that a red dot is not hit.

  Next, in step S317, the error calculation unit 620 calculates the difference amount Err_m between the pixel data I_m ′ after the error addition to the target pixel I_m and the output pixel value Out_m as follows.

Err_m (x) = I_m′−Out_m (73)
Next, in step S318, the error diffusion unit 621 diffuses the error in the same manner as the error calculation units 608 and 615. That is, using the accumulated error line buffer 616, the error Err_m (x) is diffused as follows according to the horizontal pixel position x.

E_m (x + 1) ← E_m (x + 1) + Err_m (x) × 7/16 (x <W)
E_m (x-1) <-E_m (x-1) + Err_m (x) * 3/16 (x> 1)
E_m (x) ← E_m0 + Err_m (x) × 5/16 (1 <x <W)
E_m (x) ← E_m0 + Err_m (x) × 8/16 (x = 1)
E_m (x) ← E_m0 + Err_m (x) × 13/16 (x = W)
E_m0 ← E_m × 1/16 (x <W)
E_m0 ← 0 (x = W)
... (74)
This completes binarization (quantization values 0, 255) for Gr1_1 data (magenta dot plane data M ″) for one pixel. At the same time, binarization of Gr1_2 data (red dot plane data R ′) ( Quantization value 0, 255) The result is also determined.

  In other words, the binarization of Gr1_1 data (magenta plane data) has the purpose of ensuring a more favorable arrangement with respect to Gr1_1 data. Then, the binarization result of Gr1_2 data (red dot) is determined as the remaining arrangement of the arrangement secured for Gr1_1 data. That is, Gr1_1data (magenta dot) with a relatively high priority is arranged more suitably, and Gr1_2data (red dot) with a relatively low priority is arranged after Gr1_1data (magenta dot) is arranged. It is arranged at the remaining position. In other words, it is possible to obtain a visually good image by arranging magenta dots that are visually conspicuous as compared with red dots at a more suitable position.

  In summary, in the process of step S4, first, error diffusion processing is performed independently on Gr2_data, and then control is performed so that the dots of Gr1_1data and Gr1_2data do not overlap.

  By executing the process using the grouping described in step S3 (process 1) and step S4 (process 2), it is possible to reduce the complexity of the process. In addition, since the arithmetic processing executed by each of the quantization units 601, 602, and 603 is common, the device configuration can be simplified by operating the physically same quantization unit in a time division manner. Moreover, it becomes possible to prevent the deterioration of graininess from becoming obvious by making dots with low density inconspicuous. Therefore, image formation with higher image quality is possible.

  As described above, the image processing apparatus according to the first embodiment can provide a technique that enables image formation with higher image quality while reducing processing complexity.

(Modification)
In the first embodiment, binary data (1 bit) is generated as data to be output to the printer 2. However, multi-value data (for example, 3 bits for each color) may be generated for an inkjet printer that performs multi-dot recording in which the size of ejected ink droplets is variable. That is, data having a value corresponding to the size of the ink droplet may be output.

  In the above description, the image processing is generated by the image processing apparatus 1 outside the printer 2, but a processing circuit for executing the processing may be provided inside the printer. Further, it may be realized by an electronic circuit provided in the recording head.

  The present invention also relates to a recording apparatus such as a so-called full-line type recording apparatus that has a recording head having a length corresponding to the recording width of the recording medium and performs recording by moving the recording medium relative to the recording head. Is also applicable. That is, the present invention can be applied to a recording apparatus that performs recording by moving a recording head relative to a recording medium, other than a serial type recording apparatus (printer).

(Other embodiments)
The present invention can also be achieved by supplying a program that realizes the functions of the above-described embodiments directly or remotely to a system or apparatus, and the system or apparatus reads and executes the supplied program code. The Accordingly, the program code itself installed in the computer in order to realize the functional processing of the present invention by the computer is also included in the technical scope of the present invention.

  In this case, the program may be in any form as long as it has a program function, such as an object code, a program executed by an interpreter, or script data supplied to the OS.

  Examples of the recording medium for supplying the program include a floppy (registered trademark) disk, a hard disk, an optical disk (CD, DVD), a magneto-optical disk, a magnetic tape, a nonvolatile memory card, and a ROM.

  Further, the functions of the above-described embodiments are realized by the computer executing the read program. In addition, based on the instructions of the program, an OS or the like running on the computer performs part or all of the actual processing, and the functions of the above-described embodiments can also be realized by the processing.

  Further, the program read from the recording medium is written in a memory provided in a function expansion board inserted into the computer or a function expansion unit connected to the computer. Thereafter, the CPU of the function expansion board or function expansion unit performs part or all of the actual processing based on the instructions of the program, and the functions of the above-described embodiments are realized by the processing.

1 is a block diagram illustrating a configuration of an image forming system including an image forming apparatus according to a first embodiment. 2 is a diagram illustrating a configuration example of a recording head 201 mounted on a printer 2. FIG. It is an operation | movement flowchart of the image processing apparatus 1 of 1st Embodiment. 6 is a diagram illustrating a configuration example of each color plane 61 and binary image data 62 input to a halftone processing unit 105. FIG. 2 is a diagram illustrating a configuration of a color separation processing unit 103 in the image processing apparatus 1. FIG. FIG. 6 is a diagram illustrating an example of a spot color ink separation processing LUT. 6 is an operation flowchart of the halftone processing unit 105. 6 is a functional block diagram illustrating details of an operation of a halftone processing unit 105. FIG. FIG. 10 is a diagram illustrating an example in which three planes M ″, R ′, and Y ″ are grouped into two groups. It is a figure which shows the example which groups 7 planes of CMYKRGB into five groups. It is a detailed flowchart of the process (process 1) of step S3. It is a figure explaining the error diffusion coefficient around the pixel of interest in error diffusion processing. It is a figure which shows the data stored in an accumulation error line buffer. It is a detailed flowchart of the process (process 2) of step S4.

Claims (5)

Generates n 2 gradation data from n i gradation (i is a positive integer of 2 or more) data corresponding to each of n (n is a positive integer of 2 or more) color components constituting the image data. An image processing apparatus that
Each pixel of the data expressed by the total value of each pixel of the n number of i gradation data is converted into a quantization value of n + 1 gradation by error diffusion processing, and the nth gradation data corresponding to the total of n + 1 gradation data. First quantized data generating means for generating one quantized data;
The n color components are classified into the first color group including k colors (positive integers of k <n) having relatively high visibility and nk colors having relatively low visibility. Each pixel of data represented by a total value of each pixel of nk i gradation data corresponding to the second color group, and the first quantum The data represented by the difference between each pixel of the quantized data is converted into k + 1 gradation quantized values by error diffusion processing, and corresponds to k total k + 1 gradation data corresponding to the first color group. Second quantized data generating means for generating second quantized data;
The data expressed by the difference amount between each pixel of the first quantized data and each pixel of the second quantized data is a third corresponding to the nk total corresponding to the second color group. Third quantized data generating means for generating as quantized data of
When at least one of k or nk is greater than 1, the first quantized data generating means and the second quantizing for at least one of the first color group or the second color group Control means for controlling to generate the n number of two gradation data by recursively executing the data generation means and the third quantized data generation means;
An image processing apparatus comprising: The control means further includes
Each pixel of quantized data generated from each pixel of data represented by the total value of each pixel of k i gradation data corresponding to the first color group and the third quantized data generating means The data expressed by the difference amount from the third quantized data generated by the step is distributed to each pixel of the data expressed by the total value of the pixels used by the second quantized data generating means. The image processing apparatus according to claim 1, wherein the image processing apparatus is reflected. Generates n 2 gradation data from n i gradation (i is a positive integer of 2 or more) data corresponding to each of n (n is a positive integer of 2 or more) color components constituting the image data. An image processing method for
Each pixel of the data expressed by the total value of each pixel of the n number of i gradation data is converted into a quantized value of n + 1 gradation by error diffusion processing, and the nth gradation data corresponding to the total of n + 1 gradation data. A first quantized data generating step for generating one quantized data;
The n color components are classified into the first color group including k colors (positive integers of k <n) having relatively high visibility and nk colors having relatively low visibility. Each pixel of data represented by a total value of each pixel of n−k i gradation data corresponding to the second color group, and the first quantum The data expressed by the difference between each pixel of the quantized data is converted into k + 1 gradation quantized values by error diffusion processing, and corresponds to k total k + 1 gradation data corresponding to the first color group. A second quantized data generating step for generating second quantized data;
The data expressed by the difference amount between each pixel of the first quantized data and each pixel of the second quantized data is a third corresponding to the nk total corresponding to the second color group. A third quantized data generating step for generating the quantized data of
When at least one of k or nk is greater than 1, the first quantized data generation step, the second quantization for at least one of the first color group or the second color group A control step of controlling to generate the n number of two gradation data by recursively executing a data generation step and the third quantized data generation step;
An image processing method comprising:   A program for causing a computer to execute the image processing method according to claim 3.   An inkjet recording apparatus that records the n number of two gradation data generated by the image processing method according to claim 2 in correspondence with on / off of ink ejection.

Images