JPH05290217A - Character recognition method - Google Patents

Abstract

PURPOSE:To broadly classify characters through the use of codes expressing the connection sate of a graphic. CONSTITUTION:A binarization processing part 1 binarizes an image by reading it and a run length data generation part 2 generates run data. A horizontal phase expression data generation part 3 extracts a pair of phase change from run length data at an adjacent string to generate a horizontal phase expression. A dependance relation generation part 4 generates a dependance relation (a graph consists of a node, a branch, start and end) of the horizontal phase expression. A sedin code generation part 5 outputs a code consisting of the combination of the six characters of 's', 'e', 'd', 'i', 'n' and a comma from the dependance relation. A character recognition part 6 broadly classifies characters with the sedin code.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a character recognition method for recognizing a character by using a code expression representing a connection state of figures.

[0002]

2. Description of the Related Art In a method for recognizing a binarized character image, the present applicant has previously generated run data for each line from binarized image data, and a run data pattern between adjacent lines can be obtained. Extract different pairs of rows (phase change pairs),
A method has been proposed in which a line figure is expressed by a series of the pair of lines (vertical phase expression) and a character is recognized using the vertical phase expression (Japanese Patent Application No. 3-253186). This vertical phase expression includes connection state information, which is topological information, and some quantitative information.

That is, binarized image data (see FIG.
4) is expressed in the vertical phase composed of the phase change pairs 451 to 454 (455 in FIG. 45). This is also represented by stamps (white and black circles) (Fig. 46).

A representation of the connection state information in the vertical phase representation by one character string is called a topology code in the vertical phase representation and is also called a "model". Classification is done by determining whether the model is the same as in the dictionary. FIG. 47 shows ten types of topology codes (including other codes *). For example, the number "2" is d, A, pI, p (see FIG. 4).
8). In the previously proposed character recognition method, the characters are roughly classified according to the combination of the topology codes of the vertical phase representation.

However, when recognizing a character as shown in FIG. 49, all the characters "6", "4" and "0" have the same topology code (d, Id, IA, VI, V,
p), it is not enough to use the topology code of the vertical phase representation. As described above, the topology code of the vertical phase representation can perform only the major classification of characters, and thus the classification needs to be performed in more detail.

As a character recognition method that solves such a point, the present applicant has already proposed a character recognition method using gi data and a character recognition method using a direction code (Japanese Patent Application No. 4-52213). .. That is, the classification based on the gi data is a classification performed using the amount (numerical value) information easily obtained from the vertical phase expression, and the height information of the phase change pair included in the vertical phase expression and the vertical phase expression. The position information of the run indicated by is used. Then, the classification is performed by a simple logical expression in which the classification by the threshold value is combined.

For example, the topology code (d,
The characters that generate Id, IA, VI, V, p) are 98 characters, the breakdown of which is 96 examples of the character "6" and the character "0".
And the letter "4" was one example each. Then, the model of FIG. 50 (d, Id, IA, VI, V, p)
In the above, each phase change pair is gi0, gi in order from the top.
1, ... gi5, the height difference between gi5 and gi4 is a, the height difference between gi1 and gi0 is b, the height difference between gi4 and gi2 is c, and the height difference between gi5 and gi0 is If h, then the above model (d, Id, IA, VI, V, p)
The data of 98 characters belonging to could be completely separated by the following conditions using a, b, c and h.

Condition for character "6": a / h <0.15 and 0.25≤b / h <0.80 Condition for character "0": a / h <0.15 and b / h <0.
Condition of 15 characters “4”: 0.25 ≦ a / h <0.60.

The direction code classification enables classification of numbers that cannot be classified by the method using gi data. This direction code takes sampling points at equal intervals with respect to a part of the contour, The inclination of each point is coded and arranged. Classification is performed using an automaton for character recognition.

[0010]

However, the method proposed above has a problem that it is very difficult to create an automaton for the groups d and p. That is, the groups d and p are not only the simplest model for expressing the vertical phase but also one of the models with a high frequency of appearance (of the handwritten numeral data of about 13,000 characters, 2463).
The letters corresponded to the model and were in second place). There are many character types (numbers, 1, 2, 3, 5, 5) in these groups d and p.
Not only 7) is included, but also many variations that should be classified as different shapes even if they are of the same character type are included.

In such a case, in other models, classification by gi data is effective, and both the character type and the number of deformations can be narrowed down. However, in the groups d and p, only the positions of the uppermost black run and the lowermost black run are known, so that the classification by gi data hardly functions.

Further, in other models, it is possible to select a part of the contour within a narrow range so as to include a feature effective for classification, and to create an automaton while taking into consideration the feature focused on the direction code of that part. did it. It also says, "First, roughly classify in the a part of the contour, then in the b part, ...
It also meant that stepwise classification could be effectively used, such as "."

However, in the groups d and p, only the right side surface or the left side surface (or both side surfaces) can be selected as a part of the contour, and therefore many characteristics affect the direction code at one time. , It was not possible to select a part of the contour that is effective for classification, and as a result, stepwise classification was also impossible.

As described above, although the groups d and p have many character types and many kinds of deformation, they cannot be classified using gi data, and the contour portion designation does not function effectively. , Making automata becomes very difficult,
For example, an automaton that recognizes the numbers "1" and "7" (and some numbers "2" and "3") was created, but about 700 cases of data became unrecognizable.

An object of the present invention is to provide a character recognition method for roughly classifying characters (models d and p) using a code representing the connection state of figures.

[0016]

In order to achieve the above object, in the invention according to claim 1, run data is generated for each column from binarized image data and a run data pattern between adjacent columns is generated. In the method of extracting a phase change pair different from each other, and recognizing a character by using a horizontal phase expression composed of the phase change pair, a connection relation of the horizontal phase represented figures is generated, and a correspondence relation is generated. A feature is that a code is generated and characters are classified by the code.

According to a second aspect of the invention, the code is
At least a first character indicating the occurrence of a line, a second character indicating the disappearance of the line, a third character indicating the joining of the lines, a fourth character indicating the branch of the line, and a line that does not change It is characterized in that it is formed by combining it with the fifth character that represents it.

The invention according to claim 3 is characterized in that the character classification according to the vertical phase representation and the character classification according to claim 1 are combined.

[0019]

In the binarization processing unit, the image is read and binarized, and the run length data generation unit generates run data. In the horizontal phase expression data generation unit, the phase change pair is generated from the run length data of the adjacent columns. Extract to generate a horizontal phase representation. The dependency relationship generation unit generates a dependency relationship (the graph includes four types of nodes, white branches, black branches, start, and end) from the horizontal phase representation. The sedin code generation unit determines "s", "e", "d", from the dependency relationship.
A code consisting of a combination of six characters "i" and "n" and a comma is output, and the character recognition unit roughly classifies the characters by the sedin code. As a result, the models d and p can be classified.

[0020]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be specifically described below with reference to the drawings. FIG. 1 is a block diagram of an embodiment of the present invention. In the figure, 1 is a binarization processing unit that reads an image and binarizes it, 2 is a run-length data generation unit that generates run-length data from binarized image data, 3 is an adjacent column A horizontal phase expression data generation unit 4 that generates a horizontal phase expression by extracting a phase change pair from the run length data, a dependency relationship generation unit 4 that generates a dependency relationship from the horizontal phase expression, and a sedin code from the dependency relationship. The generated sedin code generation unit 6 is a character recognition unit.

Here, the binarization processing unit 1 and the run length data generation unit 2 have the same functions and configurations as those described in the above-mentioned application. Further, in the present embodiment, the horizontal phase expression (that is, the vertical phase expression obtained by paying attention to the change in the connection state of two adjacent columns) is used, but it is essentially the same as the vertical phase expression described in the above-mentioned application. There is no difference. Figure 2
Shows an example of horizontal phase representation and its topology code.

By the way, when trying to classify handwritten numbers by the horizontal phase expression, a large number of models can be created for the number 3 (240 for handwritten number data of about 13,000 characters).
type). In this, many groups that can be regarded as the same model appear. FIG. 3 shows examples of 10 different topology codes that can be regarded as the same model. Even if limited to the models d and p described above, the number 3
There are 79 types of models, and if this model is used for the detailed classification of d and p, the number of models to be stored becomes very large.
In view of this, the present embodiment proposes the sedin code described below in detail as a method of expressing the same character string as the connection state alternative to the topology code, which is an alternative to the topology code shown in FIG.

<Sedin code> The sedin code expresses the connection state of figures by one character string.
This is also an equivalence classification obtained by regarding some topology codes as “same”. The sedin code is "s",
Each part composed of 6 characters "e", "d", "i", "n" and a comma, and separated by a comma is called a "slice".

The sedin code is, as shown in FIG.
The connection state obtained by horizontally connecting the connection states represented by the slices is shown. Each slice consists of a character string other than commas, and these indicate the connection state shown in FIG. 5, respectively. That is, s is the generation of a line (Start),
e is the disappearance of the line (End), and d is the confluence (Dec).
i) and i is a branch (Increase)
And n is a line without change (No change). As shown in FIG. 6, the connection state of slices is a graph in which each character is arranged in that order from top to bottom.

The sedin code is generated as described in detail below. First, a dependency graph is created from the horizontal phase representation, and then a sedin code that is a character string is generated from this dependency graph.

<Dependency Graph> An example of the dependency graph is shown in FIG. This graph is a directed graph and corresponds to the figure in FIG. 8 and the horizontal phase representation in FIG. The dependency graph of FIG. 7 has four types of nodes (s, e,
i, d), two types of branches (white branches represented by thin lines and black branches represented by thick lines), and start and end. 0 to branches
It is represented by the number 16 and the nodes are represented by symbols A to H. The branches 2, 5, 8, 10, 12, 13, 14 are black branches, and the branches 0, 1, 3, 4, 6, 7, 9, 11, 15, 1 are
6 is a white branch, and each branch corresponds to a series of white runs or black runs whose connection state does not change.

Further, the nodes of the dependency graph correspond to the extreme points (portions where the y-coordinates of the contour points are the maximum value or the minimum value) of FIG. 9, and the edges of the dependency graph are respectively shown in the figure. The dependency relationship graph corresponds to each of the ten areas and represents the connection relationship in the horizontal direction.

The nodes of the dependency graph are created corresponding to the change of the connection state. There are two types of nodes: one that inputs one branch and outputs three branches, and one that inputs three branches and outputs one branch. The node and the latter node are called reduced nodes. As shown in FIG. 11, a connection state change point that cannot be expressed by one node is expressed by combining a basic increasing node and a decreasing node. Therefore, the figure shown in FIG. 12 should originally be represented by a dependency graph as shown in FIG. 13, but this is converted into a basic node and represented as shown in FIG.

The dependency graph is stored in a memory or the like in the following format. That is, all increasing nodes and decreasing nodes are recorded as shown in FIG. 15 using the numbers of the branches. Although the node types are not shown in this figure, they are actually stored in the memory.
The number of the leftmost branch is 0. Each row in FIG. 15 (that is, fields corresponding to each increasing node and decreasing node)
Is called a dependency rule, and the order of the branches is important information, so it is preserved.

<Dependency Relationship Generation Unit> A method of generating a dependency relationship will be described below. The generation method of this embodiment is
The “cross section” that divides the dependency relationship shown in FIG. 7 into two parts, left and right, is created by a model that moves from left to right. As shown in FIG. 16, this cross section is a series of branch numbers from top to bottom and is stored in the form of a list, and this is hereinafter referred to as a cross section list. Each node on the cross-section list corresponds to a branch of the dependency relationship and has a branch number, and this is hereinafter referred to as a cross-section node.

FIG. 17, FIG. 18, and FIG. 19 are processing flow charts for generating a dependency relationship. In this method, it is premised that "the original image is a black figure on a white background and the edges are not touched". The initial state of the cross section list is "id = 0.
One branch (section node) ”. Then, each time the phase change pair is exceeded, the cross-section list moves to the right, and a dependency rule is created. The section list at the end is “one section node (branch) with id = n”. Incidentally, by recording this n, the subsequent processing is slightly simplified.

The branch number (that is, the section node number) is
It is given in the step of "generation of section node" in the processing flowchart. When a cross-section node is generated, the number of the cross-section node generated last time is recorded, and a node having a number one more than that is generated. By this processing, the "branch" is recognized and the branch number is assigned.

The horizontal phase representation shown in FIG.
A case where the dependency shown in FIG. 5 is generated will be described as a specific example. In the horizontal phase representation of FIG. 20, g0 and g1 represent the first two phase change pairs, FIG. 21 is an internal representation of each phase change pair g0 and g1, and 101 to 112 represent stamps, respectively. The straight line between stamps indicates a branch.

In step 001 of FIG. 17, the section list is initialized as shown in FIG. In FIG. 22, numerals 0 to 6 denoted by 201 to 207 are section node numbers, and the first section node number is id =
It becomes 0. In step 002, the first phase change pair g0 (= g) in FIG. 20 is processed. Step 003
Then, u = (stamp 101 in FIG. 21), d = (FIG. 21
Stamp 102). In step 004, c
n = (201 in FIG. 22A) is set.

At step 005, since neither u nor d is nil, the routine proceeds to step 006. In step 006, it is checked whether u next exists, the number of branches of u next is 0, and the first branch of next of u next is d, and in this case, n of u
Since ext does not exist, the process proceeds to step 008. In step 008, the next of d (= stamp 102) is
The stamp 103 exists, the number of branches of the stamp 103 is 0, and the first branch of the next (= stamp 104) of d (= stamp 102) is u.
Since (= 101), the process proceeds to step 009. Figure 1
9 indicates the processing of step 009.

In step 015 of FIG. 19, first,
Three cross-section nodes are generated. When this node is generated, branch numbers that have not been used so far are assigned to these three nodes. Since the only id that has been used so far is 0, 1, 2, 3 are assigned here. Using these ids, a dependency rule of 0-> 1,2,3, which is the first line in FIG. 15, is created and output.

Next, in step 016, the section list is modified so that the section list of FIG.
2 (b). In step 017, cn is set as the last node of the three cross-section nodes (cn = 204), and d
Let (= stamp 102) be the next of d's next, that is, d = stamp 104.

Returning to step 005 in FIG. 17, since u = 101 and d = 104 in step 005, the process proceeds to step 006. Since there is no next of u, the process proceeds to step 008, and at step 008, d Since next does not exist, the process proceeds to step 010.

In step 010, u is next to u, that is, u = nil, and d is also d = ni.
1 and cn is also set to cn = nil (end). Since u and d are both nil in step 005,
The process proceeds to step 011 and the processing is not completed for all the phase change pairs (at this point, the processing for only the phase change pair g0 is completed), and therefore the process returns to step 002.

In step 002, the next phase change pair g
Is set to g = g1. In step 003, u = stamp 105 and d = stamp 108. Step 004
Since the cross section list is that shown in FIG. 22B, cn = 202 (first node). Step 0
In 05, since u = 105 ≠ nil and d = 108 ≠ nil, the process proceeds to step 006. In step 006, u
Next exists in the stamp 106, but since the number of branches of the stamp 106 is 1, the condition of step 006 is not satisfied and the process proceeds to step 008.

In step 008, the next of d exists in the stamp 109, and the number of branches of the stamp 109 is 0.
And the next of d's next is the stamp 110,
The first branch of stamp 110 is stamp 105, which is equal to u, so the condition of step 008 is met and step 009 is proceeded to.

In step 015 of FIG. 19, the ids of the newly generated cross section nodes are set to 4, 5, and 6, respectively. Since cn = 202 (id = 1), the dependency rule 1-> 4,5,6 in the second row of FIG. 15 is generated and output. In step 016, the cross-section list is modified so as to be changed from FIG. 22B to FIG. In step 017, cn = 207 (FIG. 22 (c))
And d = stamp 110.

Returning to step 005 in FIG. 17, since u = 105 ≠ nil and d = 110 ≠ nil in step 005, the process proceeds to step 006. In step 006,
The u next exists in the stamp 106, but since the number of branches of the stamp 106 is 1, step 006.
If the condition is not satisfied, the process proceeds to step 008.

In step 008, the next of d exists in the stamp 111, but since the number of branches of the stamp 111 is 1, the condition of step 008 is not satisfied and the process proceeds to step 010. In step 010, u = 106, d
= 111, cn = 203 (FIG. 22 (c)).

Step 005 is Yes, Step 006 is No, Step 008 is proceeded to, Step 008 is No, Step 010 is proceeded to,
In step 010, u = stamp 107, d = stamp 112, and cn = 204 (FIG. 22C) are set. Returning to step 005, step 005 is Yes, step 006 is No, step 008 is No, and in step 010, u = nil, d = nil, cn = ni.
It is set to l (end). Return to step 005, u = n
Since il and d = nil, the result is No, and step 011
Since the processing has been completed up to the phase change pair g0 and g1, the process returns to step 002. Hereinafter, in the same manner, all the phase change pairs are processed to generate the dependency relationship.

<Generation of sedin code> A method of generating a sedin code which is a character string from the above-described dependency will be described below. The sedin code is created based on the idea of energy propagation. That is, two states of "activated / not activated" are defined for each node and branch on the dependency graph, and the initial state is set to "all nodes and branches are inactive state". Figure 1
A graphical representation of the dependency shown in FIG. 5 is FIG. 23 (this figure is the same as FIG. 7 already described).

First, all nodes and branches are made inactive. All nodes (A to H), branches (0 to 1) in FIG.
6) is in the inactive state. Note that FIG. 24 is a diagram showing active and inactive states of nodes and branches.

In step 1, branch 0 is first activated (FIG. 25). In step 2, all branches coming out of the activated node are activated. At this point, no node is active, so do nothing. In step 3, all the nodes whose input branches are activated are activated. Since only A is the node in which all the input branches are activated, node A is activated (FIG. 26). In step 4, the code of the newly activated node is output in order from the top. When tracing from top to bottom, if there is a black branch that is not connected to these nodes, the code is "n" at that position.
Is output. Code "s" of newly activated node
Is output.

In step 5, if all the nodes have been activated, the process ends. Since there is a node that is not activated yet, the processing is continued. In step 6, a comma is output (the total output is "s,"). Returning to step 2, the branches 1, 2, 3 are activated (FIG. 27). In step 3, Node B is activated (FIG. 28). Step 4
Then, when FIG. 28 is cut to the left and right so as to follow the node B, this section passes through the black branch 2, so the code "sn" is output. The process is continued in step 5, and a comma is output in step 6 (all outputs are "s, sn"). Returning to step 2, the branches 4 and 5 are activated (FIG. 29). Thereafter, the same processing is performed, and finally the code “s, sn, n
sn, nin, dd, ne, e ″ are generated.

Although this sedin code can classify characters slightly coarser than the horizontal phase representation, since it classifies characters in detail compared to the level shown in FIG. 3, in the present embodiment, further character classification is performed. An additional rule (1) for roughly classifying
(2) is used. This rule works recursively in step 3 above. Hereinafter, the increasing node corresponding to the code s will be referred to as a node s, and the decreasing node corresponding to the code e will be referred to as a node e.

(1) If the node s is activated and the white branch generated thereby activates the input of another node s, that node is also activated. (2); If the node e is activated and the activation of the white branch caused thereby activates all the inputs of another node e, that node is also activated.

In addition to this, there are the following additional rules, for example. (3); a rule relating to node e. As shown in FIG. 30, the input branches of node e are a, b, and c in order from the top,
Let the output branch be d. In step 3, if only the middle black branch b is activated instead of all a, b, and c, the node e is activated, but in step 2, the branch d has all a, b, and c. Do not activate until activated.

31, 32, and 33 use the above-mentioned additional rules (1) and (2) from the dependency relationship (FIG. 15),
It is a processing flowchart which produces | generates a sedin code. In the processing of the present embodiment, the extent of activation is managed using a cross section list. That is, the left side of the cross-section list means an activated node and the right side means a non-activated node.

Function make-string (FIGS. 32 and 3)
3) manages the activation of the node by transforming the section list and outputs the codes s, i, e, d.
The additional rules mentioned above are incorporated into this function.
Also, in the step, the left side and right side of the rule are
It refers to the left side and the right side of the dependency rule in FIG. Also, in the case of a rule corresponding to an increasing node,
The left side consists of 1 id, and the right side consists of 3 ids. In the case of a rule corresponding to a decreasing node, the left side has 3 ids and the right side has 1 id.
Consists of.

In the step, the "rule" in the description "Is there a rule that matches the section node cn?" Is a dependency rule, and "match" means the following. That is, if the left side of the rule is one term, the id of the cross-section node cn is equal to the left side, and if the left side of the rule is three terms, cn, cn next, and n of cn.
It means that there are three cross-section nodes next to ext, and their ids correspond in this order to the left side of the rule.

Below, using the additional rules (1) and (2) from the dependency relation of FIG. 15, the sedin code “sss,
As an example of generating "nin, dd, ee", FIG.
The processing operation of FIGS. 32 and 33 will be described.

In step 301 of FIG. 31, an index is created in order to search the dependency rule quickly and easily. In step 302, a cross section list shown in FIG. 34 (a) is created. In step 303, the unused rules still remain (all at this point), so the result is No and the process proceeds to step 304.

In step 304, cn = 401 (FIG. 34)
(A)). In step 305, 1 is substituted for the variable white that manages the black and white of the branch. In step 306,
Since cn = 401 ≠ (end), the determination result is No, the process proceeds to step 307, and in step 307, the id of cn is 0, and a rule (0-> 1, 2,
Since 3) exists, the answer is yes, and the process proceeds to step 308.

In step 308, cn = 401, wh
The function make-string is called with ite = 1 (call 1). Called function make-str
In ing (FIG. 32), the passed argument is cn = 40
1, white = 1 (step 314), and in step 315, since the matched rule (0-> 1,2,3) belongs to the increasing node, it becomes yes, and step 3
Become 16. Section node c generated in step 316
IDs (1, 2, 3) on the right side of the rule are assigned to 1, c2, c3, and the cross-section list is transformed as shown in FIG. 34 (b).

Since c3 = 404 in step 317,
Let cn = 404. In step 318, white =
Since it is 1, it becomes Yes, and in step 319, c1
= 402, so cc = 402. Step 320
Since the id of cc is 1, and there is a rule that inputs only 1 (1-> 4, 5, 6), and this rule is for the increasing node, the answer is Yes, and Step 3
21, the function make-string is recursively called with cc = 402 and white = 1 as arguments (c
all 2).

In step 314, the local variable cn = 4
02, white = 1. In step 315, since the rule belongs to the increasing node, it becomes Yes, and in step 316, the cross-section nodes c1, c2, and c3 are generated, and these ids are the values on the right side (4,5, 6) of the rule. And The section list is transformed as shown in FIG. In step 317, c3 = 407, so cn = 4
07. In step 318, since white = 1, the result is Yes, and in step 319, c1 = 405, and therefore cc = 405. In step 320, i in cc
d is 4, and there is no rule that inputs 4 only. Also, cc next (406), cc next
Next (407) has ids 5 and 6, respectively,
Even if a rule with 4, 5, 6 as input is searched for, it does not exist, so the result is no, the process proceeds to step 322, and step 3
At 22, the code "s" is output.

Since c3 = 407 in step 323,
Let cc = 407. In step 324, the id of cc is 6, and there is a rule that inputs cc only (6-
> 7,8,9) and again the rule is for the increasing node, so Yes and go to step 325.
In step 325, the function make-string is recursively called with cc = 407 and white = 1 as arguments (call 3).

In step 314, the local variable cn = 4
07 and white = 1. In step 315, since the rule belongs to the increasing node, it becomes Yes, and in step 316, the cross-section nodes c1, c2, and c3 are generated, and these ids are the values on the right side (7, 8, 9) of the rule. And The section list is transformed as shown in FIG. In step 317, c3 = 410, so cn = 4
Set to 10. In step 318, since white = 1, the result is Yes, and in step 319, c1 = 408, so cc = 408. In step 320, i in cc
d is 7, and there is no rule that inputs 7 only. Also, cc next (409), cc next
Next (410) has ids of 8 and 9, respectively.
Even if a rule with 7, 8 and 9 as input is searched for, it does not exist, so the result is no, the process proceeds to step 322, and
The code “s” is output at 22, and the code output in the processing up to this point becomes “ss”.

At step 323, cc = 410.
In step 324, the id of cc is 9, and there is no rule that inputs 9 alone. Further, since there is no rule for inputting 9, 2 and 3, the result is No and step 327
And returns cn = 410 as the return value.

The control returns to the call 3 (step 325). Variables cc, c1, c2, c3, white
Are the values at the time of calling, that is, 407, 4
Return to 05, 406, 407, and 1. cn is the return value of the called function, that is, 410. In step 327, 410 is returned as the return value.

Control is returned to call 2 (step 321). Variables cn, cc, c1, c2, c3, wh
ite is the value at the time of each call, that is, 40
Return to 4, 402, 402, 403, 404, 1. In step 322, the code "s" is output, and all the outputs so far are "sss".

At step 323, cc = 404.
In step 324, there is no rule that only inputs 3 and 3 as the id of cc. Also, because the cc next is end,
Since there is no rule corresponding to the decreasing node, it becomes No,
In step 327, 404 is returned as the return value.

Control returns to call 1 (step 30).
8). The variable white has a value at the time of calling, that is, 1. cn becomes the return value 404. In step 311, 1-white = 0 (that is, black), c
n = end. In step 306, since cn = end, the result is Yes, and in step 312, a comma is output. All the outputs become "sss" by the processing so far.

Thereafter, the same processing is performed, and finally, FIG.
Code "sss, nin, dd, ee" from rule 5
Is obtained.

The features of the sedin code of the present invention generated as described above will be explained.
When the figure shown in FIG. 35 is represented by a directed graph which is a conventional method, the graph shown in FIG. 36 is obtained. However, for the graphics as shown in FIGS. 37, 38, and 39, all have the same directed graph, making it impossible to classify the graphics. On the other hand, according to the sedin code of the present invention,
The figures shown in FIGS. 37, 38, and 39 can be classified. 40, 41, and 42 are shown in FIGS. 37 and 3, respectively.
8 shows a dependency graph and sedin code corresponding to FIG. 39.

Further, as shown in FIG.
Another feature is that each character of the din code can be associated with a stamp. Therefore, you can specify the stamp and know the position of the run corresponding to that stamp.
In the same manner as the “classification by gi data” that the applicant has already proposed, that is, for example, from the selected stamp, L
It is possible to calculate 1, L2 and classify characters by L1 / L2.

Further, since each stamp can identify the connected party on the graph (see the above-mentioned application
(t, prev, partner, branch information), the position information of the run corresponding to the next-> partner of the stamp corresponding to the character in the sedin code is used, or the branch of a stamp is used.
It is also possible to classify characters by using the position information of the run corresponding to [0]->next-> next.

In the character recognition unit 6 of this embodiment, the characters are classified for the models d and p as follows. That is, (1); the characters are roughly classified according to the topology code of the vertical phase representation, and the characters that can be recognized by the detailed classification using the gi data and the direction code are recognized by the method. (2); For the characters that cannot be recognized by the above method (1), the figure is expressed in the horizontal phase and classified by the sedin code. (3); Further, using the position of the run in the original figure corresponding to each character in the sedin code, classification is performed by the same method as "classification by gi data".

If the handwritten numeral data of 13549 characters is roughly classified only by the horizontal phase representation, the number of models of the number "3" increases (240 types), but this is expressed by the horizontal phase.
If classified by the sedin code, 34 types of models are sufficient. If models d and p are limited to the number “3”, 79 types of models are required only for the lateral phase, whereas se
With the din code, only 8 models are required.

Further, if the above-mentioned whole data is classified by the topology code of the vertical phase representation, 293 kinds of models are required, and of these, 56 kinds and 12576 characters cannot be identified only by the topology code.

On the other hand, when the characters are roughly classified by the horizontal phase expression sedin code, the sedin code is 27.
Eight types, of which 38 types and 9,942 characters could not be identified only by the sedin code. That is, the horizontal phase expression sedin code of this embodiment has a higher resolution, which makes it possible to realize a character recognition method for classifying figures by using the horizontal phase expression sedin code.

[0077]

As described above, according to the invention described in claim 1, since the characters are largely classified by the code corresponding to the connection relation of the figures expressed in the horizontal phase, the classification accuracy is high. Also, the number of models can be reduced.

According to the invention of claim 2, sedin
It becomes possible to classify the models d and p using a code, and the amount of classified data can be reduced.

According to the third aspect of the invention, since the characters are classified by combining the classification by the vertical phase representation and the classification by the horizontal phase representation, the accuracy of the major classification can be improved.

[Brief description of drawings]

FIG. 1 is a block diagram of an embodiment of the present invention.

FIG. 2 is a diagram showing an example of a horizontal phase expression and its topology code.

FIG. 3 is a diagram illustrating an example of ten different topology codes that can be regarded as the same model.

FIG. 4 is a diagram illustrating a sedin code of the present invention.

[Fig. 5] Each character (s, e,
It is a figure which shows the connection state of i, d, n).

FIG. 6 is a diagram showing a sedin code and a connection state represented by the sedin code.

FIG. 7 is a diagram showing an example of a dependency graph.

8 is a diagram corresponding to the dependency graph of FIG. 7. FIG.

FIG. 9 is a diagram showing extreme points corresponding to nodes in the dependency graph.

FIG. 10 is a diagram showing each region of a graphic corresponding to an edge of a dependency graph.

FIG. 11 is a diagram showing connection state change points that cannot be expressed by one node.

FIG. 12 is a diagram showing an example of a graphic.

FIG. 13 is a diagram showing the graphic of FIG. 12 as a dependency graph.

FIG. 14 is a diagram in which the dependency graph of FIG. 13 is converted into basic nodes.

FIG. 15 is a diagram showing a format in which a dependency relationship is stored in a memory.

FIG. 16 is a diagram showing a cross-section list.

FIG. 17 is a flowchart of a dependency relationship generation process.

FIG. 18 is a partial detailed flow of the flowchart of FIG.

19 is a partial detailed flow of the flowchart of FIG.

FIG. 20 is a diagram showing an example of horizontal phase representation.

FIG. 21 is an internal representation diagram of a phase change pair.

22 (a), (b), and (c) are diagrams showing a process in which the cross-section list is deformed.

FIG. 23 is a dependency graph in which all nodes and branches are inactive.

FIG. 24 is a diagram showing active and inactive states of nodes and branches.

FIG. 25 is a dependency graph in which nodes and branches change from an inactive state to an active state.

FIG. 26 is a dependency graph in which nodes and branches change from an inactive state to an active state.

FIG. 27 is a dependency graph in which nodes and branches change from an inactive state to an active state.

FIG. 28 is a dependency graph in which nodes and branches change from an inactive state to an active state.

FIG. 29 is a dependency graph in which nodes and branches change from an inactive state to an active state.

FIG. 30 is a diagram illustrating a rule regarding node e.

FIG. 31 is a processing flowchart for generating a sedin code.

FIG. 32 is a processing flowchart of a function make-string.

FIG. 33 is a continuation of the processing flowchart of the function make-string.

34 (a), (b), (c) and (d) are diagrams showing modifications of the cross-section list.

FIG. 35 is an example of a graphic.

36 is a diagram showing the figure of FIG. 35 as a directed graph.

FIG. 37 is an example of a figure that cannot be distinguished by the directed graph representation.

FIG. 38 is an example of a figure that cannot be distinguished by the directed graph representation.

FIG. 39 is an example of a figure that cannot be distinguished by the directed graph representation.

40 is a dependency graph and sedi corresponding to FIG.
It is a figure which shows an n code.

41 is a dependency graph and sedi corresponding to FIG.
It is a figure which shows an n code.

42 is a dependency graph and sedi corresponding to FIG. 39;
It is a figure which shows an n code.

FIG. 43 is a diagram for explaining the correspondence between each character of the sedin code and the stamp.

FIG. 44 is binarized image data.

45 is a vertical phase representation diagram of FIG. 44.

FIG. 46 is a view showing FIG. 45 by a stamp.

FIG. 47 is a diagram showing a topology code for vertical phase expression.

FIG. 48 is a diagram showing a vertical phase representation of number 2 and a topology code.

FIG. 49 is a diagram showing an example in which characters cannot be classified only by the topology code.

FIG. 50 is a diagram illustrating classification of models (d, Id, IA, VI, V, p) by gi data.

[Explanation of symbols]

 1 Binarization processing unit 2 Run length data generation unit 3 Horizontal phase expression data generation unit 4 Dependency relation generation unit 5 sedin code generation unit 6 Character recognition unit

Claims (3)

[Claims] 1. A run data is generated for each column from binarized image data, a phase change pair having a different run data pattern between adjacent columns is extracted, and a horizontal phase representation composed of the phase change pair. In the method of recognizing characters using
A character recognition method characterized in that a connection relation of the figures expressed in the horizontal phase is generated, a code corresponding to the connection relation is generated, and characters are classified by the code. 2. The code includes at least a first character indicating occurrence of a line, a second character indicating disappearance of the line, a third character indicating confluence of the lines, and a fourth character indicating branching of the lines. And the
The character recognition method according to claim 1, wherein the character recognition method is a combination with a fifth character representing a line that does not change. 3. A character recognition method, characterized in that the character classification according to the vertical phase representation and the character classification according to claim 1 are combined.