JPH0271388A - After-processing system for recognition of character - Google Patents

Abstract

PURPOSE:To perform the collation of words at a high speed by producing a finite automaton from the candidate character strings outputed from a character recognizer to accept the combination of those character strings and outputting such words contained in a word dictionary that are successively inputed and accepted by the automaton. CONSTITUTION:A scanner 104 scans the pictures of documents 110 and converts them into the binary digital pictures to store these pictures in a video memory 105. A character recognizing part 106 segments a character pattern out of the document pictures of the memory 105 and recognizes the character pattern. When the recognition of characters is through, a transition table of a finite automaton is produced from the candidate character strings and stored in a memory of a word collation part 107. Then the part 107 is started and each word contained in a word dictionary is inputed to the automaton via the transition table. At the same time, the distance to each word is outputed to the memory 105. The condidate words are displayed at a terminal 102 and selected or corrected by an operator.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to a post-processing method for character recognition, and in particular, the purpose is to automatically convert information such as addresses and names written in kana characters into kanji character strings. The present invention relates to a post-processing method for character recognition suitable for.

[Conventional technology]

In ordinary character recognition devices (hereinafter abbreviated as OCR), recognition performance is not 100% perfect, and misreading or misreading is inevitable. The unreadable characters here include those in which no candidate character is obtained as a recognition result, and those in which a plurality of candidate characters are obtained and one of them cannot be determined. Hereinafter, the former type of unreading may be referred to as rejectionive unreading or simply rejection, and the latter type of unreading may be referred to as competitive unreading or simply competition.

In order to compensate for such imperfections in the recognition performance of OCR, for example, the results of reading character strings written as words, such as addresses and names.

A method has been proposed to improve recognition performance by performing word matching. Word matching is a word dictionary in which a set of words that can exist as addresses and names is prepared in advance, and the candidate character strings obtained as recognition results are sequentially compared with the words included in the word dictionary. It removes or modifies candidate characters that cannot be obtained. Here, the candidate character string refers to a set of complementary characters for each input character pattern. Such a method is used, for example, in Japanese Patent Publication No. 60-5586.
6 "Character Recognition Device". In addition, in order to use information on recognition results from OCR when comparing words and recognition candidate character strings, a method of calculating distances between words by assigning weights to candidate characters for each rank was proposed in Japanese Patent Laid-Open No. 58. -4
8181 rCharacter recognition post-processing method J and Tokuko Sho 6]-20
038r Character Recognition Device". Furthermore, a method for comparing a character string consisting of a plurality of words, such as an address, with a word dictionary is also described in Japanese Patent Publication No. 62-62388 r Address Reading Apparatus.

[Problem to be solved by the invention]

In the above conventional technology, when comparing each of the 411 words included in the word dictionary with the candidate character string, all candidate characters that appear every +7!I!! are found to be in the same character position in the word. There was a problem in that it took a long time to calculate the distance to the characters.Therefore, although it is known that increasing the number of candidate characters is advantageous in increasing the effectiveness of word matching, However, due to calculation time limitations, it was necessary to keep the number of candidate characters to a small number, and the effectiveness of word matching could not be fully demonstrated.Furthermore, when multiple words were written in succession, breaks between words could not be detected. The first object of the present invention is to provide a high-speed word matching means.The second object of the present invention is to provide a high-speed word matching means. The purpose is to provide a means that enables word matching even when words are written consecutively.

[Means to solve the problem]

The first purpose mentioned above is to generate a finite automaton that accepts combinations of candidate character strings from candidate character strings output from OCR, sequentially input words included in a word dictionary into this finite automaton, This is accomplished by outputting such words that are accepted.

The second purpose above is to generate a partial automaton by cutting the finite automaton generated from the candidate character string of OCR output at multiple candidate points, input words included in the word dictionary into the partial automaton, and accept it. This is achieved by detecting cut points such that there are words that are accepted, and by controlling the partial automaton between each cut point so that there is no contradiction in the −-lower relationship between the word dictionaries to which each accepted word belongs. be done.

[Effect]

First, the principle of the conventional method of matching threatening words will be explained. Taking the case of a place name written in kana characters as an example, when the input character is ``Karasuyama'', the recognition result for each character is that the input power is 1st place.
Suppose that candidate characters such as SATENUKAMA 2nd place 力USUKIA 3rd place RIPUI ETA 4th place YARI TOFU are obtained.

Here, the characters with an angline indicate the correct characters.

The distance between this candidate character string and each word in the word dictionary is defined as the sum of the distances for every 5 characters, and the distance for each character is, for example, the highest candidate character in a word. At some point, it is defined as (n-1). In the case of a character that is not among the candidates, an appropriate value, for example 16, is taken as the distance. Therefore, the distance to the word "Karasuyama" is 1 because the first character "power" is in the second position, and in the same way, the distance for the entire word is D=1+2+1+2+O=6. Similarly, for the word "Sakurayama", D=O+3+16+2+0=21. Find the distance to all words in the same way.

The word with the minimum distance is set as a candidate word.

In this example, the distance to "Karasuyama" is the minimum, so this is set as a candidate word. Note that distance calculations between words in the word dictionary are normally performed only for words of equal length (in this example, five-letter words).

In the above example, the recognition results for each character pattern are all competitive and unreadable, and it is assumed that the correct answer is included in the candidates. It is clear that it can also be applied to cases of refusal to read. In the case of misreading, the minimum distance is large in most cases, except when the word is accidentally mistaken for another word in the word dictionary, and this can be used to detect misreading. On the other hand, if ] rejectable illegibility is included, the distance to any word is 16, so the minimum distance between words is at least 16 or more. At this time, by setting the threshold for accepting the minimum word distance to 16 or more,
If the characters other than the characters that are rejected and illegible are correctly recognized, it is possible to search for the correct word.

In this conventional method, the unit calculation amount required for each character is the comparison of character coats and the accumulation of distances based on the results. 1
As for the processing amount for information per word, the number of operations is the product of the word length and the average number of candidates, and in the example of -t, 19 operations are required. For example, if the number of words with a length of 5 characters is 3000, the total number of operations is 19 x 3000 = 57.0
0 (becomes IJ.

In contrast, the principle of word matching according to the present invention will be explained using FIG. In the present invention, a finite automaton as shown in FIG. 1 is generated from candidate character strings. The automaton sequentially inputs character strings representing each word included in the word dictionary, and determines whether the character string is accepted and how much it will cost in that case.

In the automaton shown in Figure 1, the circles indicate states, the letters written inside indicate the state numbers, and the lines between the six-shaped fi, where the lines between states correspond to each character position in the word, indicate transitions. , indicates that if a character written on the left side of the line is input to the automaton in a certain state, it will not follow that transition path and transition to the next state. However, "other" indicates all characters other than those specified as characters corresponding to a transition between two states, in other words, a character that does not appear as a candidate character at that character position. The number written on the right side of the line "-" is the cost required for that transition, and in this case, it is a value equivalent to the distance between characters.

From Figure 1, when the word "Karasuyama" is input to this finite automaton, it follows the path shown by the thick line, and the cost required for the entire transition, that is, the distance between the words, is easily D = l + 2 + 1 + 2 + 026. It can be confirmed. Similarly, the word "Sakurayama" has distance #21. That is, this finite automaton gives the same result as the conventional method. The advantage of this method is its high speed; since it is possible to determine which transition to follow for each input character in one unit operation, only five unit operations are required for the entire word. Here, the unit operation is the comparison of character codes, the determination of the transition destination state, and the accumulation of costs, and is realized by a very simple circuit as described later. Furthermore, when this method is implemented using software, the processing is simple and can be performed at high speed.

The number of operations required to process an entire word with a length of 5 characters in this method is 5×3000=15,000, which shows that the processing speed is faster than in the conventional method. In the above example, in order to simplify the explanation, the number of candidate characters is assumed to be relatively small. However, in actual OCR, the number of candidates is usually larger for kana characters, and the difference in the number of operations increases further.

Next, the principle of word matching according to the present invention when a plurality of words are read in succession will be explained. Taking the case of a person's name written in kana characters as an example, if the characters input to OCR are "Nakano Yasuaki (Yasuaki Nakano) J", the following candidate characters are obtained for each character as a recognition result. Suppose that

input power
#1 Su Ya So Ka Su Ta
2nd place Me San Ki Nua
Ki 3rd Place A Kafu ℃ I Mane 4th Place Ya Ri No Fu As in the previous example, the letter attached to the Angline indicates the correct letter.

In this case, the explanation is given assuming that the target is a first and last name, but even if you only know that it is multiple words and the type of word or number of words is unknown, you can use the following explanation. The principle of the invention can be established with only a few modifications.

In the case of the first and last name in this example, the number of words is two, so it is necessary to divide the above candidate characters into parts and perform word matching for each part. In the present invention, as in the case of a single word,
A finite automaton as shown in Figure 2 is generated from the candidate character strings. As in FIG. 1, the arrows indicating transitions drawn in thick lines indicate the routes followed by the correct character strings.

This finite automaton is cut into two partial automata. At that time, all six states from ■ to ■ become cutting candidate points, but the following processing is performed in each cutting state, and as described later, the cutting candidate point that yields the highest evaluation score is selected for the correct cutting point. Adopted as a point.

(]4) Since the situation is the same regardless of the cutting point, we will explain the case of cutting in state ■ as an example. The front and rear parts of the finite automaton cut in state ■ are F(5;I) and L, respectively.
(Written as 5i1n.Here, the first number in parentheses (5) means that it was cut in state ■. Also, the second number in parentheses (]) means that it was cut in the first In this example, the number of words is 2, so cutting is performed only once, but in general, if the number of words is M, cutting is performed from i = 1 to (M - 1). The word matching performed at cut i is called the first layer matching.

In the first layer, L (5; 1) of the rear finite automaton
The words M (with a word length of 2 in this case) included in the word dictionary for names are input in sequence, the distance to each word is calculated, and the words are arranged in descending order of distance. In this case, 1, for example, Taki (1), Aki (2), Maho (2).

Suppose that the order is Maki (3), Butterbur (4), Fune (5), and so on. However, in the parentheses above, each Ht, then input the words included in the word dictionary of the last name (in this case, the word length 5) into F(5;1) of the finite automaton in the front,
Calculate the distance for each word. In this case, the distances are arranged in ascending order, for example, Nakamukai (20), Nakayasu (20), Asanakai (35), Akaoki' (37), and Nakanosono (37).
,... Suppose that the following results are obtained. Adding up the distance between the first half and the second half, we get Nakamu Kaitaki (21), Naka Yasutaki (21), Naka Yasuaki (22), Naka Yasuaki (22), Naka Yasuaki (22), Naka Yasumaho (22).

Nakamukaimaki (21), Naka'yasumaki (21),
Arrange them as follows, and record several of them in the table in descending order of distance as candidates (compound !li word candidates) at cutting point ■.

(]6) Next, move the cutting point forward and use the automatons L(4;], ) and F(4;1) at the cutting point ■ to find compound word candidates and their distances. Similarly, the cutting points are sequentially moved forward to find compound word candidates and their distances. lastly. By integrating the candidates at each cutting point and sorting them in descending order of distance, for compound words with first and last names, we can find Nakano Yasuaki (9), Asano Yasuaki (10), Nakamukaitaki (21), Nakayasuaki (2J), Candidate sequences such as Nakano Kas9ki (22), . . . are obtained. As a result, for the input character "Nakano Yasuaki" to ocR, the first candidate Nakano + Yasuaki (Nakano, Nakano) + (Yasuaki, Yasuaki, Yasuaki), and the second candidate Asano + Yasuaki (Asano, Asano) + (Yasuaki, Yasuaki, Yasuaki) was selected as the candidate. Note that if you store the kanji notation shown in parentheses above for each word in the word dictionary, you can perform word matching and convert kana to kanji at the same time. (]7) It is possible.

In the above explanation regarding compound words, first and last names were used as compound words, so the words were always arranged in the order of last name and first name, and the examination of the order relationship between words could be omitted. However, for example, in the case of an address, there are hierarchies such as prefecture, city, town, village, town, and village, and there are subordination relationships between each hierarchy. Therefore, by examining this dependency relationship, word candidates can be further limited.

Now, let's consider a case where an address is cut from the back and words are compared. When word matching results in a candidate town/village name, the previous word is found using the city/town/ward dictionary. At this time, the dependent relationship between town and village names and cities/towns registered in advance in the table is checked, and a large distance is added to combinations that have no dependent relationship. Similarly, a large distance is added to combinations of cities, towns, and prefectures that do not have a dependent relationship. In this way, incorrect combinations can be eliminated.

In the above explanation, compound words are processed by cutting from the rear side, but it goes without saying that the same effect can be achieved by cutting from the front side (]8).

Next, the principle of additional processing for supplementing the recognition performance of OCR in the present invention will be explained. In other words, in word matching, if the correct character is not included in the candidate characters due to OCR misrecognition or scribe error, the distance from the correct word will become large even after matching with a dictionary. Therefore, it may be impossible to improve cognitive ability. In order to deal with this problem, in the present invention, candidates are added by applying a switching rule to the OCR recognition result, and then word matching is performed.

These rewriting rules are classified into type 1 and type 2 rules. The first type of rule is a rule for adding candidate characters to a candidate character set for a certain character pattern. The second type of rule is a rule that indicates that a virtual character pattern is generated after a certain character pattern, and candidate characters are to be added to each of these two character patterns.

An example of a rewrite rule is shown below. This Zen-kikae rule basically adds candidates to the candidate characters for a certain character pattern, but in some cases it also refers to candidate characters for the previous and following character patterns, that is, it also takes into account the context. Candidates may be added.

In the following rules, ``(k) indicates a set of candidate characters at the first character position, C is a symbol indicating that an element is included in the set, and := is a symbol indicating a change in the set. Also, & represents an AND condition. Also, the symbol φ will be explained later.

Example of the first type of rewriting rule: (1) if SEF(k) then V(k) := r”(k) + (
nu1(2) if 1(capital letter)Er(k)then
r(k) :=T”(k) +(-t (lower case))
(3) if yu CT” (k) &' (handakuten) E r (k+1) then T” (k)
:2 r(k)+ (ko)(4) if ノEr(
k) ＆ しIE T' (k+])then
r(k) :=1-(k) + (leφ)(5)
if Er (k) & Characters in line A other than A r (k-1) then r
(k-1): “T” (k-1) ” ((long sound))
Example of the second type of rewriting rule: (6) E r (k) then r'(k) :"I"(k)" (
)) and increase the character number after k+1 by 1, and
r(k+1) := + (shi)(7) if character E in line A r (K), where E is the number of candidate characters and r(
Add the symbol φ to candidates belonging to K) (other than the characters in line A), increase the number of candidate characters K by 1, and r(K):=(-(long sound)) Among these rewriting rules, (1) - (3) are for dealing with errors in character recognition, and optimal rules can be set using knowledge about the ease of misreading of the recognition device.

Furthermore, (4) and (6) are for dealing with errors in character segmentation.

(4) corresponds to an example of dealing with a case where one character is mistakenly separated into two characters. In this case, the symbol φ is attached after the added candidate character, and the symbol φ indicates that the transition corresponding to the added candidate character should skip the next state and transition to the next state.

(6) corresponds to an example of dealing with a case where two characters are erroneously combined into one character. In this case, a virtual character pattern is added after the target character. The symbol φ is used so that candidate characters other than the candidate to which the rule is applied are not connected to the added virtual candidate character.

Furthermore, (5) and (7) are for dealing with variations in notation.

In the example (5), when "apartment" is written as "abaato", the standard notation, that is, a long sound, is generated.

In example (7), when the long sound at the end of a word such as "computer" is dropped and the word "computer" is written, the long sound is supplemented, and in this case as well, a virtual character pattern is added to the end of the word. The meaning of using the symbol φ is the same as in (6).

As can be understood from the above description, any rule can be created depending on the situation of the rewriting rule, and correct candidate characters can be added, which increases the effectiveness of word matching. Conventionally, there has been the idea of adding candidate characters, but adding candidates increases the number of candidate characters, which poses the problem of slowing down the matching speed. In the present invention, as mentioned above, word matching is possible at high speed, so even if the number of candidate characters increases somewhat, there is almost no decrease in speed, and the advantage is that the effect of word matching can be fully demonstrated.

In the above description, the case where the OCR recognizes katakana is taken as an example, and the case where the character code is represented by one byte per character has been explained. Needless to say, the same holds true for alphabetic characters as well as katakana. It can also be applied to kanji as described below.

One Kanji character is usually represented by two bytes. You can create a finite automaton by considering these 2 bytes as one character code, but you can create a finite automaton by combining these 2 bytes into 2 characters as follows.
It is also possible to create a finite automaton by considering it as a character.

Assume that the characters input to the OCR are "Yasuaki Nakano" and the following candidate characters are obtained for each character as a recognition result.

Input Yasushi Nakano 1st place Nakano - Ko Ken - 3rd place Nai Kan Asa 3866 2011 361] As in the previous example, the characters with an angline indicate the correct characters. The JIS code (kuten number) for each character is in parentheses. Figure 3 is an explanatory diagram of the finite automaton in that case, where two state transitions correspond to the Kanji character, the previous transition corresponds to the ward number of the JIS code, and the latter transition corresponds to the dot number 猜. (The ward number and point number can each be expressed in one byte.) The difference from FIG. 1 is that the cost required for transition is incurred only for subsequent transitions. In Figure 3, the transition corresponding to other is represented by a dashed line,
The notation er is omitted.

Furthermore, as is clear from Figure 3, if there are multiple candidate characters with matching ward numbers for a certain character pattern, the number of states can be reduced by commonly using transitions for the ward numbers in the state transitions for them. It can also be reduced.

From the above description, it will be understood that the present invention realizes character recognition post-processing at high speed.

〔Example〕

An embodiment according to the present invention will be described below with reference to FIG.

FIG. 4 is a diagram showing the device configuration of a system that implements the character recognition post-processing method according to the present invention.

The system includes a CPU (central control unit) 100 that controls the system, a main memory 101, a terminal 102, a system file 103, a scanner 104 for scanning document images, a video memory 105, a character recognition unit 106, and a word matching unit. 107, a work file 108, and a bus 109 as basic parts.

The flow of operation of each part will be explained in detail below.

The CPU i OO controls the operation of the entire system described below by executing programs in the main memory 101. Depending on the operation of each part of the system, necessary programs are transferred from the system file 103 to the main memory 10.
1, and granting execution rights to each program are performed by the operating system program, but their operations are well known and will therefore be omitted here. In the following description, each part of the system will be described as operating autonomously, but this is a simplified description of the system actually operating under program control of the CPU 100. Further, although data is exchanged between each part of the system via the bus 109, in order to simplify the explanation, the description will be made so that data is directly transferred between each part of the system.

Terminal 102 at the time the program requests it.

Used to exchange data with the operator.

In the following explanation, the description of the terminal 102 is omitted, and the CPU 10
In some cases, it is stated that 0 directly exchanges data with the operator.

When an operator places a document 110 to be read into the scanner 104, the scanner 104 scans the image on the document 110, converts it into a binary digital image, and stores it in the video memory 105. The video memory 105 is used to store various types of data, which will be described later, in addition to document images, and each is stored in separate areas so as not to interfere with each other; however, hereinafter, the video memory 105 will be referred to as the video memory 105 unless otherwise specified. .

The character recognition unit 106 searches the document image in the video memory 105 for areas where characters are written, cuts out character patterns therein, and
recognize. Character extraction and recognition processing are well known and will therefore be omitted. The recognition results are represented as a sequence of candidate characters for each character pattern and are stored in the video memory 1.05.

When character recognition is completed, the CPU 100 performs processing as described later to generate a transition table of a finite automaton from the candidate character string. The details of the processing will be described later. The entity of the generated transition table is a table stored in the memory attached to the word matching unit 107.

Next, the word matching unit 107 is activated, and inputs each word included in the word dictionary into the finite automaton using the transition table generated from the above candidate character strings.

Performs processing to find the distance to each word. The detailed contents of this processing will be described later. Here, it is assumed that the word dictionary is previously read into the video memory 105 from the system file 1.03.

The output of the word matching section is a list of distances for each word, and is output to the video memory 1.05. The CPU IOO uses a known method to rearrange the list 1- in descending order of distance, and finds several candidate words with short distances. CPTJ]01 displays this candidate last word on the terminal 102 and allows the operator to select or modify it. Here, selection means choosing the correct word from among the displayed candidate words, and correction means selecting the correct word from among the displayed words! The operator inputs the correct word when 11 words do not exist. At this time, displaying the image of the part to be recognized on the terminal 102 at the same time as the candidate word is effective for selection or correction.

The word data selected or modified by the operator is output to the work file 1.08. Depending on the application, the first word in word matching may be output as is, without selection or modification by the operator.

Next, a process for generating a transition table used in a finite automaton from candidate character strings as a result of character recognition will be explained. Prior to explaining the process, a method of representing data in the video memory will be explained.

Figure 5 shows the letter V! An example of how candidate character strings output from the recognition unit 1.06 are expressed in the video memory 105 is shown.

In FIG. 5, 501 is a pointer table in which the number of candidate characters for each character pattern is N(1), N(2), N(3
)19. , and pointers P(1), P(2), P(3), , , to the table 502 storing candidate character strings.

has. Reference numeral 502 is a candidate character table, in which candidate characters for each character pattern are arranged, and after the relative address P(1) from the beginning, the candidates for the first character (in this example, Su, Power, Ri, Ya) are listed. ), but the candidate character for the second character is lined up after the same <P (2).

FIG. 6 shows an example of a method for representing a transition table used in a finite automaton generated from candidate character strings. The transition table is created in the internal memory attached to the word matching section 1.07.

In Figure 6, 601 represents each state 5(0) of the finite automaton.
, 5(1), 5(2), 5(3) 196. This is a table containing information corresponding to . However, 5(0) is the initial state S in FIG. 1, and 5(1)11. is the state in Figure 1 ■1. .

corresponds to Hereinafter, this table 60 will be referred to as a state transition table or a transition table for short. Further, in FIG. 6, 602 is a table storing the cost 1- for each transition, and hereinafter this table 602 will be referred to as a transition cost h table.

For each state, start address pointers J(0), , J(1), J(2) at 601, 602, 191. is determined. In this example, J(i) = J(0) + (i-1)x256x2 is determined for the j-th state. That is, 601 and 602 are 25 for each state.
This is a table with 6 entries.

The 256 entries correspond to character codes, and in this example, characters are represented by EBCDIK codes. Therefore, for example, the character "r" is 182 in the EBCDIK code, so it corresponds to the 183rd entry (counting from the beginning).

The state transition table 601 shows each state 5 (i
) (actually denoted by address J(i)), it describes the operation when C(i) arrives. Indicates a transition. The transition cost table 602 stores the cost w(, j) that occurs for the transition,
Items 601 and 602 that have the same relative address from the beginning correspond to each other. In the example of Figure 6, the initial state 5 (0
) (Actually, at address J(0)), if the character "r" arrives, the transition table 601 shows address (J(0)+18).
By subtracting the contents of 2), we obtain the cost 1 from the next address J(1) & and the same address in the transition cost table. Similarly,
When the character "ki" arrives, the next address J (1) and cost 1
Get 6. Note that the cost in this case corresponds to the example shown in FIG. In this way, it can be seen that if an input character string is given, the finite automaton can be sequentially traced by referring to the transition table 601, and the cost required for the transition can be sequentially obtained from the transition cost table 602.

In the example shown in Figure 6, entries are provided for all 256 EBCDIK codes, but if it is known that the input character string is limited to katakana, for example, the EBCD
Since the IK code falls within the range from 129 (a) to 191 (': handakuten), input code C (i
) instead of (C(i)-129), only 63 entries are required.

In the example shown in Figure 6, the next state for all input characters in one state is the same, so the data representation format shown in Figure 6 seems redundant, but as will be explained later, Since it is possible to develop a finite automaton that transitions to different states, we have adopted the highly extensible data representation format shown in Figure 6.

FIG. 7 shows a flowchart in PAD format for generating a transition table and a transition cost table of a finite automaton from this candidate character string. Prior to explaining FIG. 7, symbols will be explained.

N: Number of characters recognized by OCR (number of automaton states = N+1) K(k): Number of candidates for the th character pattern C(k
, j): Character code of the j-th candidate when the character pattern is recognized J(i): Start address T(m) of the i-th state of the transition table
): Contents of the m-th entry in the transition table (start address of the next state) P(m): Contents of the m-th entry in the transition cost table (cost required for transition) As can be seen from the explanation of this symbol, in this example, 1 This is for the case where the character code is expressed in 1 byte,
It would be easy to extend this to cases where one character is expressed in two bytes, such as Kanji.

In the flowchart of FIG. 7, 701 to 704 are initialization processes in which initial values are embedded in the transition table and the transition cost table. 701 is a loop control in which the following processing is repeated (number of states -] -) times, that is, N times, and j represents a state number. At 702, the start address A of the next state is calculated. 703 is a loop control for 256 engines belonging to the state], and n represents a character code. At 704, the entry m for the nth character code of the jth state in the two tables is calculated, and the entry m for the nth character code of the jth state in the transition table is calculated.
The start address A of the next state is embedded in the transition cost table T(+o), and the initial cost value 16 is embedded in the m-th entry 1-RIP(m) of the transition cost table.

705 to 707 in FIG. 7 are processes for creating a transition table using the OCR output results. 705 is a loop control that repeats the following process for the number of characters, that is, N times, and k represents a character pattern number.

706 is a loop control that repeats the following process for the number of candidate characters for the character pattern, that is, K(k) times; 1. j represents the rank of candidate characters. In step 707, the en-1-li m in the transition cost table for the character code C(k,j) is calculated, and (i-1) is embedded as the cost in the m-th entry P(m) of the transition cost table. Entry m is the (kth
−1) Relative address C(k
, j).

From the above explanation, it will be understood that a transition table and a transition cost table corresponding to a finite automaton can be generated from candidate character strings output from OCR.

Next, a detailed explanation will be given of the word matching unit 107, that is, the hardware that realizes the process of accepting character strings by the finite automaton.

FIG. 8 is a configuration diagram showing the configuration of the word matching section 107. In FIG. 8, a character string given from a word dictionary is input to an input terminal 800. Each character code of this character string is latched by a register 801, and the latched character code becomes an input to memories 802 and 809. The memory 802 stores the state transition table 601 shown in FIG. 6, and hereinafter the memory 802 may be referred to as a state transition table or simply a transition table. The memory 809 stores the transition cost table 602 shown in FIG.
is sometimes described as a transition cost table.

The transition table 802 has the transition table 802 as another input.
Its own output is supplied via a register 803 and a selector 804. The output of the transition table 802 is a value (start address) representing the next state in the finite automaton, and the address of the transition table is determined from the two inputs to the transition table 802, that is, the start address of the next state and the character code. The contents of that address are read and output.

The output of another register 817 is connected to the input of the selector 804, and the register 817 is connected to the input terminal 8.
It stores the starting address given from 16. Normally, an address in an initial state is given to the input terminal 816, but the starting address given to the input terminal 816 may be in any state, and is effective in processing compound words, which will be described later.

When the word matching unit 107 starts operating, the selector 804 selects 8.
17 side is selected and the address in the initial state is set as the initial value of the transition table 802. After that, the 803 side is selected using the select button 804. Thereafter, the operation of tracing the transition table is repeated in synchronization with the character code coming from the input terminal 800. When the input character strings are exhausted, the transition table 802 has reached the final state, and this state is decoded by the decoder 805 and outputted from the output terminal 806 as a result identification number. The output of the decoder 805 is O except in the final state, but
Outputs other than O serve as latch control signals for register 807, and the final state is latched by register 807.

This value is outputted from the output terminal 808 as a final attained state as a result confirmation signal. In this embodiment, the only meaningful reached state is the final state, so the decoder 805 is not necessarily required. A register 807 is provided to identify how far in the finite automaton it has reached. The value of the target state to be decoded by the decoder 805 is given from the outside and held in a register (not shown).

On the other hand, the output of the selector 804 is also connected to the input of the transition cost table 809. From the two inputs to the transition cost table, namely the start address and character code of each state,
The cost of the transition is determined and provided to adder 810. The output of the adder is latched by a register 811, and the latch output is again input to the adder 810, so that the register 811 stores the accumulated value of the cost required for transition.

This cumulative value is output to output terminal 812.

This accumulated value is also provided to a comparator 815 and compared with the worst value set in the register 814 from the input terminal 813. The output of comparator 815 is taken out from output terminal 818. By monitoring this signal with an external circuit, it is possible to abort processing for a word with an abnormally large cumulative cost.

Next, a second embodiment of the character recognition post-processing method according to the present invention will be described. This embodiment is suitable for processing compound words. As in the first embodiment, the system for realizing this embodiment has the device configuration L(0) ■ F(m;j) L(m;j) S, (+o;j) S, ( m;j), and compound word processing is performed by the processing program of the CPU 100.

FIG. 9 shows a flowchart of the -42 processing program in PAD format. Prior to explaining FIG. 9, symbols will be explained.

: Number of characters recognized by OCR (number of automaton states = N + 1) : Initial automaton created from the candidate character set of recognition results: Total number of finite automaton cuts (number of words = I + 1) : Variable representing the number of cut Oki 1s: Variable representing the state corresponding to the cutting point: First half of the finite automaton cut in state m the first time: Second half of the finite automaton cut in state m the jth time: Minimum at the cutting point m in the jth cut Cumulative distance: Centered cumulative distance V, (m; i) at cutting point m in j-th cut: Minimum distance candidate word set V2 (m; i) at cutting point m in i-th cut: Cutting in first cut Blowout distance candidate word set at point m In FIG. 9, 901 is initial value setting, which initializes variables and various tables used in subsequent processing. 902 is a loop control that repeats the following process only once, and ■ is the total number of cuts, that is, (number of words - 1). i represents the first [1 cut.

Reference numeral 903 is a control loop regarding the cutting location in the first cutting, and m represents the state corresponding to the cutting location. This cutting will be performed later, and m will decrease by 1 from the maximum value to the minimum value. The maximum value of the change range of m (the last cut point) is the value that leaves at least (i-1) states as cuttable points behind, that is, (N-i+1
), and the minimum value (the first cut point) is a value that leaves at least (I −i ) states as cuttable points in front, that is, (I−i+2).

904 is a control loop regarding the word length, P represents the word length, and the minimum value of the change range of p is 1. Also, since it is necessary that (i-1) words can be inserted after the word of length p that starts at the cutting point, (m+p-1) has (i-
1) must be less than or equal to N, so the maximum value of the variation range of p is (N+2-m-1).

905 is a part that cuts the finite automaton at the cutting point m and sets the first half F(m;i) and the second half L(m;i). This cutting does not actually create a partial automaton, but virtually cuts the partial automaton.

That is, the first half F(m;i) is the initial automaton direct O
) is defined as m.

Also, the latter half L(m;i) is L(0) and the starting state is m,
The final state is (m+p). As described later, L(m;i) accepts a string representing a word, and it is necessary to input the string from the starting state of L(+m,i) and detect that it has reached the final state. be. To do this, m is used as the starting address from the input terminal 816 in FIG.
and store it in the register 817, (4I) and (m+P) as the final state value in the decoder 805. At that time, the finite automaton L(0) configured as shown in FIG. Partial automaton L (
Work as m;i).

In FIG. 9, 906 is for setting the values of the above-mentioned starting state and final state.

907 is a loop control that repeats the process of 908 for words of word length P. 908 is a part that inputs the word to the automaton L(n+;i) and calculates the distance.

At 909, the distances obtained for each word are sorted in ascending order.

In 910, several words (in this embodiment, two words) with small distances are found. Minimum distance 3. Write the word that gives that distance as wl. The blowing distance (second smallest distance) is D
2. Write the word that gives the distance as W2.

911 is a process for calculating the cumulative distance to a compound word. Determine the minimum and cumulative distance of the blowout using the following formula.

51(n+;i)=min(St(m+p;1-1
)+01°Sl(m;1)) Sz(+i;i)=1Ilin(St(m+p
;1-1)+02°S2(+i+p;i-])+D,)
.

S2 (+++; minimum distance). The minimum cumulative distance at the (i-1)th time is that the word length is p
Considering that, the value at the cut point (m+p) is taken. The second term in the first equation is the value of the minimum cumulative distance at the cutting point m up to that point. Therefore, the first equation indicates that when the value determined by the first term becomes less than or equal to the conventional minimum cumulative distance, the minimum cumulative distance is replaced by the first term. Note that the initial value of the minimum cumulative distance S□(m;0) is set to 901, which is a sufficiently large value. The second equation above is for calculating the cumulative distance of the blowout, and the cumulative distance of the blowout is either the sum of the minimum cumulative distance at the (i-1)th time and the current blowout distance, or the cumulative distance of the blowout at the (i-1)th time. ) Cumulative distance of balloons in times Next, a second embodiment of the post-processing method for character recognition according to the present invention will be described.

The system for realizing this embodiment is realized by the processing program of the CPU 100 using the device configuration shown in FIG. 4, as in the first embodiment. The processing of this embodiment is almost the same as that of the first embodiment, but after candidate addition processing is performed on candidate characters for each character pattern obtained by the character recognition unit 106, finite automaton generation and word matching are performed. They differ in that they perform

Therefore, only candidate addition will be explained.

Prior to the following explanation, symbols will be explained.

N: Number of characters recognized by OCR k: Character pattern number K(k): Number of candidates for the character pattern C(k)
, j): The first character pattern recognition result,
Candidate character code M = Number of virtual character patterns after correction: Virtual character pattern number after correction G (s): Number of candidates for the S-th character pattern after correction D (s, c): Virtual Character code E of supplementary cfeA after correction to S-th character pattern: Number of rewriting rules: Number of rewriting rules R(e): Rewriting rule e-th Figure 10 shows the program that performs the above candidate processing. The flowchart is shown in PAD format. In Fig. 10, 1001 is the initial value setting, and in the figure, especially the virtual character pattern number S.
In addition to this, variables and various tables used in subsequent processing are also initialized.

1, 002 is a loop control in which the processes 1003 to 1034 are repeated N times, and N is the total number of recognized characters.

The number of the character pattern is represented by k.

Prior to detailed explanation of the following processing, the contents of each processing will be briefly explained. In steps 1003 to 1008, if there is even one character pattern candidate that matches the second type switching rule, it is necessary to generate a virtual character pattern, so it is detected in advance. It is a part. 10
19 to 1026 are processes for adding candidate characters to the character pattern. 1027 to 1034 are parts that add one virtual character pattern after the character pattern and add candidate characters to the added virtual character pattern. Note that since the character pattern number shifts with the addition of a virtual character pattern, the character pattern number after addition is counted by S. Further, the number of candidates for the S-th character pattern is assumed to be G(s).

1003 is a control unit for loop processing performed on the character pattern, and the processing of 1004 to 1008 is controlled by K(k
) times. Here, K (k) is the number of candidate characters for the first character pattern.

At 1004, the variable f1. Set 1 as the initial value of ag. Here, the meaning of the variable flag will be explained. When this value is 1, it corresponds to the first type of rewriting rule, and indicates that a candidate character is added to the character pattern. Further, when the value of the flag is 2, it corresponds to the second type of rewriting rule, and indicates that a virtual character pattern is generated after the first character pattern, and a candidate character is added to this virtual character pattern. Note that the rank of the added candidate character is determined to be next to the rank of the final candidate at the time of addition, and is omitted from the following explanation.

1005 is a loop control in which the processes 1006 to 1008 are repeated E times, and E represents the number of rewriting rules.

The number of the rewriting rule is represented by e.

In 1006, the e-th rewriting rule R(e) is applied.

Determine whether the candidate character set matches this rule. In 1007, if R(e) matches, it is determined whether this rule is a second type rule, and if it is a second type rule, the value of f lag is set to 2 in 1008.

In step 1019, the virtual character pattern number S is incremented by 1, and the number of candidate characters C for this character pattern is set to an initial value of 0. 1020 is a loop regarding candidate characters for the character pattern, and the loop is repeated by the number of candidates K(k). [102] First, the candidate character C(k, j) for the character pattern is copied to become D(s, c).

At that time, the number of candidate characters C increases by one. In step 1022, steps 1023 to 1025 are repeated by the number E of rewriting rules. 1
At 023, the e-th rewriting rule R(e) is applied to determine whether the candidate character set and R(e) match.

In 1024, it is determined whether R(e) matches, and if they match, candidate characters are generated in 1025.

That is, while increasing the number of candidate characters C by 1, R(e
) and candidate character c(k, J), candidate character D(
Add s, c). After adding candidate characters, 10
Number of candidate characters G for the S-th character pattern after correction in 26
Let (s) be C.

In 1011, it is determined whether the value of flag is 2,
If it is 2, the processes 1028 to 1034 are executed to add a virtual character pattern.

In other words, 1028 sets the virtual character pattern number S to 1.
The number of candidate characters C for this character pattern is set to an initial value O. 1029 is loop control regarding candidate character C(k,j) (k=1, K(k)). In 1030, the number of rewriting rules E
1031 to 1033 are repeated, and in 1031 the e-th
A rewriting rule is applied and it is determined whether the candidate character set matches this rule. In 1032, if the e-th rewriting rule matches, it is determined whether this rule is a second type rule, and if it is a second type rule, 1033
Generate candidate characters with . That is, while increasing the number of candidate characters C by 1, the e-th rewriting rule R(e) and candidate character C
Add candidate character D(s, c) determined by (k, j). After the addition of candidate characters is completed, in step 1018, the number of candidate characters G(s) for the modified S-th character pattern is set to C.

As the number M of virtual character patterns after correction in 1035,
Substitute the final value of S.

Although this third embodiment has been described for the case of a single word, it goes without saying that it can also be applied to the case of a plurality of words.

Next, modifications of the embodiment will be described. In the above example, the character strings resulting from character recognition are collated into words and compared with the word dictionary, and the words with the shortest distance are output. ), and when the difference between the two is sufficiently large, the word that gives the minimum distance is automatically output, and only when the difference between the two is small, it is displayed on the console for the operator to select. Good too. Additionally, when the minimum distance value is smaller than a certain threshold, the word with the minimum distance may be automatically output, and when the minimum distance is larger than the threshold, the result may be displayed on the console and wait for instructions from the operator. . Further, in the embodiment, the distance between words is given as the sum of the distances between characters, but the distance between words may be divided by the number of characters to convert it into a value for each character, and then compared with the threshold value.

Next, in the embodiment, a character string representing a word is output, but the number of the word, that is, the consistent number of the word in the dictionary, may be output, and the conversion into words may be left to an external party. Additionally, this number can be converted into other information. For example, after determining a kana character word as in the example, a kanji word that has that word as its reading (
Generally, there are more than one). In addition, although the explanation of the method for determining the word i# is omitted in the embodiment, it is possible to select a dictionary depending on the position on the @ ticket, or to select a dictionary to be used in other parts depending on the character recognition result of a certain part of the form. Methods such as determining the

Further, in the embodiment, the finite automaton that performs word matching is realized by a dedicated circuit, but it may also be realized by simulating its operation by software.

〔Effect of the invention〕

According to the present invention, word matching can be performed faster than conventional word matching methods, and if the performance of the character recognition unit is the same as that of the conventional method, the overall processing speed combining character recognition and word matching can be improved. Far more effective than before. In addition, word matching according to the present invention has a fast processing speed and can process a large number of candidate characters within the same processing time as the conventional method. - The possibility of selecting words is increased, and the effective character recognition rate can also be increased.

(5) Furthermore, since it can be applied even when multiple words are written in succession, word matching can be applied without having to separate addresses, names, etc., making it very convenient for the user.

In addition, by applying rewriting rules, even if there is a quirk in the recognition performance of the character recognition unit, the quirk can be corrected and correct candidates can be added, and the correct word can be recognized by word matching.
Increases word recognition rate.

[Brief explanation of the drawing]

Fig. 1.2.3 is an explanatory diagram showing the principle of single #i matching according to the present invention, Fig. 4 is a diagram showing the device configuration of an embodiment of the present invention,
5 and 6 are explanatory diagrams showing the arrangement of information in the memory in the embodiment, and FIG. 7 is an explanatory diagram showing the arrangement of information in the memory in the embodiment.
Figure 8 is a circuit diagram of a circuit that executes a finite automaton in the embodiment;
FIG. 9 is a flowchart of the matching process for compound W words in the embodiment, and FIG. 10 is a flowchart of the process of adding candidate characters in the embodiment. 100... Central control unit, ], 01... Main memory, 102... Terminal, 103... System file, 1
04...Scanner, 105...Video memory, 10
6... Character recognition section, 1.07... Word matching section, 108
...Work file, 109...Bus.

Claims (5)

[Claims] 1. A means for inputting a digital image; a means for recognizing character patterns existing within the digital image and outputting one or more candidate characters for each character pattern; and a combination of the one or more candidate characters. It has means for generating a finite automaton that accepts candidate character strings, and a word dictionary that stores a plurality of words, and the words included in the word dictionary are sequentially input to the finite automaton, and the words are accepted by the finite automaton. A post-processing method for character recognition, characterized in that a word is set as a recognition result of the input character pattern group. 2. In the character recognition post-processing method according to claim 1, the character recognition post-processing is characterized in that the finite automaton is generated after adding candidate characters to the candidate characters of the recognition result according to a predetermined rule. method. 3. A means for generating a finite automaton that receives a candidate character string obtained by recognizing a character pattern group in which M (M>1) words are consecutively written, and a plurality of types of word dictionaries, A post-processing method for character recognition by repeatedly performing word matching from i=1 to M, in which the word matching involves cutting the generated finite automaton at a plurality of cutting points and extracting the rear part of the cutting point. One of the plurality of word dictionaries is input to the partial automaton L(i) created by ), cut at multiple cutting points and perform the same operation as above, and then perform the same process up to i = (M-1), and then in the i = M-th word matching, do not cut and perform the same operation as above. This is a process of inputting one of the plural word dictionaries mentioned above to the partial automaton F(M-1) starting from the character position of the face, and all the words from i=1 to M mentioned above are matched. If there is a series of cut points in which there are accepted words, output the series of words accepted at each cut point belonging to the plurality of cut point series as candidate words,
A post-processing method for character recognition characterized in that the output order is such that the word accepted the Mth time is output first and the words accepted the first time are output in reverse order. 4. A means for generating a finite automaton that receives a candidate character string obtained by recognizing a character pattern group in which M (M>1) words are consecutively written, and a plurality of types of word dictionaries, This is a post-processing method for character recognition by repeatedly performing word matching from i=1 to M, and the word matching involves cutting the generated finite automaton at a plurality of cutting points and extracting the front part of the cutting point. One of the plurality of word dictionaries mentioned above is input to the partial automaton F(i) created by ), the same operation as above is performed by cutting at multiple cutting points, and the same process is performed until i = (M-1), and further, in the i = Mth word matching, no cutting is performed, and the final One of the above plural word dictionaries is applied to the partial automaton L(M-1) ending at the character position of If there is a series of cut points such as A post-processing method for character recognition characterized in that the words accepted at the beginning are output in the normal order up to the Mth accepted word. 5. The character recognition post-processing method according to claim 3 or 4 is characterized in that information specifying dependency relationships between words is stored in advance, and candidate words are tested using the above information. A post-processing method for character recognition.