JPH02219189A - Method for making lines constituting picture image finer and said image more sharply outlined - Google Patents

Abstract

PURPOSE: To increase the processing speed and to improve the precision by causing plural templates to pass on a picture in parallel and determining whether a selected part of the picture can be deleted from the picture or not without conditions based on comparison between each template and the picture. CONSTITUTION: This method consists of the step, where plural templates larger than a window of 3×3 picture elements are caused to pass on the picture in parallel and the step where it is determined without conditions whether a selected part of the picture can be deleted from the picture or not based on each of templates 120 to 350 and the picture. A set of used templates includes different templates 120 to 350, and each template has a specific arrangement between dark picture elements and light picture elements. Thus, the processing speed is increased and the precision is improved.

Description

[Detailed description of the invention]

[Industrial Field of Application] The present invention relates to pattern analysis and pattern recognition, and more particularly to the field of pattern analysis and recognition, and more particularly to the field of stroke analysis of imaged symbols, characters, or binary images that can be used in classification processes in general.
ke) to thinning (thlnnlng) or skeletonization (sk
eletonlzing) system. The present invention relates to a patent application entitled "Image classification method, image white character classification method and identification device, and image thinning method" filed on the same day as this specification. PRIOR ART There are a wide variety of applications in which it is desirable for a machine 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 1980'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. Bakis et al. (IBM) published ``An Experimental Study on Machine Recognition of Handwritten Numbers''.
5tudyof' Machine Recognl
tron of Hand Pr1nted Nuae
rals) J, IEEE Transactions on Systems Science and Cybernetics (I
EEE Transactlons on 5yste
ss 5science and Cybernetics
) No. 5SC-48, No. 2, July 1968, reports on a method for recognizing handwritten digits. In the system described, the numbers are converted into a 25.times.32 binary matrix. 800 bit vector (2
5X32) to about 100 to about 100.
f'eature) is extracted and the 100-bit vector is sent to several classifiers (categ. rlzer). Normalization (n
. rmallzatlon) J is also performed. The authors ranged from 8B to 99.7B depending on the handwriting samples used.
% recognition rate will be reported. Since the recognition rate is low compared to the desired level for commercial applications, the authors recommend that the "tracking course combines a curve-tracking type ?#1 constant... with automatic feature selection and parallel decision logic. It seems that it should.'' In what appears to be a follow-up work, R.G. Cathey (R, G., Ca5ey) applied Bakis et al.'s "normalization" to target character slant correction (deskevl).
An experiment extended to the method of ng) is described. “Moment normalization of handwritten characters (Moment No.
rmallzation of'l1andpr1n
t Characters) J, 18M Journal
On Research Development (IBM Jou)
rnal or Re5earch Devel
opment), September 1970 issue, 548-557
See page. Cathay uses curve tracking and template matching as suggested by Bakis et al.
A feature recognition method was used that combined a decision method system including clustering, autocorrelation, weighting, cross-correlation, and region segmentation with n elements. In the paper below, NaFfor (also from IBM) describes OCR (Optical Character Recognition) using a computer, an interactive graphics console, and gradient normalization.
Reporting on the system. ``Several studies in the interactive design of character recognition systems''
teractlveDesign or Charac
ter Recognition Systems)J
IEEE Transactons on Computers
Computers), September 1971 issue, 1075
-1080 pages. The purpose of his system was to develop appropriate logic to identify the features to be extracted. Another extraction feature approach is described by Todd in US Patent No. 4.259.681, 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 stored and compared to a set of feature vectors representing the character being displayed, and the best match is selected as the recognized character. rsPTA: Proposed algorithm for thinning a binarization pattern (SPtA: A Proposed A
1goritb+e for Thlnnlng Bi
Nary Patterns) J, IEEE Transactions on Systems Man and Cybernetics (IEEE Transactlon onS)
systems, mans, and cyberneti
cs), Volume SMC-14, No. 3, May 1984/
In a paper entitled June issue, pages 409-418, Naccache et al. present another approach to the OCR problem. This method is based on the fact that patterns often consist of wide strokes, and
and skeletonize the pattern
It is presented that it is advantageous to do so. 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 proposes its own algorithm (SPTA). All described skeletonization algorithms, including 5PTA, use 3 rows x 3
It is based on the idea of passing through a row of square windows (usually called 3x3 windows). As the square 3x3 window passes over the image, the algorithm evaluates the eight neighboring pixels surrounding the center pixel and converts or modifies the black center point to white based on its evaluation. or leave it as black. Pattern classification has also received significant support from other quarters that have shown recent progress in related fields. In particular, research by Hopr1el'd, disclosed in U.S. Patent Specification Box 4,060.18ti, issued April 21, 1987, led to the development of advanced parallel computing circuits ("neural circuits"). ``Net'') has been in the spotlight. Especially Gullchsen.
[Pattern Classification by Neural Networks: A Practical System for Symbol Recognition] by et al.
slf'1cat1on by Neural Net
works: An ExperiIIIental Sy
stam ['or Icon Recognltlo
n) J, IEEE Proceedings of the 1st International Conference on Neural Networks (
Cardil (other lines), IV-725-
The work reported on page 732 focuses on character classification methods. The system they describe uses some kind of image processing but no feature extraction. Instead, they found that neural networks are capable of “back propagation.
training method
It relies completely on the original classification intelligence acquired through the ``process''. 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. Despite all the efforts put into solving the character recognition (i.e., classification) problem, existing systems lack the accuracy and accuracy that would be necessary for a successful commercial system for recognizing handwritten symbols. Suffice it to say, it doesn't offer speed. SUMMARY OF THE INVENTION The present invention provides improved thinning and skeletonization of handwritten characters or other variable line width images, thereby enabling recognition with higher accuracy. Furthermore, an increase in accuracy is achieved with an inherent increase in processing speed. Similar to Nacassini et al. above, our invention also uses a template to scan over the image to be thinned. However, whereas prior art systems use 3x3 templates, our invention uses templates that are larger than 3x3. Furthermore, our templates are chosen such that each template is able to remove image pixels unconditionally without considering the impact of such deletion on the behavior of other templates when removing an image pixel. . Therefore, templates are independent of each other. According to one aspect of our invention, the set of templates used includes different templates or masks, each having a specific arrangement between dark and bright pixels. A small number of these templates (one containing either more than three pixels per row or rows of more than three pixels; an odd number, such as five, is a good choice). This is accomplished by stepping each template over the image. The number of steps depends on the selected size of the template and the image size. At each step of each template, should one or more pixels be removed from the image? A decision is made whether or not to delete. The decision to delete is performed independently of decisions made regarding other templates. Because of template independence, our system for skeletonization of the templates at the same time, which substantially increases the processing speed and thereby enables the operation of an effective OCR system.According to another aspect of our invention, passing multiple templates over the image Instead, one template is passed through, but at each step the template starts from a template of size kXk (where k is a number greater than 3) and increases the template size by one for each substep. The size is changed to decrease. At each substep, a test is made to see if removing the central core of size (k-2) The core is deleted when a determination is made that the 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 implementations, an image is represented by an ordered set (array) of pixels.The value of each pixel is determined by the amount of light emitted from a particular subregion of the image ( (brightness, color, etc.). The pixel values are stored in the memory. Smudges and extraneous strokes are often found near the characters, and their presence makes the recognition process more difficult. According to our invention, block 20 follows block 10, the function of which is to clean the image. The first step: Images of symbols or characters, such as numbers, usually contain 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 digits 0-9 and the Latin alphabet (excluding lowercase i and j) form such a set, but most other alphabets (Hebrew, Chinese, Japanese Hangul, Arabic, etc.) 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 foreign regions of To find out, the image is raster scanned from top to bottom. When such a cluster is found (i.e. a black pixel not previously considered), the scanning is interrupted and a "brush fire" is started. ignited, i.e., the encountered pixels are marked with an identifier, and the marking is caused by a diffusion process (s
preadlngprocess). In the diffusion process, each of the eight immediate neighboring pixels is considered. These neighboring pixels that are black are similarly marked with an identifier, each marking starting its own diffusion process. In this way, the first "black" group of pixels encountered is
All groups are 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 that do not have 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, "Fire;
rlre) The method for spreading J is to add 8 additional pixels a little further away from the 8 immediate neighbors (the 8 pixels are the corner of the large window and the center pixel of the side of the large window). Contains options for defining neighboring pixels to include. After all, we understand that "fire" is "fire break;
This makes it possible to jump over the ignition break line). Size 31 of the image in block 25 to a predetermined size!
A process of scaling (scaling; 5eal lng) follows the cleaning process. It not only adjusts the size but also removes meaningless variations in the image. The cleaning process performed before resizing is done because it is desired not to resize the image while it still contains 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 independently in both dimensions with some limit placed on the maximum difference between the 17) 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 image deskewing.
ng). In other words, the function of block 30 is to make all the characters 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. In 22, X and y are the initial coordinates of the image, and Xo and y. , defines the origin, U and ■ are the coordinates of the transformed image, and m xy and yy are the image moments calculated by ) takes a value of 1 when the pixel at position x, y is "black", and takes a value of 0 otherwise. The effect of this function is to reduce the xy moments to essentially zero. 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
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 in most methods these conditions involve iterative testing with various predefined ill-conditions. For example, Ben-Lan and M.
onto) algorithm, a dark center is defined if it has the following conditions: l) 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 obscured). 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 11G are two 3x3 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.
04 and 105) upper bright section (pixels 101, 10
Looking for edge conditions 2 and 103) predicts that the dark region must be at least two pixels thick. When such a condition is encountered, the center pixel (104) is turned from on to off (dark to bright). Thus, 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 Tenbray) 100 and 110 are applied in image segment 10G of FIG.
It is not applicable in this case because the two-pixel wide horizontal line being drawn would be completely removed. The top row will be removed by template 100 and the bottom row 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 12G and 140. These templates correspond to templates 100 and 11G in 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 12G test whether they are on pixels, and the corresponding pixels in template 100 are set to "don't care." different. That is, template 120 ensures that steered (lightened) pixels are above lines that extend in both directions. Template 140, on the other hand, is similar to template 1 in that it is effectively a 3X4 template.
Different from 10. It includes a 3×3 section similar to 3×3 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 I30 and 15G are template pair 120
and 140 similar template pairs are formed. ° Templates 130 and 15G thin vertical lines. Templates 180.170.18G and 190 face right, left, top and bottom, respectively. “Knee (k-ne6s)
Thin J; template 20G, 210.220
and 230 thins the inclined line from the top and from the bottom; and so on. 11i0-230 are all 5X5 templates. According to other approaches for skeletonization, size kXk
, where k is greater than 3, we have found that the template can track a particular algorithm for any value of k. This algorithm can be executed iteratively or in parallel. The effect of the kXk template is to erase the (k-2)X (k-2) central core of the template whenever a certain criterion (Talaiteriya) is met. As expected, the larger the value of k, the coarser the thinning, but the fewer calculations are required. The thinning criteria can be stated as follows. For kXk template, if its core RCxs
ySk) is on (dark), then the core is turned off (removed or brightened) if the following conditions are met: 1, χ (η)−1, 2, φ1 (η) > k−2, and 3, φ0 (η) > k−2, where φ0 (η) is the 4(k−
1) is the maximum length (within a pixel) of a chain of 4 connected off pixels within the contour. This is the neighborhood η. Also, φ1 (η) is the maximum length of a chain of 8 connected on pixels in the neighborhood, and χ(η) is the number of chains of 8 connected on pixels in the neighborhood. The value of χ(η) can be calculated using the following formula. In the above equation, η(i) corresponds to the first pixel within the neighborhood η, counting clockwise from the upper left corner of the neighborhood; It is 1 when , and O when the corresponding pixel is off. 8 Connectivity is defined below. 1 if one of the two pixels is adjacent to the other in any of its 8 neighbors; the two pixels are in the same 8-connected chain. The four-way chain includes adjacent neighbors only in the horizontal and vertical directions, but not in the diagonal directions. Criterion (1) is necessary to ensure that the connectivity of the straftures remains unchanged. If χ(η) −1, then the neighborhood contains a single chain of 8 connected on-pixels, and erasing the core destroys the connectivity between the core and any on-chain in the neighborhood. do not. If χ>1, then there are two or more 8-connected on pixels in the neighborhood, so erasing the core will separate the chains and destroy connectivity. If χ-0, then the core is not even isolated from neighboring pixels that are on, and it is completely surrounded by on pixels. In such cases, erasing is not preferred. Reference (2) maintains the line end (the line end (end line) is the end of the line). At level k, the line end is defined as having a width less than or equal to -2 in the core side length. For cores with 8 connected chains of k-2 pixels or less, the core is defined and maintained as the line end at level k. When χ(η)-1, φ1 (η)
is equal to the number of on pixels in the neighborhood. Criterion (3) can be considered as the inverse condition of criterion (2). If criterion (2) prevents line end erosion, criterion (3)
prevents inward erosion of the off region into the on region. The steps of the sequential processing multilevel kXkm lineization algorithm are listed below. 1, for each position (x, y) in ascending order of x, y = a) k
' set to 1; b) For the kernel R(XSyx k' ), consider a certain canceled neighborhood value as on and test the thinning criterion; C) if the thinning criterion in b) If it is satisfied,
In this case, for each side and its adjacent corner, set a certain erased value to OFF (except for the ERASE D A anchor value in the NW (northwest) corner, which is set to ON), and Set all other erased values on; test connectivity with respect to thinning criteria and set the core to ERASED if they are met or ERASED if it is an anchor core.
Set to EDA; if not, set '- to -1, and if '≧3, return to b); 2. Stop if pixel was not made ERASED or ERASEDA; Otherwise, all ER
Set the values of ASED, ER, and ASEDA to OFF and repeat (1). In the above, the anchor is a core placed at the starting line end of a diagonal line oriented in the direction of scanning. The anchor is N
It is the W line end; ie, the nucleus whose north side and two corners and its west side contain only off values. In the parallel algorithm, the thinning results on a path do not affect the thinning operation on that path, so all pixels of the image can be affected at the same time. To achieve this independence, applying the criterion to the window through all images in each iteration) is divided into four separate subcycles, and the thinning is applied to N,S on each of the four subcycles. , E and W only. The rules used to assign compass (spread) directions to nuclei are as follows: If the north flank contains only off values, then the nucleus is a north contour kernel (a "flank" is a contour pixel in the row or column containing the corner pixel); if the south edge contains only off values and the kernel is not the north contour kernel, then the kernel is the south contour kernel; if the east edge If the nucleus contains only off values and the nucleus is not a north or south contour nucleus, then the nucleus is an east contour nucleus; and if the west side contains only off values and the nucleus is not a north, south or west contour nucleus. In this case, the nucleus is the western contour nucleus. A further flowchart of the algorithm is shown in FIG. Depending on whether sequential or parallel processing is desired, the algorithms differ in their specifications, as explained below. The steps of the parallel processing binarization kXk thinning algorithm are listed below. Note that for this algorithm there is no need to retain the cleared value and it is turned off after it is cleared. 1. In a sequential (NSSSESW) iterative circular sequence, do the following for all contour nuclei: a) set k″-; b) for nucleus R(x,ySk) Test the thinning criteria and if they are met, erase the core and turn it off; otherwise set - to -1, and if '
If ≧3, repeat b); C) stop if no pixel is erased on the last 4 consecutive sub-cycles; otherwise a) for the next contour direction in the sequence.
Repeat. This concludes the explanation of the thinning process. 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 layer of windows over the image. The 6 windows in our system are 7X7 templates, and each template has endpoints,
Detect the presence of certain features like diagonal lines, horizontal lines, vertical lines etc. Detection is carried out by a main rule meaning that a feature is concluded to be present when a large proportion of 49 hydrogens (7×7) fits into the template. In our system, 49FJ as shown in Figure 4
Use different types of 7X7 templates. 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 feature maps of class 49tI corresponding to templates of class 498 of FIG. 4, in block BO 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 (of an 18x30 pixel array). The reduction number was determined heuristically. We reduce the array (in the storage where we store the array) to We call this detected feature a "map" because we construct it and we place the detected feature within the appropriate position in the array. Thus we record the presence of the feature and its location. Other mechanisms can be used to record indications of "hit" positions, but it is conceptually easier to think of them in map form. An 18X30 array is too detailed for classification purposes. It turns out that the details can actually mask the text, but 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 (blocki
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 given 270 bits. Once it is known which template most likely corresponds to the character to be identified, a simple algorithm such as determining the lowest Hamming (Haa+mlng) distance may be sufficient. The important point is, of course, in determining these templates; and the manner in which they are
It 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. Let us assume that each electronic circuit block described below provides the necessary signals and control to the following circuit blocks, along with the necessary identification as to which pixels are to be considered. 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 (1'raa + e g
camera) and a video camera coupled to a storage device. When the classification process is initiated, storage is accessed to retrieve the center pixel and 24 neighboring pixels, and the retrieved signal set is provided to block 20. Blocks 20 and 30 are in this case executed 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 what is available with a microprocessor,
Specialized hardware can typically be designed to perform the required calculations. In fact, the necessary operations can be easily designed into one architecture. 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. 6, 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 uses 3
It has "diversity" of types. 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 I −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, 1, 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 (or combining) of templates can be accomplished by burn-through of appropriate links. If the template were 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 41G 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 inputs, one input responsive to the human power lead of network 420, and a number of sources (eg 425-427) connected to the 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 value of 1 or 0 depending on whether the amplifier input signal exceeds or does not exceed a threshold. The 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 BO 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, this selection is easily achieved using a counter operating with modulus 5, where the full value of the counter (full
value) is used to access the large segment, while the whole number after dividing by modulus 5
number) 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 may be advantageous to use the teachings of Hopfield's content matching scheme in the aforementioned US Pat. No. 4,880,188. Following this teaching, the feedback circuitry of his circuit can be inputted with information about the characters in the subject set. Using this memorized information, content matching form (
The associative (associative) storage identifies the character feature vector that is closest to the supplied feature vector. Hopfield's network is extremely robust (strongly adaptive) so that it makes "accurate" selections even when the input appears 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, the Kono technique is generally referred to as “backpropagation
ack propagation). This is, for example, ``Exploration within the fine structure of recognition (Exploration)''.
ratlons in tlle MIcrosLru
cLure ol' Cognitlon) J, M
IT Publishing, 1988, Chapter 8 “Parallel distribution processing (Pa
rall Distributed Processes
``Learning by Error Propagation'' in eds.
Internal Rcpresentatlons
by Error Propagation) as explained by E. Rammelhardt in J. FIG. 7 includes 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
W, is connected to each output lead wire j. In our application, network 81 has 270 input leads and 40 input leads. 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. The training of the circuit of FIG. 7 provides the developed feature vectors of the known characters and maximizes the output signal at a designated output lead of the circuitry 82 corresponding to the provided known characters. 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
[j is formed. It may be appropriate to state that the coupling way Wlj 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 voltage at any output lead coupled to that output lead.
lred up) is the sum of the contributions of 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 where B is the value of the first human 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. After considering these various requirements, an efficient analog coupling weight circuit or strength circuit was fabricated using MO3VLSI technology. While each connection weight in FIG. 7 is simply shown as a black circle, FIG. 8 shows the circuitry for implementing these circles. More specifically, FIG. 8 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 8G2 and small MOS switches 803 and 804
, a somewhat large MOS transistor 805, and a differential amplifier 8
0B and a multiplier 807. Second, the circuit of FIG. 8 includes a charge coupled switch 808, 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
0B has its two inputs connected to capacitors 801 and 802. Amplifier 80 representing the coupling weights
The output of B 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. Thus, multiplier 807 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 represented by the differential voltage created by amplifier 80B in response to the voltage difference between capacitors 801 and 802. 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 weight is vC80
It will be seen that it is proportional to 1-vC802, so even if there is a charge loss, there is no change in the weight as a result when it is the same on both capacitors. Nevertheless, a clear path must be provided to refresh the information onto capacitors 881 and 8G2. 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 briefly opened to bring the fixed voltage level to voltage Rgte.
to the capacitor 801. Voltage corresponds to a fixed charge. Switch 80B is then turned off. At this point, capacitor 801 is connected to the non-inverting input of amplifier 80B 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. The transistor 803 is extremely small compared to the transistor 805, and therefore, to make the phenomenon easier to understand, the transistor 8◎3 can be considered to be 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 its input leads are turned on in sequence to cause 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 1112. During a refresh operation, each combined weight is isolated as described above, but at this time the voltage output on sense bus 810 is connected to the D/D output to which the digital output of storage device 812 is applied.
It is compared with the analog voltage of A converter 813 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 results, the sequence of switch elements 803, 804 and 805 is amplified.
14, the capacitor 801
The voltage across capacitor 802 is increased or decreased. The output of bus 81G is converted to A/D converter t.
A switch 815 controls whether to supply the signal to ill or to the comparator amplifier 814. 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. In addition, Tables 1 to 15 refer to “Fire (rlre)
Display the J source program. In Tables 1 to 3, check the broken image, and if it is completely blank, give -1, if it is connected, give 0, if it is connected except for a minute part, give 1, and if it is in poor condition, give -1. If they are not connected, return 2 for each. It is assumed that black pixels are positive. In Tables 4(1) and 4(2), magical recursive burning routines are shown. In Table 5, the above process is shown when black pixels are not assumed to be positive. In Tables 6-15, most of the processing for the linear transformation program is performed. Table 1 Table 2 //flre, c 9/7/88 LDJ〃 77 check for broken image
s// returns -1if complete
ly blank // returns Oif co
connected // returns l if co
connected except for samll
flyspecs // returns 2 if
badly disconnected // uses
recursive brushflre a1go
rithm//Diagnostic output
: prirus number of segmen
ts. // and 1 location and code
of the largest // 5ide eff
ec

[:5ets up Lseg (in rec2
com) // IMPORTANT ASSUMFrT
ON: firel assumes img, pix
black pixels are PO5mVE/
/ and white pixels are ze
ro = // Tf you can't guara
ntee that, call fire□ ins
+ead of &eQ//negative pi
xels will cause rouble//
Th1s routine modifications img
, pix l +#1nclude"err1.h" 岨nclude "fire, h" 1nline int 1m1n(int4 int
b) (return(ikub? a : b); 1in
line int imax(int a, int
b) [remrn(a>b? a : b); ) st
Yuro c int xdl; //copy ofimg
, xstaoc +ntydl; //arid i
mg, ystatic char” pixl;//
and img, pixstatic Pa1r"p
i; 5tatic Pa1r"p2; 5tatic int ust 5ize = -1;
5tatic Seg myseg; // segem
ent being processedSCg Ls
eg; // longest segment
there 1sstatic int nseg; 5tatic int totpix; // tota
l pixels in imageint&elσm
age img) ( // make 5ure we have allc
enough room to keep
our pair-1ists: int 1 size x
img, x umbrella img, y; // max possi
ble 5ize of Li5t request life edif
(lsiz > 1ist-size) 1if(p
I) (delete pi; delete p2; pi m new Pa1r[1sizl;p2 s+
new Pa1r[1sizl;1ist 5ize
x 1size; Lseg, 1ist! O; // no long
est segment yetLseg, 5ize
wn OH// &st seg will beat
this for surenseg m O; to ψix 0; Table 3 // find first black pixel
, so we can initiate the
bum there: int xx; int yy; for ('/'l ” o; yy < img, y
;yy++)(for(xxsaO;xx<img,
x; xx+ten)(if (img, pix[yyl[
xxl > O) (/l/ fprintf(std
err, ”&stx!%dfirstym10.
xx, yy); // a lot of thes
e things might be logically
be arguments to burnQ. // but 5tatic variables ue
faster &simplernseg++;
// count this segment
g, ashes m-nseg; myseg, 1is
t m (Lseg, 1st!+m pi)?
pi: p2; myseg, sizemo; xdl wm img, x; ydl vm img,
y; pixl wa img, pix; burn(x
x, 'IY)J/ burn, baby, bum
! if (myseg, 5ize > Lseg, 5i
ze) Lseg g myseg;#1fdef″r
EsT fprintf(stderr, ”Saw%d se
gments', nseg); if (nseg)
fprintf(stderr, ”Longest
(code%d) 5tarts at 'Fod%d
o. Lseg, uhes, Lscg, 1st [O], x,
Lseg, 1ist(O], y);#endif if (nseg w 0)re+urn -1;if
(nseg m 1) return O: float
t frac m float (Lseg, 5ize)
/ float αotpix); const float
at m1nfrac m ,9;if (fTac>
m m1nfrac) return 1; rentr
n 2; Table 4 (1) // the magical recursive
burning routine // turns
o ashes all points that a
re 8-connected to the 1ni
tial point void burn ( int xcent. int ycent 77 center of
3 x 3 region or 1 interest/
/1fthiipointisoff-settle:
・'1f(xcent(OycentcOxcen
c>mxdl ycenowydl)return;
//No″r1:: this is 1ndeed
h check for > O. // not just nonzero, so t
Hings don't burn twice. 1f(pixl[ycentl[xcentl > 0
) (int top m myseg, 5ize++;
// keep track of length of
segmenttorpix++; // course
u total pixelspixl[ycentl
[xcentl mmyseg, as city eS', II
turn L)is point 10 ashes
burn(xcent+1.ycent+1);//
1gn1te ncigborsburn(xccn
t+l, ycent); burn(xcent+l
, ycent-1); burn(xcent, y
cent+1); burn(xcent, ycent
-1); burn(xcent-1, ycent+1)
;burn(xcenc1.ycent);bur
n(xcenc1. yient-1); #dcfln
e jump breaks YES#ifdefjum
pbreaks Part 4 (2) Table int jump = imax(xdl, ydl)
;jump = jump / 20; if (jump < 3) jump = 3; if
(jump > 1) ( burn (xcent+jump, ycent-jum
p); burn(xcent, ycent+jum
p);burn(xcent, ycent-jum
p); burn(xcent-jump, ycent
-jump); #endif Table 6 // do most of the work for
r 1inear transform pro
gram // see 1in, plan for e
xtended discussion // if y
you don't care about grayl
evels. // Caller allocates the a
rray; we fill it. #1nclude 1ldo lin, h"1nlin
e int imax(int a, int b)(
return (a>b? a : b); ) Table 5 int fire (Image img) (retu
rn (fwl(fng)); Table 7 void do-1in (const Image raw, // 1nput
image-// Om> all parameters
rs take default v ucscons
t char” sname // filename,
for informational message
es// prowide”” if you can
't do better P company-bl; inE pp* qQ; for (q(1"o; qq <rag,)';
qq4+) [bl[1b11. y -qQ; ibl++; Table 8 Table 9 void 1inl(const int pdimJI 5ize of
1nput arrayconst int qdim
)1. . const Pa1r” blJl 1nput:
1st of black pixelsconst
int nbl, // 5ize of 5aid
1istconst int known fit,
// 1 =) char already fill
s box pdim by qdim. Image des, // result: a
rray of small integersFIL
E” paxxm-fpJI parameter f
ile filepointer // O=x) al
l parameters take default
values // provide song if you
can't do betterFget(kern
el, 2); // convolution kern
el (units of PQ rows/cotts)
Iget(mingray, 3);// this o
r larger: return gray level
l, else return zer. float pkem kernel; float
qkern m kernel;const int
XO proverb 0; const int yOx O; const float xmid x (des, x
-xO) / 2.0; const float y
mid x (des, y −yO) / 2.0; /
/ find raw bounding boxin
t po, qO, p2. q2; int ibl; int PP, (Iq; if (known-fit) (po 0; qOg O; p2-p city m; q2 w q city m: ) else (pO= bl[0], x; qO -bl[o],y;p
2 x po; q2 snow qO; for (ibl x 1; ibl <nbl;
ibl++) (pp -bl[1b11.x; qq
-bl[1b11. y; pQ = 1m1n(po,
PP);p2 x imax(p2.pp);qo
x 1m1n (qO, qq); q2 x 1rnax (q2. qq); p2++;
q2++; Table 10 // calculate some moments
:float” xyflt m new float
(des, y, des, x); // note th
at we are treaig the pixe
ls as BOXES of ink, not p
oints// so the (0,0) pixe
l extends from (0,0) to (
1-cps, 1-eps) // and has it
s center at (,5,,5)float
pmid m (po + p2) / 2.0;fl
oat qmid proverb (QO+ q2) / 2.0;
// but if we 5hift the m1
ddle half a bit. 77 we can defend the (0,
0) pixel is centered at (
0,0) float pmx x pmid −,5;
float qmx m qmid −,5; float
t mpq x O,; // PQ rnomentf
loat mqq! O,; // QQ momen
tfor (ibl m O; ibl <nbl;
1bl-+) [pp-bl[1b11. x; q
q -bl[1b11. y;mpq +m (qq −
qmx)” (pP -pmx); mqq ten counties (qq-q
mX)” (qq−q え■);] float theta sr mpq / mqq;
// Note: 5ince pixels are
numbered from UPPER1ef. // positive theta corresp
onds to ”// neganve theta
corresponds to ”r// (pL
qt) is the coordinate which
re (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. jFIL1 table // Calculate min and mix
horiz coordinates. float P(Oproverb pryu%bl[0], x, b
l[o], y) ;// Iefunost blac
k pixelpt2 m fmax(pt2.XX
II); float dsw wa pt2- pto
J/deskewed widthRout kf
wm dsw / (p2-PO); // krun
ch factorauao+c, pA-pLl, qj
-qLI, IIteJdew, kf, nfat); 1st
Table 2 Table 13 // c31 curate the coeffici
ents of the 1inear transf
Ormation: float doo, dol,
d02. dlo, di 1. di2; if (i
nflate) (// old ”1nflatio
nary” schemefloat fif = n
fat>fcorn? d 11 = (des,
y-yO) / conhgt; // make ou
tput char fill its box ve
rticallydoo-dll”fif; dot = -dil “fif” theta;
else (// never 1nflate sc
hemefloat ygrow = (des, y-
yO) / conhgt; float xgrow m
(des, x-xo) / conwid; / l m
ake the output 5pace all
white and xx, face y; for CYY = yo; y'J < des, y
; yy++) (for (xx w xo; xx
< des, x; xx→)(xyflt[yyl[
xxl x O,;// and 5tan bequ
ea out blacknessint 5pip
m imax(1,1nt(10°di 1))Jsp
ip =x= 5cans per 1nput pi
xelfloat 5tep = pkern / 5
pip; float offset = 5tep /
2. ; int ii; fioat f) l, fq; int iy; float fxo, ii2; int ixo, ii2; float rxo, ii2; d 11 = dogrow; // 5hrink y
Table 14 #define oops (X) (fpriruf(s
tderr,”oops (X)%$%f%nko,sn
ame, fxαfx2); continue;)fo
r (ibls O; ibl <nbl; ib
l++) (// 1oop over black 1
nput pixelspp -bl[1b11. x;
qq -bl[1b11. y；fxos+doO”p
p +d01”qq+d02;//5urtofsca
nline (inxspace) ii2 dew doO” (
pkcm+pp)+dO1”qq+d02;//end
orscanline(,,)ixo s+ 1nt(
fxo); // integer pansix2 s
1nt(ii2); rxom fxo-ixo; // remILin
dersnc2 wa ii2- ii2; if (ixo < 0) oops(1); //
error checks & defense
(ixo >m des, x) oops(2);i
f (ii2 < O) oops(3) ;if (
ii2 >wa des, x) oops(4);f
or (if ! O; if <5pip; ii
+-+) [// 1oop over 5can u
nes per 1nput pixelfq! q
q + 0ffset +5tep"ii; fy-dl
o”pp+dll”fq10d12;iy m (int
) fy; if (iy < O) oops(5) ;if (
iy )w des,y) oops(6);xyf
lt[iyl[ixO] -m rxo;xyflt[
iyl [company] axis ■λ for (int ii ! ixo; jj < i
i2; jj++) (xyflt[1ylQil +s
+ 1.0; Table 15 77 clip the bouom off of
the gray-scale // using qu
estionable threshold sche
me// &st, find blackest o
output pixel float zmax w O
; for (yy! yO; yy < des, y;
yy→)(for (xx m xO; xx <
dcs, x; xx++ ) (zmax = fma
x(zmax, xyflt[yyl(xxl); //
then clip away... for 01)l! yO; yy < des, y
; yy+-+) (for (xx z xo; x
x < des, x: xx++ ) (float
zz w xyflt[yylIxxl;int g
x 1nt (9,9 umbrella zz / zmax); if
(gr < mingray) gr z O; des
, pix[yyl[xxl m plollllllllll
lllllllllllllllllllllllllllllll
IIIll11/ put away all our
toys:delete2(xyflt);

[Brief explanation of the drawing]

Figure 1 is a general flowchart of the classification method; Figure 2 is an example of a problem that arises when using independent 3x3 templates; Figure 3 is used in the present invention involving templates larger than 3x3. A set of thinning templates; Figure 4 is a set of feature extraction templates; Figure 5 is a set of feature extraction templates;
Flowchart of a thinning procedure using a window larger than 3x3 but different from the procedure used in connection with the template of Figure 6; Figure 6 used in connection with the template of Figures 3 and 4. Structure of the neural network determination circuit: FIG. 7 shows the structure of a two-layer neural network with analog value combination weights: and FIG. 8 shows an embodiment for the analog value combination weight neural network. 121.122, 141, 142...pixel 801.8
02...Capacitor 803.804.808, 809.815.826...
・Switch 805.825.827...MOS) Transistor 80[i, 814...Comparator means 801...Multiplying means Application Person: American Telephone Telegraph Company and 1-49...Feature extraction template 120 .130,140.150-350... Thinning template FIG, 3 FIG, 4 FIG, 4 ()7″?) FIG, 4 (Hupun°) FIG. FIG. FIG.

Claims (15)

[Claims] (1) A method for thinning an image composed of pixels arranged in an array; passing a plurality of templates in parallel over the image; and each template. unconditionally determining whether a selected portion of the image can be deleted from the image based on a comparison between the template and the image. Method. 2. The image thinning method according to claim 1, further comprising the step of: (2) deleting the portion of the image according to the unconditionally determining step. (3) The image according to claim 1, wherein 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. Thinning method. (4) The image thinning method according to claim 1, wherein at least one of the templates forms an array of more than 3 pixels x 3 pixels. (5) In a method for thinning an image composed of pixels arranged in an array; passing a plurality of templates over the image simultaneously; and, for each template, forming a line between the template and the image. A method for thinning an image, comprising: unconditionally determining whether a selected portion of the image can be deleted from the image based on the comparison. (6) The image according to claim 5, wherein 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. Thinning method. (7) The image thinning method according to claim 1, wherein at least one of the templates forms an array of 5 pixels x 5 pixels. (8) The image thinning method according to claim 1, wherein the selected portion includes more than one pixel. (9) Image skeletalization including repeated steps
tonization) method, wherein each step removes pixels from the image in a direction that reduces the pixels to a line one pixel wide; An image skeletonization method comprising the step of terminating a repeating step. (10) A method of skeletalizing an image comprising repeated steps, each step removing pixels from the image in a direction that reduces the pixels to a line one pixel wide; A method of image skeletalization, characterized in that it comprises an iterative terminating step enabling the terminating of said skeletalization before being reduced to pixel width. (11) In a method for thinning lines in an image composed of an array of pixels; a first step of selecting a window of size k×k (where k is an integer); The core of the image is determined by applying thinning criteria to a portion of the image.
) determining whether the local portion is removable; and removing the core local portion when the step of applying a thinning criterion indicates that the core local portion should be removed. reducing the size of the window by one when the step of applying a thinning criterion indicates that the core local portion should not be removed; and the step of reducing the size. returns control to said step of applying a thinning criterion when k is given a size of k greater than 2; and, subsequent to said returning control and deleting step, selecting another window. A thinning method characterized by comprising the following steps. (12) The thinning method according to claim 11, wherein the core local portion has a size of (k-2)×(k-2). (13) Following the step of selecting the other template, the step further includes the step of selecting another part of the image to interact with the template in the step of applying the thinning criterion. The thinning method according to claim 11. (14) The thinning method according to claim 11, wherein the step of applying the thinning criterion applies the thinning criterion in parallel to different parts of the image. (15) The thinning method according to claim 11, wherein the step of applying a thinning criterion applies the thinning criterion to different parts of the image.