JPH02257381A - Sorting of image, sorting of and identifier for character in image and fine line conversion of image - Google Patents

Abstract

PURPOSE: To improve the precision of the automatic recognition of the character pattern of a prescribed picture by a machine by executing the skeletonization of the picture and the correction of the inclination of the picture. CONSTITUTION: A pixel picture is formed by scanning a character to the recognized, and this picture is given scaling, and is 'purified', and is corrected in its inclination, and is skeletonized, and the line-thinned picture is formed. A picture map is formed by executing the extraction of a feature by a neural network by using this line-thinned picture, and the features are combined, and a 'higher rank (super) feature' is formed. After that, the picture is made into a block roughly, and the dimension number of a feature vector is reduced. Finally, a sorter specifies the character by the feature vector. Thus, the reliable automatic character recognition can be realized.

Description

[Detailed description of the invention]

INDUSTRIAL APPLICATION FIELD OF THE INVENTION The present invention relates to pattern analysis and pattern recognition, and more particularly to a system for pattern or symbol recognition in images consisting of pixel (pixel) arrays.

[Prior art]

There are a wide variety of applications in which it is desirable for machines to automatically recognize, analyze, and classify character patterns in a given image. The explosive development of computer-based information collection, processing, handling, storage, and transmission systems is providing the technology that enables the realization of these desires. Although sophisticated programs have been written for general purpose computers to perform pattern recognition, their level of success has been limited. Their success has mostly been achieved in the area of recognizing standard printing fonts. Character recognition technology dating back to the early 1960's used a method of tracing the curve of the character to be recognized. This was intuitively appealing, but unfortunately it often failed when the letters were distorted or contained unnecessary strokes. Bakls et al. (IBM) published ``An Experimental Study on Machine Recognition of Handwritten Numbers''.
5tudyor Machine Recognize
ion or Hand Pr1nted Nu＊era
ls) J, IEEE Transactions on Systems Science and Cybernetics (IE
EE Transactlons on Sys
tems 5clence and Cyberne
tlcs) Vol. 5SC-4, No. 2, July 1988 issue, reports on a method for recognizing handwritten digits. In the system described, the numbers are 25X32
is converted into a binary matrix. Features are extracted to reduce the dimensionality of the 800-bit vector (25X'12) to about 100, and the 100-bit vector is sent to several classifiers. Some kind of “normalization” of characters (n
. rg+a11zat1on)J is also performed. The authors ranged from 8B to 99.7B depending on the handwriting samples used.
% recognition rate is reported. Due to the low recognition rate compared to the desired level for commercial applications, the authors conclude that ``tracking courses should combine curve-following measurements...with automatic feature selection and parallel decision logic.'' It seems so,'' he concludes. In what appears to be a follow-up study, R.G. Cathy (R, G, Ca5ey) has applied the "normalization" of Bakis et al.
An experiment extended to the method of ng) is described. "Moment normalization of handwritten characters (No ant No
rsaLlzation of Handprint
Characters) J, IBM Journal on Research Development (IBM Journal
l or Research Development
), September 1970, pp. 548-557. Cathay uses curve tracking as suggested by Bakis et al.
and a decision method system including template matching, clustering, autocorrelation, weighted cross-correlation, and region segmentation with n elements. In the paper below, Naylor (also from IBM) describes OCR (optical character recognition) using a computer, an interactive graphics console, and gradient normalization.
Reporting on the system. ``Some studies in the interactive design of character recognition systems''
teractiveDeslgn of Charac
ter Recognltlon! 3 systems)
IEEE Transactions on Computers
Co5puters), September 1971 issue, 107
Pages 5-1086. The purpose of his system was to develop appropriate logic to identify the features to be extracted. Another extracted feature approach is described by Todd in US Pat. No. 4,259,661, issued March 31, 1981. According to Todd's method, the rectangular area formed by the outline of the character is normalized to a predefined size and then divided into sub-areas. The "darkness" J of the image within each of the sub-regions is evaluated and a "feature vector" is formed from the set of darkness estimates. The feature vector is compared to a stored set of feature vectors representing the character, and the best match is selected as the recognized character. [5PTA: Proposed algorithm for thinning a binarized pattern (SPtA: A Proposed A
lgoritha for Thinning Bin
ary Patterns) J, IEEE Transactions on Systems Man and Cybernetics (IEEE Transactions on Systems Man and Cybernetics)
stems, mans, and cybernetic
s) s SMC-14, No. 3, 1984 576
In a paper titled, Monthly Issue, pp. 409-418,
Naccache et al. have published other approaches to the OCR problem. This method provides that patterns are often composed of wide strokes and that it is advantageous to skeletonize the patterns. As explained by Nakash et al., "Skeletonization is performed by iteratively removing black points along the edges of the pattern (i.e., turning black points into white points) until the pattern is thinned to form a line drawing. It is ideal if the initial pattern is thinned to its solid axis. This paper briefly describes 14 different known skeletonization algorithms and then describes its own algorithm (
SPTA). All described skeletonization algorithms, including 5PTA, are based on the idea of passing a 3 row by 3 column square window (commonly referred to as a 3×3 window) over the image. When a square 3x3 window passes over the image, the algorithm uses 8 pixels surrounding the center pixel.
Evaluate the two neighboring pixels and, based on the evaluation, convert the black center point to white or leave it black without changing it. Pattern classification has also received significant support from other areas that have shown recent advances in related fields. In particular, the work by Hopfleld disclosed in U.S. Pat. No. 4,660.188, issued April 21, 1987,
・Advanced parallel computing networks (“neural networks”) have been in the spotlight. In particular, Gullehsen et al., ``Pattern classification using neural networks: a practical system for symbol recognition
ifieatlon by Neural Netwo
rks: An Experimental System
m for 1eon Recognition)J,
The work reported in the Proceedings of the IEEE 1st International Conference on Neural Networks (Cardll et al. W), pages IV-725-732, focuses on character classification methods. The system they describe uses some kind of image processing but no feature extraction. Instead, they believe that neural networks are
training pro
It relies completely on the original classification intelligence acquired through cess). Although the reported system appears to work well, many issues remain to be explored, as suggested by the authors. System performance is below acceptable limits. Many other character classification techniques and approaches (research methods)
and algorithms exist. However, for purposes of this disclosure, the above references provide a reasonable description of the most pertinent prior art. refers to the fact that, despite all the efforts put into solving character recognition (i.e., classification) problems, existing systems do not provide the accuracy that would allow reliable automatic character recognition. Let's just keep it that way. SUMMARY OF THE INVENTION The present invention provides a highly efficient OCR system by selecting the right combination of techniques and modifying those techniques to be high performing in terms of speed and accuracy. The general approach of the present invention is to remove meaningless variations and capture meaningful variations before classification. In particular, in accordance with the principles of the present invention, a character to be recognized is scanned to form a pixel image, and that image is scaled and "cleaned." The scaled and cleaned image is tilt corrected and skeletonized to form a thinned image. A nine-dimensional network extracts features from this thinned image to form an image map. The features are then combined to form "super features." The image is then coarsely blocked to reduce the dimensionality of the feature vectors. Finally, a classifier identifies the character using the feature vector. EXAMPLE FIG. 1 shows a flowchart of our method for character or symbol classification. At block 10, a character image is advantageously captured and stored in a frame buffer, such as a semiconductor memory device. The image may be acquired via electronic transmission from a remote location, or it may be acquired "locally" using a scanning camera. Regardless of the source of image acquisition according to typical embodiments, the image is represented by an ordered set (array) of pixels. The value of each pixel corresponds to the light (brightness, color, etc.) emitted from a particular subregion of the image. Pixel values are stored in storage. Smudges and extraneous strokes are often found near the characters, and their presence cannot but make the recognition process more difficult. According to our invention, block 20 follows block IO, the function of which is to clean the image. This is the first step in our effort to remove meaningless variability from images. Typically, an image of a symbol or character, such as a number, contains one large group of (adjacent) pixels and a small group of decimals, which may be zero. Our cleaning algorithm essentially identifies all such groups and removes all but the largest group. If the sum of the deleted groups constitutes more than a certain percentage of the initial image, it indicates that the image is anomaly, and this fact is noted for later use. Within the context of this description, it is assumed that image symbols are composed of dark strokes on a light background. "Inverted" images can of course also be processed with similar equipment. The cleaning algorithm described above also assumes that the expected symbol set in the image does not contain symbols that require uncombined strokes. The numbers 0-9 and the Latin alphabet (excluding lowercase l and j) form such a set, but most other alphabets (Hebrew, Chinese, Japanese, Hangul, Arabic, etc.) Contains unbound strokes. For such other sets, a somewhat different cleaning algorithm would have to be applied, looking only at each disjoint region rather than the entire set of regions. There are many methods that can be applied to detect and identify these foreign regions. The method we use is similar to brush fire. According to our method, the image is raster scanned from top to bottom to find the "black" pixels. When such a group is found (ie, a black pixel not previously considered is encountered), the scan is interrupted and a "brushfire" is ignited. That is, the encountered pixels are marked with an identifier, and the marking starts the dilation process. In the dilation process, each of the eight immediate neighboring pixels is considered. Those neighboring pixels that are black are similarly marked with an identifier, each marking starting its own dilation process. In this way, I first encountered "black"
The groups of pixels allow all groups to be quickly identified by the selected identifier. At this point in the process, scanning of the image is resumed so that other groups can be found and identified (with different identifiers). When the scan is complete and all "black areas" have been identified, area calculations can be performed. As shown above, all groups except the largest group are removed from the image (ie, inverted from dark to light or turned off). At this point, it can be seen that in character recognition technology it is more important not to make the mistake of incorrectly identifying a character than to refuse to make a decision. For this reason, in systems designed to identify numbers or other character sets without discontinuous strokes,
The region removal threshold should be set to a fairly low level. Normally it would be expected (in the 0-9 character set and the Latin alphabet mentioned above) that the pixels comprising a significant portion of the image would be strictly contiguous. On the other hand, perhaps this should be an exception when the areas are only very slightly separated, and the letters (e.g. when written with a pen that does not produce ink well or on a coarse paper surface) External information leads one to believe that a stroke can be broken accidentally. In order to prepare for such contingencies,
) Our method for spreading J is to spread 8 additional pixels a little further away from the 8 immediate neighbors (the 8 pixels are the large window corner and the center pixel of the large window side). Contains an oncisine for defining a neighboring pixel to include. In the end, we allow "fire" to jump over "f'ire break". Resize the image in block 25 to a predetermined size (
A scaling process follows the cleaning process. Size H! ! Of course, it also removes the meaningless variability of the image. The cleaning process performed before size adjustment is performed because it is desired not to adjust the T size of the image while containing smudges. The scaling process may use any of a number of different algorithms. For example, according to one algorithm, an image can be resized by the same factor in both dimensions until one dimension of the image reaches a predetermined size. Other algorithms perform size adjustment in both dimensions independently with some limit placed on the maximum difference between the size adjustment magnifications in both dimensions. Both approaches work well, so we leave the choice of algorithm and its implementation to the reader. We first size each character image to the appropriate number of pixels, such as an 18x30 pixel array, using the algorithm described. People generally write letters diagonally. The slope differs from person to person. Character slant or skew is another meaningless variability of handwriting that carries no information, so we remove it. Returning to FIG. 1, block 30 following block 25 performs deskewing of the image.
ng). In other words, the function of block 3o is
The goal is to make all the letters more evenly upright. Block 30 can use any of a number of conventional procedures to perform skew correction of the image. One such procedure performs a transformation of the following form on the image. Here, X and y are the initial coordinates of the image, and Xo and y. defines the origin, U and V are the coordinates of the transformed image, and m, and yy are the image moments calculated by ), the pixel at position Xs'/ is "
Takes a value of 1 when the color is black, and 0 otherwise.
takes the value of The effect of this function is to reduce the xy moments to essentially O. Size adjustment (block 25) and tilt correction (block 3)
0) are both linear transformations. It would be advantageous to perform a composite transform on the cleaned image to directly form a tilt corrected image. By performing this compound operation, it is possible to avoid the need to display the resized image in explicit form as an array of pixels. This will eliminate sources of (computational) noise. Block 40, which follows block 30 in FIG. 1, thins the image. Image thinning also removes meaningless variability in the image. As mentioned above, skeletonization according to the prior art (skeletonizatS
The method on) uses a 3x3 window that is passed over the image. The center point of the H.383 window is turned off if certain conditions are met; and for most methods, these conditions involve iterative testing with various predefined window conditions. For example, Ben-Lan and Monto 04
01toto) The algorithm detects a dark center if it has the following conditions: 1) its pixel has at least one bright neighbor out of four; and 2) its neighborhood has eight predefined 3x3 windows. does not match any of the following; if it satisfies, it is deleted (i.e., turned off or cleared). A four-neighborhood is a pixel to the east, north, west, or south of the considered pixel. Until recently, processors could only handle one task at a time anyway, so algorithms similar to the above were perfectly usable in software implementations. However, these algorithms are inevitably slow due to the nature of their procedures. Moreover, each of these prior art tests targets certain features of the pattern but not others. Different tests must be used to thin the strokes of different characters (e.g. vertical and horizontal lines). Furthermore, when using prior art tests, it is necessary that at least some of these tests be performed sequentially before a particular pixel can be reliably detected; and unless these tests are performed, the pixel cannot be turned off. The embodiment of FIG. 2 illustrates this problem. In FIG. 2, templates 100 and 110 are two 3×3 pixel windows. The three top pixels in template 100 are circle-shaded to indicate looking for ON pixels. The center pixel and the pixels within the center of the bottom row are shaded to indicate looking for OFF pixels. The remaining pixels are blank to indicate a "don't care" condition. Template 100 has a bright section (pixel 10151) above a dark section (pixels 104 and 105).
Looking for edge conditions of G2 and 103) predicts that the dark region must be at least two pixels thick. When such a condition is encountered, the center pixel (104)
can be changed from on to off (dark to light). Therefore,
Template 100 provides a mechanism for starting from the top and nibbling away the on area until only one on row is left. Template 110 works similarly, except that it has a bottom row that searches for off pixels while the center pixels of the first and second rows search for on pixels. Template 110 scrapes the on (dark) area from the bottom. The above template, where horizontal lines are thinned and vertical lines are not thinned, indicates that it is preferable to pass a number of different templates over the image, where each template is sensitive to different features of the image. It is also preferable (from a speed point of view) to pass the various templates simultaneously. However, if templates 100 and 110 were applied to image segment 10B of FIG. 2, the two pixel wide horizontal lines depicted would be completely removed, so this would not be applicable in this case. The top row will be removed by template 100 and the bottom row will be removed by template 110. If thinning is to be performed efficiently, interdependencies between different templates must be broken. Unexpectedly, this interdependence is 3X3
It has been found that it is possible to defeat this by using a larger window. Therefore, we use a template set that includes at least some templates larger than 3X3. Some things are 3X3 and some things are 3
×4, some are 4×3, and some are 5×5. A feature of the set is that the templates can be passed over the image simultaneously. This possibility is realized by the special selection of templates that allow images to be modified in response to one template without detrimentally affecting the ability of other templates to modify images independently. This rather unique set of templates is shown in Figure 3. We have found that the set of templates shown in Figure 3 is a sufficient set. According to our invention, such a set is characterized in that it contains at least one template larger than 3X3, although other sets are of course possible. To explain the operation of the illustrated templates, we begin with templates 120 and 140. These templates correspond to templates 100 and 110 of FIG. Template 120 is shown as a 5x5 array, but the outer columns and rows are "don't care" so essentially this forms a 3x3 window. Template 120 differs from template 100 in that pixels 121 and 122 in template 120 are tested to see if they are on pixels, and the corresponding pixels in template 100 are set to "don't care." is different. That is, template 120 ensures that steered (lightened) pixels are above lines that extend in both directions. Template 140, on the other hand, differs from template 110 in that it is actually a 3X4 template. It contains a 3x3 section similar to 383 template 110 (except for pixels 141 and 142)
And it also includes pixel 143 in the center of the first row. Pixel 143 eventually requires the horizontal line to be three pixels wide before the pixel is allowed to be scraped (from the bottom). Templates 130 and 150 are template pair 120
and 140 similar template pairs are formed. Templates 130 and 150 thin vertical lines. Template 16-Q, 170.180 and 190
point to the right, left, top, and bottom, respectively. "knees"
) Thin J; templates 200, 210,
220 and 230 thin the inclined line from the top and from the bottom, and so on. Template 160-230
It will be seen that all are 5x5 templates. Returning to FIG. 1, the skeletonization block 40 is followed by a feature extraction block 50. Although the operations are similar, skeletonization differs from feature extraction in mechanical terms. In skeletonization,
Unwanted pixels are identified and they are changed from dark to bright. In feature extraction, relatively macroscopic features are identified that aid in character classification. The macroscopic features identified are those types of features that do not depend on the size or thickness of the letter, but that give the letter its particular "signature."
) gives J. It is therefore these characteristics that block 50 seeks to identify. Feature extraction is operationally accomplished by passing a partial window over the image. Each window in our system is a 7x7 template, and each template has endpoints,
Detecting the presence of certain features such as diagonal lines, horizontal lines, vertical lines; etc. Detection is done by a main rule meaning that a feature is concluded to be present when the majority of 49 pixels (7×7) fit into the template. In our system, we use 49 different 7X7 templates as shown in FIG. For each template, we form a "feature map" that essentially indicates the coordinates within the image array where the template's pattern matches the image. After developing the 49 feature maps corresponding to the 49 templates of FIG. 4, at block 60 we form a number of super feature maps that are logical combinations (AND and OR) of the feature maps. In this way, we reduce the set from 49 maps to 18 maps (in an 18x30 pixel array). The number of reductions was determined heuristically. We call this detected feature a "map" because we construct the array (in the memory where we store the array) and we place the detected feature within the appropriate position within the array. In this way we record the presence of features and their locations. Although other mechanisms can be used to record "hit" location indications, it is conceptually easier to think in map form. The 18X30 array was found to be too detailed for classification purposes. Although the details can actually mask the text, they make the classification task more difficult (as the saying goes, "You can't see the forest for the trees"). Therefore, block 70 is coarsely blocked (blockl
ng) to reduce the 18×30 feature map to only a 3×5 feature map. This results in a final map or vector of 270 bits corresponding to 18 3.times.5 maps. Finally, block 80 executes a classification algorithm to
Determine the most likely candidate from the given 270 bits. Once you know which template most likely corresponds to the character to be identified, you can use the minimum humming (
A simple algorithm such as determining the distance (Ha++ning) would be sufficient. The key, of course, is in determining these templates; and that aspect requires learning methodologies (such as backpropagation) that the technology currently deals with. Hardware Implementation FIG. 1 shows the process of our OCR system, but it also closely represents the hardware implementation. The actual details of signal flow will vary with the particular design, but are entirely within the scope of normal circuit design techniques. For the purposes of the following discussion, our system operates in a vibline manner and each electronic circuit block provides the necessary signals and control to the following circuit blocks, along with the necessary identification as to which pixel is to be considered. Let's assume that. As previously indicated, block 10 includes the usual equipment associated with the particular source of images to be classified. It is simply a commercially available "frame grabber".
It may also be a retardo video camera that combines a camera (Bber) J and a storage device. When the classification process is initiated, a storage device is accessed to retrieve the center pixel and 24 neighboring pixels;
The set of searched signals is provided to block 20. Blocks 20 and 30 are executed in this case on a SUN workstation using the simple program shown in the appendix. Local memory is included in the microprocessor for storing image signals and, if necessary, temporary calculation results. In fact, any microprocessor can be used equally well, but if you need faster speeds than you can get with a microprocessor,
Specialized hardware can typically be designed to perform the required calculations. In fact, since the required operations are simply additions, subtractions, comparisons, and rudimentary multiplications, pipelined architectures that provide extremely high throughput can easily be designed. The output of block 30 is a series of signal sets, each having a center pixel and its neighboring pixels associated with it. Block 40 is implemented using the neural network of FIG. 5, which includes a series-coupled switch 400, a template match network 410, and a threshold network 420. An input signal corresponding to the values of the 25 pixels of the image covered by the 5×5 window at a given moment is applied to switch 400 at the input of 410 . Switch 400 ensures that these values are provided to the network simultaneously. Network 410 includes 25 input leads and a number of output leads equal to the number of templates stored. Within network 410, all input leads are coupled to each output lead through a column of preset coupling nodes. Each such column of combined nodes (e.g., the column containing nodes 411-414) has a stored one
Compatible with two templates. Therefore, the signal of each output lead indicates which template the input signal belongs to. More specifically, the coupling node has three types of "diversity" to know the excited state (E), the blocked state (1) and the "don't care" state (D). The response to a match or mismatch is different for each variety according to the truth table below. Input Synapse Output OE 0 1 E 1 1 l -2 0D 0 1 D O The node 411 that executes this truth table can be easily realized using a gated amplifier. Information regarding whether a node is an E-node, I-node, or D-node can be stored in two flip-flop sets attached to each node (when diversity is desired). Alternatively, the information is "connected" to an array of links attached to the array of nodes.
) J is possible. Programming (i.e., binding) of templates can be accomplished by burn-1hrogh of the appropriate links. If the template were completely and completely immutable, it would naturally be possible to design the template information directly into the integrated circuit mask of the array of nodes. Current in the output line flows through the impedance, and that flow raises the voltage on each output line of network 410 to a level proportional to the degree of matching between one in the set of input signals and the excitation node. It will be appreciated that the voltage will also be reduced by the degree of matching between one in the set of input signals and the blocking node. The output line of network 410 is fed to a threshold circuit 420, where its impedance can optionally be placed. Network 420 provides a set of thresholds to the output signal of network 410. In particular, the circuit network 420 is
A set of two sources having one input responsive to the input lead of network 420 and a number of sources (e.g. 425-427) connected to second inputs of amplifiers 421-424.
Includes human power amplifiers (e.g. 421-424). Each of the sources supplies a different current and each amplifier 42 accordingly
1-424 develops a voltage on its second lead related to the particular coupling that lead has to sources 425-427. In this manner, different amplifiers within circuitry 420 can be provided with different thresholds. The output leads of network 420 are the outputs of amplifiers 421-424, and they assume a logic 1 or 0 value depending on whether the amplifier input signal exceeds or does not exceed a threshold. Block 50 is composed of a neural network as shown in FIG. However, since block 50 handles 7X7 templates as opposed to the 5X5 templates of block 40, storage 55 is inserted between the two neural networks to buffer the data. Block 60 generates 18 feature maps. It simply accepts the output of block 50 and stores the appropriate information in memory along with a signal characterizing the consistency of the center pixel. The result is 18 memory segments, each segment containing information about features found within the image. Each such segment is therefore one of our feature maps. Coarse blo block 70
cking) is accomplished by using 18 additional small memory segments, possibly within the same physical storage device. Block 70 stores information within these small memory segments regarding features found within appropriately selected portions of the large memory segments. When the size of the initial image is 18 pixels by 30 pixels, the selection is easily achieved using a counter operating with modulus 5, where the full value of the counter (full v
alue) is used to access the large segment, while the whole number (whole n
uIlber) is used to identify cells within the 18 small memory segments. The 270 storage locations of the small memory segment are block 7
produces an output of 0, resulting in a vector representing the characters contained within the image. The last function that needs to be performed is to feed this vector to some circuitry that will select the most likely candidate character for the given feature vector. This is the function of block 80. Block 80 may be performed in a number of ways. For example, it would be advantageous to use the teachings of Hopfield's content matching scheme in the aforementioned U.S. Pat. With such information stored, the content-matching (associative) memory identifies the feature vector of the character that is closest to the supplied feature vector. The network is extremely robust (strongly adaptive) so that it makes "accurate" selections even when the input appears to be highly distorted. However, the design of the feedback network for the Hopfield circuit is somewhat difficult because feedback to the Hopfield circuit causes all stored vectors to be distributed within the feedback network and mixed with each other. This difficulty limits how we recognize the letter ``4'', for example, and the limits of when it is possible to recognize ``4'' and when we are unsure and refuse to decide. is compounded by the fact that it is not known exactly. Despite this, we can recognize the letter "4" just by looking at it! This research attempts to solve this problem by having the classification circuit perform "learning" through trial and error in order to arrive at the correct decision. One configuration with the possibility for such "learning" is shown in FIG. In the current state of the art, this technique is generally referred to as "backpropagation"
ack propagatlon). This is, for example, ``Exploration within the fine structure of recognition (Exploration)''.
rations 1n the Microstruc
ture of' Cognltlon) J, M I
T Publishing, 1986, Chapter 8 “Parallel distribution processing (Par
allel Distrlbuted Process
ing) J., D.E. Ru+++elhart, J.L., Me C1elland, eds. [Learning
Internal Representatlons
by Error Propagatlon) by E. Ramelhardt in J. FIG. 6 includes optical interconnect networks 81 and 82 coupled in series. An input signal set is applied to the input of network 81 and an output signal set appears at the output of network 82. Each network has multiple input and output leads, with each input lead connected to all of the output leads. More specifically, each input lead i has a connection weight
It is connected to each output lead j via Wlj. In our application, network 81 has 270 input leads and 40 input leads. circuit network 82
has 40 input leads and 10 output leads. The number of input leads of network 81 is determined by the length of the feature vector. The number of outputs of network 82 is determined by the number of characters in the classification set. The number of intermediate lead wires (40 in this case) is determined heuristically. Training the circuit of FIG. 6 provides developed feature vectors of known characters and maximizes the output signal at a designated output lead of the circuitry 82 corresponding to the provided known character. This can be done by adjusting the weights in both networks 81 and 82. The available samples of all the characters in the set to be sorted are thus fed into the network, each time using weights in the interconnection network to maximize the signal on the appropriate output lead. is adjusted. In this way, one set of weights W for both networks
1j is formed. It may be appropriate to state that the coupling way W1j is essentially an analog quantity and that the circuit operates in an analog manner. That is, the voltage on any output lead of network 81 will be the same as the ignited voltage coupled to that output lead.
fired up) is the sum of the contributions of the J weights. Each weight is "fired" by a binary signal on the input lead to which it is coupled. Therefore,
The output at lead j is equal to 〒Biwlj, where B is the value of the first input lead (0
Or 1). Although the concept of such learning networks is fairly well understood, the challenge remains of implementing such analog circuits efficiently and compactly. The requirements for such circuits are not simple. For example, if optimization of the network is to be achieved, the minimum weight change or modification must be fairly small. The iterative improvement method described above is based on the heuristic assumption that better weights may be found in the vicinity of good ones, but that heuristic assumption fails when the subdivision is not fine enough. For small networks 81, an analog depth of at least 8 bits is required. Larger networks will require finer subdivision. The weights must also represent both positive and negative values, and changes must be easily reversible. During the learning and training sections, the number of changes to the weights may be sufficiently large. Therefore, a practical circuit must allow for quick modification of weights. Taking these critical demands into consideration, we fabricated an efficient analog coupling weight circuit or strength circuit using MOSVLSI technology. Although each connection weight in FIG. 6 is simply shown as a black circle, FIG. 7 shows the circuitry for implementing these circles. More specifically, FIG. 7 shows input line 83 and output line 8.
Figure 4 shows one coupling weight with its coupling to 4 and some conventional circuits. First, the mutual coupling weight part in FIG.
01 and 802 and small MOS switches 803 and 804
, somewhat large MO5) transistor 805, and differential amplifier 8
0B and a multiplier 807. Second, the circuit of FIG. 7 includes a charge coupled switch 80g, a sense switch 809, and various control leads. The circuit operates as follows. Capacitors 801 and 8
02 are charged to different voltage levels, and the voltage level difference is reflected in the output voltage of the differential amplifier 806. amplifier 8
06 has its two inputs connected to capacitors 801 and 802. Amplifier 80 representing the coupling weights
The output of 6 is connected to multiplier 807. Multiplier 807 may be any conventional transconductance amplifier. Multiplier 807 is also connected to input line 83 of the cross-coupling network. The output of converter 807 is connected to the output lead of the interconnect network. Multiplier 807 thus sends a current to the output lead that is the product of the signal on the input lead and the value of the combination weight. The coupling weight is capacitors 801 and 80
is represented by the differential voltage formed by amplifier 80B in response to the voltage difference between 2 and 2. The voltage difference on capacitors 801 and 802 is maintained for a long time (compared to the operations involved within the OCR system);
It has also been found that freshening is not necessary when the circuit is maintained at a moderately low temperature. For example, 77°K
There was no detectable loss over time. One advantage of our circuit is that the weights are vC801-
It will be seen that it is proportional to VC802, so even if there is a charge loss, there is no change in weight as a result when it is the same on both capacitors. Nevertheless, a clear path must be provided for refreshing the information onto capacitors 801 and 802. Furthermore, capacitors 801 and 802
A path must be provided for setting the voltage (charge) value on the top and modifying that setting to enable the "learning" procedure described above. This is where the rest of the switches and controls come in. To bring the coupling weights to the desired level, switch 808 is slightly opened or closed to set a fixed voltage level to voltage source 81B.
to the capacitor 801. Voltage corresponds to a fixed charge. Switch 808 is then turned off. At this point, capacitor 801 is connected to the non-inverting input of amplifier 806 to provide a positive voltage, while capacitor 802
is connected to the inverting input of amplifier 80B, so the coupling weight is at the maximum positive level. Connection weights are changed as follows. First, transistors 803 and 804 are turned on. Transistor 803 is extremely small compared to transistor 805, so to make the phenomenon easier to understand, transistor 803 can be considered as a simple switch. By comparison, transistor 805 is long and narrow, so when it is turned on, it can be thought of as a capacitor. Switch 803 is closed and transistor 805
When turned on (assuming it is an n-channel device), the charge on capacitor 801 is
01 and the inverted charge on transistor 805, which is turned on. Transistor 803 is then turned off, thereby trapping charge within transistor 805. Transistor 804 is then turned on, and if transistor 805 is then turned off slowly, the mobile charge in its channel will diffuse through switch 804 and into capacitor 802. Therefore, the above steps transfer an amount of charge from capacitor 801 to capacitor 802. This corresponds to capacitor voltage changes and mutual coupling weight changes. The above sequence can be repeated as many times as necessary to bring the combination weights to the desired level. In this way, optimization of the connection weights proceeds during the training period, so that each connection weight in networks 81 and 82 is set to the correct level. The above description relates to the training aspect of the circuit. Once the learning process is finished, a means should be provided: l) for determining the values of the weights, and 2) for refreshing losses over time, etc. This includes a detection switch 809, an A/D converter, and a D/A
This is achieved using a converter and non-volatile storage. To determine the weight values within the interconnect network, all input leads are turned on one at a time. Each time a lead is turned on, the sense switches 809 of the weights coupled to that human lead are turned on in sequence, causing each amplifier's voltage to appear on the sense bus 810. The voltage is supplied to A/D converter 811 and the resulting digital information is stored in storage device 812. In this manner, all weights are converted to digital form and stored in storage 812. During a refresh operation, each combined weight is isolated as described above, but at this time the voltage output on sense bus aLQ is connected to the D/A to which the digital output of storage device 812 is applied.
The analog voltage of converter 813 is compared in amplifier 814 . Of course, storage device 812 is caused to emit a digital output corresponding to the refreshed combination weights. Based on the comparison result, the sequence of switch elements 803, 804 and 805 is amplified 81
4 to increase or decrease the voltage on capacitor 801 relative to capacitor 802. The output of bus 810 is converted to A/D converter 81.
1 or to comparison amplifier 814 is controlled by switch 815. If it is necessary to completely discharge both capacitors 801 and 802, the voltage on voltage source 81B can be reduced to zero and switches 803, 804 and 805 can be turned on. //fire, c 9/7/88 LDJ〃 1/ check for broken image
s// returns -1if complete
ly blank // returns Oif co
connected // returns l if co
connected except for samll
flyspeaks // returns 2 if
badly disconnected // uses
recursive brushfire a1go
rithm//Diagnostic output
: prints number of segment
ts. // and 1 location Bd code o
f the largest775ide effec
t: 5ets up Lseg (in rec2c
om)1/IMPORTANT ASSUMFr10
N100ml assume img, pix blac
k pixels are PO3mVE// and
white pixels are zero −/
/ If you can't guannree
hat, call fireQ m5reatio
f fwQ1/ negative pixels w
ill cause // Th1s
routine modifications fng, pix
! ! #1nclude"err1.h" Finger nclude "fire, h" 1nline int 1m1n(iru a, in
t b) (x℃turn(a<b?a: b);)i
nline int imax(int ty ir+
+ b) (remrn(ayb? a : b); 1
staoc int xdl; // copy of
img, xstatic int ydl; //
and img, yTable 2 5taIic char” ” pix 1 ;//
yd img, pixstatic Pa1r” pi
; 5raoc Pa1r"p2; 5tatic int 1ist 5ize = -1
;5tatic Seg mysegJsegmen
t being processed SCg Lseg
; // longest segment th
are ismtic int nseg; 5tatic int totpix; // tota
l pixels in imageint&elσm
age img) ( // make 5ure we have allc
enough room to keep
ow pair-■S family int 1 size w img
, x ” img, y; // nux possible
e 5ize of■st required (
lsiz > 1ist-size) (if(plN delete p i : delete p2; ] pi w new Pa1r[l5izl; p2 =
new Pa1r[1size];1ist 5ize
1+1lsiz; Lseg, 1yst z O; //
no longest segment yetLs
eg, 5ize z O; // first seg
will beat this for surens
eg 0; rotpix = 0; Table 3 // find first blILck pixe
l, so we car+ 1nitiatr, t
int xx; int
yy; for (yy wa (); yy < fng, y
; yy++) (rot (xx sw O; xx
< img, x; xx++) (if(tmg-P
iX[yyl[XXl > O) t/// fpri
nl(stderr, "firstx s-%d f
irsty -%d O, xx, yy):// *
lots of these things might
Iogicily be arguments +o
burnα77 but 5ta6c variab
les ty faster & simplerns
eg++; // count tMs segmen
tmyseg, ashes +w+ -nse4myg
g, 1ist m (Lseg, 1ist 1m pi
)? pi: p2; myseg, 5ize wa
O; xdl wa img, x; ydl wa img,
y; ptxl M img, pix; burn(xx
, yy'), 77 bum, baby, burnt
if (myseg, 5ize > Lscg, 5ize
e) Lscg g myseg;] 川fdef TEST fprintf(stderr, ”Saw%d se
gments', nseg); if (nseg)
fprintf(stderr, 'Longest
(code %d) 5tans at %d %dO
. Lseg, uhes, Lseg, 1is+[Ol, x
, Lseg, 1ist (Ol, y); #endif if (nseg m O) rerum -1; if
(nseg W 1) return O; float
t frac ta float (Lseg, 5ize
) / floatQotpix); cons+ fl
oat m1nfrac wm, 9;if (fra
c)s m1nfrac) return 1;re
turn 2; Table 4 (1) // the magieIIIrecursive
burning routine // turns
o ashes all points that a
re 8-connected to the 1ni
tial point void burn ( int xcent. truycent // ceruer of
3 x 3 region or 1ruest/
/ if this point is off-sc
ale:1f(xcent<Oycenta xce
nt>fable xdl ycenosa-ydl)retu
rn;17 N0TE: this is 1ndee
d a check for > O. // not jusr nonzero, so t
Hings don't burn twice. 1f(pixl[ycentl(xcentl > O
) [int top m myseg, 5ize++;
// keep track of length o
f segmenttotpLx++;/1count
totalpixelsptxl[yceru][xc
eru] wamyseg, ashes; //1urn
this point to ashes burn(xcen
t+1. ycent+1); // 1gn1ten
eigborsburn(xcent+1.ycen
t);burn(xcent+1.ycentl) to um(xcent, ycent+1);burn
(xcent, ycent-1); burn(xc
ent-1, ycent+1); burn(xcent1. ycent); burn(xcent-1, ycent
cent-1); #define jumpbreak
s YES #ifdefjumpbreaks Table 5 // same as above, but doe
s not +lssume that black
pixels are positive;/l no
n-zero 5offices. int fire(Image img)(for (
tnt yy = 0; yy < img, y; y
y++) (for (int xx = O; xx
< img, x; xx++) [img, pix[
yyl[xxl = img, pix[yyl[xxl
! = O;return (fire(img)
); Table 4 (2) int jump x imax (xdl, ydl)
;jump w jump / 20; if (jump < 3) jump = 3; if
θump > 1) ( burn(xcent+jump, ycent-jum
p);burn(xcent, ycent-jump
); burn(xcent-jump, ycent-
jump); #endif // if this point NOT set,
or already bumed, do not
hingreturn; 6 tables/l do most of the work for
r limar transformation pr
ogram//perform lir+ear t
transforms on post off
ice data // i, e, convert t
o 5standard 5ize and aspec
trati. // see lin, plan for extend
ded discussion // Note: xy
pLx[][] win contain small
integers O,,9//for gray
levels below threshold, y
you get zero; // for grayle
vels above threshold, you
get the graylevel num anti-r/
/ Th1s gives you the opti
on of treating it as a bo
olean // if you don't care
About gray levels. // Cauer allocates the ar
ray; we fill it. #tnclude <5tcuo, h>#tnclude
e<rmth,h> inlinefloatfmin(floata, fl
oatb)(return(a<b?a: b);1i
nline float fma, t(float a
, float b) (return(a>b? a
: b); )inlineiruimin(tnta
, 1rub) (return(a<b?a : b);
) inline int imax(int IL,
int b) (returg(a>b? a : b)
]Table 7 voiddo tin(const Image rawJl 1nput i
mageconst int known-fit, /
/ 1111 => char ready fil
ls box pdim by qdim. Image des, // res+rlt:
array of small integersFI
LE” pmm-fpJ/ paruneter fi
le filepointer // O=> all
parameters take default v
aluesccnst char” sname//
filename, for information
al messages/l provide+"'
if you can't do better] (Pair"bl; int 1) I), (Iq; for (Qq= O; qq <raW,)';
Qq++) (for (ppIll O; pP <
raw, x; pp++) if(raw, pix(
qql[ppl) (bl[1b11.x -pp; bl[1b11.y -qq; ibl++; ] do-1in 1(raw, x, raw, y, bl
, ibl, kr+own-fit, des, p
aram fp, sname); delete(bl
); Table 9 // find raw bounding boxi
nt pO, qO, p2. q2; int ibl; int pp+ qQ; if (known fit) (pO=O; qO=O; p2=pselfm; q2=qmountm; ) else (po=bl[0],x; qO=bl [0],y
;p2 = po; q2 = qo; for (ibl z 1; ibl <nbl;
ibl←) (pp = bl[1b11.x; qq
= bl[1b11. y; pO = 1m1n (pO・
PP); p2 size rnax (p2. pp); qo = im Tsumugi (qO, qq); q2 = imax (q2. qq); p2→; q2+
+; Table 8 void do-fin 1 (const int pdimJI 5ize of
1nput arrayconst int qdim
, // ,. const Pa1r” bl, // 1nput:
1st of black pixelscons
t int nbl, // 5ize of 5ai
d 1ist// O=+) all parameters
ers take default values//
provide "" if you can't
do beuerFget(kernel, 2)Jc
involution kernel (units)
of PQ rows/cols)Iget(ming
ray, 3) Jl this or larger:
return graylevel, else
etern zer. float pkem kernel; float
qkem kernel;const int
xo m O; const inc yOw O; const float xmid m (des, x
-xO) / 2.0; const float y
mid w (des, y −yO) / 2.0; Table 10 // calculate some moments
:float” xyflt x new-float
(des, y, des, x); // note th
at we are treating the pi
xels as BOXES of ink, not
points// so the (0,0) pi
xel extends from (0,0) to
(1-eps, 1-eps)/l and has
its center at (,5,,5)flo
at pmid m (po + p2) / 2.0;
float qmid x (qO+q2) / 2.
0; // but if we 5hift the
m1ddle half a bit. // we can pretend the (0,
0) pixel is cerured at (
0,0) float pIj1X++a pmid −
,5:float qmx m qmid-,5;f
loat mpq ws O,;/l PQ rnom
enrfloat mqq w O,;// QQ m
omentfor (ibl z O; ibl <
nbl; ibl+-+) [pp-bl[1b11
．． x; qq -bl[1b11. y;mpq 4m
(qq −qmx)”(pp −pmx); mqq +
= (qq - q plate t)" (qq - qmx); flo
at theta w mpq / mqq; // N
ote: 5ince pixels are num
Bered from UPPER1ft. // positive theta corresp
onds to ”/l negative thet
a corresponds to ”/'// (p
c, qt) is the coordinate
where (p, q) will go when
the char is deskewed. // Th1s is not quit the
same as (x,y) 5ince the 1
atter // has 5ize changes
as well. Table 11 Table 12 Jl Calculate min and max
honz c■-1nates. // measured relative to a
1ine pu resistance 1el to the 5ides
of Yue parallelogram〃

[Mountain e re
ference 1ine goes through
(pmid, qmid) // which is
+he m1ddle of the raw POr
ectangle) #definepmap(p, q)
(p-pmx −(q-qmx)intheIa)flo
at ptOm prnap(bl[o], x, bl
[o], y) JIeftmos+ black pi
xelfloat pt2 m ptO; // rig
htmo* black pixelfor (ibl
m 1 ; ibl'<nbl; ibl++) (
float xxx wa pmap(bl[1b11
．． x, bl[1b11. y) ;pto w fmi
n (ptO, xxx); pt2 tz fm red (PQυ
■); // The points we just cal
cubed are centers of par
allelo furnace boxes // Calculate
how much the box 5ticks
out from the mountain are. pt2-w, 5”fabs(theta) +, 5
01; //, 001 to catch round
ff errorspto-m, 5”fabs(t
heta) + , 501; floatdswmpt2
-ptoJldeskewedwfdthfloat
kf m dsw / (p2-pop; // kru
nch factor // usually (but
not Iwmys) 1ess than 1//
(not used in funher calc
ulations) float conwid m d
sw + pkern-1, Jl yetervi w
ider to make room for con
volumefloat conhgt W q2
- qO+ qkem -I Jl and 7er,
also for convolution floor
t qanid m qmid + (qkern-1
,) /Z, Jl height of m1ddle
of charfloat dfat sw des
, x / (float) des, y; // des
ired fatneu nti. float nfat m fat/dfar, //n
normalized fatneu rati. if (info) fprintf(stdout, ”%sw:%d,
h:%d, mountain:%5.2f, dsw:%5.2f
, M:%5.2f, nfat:%5.2fO. 5nxrrhe, p2-po, q2-qo, th
em, dtw, kf, nfat); Jl cal
curate the coefficients o
f the 1inear transformation
on: float doo, dot, d02. d
lo, di 1. di2; if (inflate
) (// old “1nflationary”
schemefloat fif +a nfat >
fcorn? 1, /nfat: LJfcom
Jl fatness increasing fac
tordlo = O, : // pure ske
wdi 1 x (des, y-yO) / conh
gt; // make output char fi
ll its box vertically =
dll” fif; dol--dll umbrella fif ” theta; d02
= xmid - doonotmid - do1 umbrella qt
mid;//centerpoint is fixed
d point d12 = ymid - d10 umbrella pt
mid -di1 umbrella qtmid; ] else (// never 1nflate sc
hemefloat ygrow x (des, y-
>ro) / conhgt; float xgrow
z (des, x-xo) / conwid; fl
oat dogrow = fmin(xgrow,
ygrow）；／／gow as 1little a
s possible77 i, e, 5luink
so BOTHfitdogrow z fmin(t
, o, dogrow);// but NEVERr
ally 1nflatedlo x O; //
pure skewdll -dogrow;//
5hrink ydoo x dogrow; // a
nd x equallydol m -dogrow
"theta;d02 w xmid -doo"
ptmid -dol ”qtmid; // cent
er point is fixed pointd1
2- ymid-d10 umbrella ptmid-dll umbrella qt
mid;Table 13//make the output 5pace
all white and xx, face yy; for (yy = yO; yy < des, y;
yy++) (for (xx w xo; xx
< des, x; xx++) (xyflt[yyl
[xxl! O,; // and 5 tart be
queathing blacknessint 5p
ip = imax(1,1nt(10"dl l))
;// 5pip w 5cans per 1npu
t pixelfloat 5tep a pkern
/ 5pip; float offset = 5t
ep/2. ; int ii; float fy, fq; int iy; float fxO, fx2; int ixO, ix2; float rxo, rx2; Table 14 #define oops (X) (rprintf(
stderr, 'oops (X)%S%'%f'o
, sname, fxo, fx2); can6n
ue;1for (ibl w O; ibl < n
bl; ib+++) [// 1oop over
black 1nput pixelspp -bl[
1b11. x; qq -bl[1b11. y;fxo
-doo umbrella pp + dol”qq+d02;
//sun ofscan 1ine (in x 5
pace) rx2 = doo” (pkern+pp)
+dO1"qq+d02; // end of 5c
axlline (-,)ixo m 1nt(fxo
); // integer pansix2 w 1n
t(fx2); rxo m fxO-ixo; //remainde
rsrx2 compilation fx2- ix2; if (ixo < O) 0OpS(1); //
error checks & defense
(ixo > wm dci, x) oops(2);
"Medium C2 < O) oops (3); if (ix2
> dcs, x) oops(4) ;for (i
i m O; it <5pip; ii++) (/
/ 1oop over 5can 1ines pe
r 1nput pixe! fq s++ qq +
offset +5tep”ii;ry f10”pp
+di1 umbrella fq+d12;iy w 6nt) fy; if (iy < O) oops(5);if (
iy % des, y) oops(6) ;xyfk
[iyl[ixOto1rxo;xyflt[iyl[i
x2] +-nc2;for (int jj m i
xo; jj <ix2; jj++) (xyfl
t[1yllj] +I! = 1.0; Table 15/l clip the bouom off of
the gray-scale // using qu
estionable threshold sche
me// &st, find blackest o
output pixel float zmax m O
; for (yy x yO; yy < des, y;
yy++) (for (xx w xO; xx
< des, x; xx→)(zmax x fmax
(zmax, xyflt[yyl[xxl);//
then clip away... float zz m xyflt[yyl[xxl
;int gr W 1nt(9,9” zz / z
max);if (gr < mingray) gr
x O; des-1) iX[>'y][xxl s
gr; W seat 'II//11. Saddle m seat mH shield imitation q//p
ut away all our toys: dele
te2(xyflt);

[Brief explanation of drawings]

Figure 1 is a general flowchart of the classification method; Figure 2 is an example of a problem that occurs when using independent 3x3 templates; Figure 3 is used in the present invention where templates larger than 3x3 are included. A set of thinning templates to be used: Figure 4 is a set of feature extraction templates; Figure 5 is a set of thinning templates.
Structure of a neural network determination circuit used in conjunction with the templates of FIGS. and 4; FIG. 6 is a structure of a two-layer neural network with analog value connection weights; and FIG. 1 shows an embodiment for a neural network. 1-49... Feature extraction template 120.130, 140.150-350... Thinning template 121.122.141.142... Pixel 80L, 8Q2... Capacitor 803.804, 808, 809, 815.828...
・Switch 805.825.827...MOS) Transistor 80B, 814...Comparator means 807...Multiplying means Applicant: American Telephone & Telegraph Company FIG. FIG, 4 (fufugu) FIG, 4 FIG, 4 (in p1) FIG. FIG.

Claims (20)

[Claims] (1) A method for classifying images, comprising: processing a signal corresponding to the image to form a processed image; and extracting features to form features of the processed image. and a step of classifying; the processing step includes skeletalizing the image.
1. A method for classifying images, comprising a partial step of etonization and a partial step of deskewing the image. (2) The processing step includes size adjustment of the image (
The method of claim 1, further comprising a partial step of scaling. 3. The method of claim 2, wherein the skeletonization substep follows the size adjustment and skew correction substeps. 4. The method of claim 2, wherein the skeletonization partial step precedes the size adjustment and skew correction partial steps. 5. The method of claim 2, wherein the processing step further includes a substep of cleaning the image before the size adjustment substep. (6) the step of processing further comprises the substep of removing from the image discontinuous strokes whose area is less than 10% of the area occupied by other strokes in the image; The image classification method according to claim 2, characterized in that: (7) The classification step is characterized in that the consistency of the symbols included in the image is determined based on a stored set of weights obtained from a training set of given sample symbols. The image classification method according to claim 1. (8) the feature extraction step includes forming feature identifiers that describe features of the processed image and their locations within the processed image; A method according to claim 1, characterized in that, between the step of classification, the method comprises a step of coarse blocking, encoding the feature identifiers into a reduced set of feature identifiers. (9) said step of feature extraction; forming a plurality of feature maps describing features of said processed image and locations of those features within said processed image; 2. The method of claim 1, further comprising: combining the feature maps into a super-feature map corresponding to composite features. (10) The method of classifying images according to claim 9, wherein the high-level feature map is formed through combinatorial logic that combines some of the feature maps. (11) A method for classifying characters in an image; capturing the image in the form of an array of image elements; resizing the array of image elements to a selected size; and removing unnecessary image portions from the image. and processing the image to thereby form a processed image; skewing and skeletonizing the processed image to form a thinner and more upright modified shape of the image; extracting features from said thinner and more upright image characterizing said image and forming feature identifiers to represent features of said image and their locations; and a coarser feature map. coarse blocking of the feature map to form
and classifying the coarse feature map as representing one of a known set of symbols or as representing an unknown symbol. Method. (12) In an apparatus for identifying characters embedded in a given image; a first means for capturing said image in the form of an array of image elements; and a first means for capturing said image in the form of an array of image elements; second means for identifying the presence of characters in said image in response to means and for adjusting said characters by deskewing and skeletonizing said image; third means for extracting features of the adjusted image in response to the second means to form an associated feature map; and third means for extracting features of the adjusted image in response to the third means; a fourth means for expressing a roughly blocked modified shape;
and means for classifying the coarsely blocked shape of the feature map as representing one of a known number of characters or an unknown character; Character identification device. (13) The partial steps of skeletonization include: passing a plurality of templates in parallel over the image; 2. The method of claim 1, further comprising: unconditionally determining whether the selected portion of the image can be deleted from the image. 14. The image classification method according to claim 13, further comprising the step of deleting the portion of the image according to the unconditionally determining step. (15) The step of passing the plurality of templates includes passing the template over the image within the step of sequentially aligning the template with different parts of the image. How to classify images. (16) The method of classifying images according to claim 13, wherein at least one of the templates forms an array of more than 3 pixels by 3 pixels. (17) A method for thinning a pixel comprised of pixels arranged in an array; passing a plurality of templates over the image simultaneously;
and unconditionally determining, for each template, whether a selected portion of the image can be deleted from the image based on a comparison between the template and the image. Image thinning method. (18) The step of passing the plurality of templates includes passing the in-plate over the image within the step of sequentially aligning the template with different parts of the image. Image thinning method. (19) The image classification method according to claim 13, wherein at least one of the templates forms an array of 5 pixels x 5 pixels. (20) The method of classifying images according to claim 13, wherein the selected portion includes more than one pixel.