KR100279594B1 - How to enlarge and reduce binary image - Google Patents

Abstract

The present invention relates to a technology for enlarging or reducing binary images represented by 0s and 1s after a halftone process in an image processor such as a facsimile or printer, in order to improve image processing speed and reduce costs. Find the scale table S (x) = [X ^* (L _out / L _in )] and the table values T (x) = S (x + 1) -S (x), respectively. A table calculation process of deleting data lines, outputting them as they are, or outputting them twice; The mask sequence includes determining a mask output mask_out = (MASK1 & pre_data) | (MASK2 & data) using the mask values MASK1 and MASK2 in which the bit strings are symmetrically fixed to each other.

Description

How to enlarge and reduce binary image

The present invention relates to a technique for enlarging or reducing binary images represented by 0s and 1s after a halftone process in an image processor such as a facsimile or a printer. In particular, it is easy to implement hardware and improve processing speed. The present invention relates to a method for enlarging and reducing a binary image in which a calculation for zooming in / out is performed in parallel when calculating a table value for a zoom-out position.

In general, an image processor converts an image expressed in gray levels into a binary image having digital values of 0 and 1, in order to output image data. When outputting an image represented by binary data, it may be necessary to reduce the size of the print paper to suit the output environment such as the size of the print paper or the print resolution.

To this end, the Run-Length Scaling method according to the prior art that enlarges or reduces while maintaining the information of the binary image to the maximum is as follows.

The pattern correspondence method and the error diffusion method are not efficient in facsimile processing with MH, MR, and MMR because the size of the output image is converted by using the data decoded by bitmap (BITMAP). Therefore, after performing horizontal resolution conversion using run length data inevitably generated during decoding and processing, vertical resolution conversion is performed to improve processing speed.

First, the horizontal correspondence conversion process will be described.

Run-length data is obtained from the data encoded by MH, MR, and MMR, and then scaled before conversion to bitmap. At this time, a fast speed can be obtained using a previously created scale table, and the scale table is created by using Equation 1 below.

Equation 1

Where x = 1,2, ..........., L _in

Lin is the number of pixels in the input line, Lout is the number of pixels in the output line, and [x] is the maximum integer not exceeding x. If the input run length sequence is {P _n } and the output run length sequence is {R _n }, the following relationship is established between P _n and R _n .

[Equation 2]

Where n = 1,2, ..........., N _in

Where N _in is the size of the input run length sequence. This scaling works the same as removing or copying points at a certain rate.

For example, consider the case of Lin = 5 and Lout = 7. S (0) to S (5) in turn have values of 0,1,2,4,5,7. Here, the difference between S (3) and S (2), S (5) and S (4) is 2, which means that the third and fifth pixels of the input line are copied.

In the case of Lin = 7 and Lout = 5, S (0) to S (7) have values of 0,0,1,2,2,3,4,5. Here, the difference between S (1) and S (0), S (4) and S (3) is 0, which means that the first pixel and the fourth pixel of the input line are deleted. However, copying or deleting pixels at a certain position may cause annoying vertical lines, particularly for the halftone image. This phenomenon is more severe as the rate of change approaches 100%. To avoid this, use multiple scale tables with different copy or delete locations. However, it is not preferable to use too many scale tables because of the limitation of the memory size. With four tables, good image quality can be obtained even at about 95% or 100% conversion. Four scale tables are generated as shown in Equation 3 below.

[Equation 3]

However, when the conversion ratio is about 150% or about 67%, S ₀ (x) = S ₂ (x) in Equation (3) above, so three scale tables obtained by Equation (4) below are obtained. Using it will yield better results.

[Equation 4]

Applying the scale table created in this way has little effect on speed, and only needs to allocate memory for the scale table.

By the way, all facsimiles display letters or pictures in black on white paper, and especially in halftone processed images, the number of white and black dots in a certain area and their distribution patterns are not individual points, It will affect your eyes. Therefore, simply maintaining the same ratio of black and white points is not enough.

Experimental results show that the reduced image is faint than the original image because the size of the black dot is larger than the size of the white dot in the actual printed output image. In the case of 50% reduction in which a 4 × 4 matrix is converted into a 2 × 2 matrix, an odd-numbered line is deleted from an odd-numbered pixel, and an even-numbered line is deleted from an even-numbered pixel. Is converted as in FIG.

The ratio of the number of black points to the total number of points is equal to 0.5 for both the original image and the reduced image, but the ratio of the black area to the total area is different. This is because, in a laser printer or an inkjet printer, the shape of the actual black spot is closer to the circular shape larger than the pixels displayed in the square as shown in FIG. If the length of one side of the square is a and the diameter of the circle is √2a, the ratio of the black area in the circle image is calculated as follows.

In addition, the ratio of the black area in the reduced image is calculated as follows.

As a result, it can be seen that the reduced image is brighter than the original image as in the above calculation result. Of course, this difference depends on the distribution pattern of the black dots, and in some cases, the reduced image may be darker.

To compensate for this, you can achieve darker results by applying a method that protects black spots when scaling. That is, if the value of R _n corresponding to black is 0, the left point is changed to black, thereby protecting the black point. In the case of reduction, emphasizing the point gave a better feeling.

Now let's take the case of 150% magnification, where a 2x2 matrix is transformed into a 3x3 matrix. In this case, odd-numbered lines are copied to odd-numbered pixels, even-numbered lines are copied to even-numbered pixels, and according to vertical conversion, which will be described later, as shown in FIG. 2.

As in the case of the reduction, the ratio of the black area of the original image is 0.57, but the ratio of the black area of the enlarged image is calculated as follows.

Accordingly, it can be seen that the enlarged image is darker than the original image as opposed to the case of the reduced image. Of course, this difference depends on the distribution pattern of the black dots, and the magnified image is usually brighter.

To correct this, emphasize white points rather than black ones for cleaner results. That is, the value of P _n corresponding to the black dots is smaller than the threshold value (32 in the experiment), the value of R _n can be obtained such an effect by one the value of R is greater than the _n decreasing P _n. Experimental results show that in the case of magnification, emphasizing the white point gives a cleaner feeling.

Meanwhile, the vertical resolution conversion process will be described.

The vertical resolution conversion is done through proper filtering using the bitmap obtained from the horizontal resolution conversion. In this case, the data is in bitmap format after the horizontal resolution conversion. Can be. In this example, two lines are used to improve the speed, and they are expressed in C as follows.

[Equation 5]

New_line = (Upper_line & Mask1) | (Lower_line &Mask2);

Here, New_line, Upper_line, and Lower_line are variables of unsigned int type, and Mask1 and Mask2 are appropriate values with possible irregularities satisfying the following Equation (6).

[Equation 6]

(Mask1 | Mask2) = OxFFFFFFFF

The value of Mask1 and Mask2 does not have much influence on the text image, but the value of mask has a big influence on the picture image processed by halftone because the distribution pattern of black dots is important. Experimental results showed that Ox6B3696D9 and Ox96D96B36 showed relatively good characteristics, and Ox5555555 and OxAAAAAAAA showed good results because the original image itself had irregular characteristics for halftone images processed by error diffusion, but it was treated by dithering. The results were quite bad for the halftone image.

The reason for satisfying Equation (6) is to make a complete black line from two black lines, and because the black point is printed in black on white paper, the black point is more important than the white point. The number of bits to have is slightly more than the bit with a value of zero. The number of bits having a value of 1 of Ox6B3696D9 is 18 and the number of bits having a value of 0 is 14.

In order to reduce regularity and obtain better results than the method of Equation 5, the table can be used as follows.

[Equation 7]

New_line = Mask_table1 [Upper_line] ｜ Mask_table2 [Lower_line];

Here, New_line, Upper_line, and Lower_line are variables of unsigned char type in consideration of the table size, and Mask_table1 [] and Mask_table2 [] are particularly arranged to correspond to the halftone pattern. In other words, for small values (OxOF, OxEO, OxFF) with small changes of 1 and 0, the values in the table should be determined so that the black dot distribution pattern is similar, and for larger values (Ox54, OxAB, etc.) Since it is most likely to be a picture, determine the values in the table so that the black dot distribution pattern becomes irregular. Of course, even in this case, the following Equation 8 should be satisfied, and the experimental results showed that the method showed the best characteristics.

[Equation 8]

Mask_table1 [OxFF] ｜ Mask_table2 [OxFF]

In the case of zooming in, a new new line is inserted between two lines. In case of zooming out, new lines are printed instead of two lines. The position to insert or delete is determined as follows.

If the ratio of the number of input lines to the number of output lines is x: y (where x and y are natural numbers), the vertical conversion table V _n is generated through a predetermined algorithm regardless of the reduction and enlargement. Here, x and y are natural numbers, so L and S cannot be zero. In the scale table for horizontal transformation, deletion or insertion is performed when S (n) -S (n-1) ≠ 1, and when V _n = 0, insertion is performed when zooming in or zooming out when V _n = 0.

Let the input line counter currently being processed i be the j, and the output line counter be j. First of all, when the zooming is performed, the case where V _{[(j-1) mod L]} is 0 is the position to insert, so (i-1) Outputs a new line consisting of the first and ith lines, increments the output line counter by one, and does not increment the input line counter. In case of reduction, since V _{[(i-1) mod L]} is 0, it is the position to delete, so make a new line using the i-th line and (i + 1) th line to replace the (i + 1) th line. It increments only one input line counter without increasing the output line counter. This method is applicable to conversions below 50% but above 200%.

However, in the conventional binary image enlargement and reduction method, since a mask table must be made before image processing for enlargement or reduction, image processing speed is slowed accordingly, and a large amount of memory is used for image processing. Because of this, there is a defect that the cost is increased by this.

Therefore, the technical problem to be achieved by the present invention is to calculate a table for which position to enlarge or reduce the binary image using the Gauss (Gauss) function, and to calculate the enlargement and reduction in parallel with the table creation The present invention provides a method of enlarging and reducing binary images.

1 is an exemplary diagram of 50% reduction of an image according to the prior art.

Figure 2 is an exemplary view of 150% magnification of the image according to the prior art.

3 is an exemplary view of using a mask according to the prior art.

4 is a signal flowchart of a method of enlarging and reducing a binary image according to the present invention.

5 is an exemplary calculation diagram of an enlargement and reduction table according to the present invention.

6 is an exemplary mask use according to the present invention.

7 is a mask output example table according to the present invention.

8 (a) is the original image, (b) is a 1.5 times magnified image according to the present invention.

In order to achieve the object of the present invention, a method of enlarging and reducing the binary image of the present invention includes a scale table S (x) = [X ^* (L _out / L _in )], and a table value T (x) = S (x + 1). A table calculation step of obtaining each of S-x and deleting the corresponding pixel data line, outputting it as it is, or outputting twice according to the T (x); The mask output mask_out = (MASK1 & pre_data) | (MARK2 & data) includes a process of using a mask, which will be described in detail with reference to FIGS. 4 to 8 attached to the operation of the present invention.

When zooming in or out of a binary image, a table of where to zoom in and out is created by using a Gaussian function, and in parallel, an algorithm for implementing zoom in and zoom out is implemented. When calculating a table using the Gaussian function, the following equation (9) is used.

[Equation 9]

S (x) = [X ^* (L _out / L _in )]

In Equation (9), L _out is the number of output lines, and L _in is the number of input lines. Therefore, the value of L _out / L _in is a value (Scale) that determines the expansion and contraction. X is a variable that varies from 0 to the number of input lines.

After obtaining S (x) in Equation (9), the table is obtained as S (x + 1) -S (x). If the calculated table value is T (x), T (x) has a value of 1 or 2 when the magnification is 2 times or less, and T (x) is 0 when the magnification is 1/2 or more times. Or a value of 1.

If the result value is 0 and the table value is 0, the corresponding pixel or line is deleted. If the value is 1, the pixel or line is output as it is. If the value is 2, the method is output twice. Calculate zoom in, zoom out.

If you calculate a table about where to zoom in or out by using a Gaussian function and then subtract to calculate the table, each line requires a certain amount of time and memory for storing table values. To solve this problem, the integer value is set as the upper bit, the value below the decimal point is assigned as the lower bit, the integer value is used as a table, the addition operation is performed again with the remaining value, and the integer part (high bit) of the result value Is used as a table value. Calculating in this way can produce the same result as the table value calculated by the conventional method.

5 shows an example of calculating a table according to the present invention when the scale is 1.66.

The calculation as described above is not only easy to implement, but also the corresponding table value can be calculated for each pixel value, thereby facilitating real-time implementation. Each bit of the scale or the remainder is easily implemented in hardware by allocating an appropriate number of bits according to the resolution of scaling up and down.

Meanwhile, a method of using a mask for a simple design proposed by the present invention will be described.

If the previous data in the buffer is called pre_data, the output is determined by Equation 10 below.

[Equation 10]

mask_out = (MASK1 & pre_data) ｜ (MASK2 & data)

If the mask is designed in this way, the design can be implemented using only one pixel buffer corresponding to pre_data, which enables simple hardware design. The masks MASK1 and MASK2 at this time are designed using the following fixed values.

MASK1: 0x55555555 (Bin: 01010101010101010101010101010101)

MASK2: 0xAAAAAAAA (Bin: 10101010101010101010101010101010)

If these masks (MASK1) and (MASK2) are used, in the actual implementation, the mask data of "0" and "1" may be used alternately, thus modifying the existing design that used the mask in the horizontal direction and masking in the vertical direction. It is possible to apply. The reason for applying the mask is to prevent the same pattern, so the horizontal mask and the vertical mask have the same effect.

As shown in FIG. 6, since the mask is changed for each line, a pattern generated by overlapping lines can be prevented. In this case, when the table value is 2 according to the table value, the enlargement and reduction in the vertical direction is processed again while the mask is changed to remove the overlap pattern for the same line.

For example, data = 0001111

mask = 0101010

, The output appears as shown in FIG.

That is, when the table value is 1, the input data is output as it is, and when the table value is 2, the previous pixel value and the respective mask result are output, and then the current pixel is enlarged. In the case of the reduction, the pixel value to be deleted and the next pixel value are masked and reduced.

For reference, FIG. 8 (a) shows the original image (ED, 256 × 256), and FIG. 8 (b) shows the original image magnified 1.5 times by the present invention.

As described in detail above, the present invention uses a Gaussian function to calculate a table at which position to enlarge or reduce the binary image, and to perform the enlargement and reduction calculation in parallel with the table creation. Is improved and the cost is reduced.

Claims (3)

In the binary image reduction and enlargement method in which the halftone process is performed, the scale table S (x) and the table value T (x) are obtained by the following equation, and the corresponding pixel data line is deleted according to the T (x). A table calculation process of outputting the data as it is, or outputting it twice; A magnification of a binary image comprising a mask use process of determining a mask output (mask_out) using the masks MASK1 and MASK2 having bit values symmetrical and fixed to each other, How to shrink. S (x) = [x ^* (L _out / L _in )] T (x) = S (x + 1) -S (x) mask_out = (MASK1 & pre_data) ｜ (MASK2 & data) Where L _out : Number of output lines L _in : Number of input lines X ^* : integer pre_data: previous data The method of claim 1, wherein the table calculation process uses an integer value as an upper bit, a value below the decimal point as a lower bit, and uses an integer value as a table, and adds to the remaining values to perform an integer part. And using a table as a table value. The method of claim 1, wherein the mask use process comprises outputting the input data as it is when the table value is 1, and outputting the current pixel after outputting the previous pixel value and the respective mask result when the table value is 2. A method of enlarging or reducing a binary image.

Images