JPH09259288A - Polygonal approximation device for pixel array - Google Patents

Abstract

PROBLEM TO BE SOLVED: To shorten a processing time by determining the pixel right before an end point as the end point and generating a thinned-out vector when it is decided that the addition value of code distances exceeds a permissible error. SOLUTION: A comparison part 20 decides whether or not the addition value of code distances calculated by an addition part 18 is less than the permissible error as to each pixel from a start point to an end point. When it is decided that the addition values of the code distances are all less than the permissible error, an affix number setting part 22 increases the affix number of the end point to obtain a next pixel, and resets a comparison point to obtain a pixel right after the start point; when the permissible error is exceeded, a process for resetting the affix number is performed to set a start point and an end, point newly. Further, a thinned-out vector generation pat 24 determines the pixel right before the end point as an end point ad generates a thinned-out vector when the comparison part 20 decides that the addition value exceeds the permissible error.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention is applied to a polygonal line approximation device for a pixel column, and more particularly, to a polygonal line approximation vector composed of one or more thinned-out vectors from a two-dimensional pixel column described by a chain code sequence. The present invention relates to a broken line approximation device for a pixel column.

[0002]

2. Description of the Related Art Generally, for example, the contour of a binary image is
In the case of defining by the value pixel row, in order to reduce the data amount, pixels are thinned out within an allowable range and the binary pixel row is approximated to a broken line thinning vector row.
As described above, as a main method of creating the polygonal line approximation vector composed of the thinning vector from the binary pixel array, there are the division / synthesis method and the tracking method.

In the division / synthesis method, a rough approximation (such as connecting a start point pixel and an end point pixel) is first performed on a binary pixel string, and a pixel string that is sequentially approximated is divided or combined within a range satisfying an allowable error. However, this is a method of obtaining vector data with a required approximation accuracy. The tracking method is a method of sequentially vectorizing pixels within a range satisfying a required approximation accuracy from a start point.

In both of the above two methods, minimax evaluation and least squares evaluation are used as error evaluation methods.

The minimax evaluation means, as shown in FIG. 8, a start point is determined and an arbitrary end point is predicted in a binary pixel array composed of a plurality of elements (pixels) Pi.
For the approximate line L connecting these starting point and the expected end point, 2
The Euclidean distance Ei from each element Pi of the value pixel array to this approximation line L is calculated, and evaluation is made based on whether or not the distance Ei exceeds an allowable value ε, and the longest approximation obtained within a range not exceeding ε. This is a method of using the straight line L as one thinning vector.

On the other hand, the least-squares evaluation means that the sum of squared errors {Σ (Ei ² )} ^1/2 between the approximation line L and the binary pixel array, which corresponds to the area | S | shown in FIG. In this method, the evaluation is performed under the condition that the allowable value ε is not exceeded, and the longest straight line L at that time is similarly used as the thinning vector.

The outline of the current method for creating the polygonal line approximation vector has been described above. However, whichever method is adopted, the distance Ei between the approximation line L and the element Pi can be obtained at high speed. Needed. Then, this distance calculation is generally performed in the process of creating the polygonal line approximation vector by the thinning-out method performed according to the flowchart of FIG.

The thinning process will be described below. First, the symbols used will be described. Here, for the sake of convenience, the vector is represented by capital letters of the alphabet.

Vi = (x1i, x2i), (i = 1, 2, ..., N) (1)

Here, Vi represents a two-dimensional vector coordinate sequence defined by real numbers x1i and x2i, and i is a subscript representing a data number, which is a natural number from 1 to n.

Ε: Maximum error of the thinned-out vector sequence with respect to the original vector sequence, which is a positive real number.

‖‖; Euclidean norm (distance) For example, for vector A, ‖A‖ = (A, A) ^1/2 .

(,); Vector inner product P; start point expressed in vector Q; end point expressed in vector R; comparison point expressed in vector

[0014]

[Equation 1]

P = (p1, p2); component display of point P Q = (q1, p2); component display of point Q R = (r1, r2); component display of point R

First, the indices i, j, and k used in the subsequent iterative calculation are set to i = 1, j = 1, and k = 2 in order to set initial values for starting the thinning-out process of the vector sequence. (Step S31). At this time, the start point P, the comparison point R, and the end point Q set in step S32 are the first three points V1, V2, and V3 of the vector sequence.

Next, as shown in FIG. 11, the foot of the perpendicular line drawn from the comparison point R to the line segment PQ (corresponding to the approximate line L) is defined as a vector S, and at this time, RS is calculated by the following equation (2). The distance ‖R-S‖ is calculated, and this distance is
Whether or not it is within the range (steps S33, S3)
4).

[0018]

[Equation 2]

When the distance ‖R-S‖ is within the allowable range in step S34, the index j is incremented by one to advance the comparison point by one (step S35). At this time, if the index j and the index k satisfy the relationship of j <k,
The comparison can be performed again by this j, and the process returns to step S32 to reset the comparison point R (step S32).
36). This is the starting point P that is the reference in FIG.
(= Vi) and the end point Q (= Vi + K) are left as they are, and only the comparison point R (= Vi + J) between them is advanced by one. In this case, the distance between the RSs can be calculated in exactly the same manner as above by using the above-mentioned equation (2), and this operation is performed by determining whether the distance ‖R-S | Alternatively, the process is repeated until the index j is equal to the index k.

Here, if j is incremented by 1 in step S35, and if it matches k in step S36,
That is, if the comparison point R matches the end point Q, step S3
In step 7, k ← k + 1, and the vector Vi + which is a candidate for the end point
Extend k by one. As a result, when Vi + k exceeds the final point of the target binary pixel array, that is, when i + k exceeds the total number of data n (step S38), Vi + k-1. Is registered as the final point, and the process ends (step S39).

On the other hand, when Vi + k is within the target pixel column, j is returned to 1 (step S40) and step S32 is performed in order to perform the thinning-out processing similar to the above.
Then, the start point P, the end point Q and the comparison point R are reset.

If the distance between the comparison point R and the approximate line L exceeds the allowable error ε in step S34, the point vector Vi + k-1 immediately before is added to the thinning vector sequence. (Step S41), this point is registered as the start point of the next thinned-out vector sequence, this is set as the value of i + k that is the next point of the registered point, and j and k are also returned to the initial values 1 and 2, respectively. (Steps S42 and 43), in the next step S44, it is determined whether or not i + k at that time exceeds the total number n of data, and if it does not exceed n, the addition of i, j, and k at that time is performed. Using a number, the step S
Returning to 32, the start point P, the comparison point R, and the end point Q are set respectively, and the same processing is repeated.

If i + k exceeds n in step S44, the point vector Vi + k-1 immediately before is registered as the final point of the thinned-out vector sequence in the same manner as described above, and the processing is executed. It ends (step S39).

By performing the processes of steps S31 to S43 described in detail above, the most efficient thinning-out vector sequence whose deviation from the original binary pixel sequence does not exceed the allowable error ε can be sequentially determined. .

As a result, it becomes possible to obtain a polygonal line approximation vector composed of thinned-out vectors L1, L2, and L3 whose maximum error is within ± ε, as shown in FIG.

[0026]

However, in order to obtain the polygonal line approximation vector by the above-mentioned conventional method, every time the end point Q is extended, a straight line is drawn with respect to the comparison point R between P and Q. Since the process of calculating the distance from the PQ has to be repeated, the amount of calculation becomes enormous and the processing time is too long.

The present invention has been made to solve the above-mentioned conventional problems, and dramatically reduces the calculation amount when generating a polygonal line approximation vector for a binary pixel array, and significantly reduces the processing time. It is an object of the present invention to provide a polygonal line approximation device for a pixel column capable of performing the above.

[0028]

SUMMARY OF THE INVENTION The present invention relates to a pixel line polygonal line approximation device for generating a polygonal line approximation vector composed of thinned-out vectors created by thinning out pixels within a permissible error from a binary pixel column. A means for storing data in which a pixel string is described by a chain code string, a means for setting a start point and an end point of a thinning vector within a range of a binary pixel row, and a line segment that connects the set start point and end point Means for calculating the code distance from the line segment when the line segment of the inclination angle is made to coincide with the center of the target pixel to each center of the eight pixels in the vicinity of the target pixel corresponding to each code, and the pixel from the start point to the end point A means for sequentially adding corresponding code distances according to each code value describing the column, a means for determining whether or not the added value of the code distances is within an allowable error for the pixel row from the start point to the end point, When all the added values of the code distances are determined to be within the permissible error, a means for updating the pixel next to the end point to a new end point, and the addition value of the code distance is determined to exceed the permissible error In addition, the above problem is solved by providing a means for determining a pixel immediately before the end point as the end point and generating a thinning vector.

[0029]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS As a result of various studies, the present inventors have made direct distance calculation for individual comparison points when describing a point sequence (binary pixel sequence) before thinning out by a chain code sequence. We have found that it is possible to efficiently generate a thinned-out vector sequence while omitting it.

Here, the chain code is a code number used when describing a binary pixel array such as the contour of a binary image, which was devised by Freeman.
As shown in FIG. 1, considering 9 pixels of 3 × 3, the shaded center pixel is assigned to the pixel of interest, and the next pixel connected to this pixel of interest is located in the 8 neighboring coordinates around the center pixel. For example, it is a number from 1 to 8 for defining the position and the direction depending on the location.

In this way, when the code of the next pixel is fixed, the pixel of interest is moved to the fixed pixel, and similarly, the operation of fixing the code of the next pixel is repeated, so that the binary pixel rows 1 to 8 are selected. It can be described by a code string consisting of numbers. Therefore, it is possible to register the first first point, and describe the pixel row with a row of numbers 1 to 8 from the second point, for example, 2, 3, 3 ,. The chain cord may be a clockwise neighborhood system as shown in FIG. 1 or a counterclockwise neighborhood system as shown in FIG.

Now, considering the case of adopting a clockwise neighborhood system as shown in FIG. 1, in the chain code string, the next point is always any of the eight coordinates near the pixel of interest as described above. Therefore, for each code, the distance (hereinafter also referred to as the code distance) is calculated by calculating how close (or distance) the comparison point is from the line segment (approximate line) connecting the start point and the end point. By repeating the process of adding the previously obtained distances for a plurality of comparison points between the start point and the end point of the thinning vector, the distance from the line segment to each comparison point (hereinafter, the actual distance (Also called) can be sequentially obtained.

This will be specifically described as follows. As shown in FIG. 3, a straight line connecting the start point P and the end point Q is moved in parallel, and a line segment that passes through the center of the comparison point (target pixel) R is defined as L ′, and the code numbers near the comparison point R are The code distances, which are the distances between the center point of each pixel indicated by the black dots and the line segment L ', are defined as D1 to D8.

Further, the distance between each pixel in the x direction and the y direction is d
Assuming that x and dy are unit vectors indicating the direction from the start point P of L to the end point Q, (ex, ey), the code distances D1 to D8 are relative coordinates of each pixel in the neighborhood with respect to the neighborhood center in FIG. And a vector representing (ex, ey)
It can be obtained by obtaining the determinant of a 2 × 2 matrix consisting of This is because, as shown in FIG. 4, the value of this determinant is a value obtained by adding a sign to the area of the parallelogram formed by the above two vectors, but since (ex, ey) is a unit vector, Its length is equal to 1, and in the end, the absolute value of the value of the determinant obtained above is equal to the length of the perpendicular line drawn from the end point of the vector representing the relative coordinates of each pixel to L, and its sign is The vector representing the relative coordinates of (ex, e
It indicates whether it is in the counterclockwise position or in the clockwise position with respect to y).

Specifically, when D1 to D8 are obtained in the case of a clockwise neighborhood system, the following is obtained.

[0036]

(Equation 3)

As described above, the cord distances D1 to D are previously set.
8 is obtained, for example, in the case where the center of the binary pixel array is as shown in FIG.
From each code compare points R1, R2, R3, simply adding the (given either all D1 to D8) advance distance had been determined _{Dr 1, Dr 2, Dr 3} , each comparison point, It is possible to determine whether or not it is within the allowable error ε.

Therefore, in the present invention, as described above,
The binary pixel string is described by a chain code string, the starting point and the ending point of the thinning vector are set, and the actual distance from the line segment connecting the starting point and the ending point is set for the pixel string (comparison point) existing between them. Since the distances of the code distances D1 to D8 corresponding to the respective codes previously obtained by the method shown in FIG. 3 can be obtained by simply adding the distances from the starting point side in accordance with the code value of the pixel row, For each comparison point, the calculation amount when calculating the actual distance can be significantly reduced, and the processing time can be significantly reduced.

Hereinafter, a more specific example of the embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 6 is a block diagram showing a schematic configuration of a polygonal line approximation device for pixel columns according to an embodiment of the present invention.

The polygonal line approximation device 10 of the present embodiment has a function of generating a polygonal line approximation vector composed of one or more thinned-out vectors created by thinning out pixels within a permissible error from a binary pixel array. , A storage unit 1 for storing data in which the entire target binary pixel sequence is described by a chain code sequence
2, a start point / end point setting unit 14 that sets a start point and an end point of a thinning vector within the range of the binary pixel array, and a unit vector calculation unit 15 that obtains a unit vector indicating the direction of a line connecting the start point and the end point. , A code distance calculation unit 16 for calculating a code distance from the line segment connecting the set start point and the end point and indicating the unit vector in the direction, and the relative coordinate value corresponding to each code, and the pixels from the start point to the end point A code distance adding unit 18 that sequentially adds the code distances corresponding to each code calculated by the calculating unit 16 according to each code value describing a column, and an adding unit 18 for each pixel from the start point to the end point. The comparing unit 20 that determines whether the calculated added value of the code distance is within the allowable error, and that the added value of the code distance is all within the allowable error in the comparing unit 20. If it is constant, the 1 indices endpoint
Increase the number of pixels to the next pixel, reset the comparison point to the pixel next to the start point, and if the error exceeds the allowable value, reset the index to set new start point and end point. When the addition value setting unit 22 performing the above and the comparison unit 20 determine that the added value exceeds the allowable error, the pixel immediately before the end point is determined as the end point, and the thinning-out vector for generating the thinning-out vector is performed. The vector generating unit 24 is provided, and the thinned-out vector is stored in the storage unit 12.

In the present embodiment, a thinning vector is created according to the flowchart shown in FIG. 7 corresponding to the flowchart shown in FIG. 10, and a polygonal line approximation vector composed of one or more thinning vector strings is generated. be able to. In this case, too, capital letters of the alphabet also represent vectors in principle.

First, all the vector sequences of the target binary pixels are described by the chain code sequence and stored in the storage unit 12, and the first three points of the vector sequence are used as the start point, the comparison point, and the end point, respectively. Therefore, the index is initially set (step S1).

Here, if a chain code string obtained by chain-coding a vector string consisting of pixels with the total number of data n is Ci (i = 1, 2, ..., N), the starting point coordinates V
Using 1 = (x11, x21), the coordinate of Q at the 1st point can be obtained as in the following expression (11). Note that C
i represents any one of the numerical values 1 to 8 described above.

[0045]

(Equation 4)

X [Ci], y in the above equation (11)
[Ci] takes each of the following values when the code value is set clockwise as shown in FIG.

(X [1], y [1]) = (− dx, dy), (x [2], y [2]) = (0, dy), (x [3], y [3] ) = (Dx, dy), (x [4], y [4]) = (dx, 0), (x [5], y [5]) = (dx, -dy), (x [6] , Y [6]) = (0, −dy), (x [7], y [7]) = (− dx, −dy), (x [8], y [8]) = (− dx, 0)

Here, dx and dy are the distances between pixels in the x direction and the y direction used when explaining the method of calculating the code distance.

In the case of counterclockwise rotation shown in FIG. 2, the following values are set.

(X [1], y [1]) = (− dx, dy), (x [2], y [2]) = (− dx, 0), (x [3], y [3 ]) = (-Dx, -dy), (x [4], y [4]) = (0, -dy), (x [5], y [5]) = (dx, -dy), ( x [6], y [6]) = (dx, 0), (x [7], y [7]) = (dx, dy), (x [8], y [8]) = (0, dy)

Subsequently, the start point / end point setting unit 14 uses the chain code value to start point Vi, comparison point Vi + j, end point V.
The coordinate value of i + k is obtained (step S2). This can be obtained recursively by using the equation (11). or,
A variable Λ that stores the distance between the comparison point and the straight line L connecting the start point and the end point is initialized (step S3). Next, in the unit vector calculation unit 15, when the coordinates of the start point are (px, py) and the coordinates of the end point are (qx, qy), the following (12), (1
The unit vector (ex, ey) is calculated using the equation 3) (step S4).

[0052] ex = (qx -px) / { (qx -px) 2 + (qy -py) 2} 1/2 ... (12) ey = (qy -py) / {(qx -px) 2 + ( qy-py) ² } ^1/2 (13)

At the same time, the calculation unit 16 uses the results of the above equations (12) and (13) obtained above to obtain the results shown in FIG.
The code distances D1 to D8 similar to those shown in are calculated in advance and stored.

Then, the value of Λ representing the distance between the straight line L and the comparison point at the first comparison point is set to Λ as the code distance Dc _i.
Is added (step S6), and the absolute value thereof is compared with the allowable error ε (step S7), and if it is within ε, 1 is added to the index j (step S8). If j is smaller than k, the comparison point has not yet coincided with the end point, and therefore the process returns to step S6 and the same addition process can be repeated (step S9).

When j and k are equal in step S9, the comparison points and the end points are coincident, and therefore all the comparison points between the start point and the end point are within the allowable error ε. . In this case, 1 is added to k (step S1
0). At this time, if i + k exceeds the total number n of data, it corresponds to the point before adding 1 to k, that is, the end point is the final point of the total data. Therefore,
In this case, the above-mentioned end point Vi + k-1 (after adding 1 to k, it is necessary to subtract 1 and return to the original) is registered as the final point in the thinning-out vector sequence (step S12). To finish.

On the other hand, when the value of i + k is equal to or less than the total number of data n, j = 1 is set to reset the comparison point (step S13), and the value of the newly set end point Vi + k is set to the following (14). Obtained from the formula (step S14).

[0057]

(Equation 5)

Here, returning to step S3, the same repetitive calculation is performed again. Returning to the previous step, the processing when the absolute value of the variable Λ indicating the distance between the straight line L and the comparison point exceeds ε in step S7 is as follows.

In this case, since the end point is extended too much, it means that the end point cannot be completely within the allowable error ε at the comparison point. Therefore, the point Vi + k-1 obtained by returning the start point to the previous one is the allowable error ε at all comparison points between the start point and the end point.
Of the end points that fit inside, the farthest from the start point. Therefore, this is added to the thinned-out vector sequence (step S15), and the indices i and k are set in order to perform the next processing with the end point in the previous calculation process as the start point (step S15).
16, S17).

At this time, similarly to the above, it is checked whether i + k exceeds the total number n of data, and if it is n or less, the index j representing the comparison point is reset (step S19), and the comparison point Vi + The coordinate values of j and the end point Vi + k are set to the following (15), (1
It is obtained by the equation 6) (steps S20 and S21).

[0061]

(Equation 6)

Then, the process returns to step S3 again, and the processing such as code distance addition for thinning out the target pixel column is continued.

If i + k exceeds n, Vi + k-1 is registered as the final point in exactly the same manner as in step S12, and the process is terminated (step S12).

As described above in detail, when the thinned-out vector sequence is created and the polygonal line approximation vector is generated, the actual distance calculation is executed for each comparison point R each time, whereas in the present embodiment. According to the embodiment, by simply repeating the process of adding the code distances D1 to D8 corresponding to the code number Ci + j of the comparison point Vi + j, the object is achieved.
For example, a polygonal line approximation vector can be generated similarly to that shown in FIG.

Therefore, it is possible to significantly reduce the calculation load as compared with the conventional calculation method. When the same binary pixel row is actually compared, the calculation load according to the present embodiment is about 1 / l of the conventional calculation method. I was able to get to 7.

Although the present invention has been specifically described above, the present invention is not limited to the above-described embodiments, and various modifications can be made without departing from the scope of the invention.

For example, the specific configuration of the polygonal line approximation device is not limited to that shown in the above-mentioned embodiment.

[0068]

As described above, according to the present invention,
It is possible to dramatically reduce the calculation amount when generating the polygonal line approximation vector for the binary pixel column, and to significantly reduce the processing time.

[Brief description of drawings]

FIG. 1 is an explanatory diagram showing an example of a code value used to describe a chain code string.

FIG. 2 is an explanatory diagram showing another example of code values used to describe a chain code string.

FIG. 3 is a diagram showing the calculation principle of the chord distance.

FIG. 4 is a diagram showing a principle of calculating a code distance using a unit vector.

FIG. 5 is a diagram showing a principle of calculating an actual distance using a chord distance.

FIG. 6 is a block diagram showing a schematic configuration of a polygonal line approximation device according to an embodiment of the present invention.

FIG. 7 is a flowchart showing a processing procedure by the broken line approximation apparatus according to the embodiment.

FIG. 8 is a diagram showing a conventional method for creating a thinning vector.

FIG. 9 is a diagram showing another conventional method for creating a thinning vector.

FIG. 10 is a flowchart showing a conventional procedure for creating a polygonal line approximation vector.

FIG. 11 is a diagram showing a relationship between a start point, an end point and a comparison point that are initially set.

FIG. 12 is a diagram showing the relationship between the start point, the end point, and the comparison point set after the second point.

FIG. 13 is a diagram schematically showing an example of a final polygonal line approximation vector.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 10 ... Broken line approximation device 12 ... Storage unit 14 ... Start / end point setting unit 15 ... Unit vector calculation unit 16 ... Code distance calculation unit 18 ... Code distance addition unit 20 ... Comparison unit 22 ... Index setting unit 24 ... Decimation vector generation unit

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Akira Takakura 1-1-1, Ichigaya-Kagacho, Shinjuku-ku, Tokyo Within Dai Nippon Printing Co., Ltd. (72) Teruaki Iinuma 1-1-1-1 Ichigaya-Kagacho, Shinjuku-ku, Tokyo No. 1 Dai Nippon Printing Co., Ltd.

Claims (1)

[Claims] 1. A polygonal line approximation device for generating a polygonal line approximation vector composed of thinned-out vectors created by thinning out pixels within a permissible error from a binary pixel column, and describing the binary pixel column by a chain code sequence. The means for storing the stored data, the means for setting the start point and the end point of the thinning vector within the range of the binary pixel row, and the line segment having the same inclination angle as the line segment connecting the set start point and the end point. Means for calculating the code distance from the line segment to the center of each of the eight pixels in the vicinity of the pixel of interest corresponding to each code when matching the center of the pixel, and according to each code value describing the pixel string from the start point to the end point , The means for sequentially adding the corresponding code distances, the means for determining whether or not the added value of the code distances is within the allowable error for the pixel row from the start point to the end point, and the added value of the code distances are all Means for updating the pixel next to the end point to a new end point when it is determined to be within the tolerance, and one of the end points when it is determined that the added value of the code distances exceeds the allowable error. A means for determining the previous pixel as the end point and generating a thinning-out vector, and a polygonal line approximation device for a pixel column.