Apparatus and method for optical recognition of chemical graphics
BACKGROUND OF THE INVENTION 
     This invention relates to the recognition, characterization and representation of chemical notational indicia, including graphic and textual components thereof. 
     Computers have proven themselves useful as tools for manipulation and display of graphical information, as witnessed by the rapid transition to CAD from manual design systems and the widespread use of desktop publishing. These graphic capabilities are also important in the scientific research environment for modeling and displaying natural phenomena. In the chemical sciences field, graphical requirements are combined with another, the notion of a graphical database that can be searched and accessed on the basis of graphical characteristics. 
     Today, there are numerous databases comprising vast quantities of chemical and biological information which are dependent on graphic representations of molecules as the critical feature allowing for this data to be accessed graphically via substructure searching techniques. Once a database is created, it serves as the central facility for a wealth of other applications, such as information retrieval, publishing, scientific analysis, etc. 
     Facilities for entering graphical data are less advanced than those for manipulating it. For many years, this problem impeded the transfer to computers of paper systems, such as, utility maps, engineering diagrams, graphical chemical data, etc. To create a graphical object in digital format, an engineering diagram, for example, requires appreciable time on the part of a trained operator. Frequently, it requires a duplication of effort in the sense that the operator works from an already created printed drawing or hand sketch. Chemical structures that are candidates for addition to databases, for example, are often already printed in journals and catalogs, etc. 
     SUMMARY OF THE INVENTION 
     The present invention is directed to an apparatus and method for the automated creation of digital representations of chemical structures from printed matter, including chemical structures represented in graphical form with associated textual components and chemical structures represented solely as character strings. To that end, in accordance with one aspect of the invention, a chemical diagram on a printed page is optically scanned to provide a raw spatial arrangement of black and white elements that is 1:1 with that of the printed page. The scan data is interpreted using a pattern recognition process in order to arrive at a high order description, that of a chemical structure. The pattern recognition process reads printed characters (optical character recognition, OCR), detects lines and determines their interactions, recognizes their geometric shapes, accommodates different drawing conventions, and applies the rules of chemistry to identify the atoms of the chemical structure and the bond connections between atoms. The process further resolves ambiguities and validates results. Character string textual components representing chemical structures or substructures, are drawn in graphical form. If desired, graphical images derived from character string representations and/or scanned directly from the input text may be displayed for evaluation. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a diagrammatic representation of a digital processing apparatus constructed in accordance with the present invention. 
     FIG. 2 is a block diagrammatic representation of a functional sequence to be performed by the apparatus of FIG. 1. 
     FIG. 3 is a diagrammatic representation of a page of text showing a chemical entry that has been scanned and separated. 
     FIG. 4 is another diagrammatic representation of a page of text showing a chemical entry that has been scanned and separated. 
     FIG. 5 is a diagrammatic representation of a vectorized image. 
     FIG. 6 is a diagrammatic representation of a vectorized image after segmentation. 
     FIG. 7 is a diagrammatic representation of another vectorized image showing an example of imperfect conversion. 
     FIG. 8 is a diagrammatic representation showing the segmentation of diagram and residual text. 
     FIG. 9 is a diagrammatic representation of another vectorized image with problem identification. 
     FIG. 10 is a diagrammatic representation of an image after structure recognition. 
     FIG. 11 is a diagrammatic representation of a character cut out and normalized from the source file. 
     FIG. 12 is a block diagrammatic representation of a chemical string recognition sequence to be performed by the apparatus of FIG. 1. 
     FIG. 13 is a diagrammatic representation of a state machine used to separate chemical front information from substring atom representations. 
     FIG. 14 is a diagrammatic representation of a state machine used to create a stack of substring atom representations. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     There are a number of mathematical equivalent methods of representing the chemical structure of a molecule, e.g., adjacency matrices, connection tables, and link lists. Recent efforts to develop standards for molecular connection tables range from the Brookhaven Protein Data Bank format to the Molecular Design Limited (MDL) MOLFILE format, the Standard Molecular Data (SMD) format and others. See, Barnard, &#34;Draft Specification for Revised Version of the Standard Molecular Data (SMD) Format&#34;, Journal of Chemical Information and Computer Sciences, 30:81-96, American Chemical Society (1990); Wipke, &#34;Evolution of Molecular Graphics&#34;, ACS Symposium Series 341 - Graphics for Chemical Structures, American Chemical Society (1987). The output of the optical recognition apparatus and method set forth herein is a molecular structure file that includes a list of nodes (atoms) with their coordinates for a two dimensional representation, plus a connection table defining the bonds between the nodes. The output molecular structure file may be used as an appropriate input format for other applications such as image rendering, text processing, and molecular modeling programs. 
     A. OVERVIEW 
     Optical recognition of chemical graphics in accordance with the present invention may be performed by the data processing apparatus of FIG. 1, which includes a programmable computer 10 with keyboard, a memory 20, a display monitor 30 and an optical scanning device 40. These components are conventionally known and may include a wide variety of component types and system arrangements. The data processing apparatus is controlled by a software system which may be resident on the memory 20. The software system may also be placed on a variety of data storage media in addition to the memory 20, for example, if the software system is to be transported. Such storage media may include floppy magnetic disks, optical disks, magnetic tape, portable hard disks, and other media. The software system includes an executable instruction set for controlling the data processing apparatus for automatic recognition of chemical structure images formed on an input text 50. The software system controls execution in accordance with the flow diagram shown in FIG. 2. The flow steps include scanning, separation, vectorization, segmentation, cleanup, ocr, structure recognition, aggregation and post processing. These steps are outlined and discussed in detail below. 
     In one aspect of the optical recognition process, ambiguities in recognizing characters or chemical string types are flagged and displayed on the monitor 30 so that a user may resolve the ambiguity by using a keyboard or mouse input. In this way, a large number of chemical structures and notations can be recognized. In another aspect of the optical recognition process, character strings representing chemical structures or substructures may be drawn in a graphical structural format. If desired, the graphical images derived from character string representations and/or scanned directly from the input text may be displayed on the monitor 30 so that a user may verify the results of the optical recognition process. Further, chemical strings may be input by other means, such as a keyboard, to be drawn and displayed. 
     B. SCANNING 
     Optical scanning devices of differing characteristics are available commercially. In the present method, the diagrams and surrounding text are typically printed in black ink on white paper and are of a size convenient for reading. The scanner need only produce a bi-level image at a continuity that preserves visual quality when the image is displayed on a screen or reprinted on paper. 
     The image, which may be stored in the computer memory 20, consists of a two-dimensional array of 0s and 1s representing white and black, respectively. The 0s and 1s are in one-to-one correspondence with the cells of a grid that can be imagined to overlay the printed page. Because automatic methods for interpretation of text are less discriminating than the human recognition process, the number of cells per unit area has to be greater than, for example, the resolution used in facsimile transmission of documents, which does not exceed 200 cells per inch. Resolutions of 300 samples per inch are suitable, however, and character recognition is not significantly improved at higher resolutions. 
     C. DETECTION AND SEPARATION OF A DIAGRAM 
     The Separation step employs an image analysis program that is set forth in detail in pseudocode form in Appendix A, hereto. As shown in Appendix A, and with reference to the sample text inputs shown in FIGS. 3 and 4, the program resolves the scan array into rectangular subimages or &#34;RSIs&#34; each containing a connected component or &#34;cc.&#34; The connected components are uniquely defined by two properties. Each connected component is composed of a contiguous set of black pixels, and no two connected components are in contact. The x and y extent of each connected component is computed in the process. These dimensions are the width and height, respectively, of the enclosing bounding rectangle (&#34;RSI&#34;) for the connected component. 
     Next, the system searches for a connected component whose height and width dimensions exceed thresholds w and h, respectively. The parameters w and h are chosen to exceed the maximum character size expected on the page. It is thus assumed that a subimage satisfying the threshold test is a section of a chemical structure. 
     A search is then made for neighboring connected components within a distance threshold t in the x direction and v in the y direction from the selected connected component. The values t and v are also parameters of the system, chosen to be smaller than the white-space that separates diagram elements from surrounding text. If any connected components are found within the expanded region provided by t and v, they are combined with the initial connected component to define an enlarged bounding rectangle containing the entire group. The search then iterates using the expanded region. This region growing process terminates when no further connected components are found within the margin determined by t and v. 
     As an alternative to the above-described process, the separation step could be performed manually by a user using the monitor 30 to display the scanned input text, the user could select the corners of the rectangular subimage using a mouse to position a dragging rectangle over the desired area and clicking a mouse button. 
     The output of the Separation stage is the subimage for the bounding rectangle determined by the growing process, as well as the list of connected components within this region, as shown in FIGS. 3 and 4. This data is assumed in the subsequent processing to constitute the subimage of the chemical structure and associated characters, as well as the connected component list for the structure and characters, respectively. At this point, the chemical structure and character subimage is referred to as the isolated raster image. 
     D. VECTORIZATION 
     A commercially available software package known as the Graphic Image Formatting and Translating System, GIFTS, developed by the assignee of the present application, has been used advantageously for the raster to vector conversion of the structure subimage. An OS/2 adaptation of this program is known commercially as MicroGifts and is part of the IBM CAD Plus Product (Program Number 70F9287). The MicroGifts routines called are MGPREP (preprocess image), MGTAIN (thin lines) and MGRUCIV (vectorize image). Other known vectorization programs could no doubt also be employed in the present process. The vectorization algorithm attempts to fit line segments (i.e., vectors) to the given pixel array, producing as output the endpoint coordinates of the approximating lines. The thickness of each line is also estimated, and end points of lines are labeled as free ends (endpoints), junctions (junctionpoints) (where 3 or more lines meet), loop closures (circlepoints), or connections (chainpoints) (2 lines meeting). A typical vector representation of a raster image is shown in FIG. 5. 
     The vector representation serves as the basis for converting the structure diagrams to a molecular structure file. The vector representation also serves as a basis for determining the positions of characters in the isolated raster image for subsequent OCR processing. The vector description is graphical, consisting of points in space, or nodes, and connections between nodes, i.e., branches. For the vectors representing chemical structure, the vector elements are ideal and depict, respectively, the atoms of a molecule and the bonding between atoms. The vectorization output, however, is an imperfect graph that must be processed further in order to arrive at the molecular structure file corresponding to the selected image. 
     Two types of imperfections occur in the initial vectorized version of a chemical structure diagram. First, the node information for a molecular structure file is partly symbolic data, e.g., the designation of a chemical element. The vectorization algorithm encodes the entire image as vectors, including printed characters. Furthermore, this representation of characters by vectors is often poor due to noise in printing and scanning, as well as other factors. Consequently, as will be shown below, the vectors derived from characters are used only to distinguish between the characters and other diagram elements. Actual identification of symbols is done by reference back to the isolated raster image from which the vectors were obtained. 
     Secondly, because the vectorizing algorithm is based on very general principles, a straight line in the diagram may be broken in the approximation, that is, resolved into two or more segments. This happens more frequently in the neighborhood of junctions where several lines connect, but can happen anywhere on the drawing. Thus, the branches, as well as the nodes of the initial graph obtained by vectorization, may be in error, as shown in FIG. 7. It is the task of subsequent stages to consider both the characteristics of the vectorization process and the syntax of structure diagrams in order to achieve an appropriate transformation from one domain to the other. 
     E. SEGMENTATION OF CHARACTER IMAGES 
     Vectorization algorithms tend to represent the irregular shapes of most printed characters or text contained within the structure by sets of short vectors. This property can be used to detect characters in the diagram and record their locations. This step is called Segmentation and entails the construction of vector groups and the classification thereof into those derived from character patterns such as text contained within the structure to define various heteroatoms, etc., versus those vectors derived from the rest of the diagram which may be used to define chemical bonds. The Segmentation process also creates strings of connected character vector groups. 
     It is assumed for purposes of the present discussion that the scanned chemical structure image includes graphical components, such as bonds, benzene rings, etc. and character strings attached to the graphical components. It will be appreciated that many chemical structure representations will contain only character strings. As will be apparent below, the apparatus and method described herein is adapted to evaluate all such formats including input text containing graphical components, character strings or both. The Segmentation process is set forth in detail in pseudocode form in Appendices B, C and D hereto. 
     As shown and described in Appendix B, the first step of the Segmentation procedure is to assemble the vectors into connected groups. The Construct Group program of Appendix B scans the vectors generated by the vectorization program and arranges the vectors into groups of connected vectors. First, the program creates a set of vertices with associated connectivity information. Each vertex is defined by its x and y position, its status, i.e., endpoint, chainpoint, junctionpoint or circlepoint, and the set of points connected to the vertex. In a second step, the vertices are grouped by the object they describe. The groups are defined by their x and y minimum and maximum positions, class (see below) and the set of vertices in the group. 
     Following the construction of vector groups, these groups are classified as characters (text within the structure), bond structure, or other symbols, such as circles which are sometimes used by chemists to represent aromatic rings. This is done using the size of each group as follows: 
     1. Small groups containing only a few vectors are classified by context: if close to another letter they will be classified as a character. This rule accommodates the occurrence of lower case &#34;1&#34;, as in the chemical symbol for chlorine, C1. 
     2. If the maximum dimension of the group is less than a preset ratio (e.g., 1/6) of the maximum group dimension in the diagram, then the vector is defined as part of a character or text. This ratio is referred to as the text to bond ratio. 
     3. If the group has at least N vectors (e.g., N=8) and is circular, then the group is classified as a circle. A similar group having fewer vectors is declared a bond. 
     4. If the group satisfies none of the above, then it is classified as a bond structure. 
     Referring now to Appendix C, the Classify Groups routine set forth therein assumes that the smallest groups formed by a large number of vertices are characters. Bond groups are deemed to be formed by groups having a large number of vertices and having one dimension that is at least twice as large as the average dimension of the character groups. Dots are deemed to be represented by groups having a height which is less than 0.2 times the average character height. Finally, minus signs are deemed to be formed by small horizontal vectors. 
     Applying these assumptions, Classify Groups identifies and sorts the groups formed by more than three vertices in accordance with their height and width in ascending order. These groups are searched to find the character groups therein using a text-to-bond ratio test. Beginning with the smallest group, each group with a gheight, (group height) less than two times the median height of all groups previously treated as potential letters (median height initially=gheight of first group) or a gwidth (group width) less than four times the median width of all groups previously treated as potential letters (median width initially gwidth of first group), are classified as letters. The median height and median width are recalculated as each group is treated as the median gheight and gwidth of all groups previously classified as letters. All remaining groups composed of a large number of vertices are classified as bonds or circles. If the number of character groups is equal to the total number of groups, it is assumed that there is no character among the large groups. 
     All groups composed of less than four vertices are deemed to be bonds if their height or width is greater than 1.8 times gheight or gwidth (i.e., letter size). If the groups are composed of three vertices and are letter size, they are classified as letters. If the groups are composed of two vertices and have a length of less than 0.2 times the height of the smallest group, they are classified as dots. If the group has two vertices and is horizontal and of letter size, the group is classified as a minus sign. Some groups remain unknown until they are classified later by the Create-String process, depending on the context. 
     Referring now to Appendix D, the Create-String routine for generating character strings is set forth in detail. The Create-String program sorts all groups classified as letters or unknown into horizontal and vertical strings of two or more characters. First, for horizontal strings, all characters are ordered in ascending order depending on their x position. For all characters starting from the left most, a search is made to the left for minus or unknown character size groups. If found, they will be identified as letters and added to the string. A similar search is then made for letter or minus or unknown character size groups on the right. If found, they will be identified as letters and also added to the string. If the search is unsuccessful, the first character does not have neighbors, and no string of length 1 is created during this pass. 
     To find the vertical string, a similar process is used after ordering all remaining characters on the y scale. This time, all single character strings are also created. If there still are remaining unknown or minus groups, they will be classified a bonds. 
     FIG. 6 shows bounding rectangles that have been drawn around groups which have been classified. FIG. 8 illustrates the overall result of Classify Groups and Create-String as partitioning the vectors into those that specify the bond structure of the diagram and those that make up characters. The bond structure vectors are input to a Vector Cleanup process, described in detail below. The character vectors are processed to determine the bounding rectangles of each group, and the coordinates of these character rectangles are sent to the OCR stage, also described in detail below. 
     F. VECTOR CLEANUP 
     Following the classification process described above, the bond structures are processed to remove artifacts incurred during vectorization. The Vector Cleanup process is set forth in detail in pseudocode form in Appendix E hereto. Vector Cleanup is necessary because vectorization algorithms tend to over-vectorize diagrams composed of straight lines. That is, the algorithm may represent a single straight line as several vectors, but seldom does the reverse. The Vector Cleanup stage corrects two types of defects: 
     1. The breaking of lines in the region of a junction, as seen in the asymmetric central atom in FIG. 10. 
     2. The breaking of a single diagram line into two or more vectors at points remote from a junction, as seen in the ring structures in FIG. 10. 
     As shown and described in Appendix E, the first objective is accomplished by detecting any vector with a length less than a specified fraction (e.g., 1/20) of the median value of a line diagram. Such a vector is, in effect, shrunk to a single point, its midpoint. That is, the terminus of any vector connected to the detected one is relocated at the midpoint, and the short vector itself is deleted. 
     As further set forth in Appendix E, the second case is treated by a procedure that measures the angle of intersection at vertices where exactly two vectors meet. If the angle is less than a predefined value (e.g., 35 degrees), the vertex is removed. 
     Additional Vector Cleanup steps may be implemented as desired, for example, to remove printing or scanner defects such as broken lines, or for characters that touch the bond structure line. A user interface may also be provided after vectorization to add or delete vectors. 
     G. OCR 
     A preferred OCR program which may be employed in the present procedure is disclosed in U.S. Pat. No. 4,499,596. Other OCR programs could no doubt also be employed. The OCR program is modified slightly, which modifications are set forth in detail in pseudocode form in Appendix F hereto. 
     From the isolated raster image, the OCR process locates and cuts out a character pixel image using the x and y position of the corresponding vector group classified as a character. If a character is wider than a predetermined threshold, indicating that two characters are touching, this process will separate them before normalizing and sending them to the recognition function. Thus, as shown in Appendix E, for separate characters, the OCR program determines a &#34;column of separation&#34; representing the position at which the characters are joined by a minimal number of pixels. The program separates the characters and calls the recognition procedure for each character. The output of the OCR stage is a list of character ID codes in 1-1 correspondence with the bounding rectangles for characters determined prior to the OCR step. 
     H. STRUCTURE RECOGNITION 
     If the cleanup routine has operated correctly, the bond structure vectors will accurately represent the connections between atoms portrayed in the printed diagram. The vector connection points are then listed as an array of atoms in accordance with the Structure Recognition process now to be described. This process is shown in detail in pseudocode form in Appendices G, H and I hereto. 
     The Structure Recognition procedure produces the information necessary to create a molecular structure file, that is, a list of atoms and their graphical coordinates, and a connection table defining the bonds between atoms. To do this, the procedure looks first through the character strings and adds each character to a list of atoms AL. As shown in Appendix G hereto, the Atoms Recognition routine designates the group letters in the character strings as atoms. Each atom is identified by an associated position and a character meaning. The program then searches through each group classified as a bond. For all vertices in the bond groups, the program correlates each vertex representing a junctionpoint (i.e., two or more connections) with a carbon atom C. Otherwise, the program finds the closest atom in the atom list and reports the vertex bond connections to the identified closest atom. Otherwise, if there is no closest atom A, the program adds a new carbon atom C for the vertice. 
     Aromatic rings may be represented in a diagram by one of several conventions. Often, the bonds are explicitly shown as single or double vectors, and this case is accommodated by the routines described above. A different convention employs a circle in the center of the ring rather than distinct bond lines. The Segmentation process has already checked for the existence of a circle, thus, if one has been found, a special procedure is invoked. This routine, called Interpret Circles, is shown in detail in Appendix H. 
     The Interpret Circles procedure first arranges all groups classified as a circle by their x position. For each circle group G, there is located a ring of vertices R in the atom list AL that surrounds the circle G. Each ring R is added to a ring list RL. Because molecules sometimes include one or more adjacent sets of three benzene rings sharing common vertices and bonds, the Interpret Circles procedure must accommodate such configurations. To do this, Interpret Circles first searches for all vertices Wi in common within three rings and adds them to a set of such vertices TW. In a loop called START, the Interpret Circles procedure finds paths going through the triple ring vertice in TW that are not fully connected (based on an assumed carbon valence of 4). Starting from the first triple ring vertices in a path, the START loop designates alternating single and double bonds, starting with a single bond, between the successive vertices in the path. Each path is treated accordingly. Thereafter, if all vertices in TW have four bonds, the program jumps to a SINGLE-DOUBLE-RING loop. If each vertex W1 in TW is not fully connected, the procedure adds a double bond from that vertex to a W2 atom common to only two rings and adjacent W1. W2 will be a vertex on the contour of the group of rings. All W2 are added in a set called DW. 
     In CONTOUR, the process starts from each vertex in DW and navigates around the outer bonds of the rings and designates alternating single and double bonds, starting with a single bond, to the adjacent vertices W2 not in DW and not fully connected. Each treated ring is marked as used. When the process reaches a vertex that is in DW, the CONTOUR loop ends without drawing the last bond, and a new vertex from DW is considered. The SINGLE-DOUBLE-RING section finds all rings not yet marked, including single rings, adjacent rings having only vertices common to two rings at most, or other rings where all vertices to three rings are fully connected. The process finds a vertex W1 of the contour that is a member of only one ring. In the SINGLE-COUNTOUR loop, the procedure navigates around the outer bonds of the rings and designates them as alternating single and double bonds starting with a double bond. The rings are marked as used. When the process reaches the first vertex used, the SINGLE-CONTOUR loop ends without drawing the last bond, and a next unmarked ring is considered. 
     The next step of the Structure Recognition process is Interpret Formula. As shown in Appendix I, Interpret Formula routine provides character string inputs to the Formula String Processing procedure (Appendix J) and positionally integrates the String Processing output with the graphics structure previously defined (i.e., the list of atoms generated by the Atoms Recognition routine and their positions in a graphics space). If a string is not &#34;useful,&#34; i.e., has no connection to the structure, the Interpret Formula routine attempts to find a connection with another string located above or underneath it (see example below): 
     
         ______________________________________                                    
          CH3                                                             
          O                                                               
            (Bond from structure)                                         
______________________________________                                    
 
    
     A string with no connection is ignored and deleted. The input string to the Formula String Processing program is built with &#39;=&#39; signs representing outliaison connection(s) to the graphics structure. The String Processor produces a list of all atoms involved in the string with their coordinates (in a table space) and a connection table. It also adds one or more fictitious outliaison atoms to the string for outliaison bonds to the graphics structure. The fictitious outliaison atoms correspond to the actual atoms in the structure that are connected to the string, and are used only to insure that the string can be correctly oriented with the graphics structure. A last step of the Interpret Formula routine introduces the table space position information received from the String Processor to the graphics space devised to define the position of the members of the atom list. The table space coordinates are translated into the graphics space using the coordinates of the fictitious outliaison atom(s) as their origin. The Interpret Formula routine adjusts the string position and orientation in the graphics space in the event there is an interference between the string and other structure. If there are two outliaisons, a scaling factor is applied in addition to determining correct string position and orientation. 
     Interpret Formula defines a rectangle circumscribing the atoms of the string following their translation from the table space to the graphics space. If there is no graphics structure inside the rectangle, or bonds intersecting the edges thereof, Interpret Formula ends. If there is an overlap, Interpret Formula performs symmetry about the x axis and then, if necessary, about the y axis, and again, if necessary, about the x axis, where the x and y axes are defined by the x and y coordinate values (in the graphics space) of the outliaison atom. If an interference still exists, the string is rotated 90 degrees about the z axis extending through the outliaison atom. If an interference continues to exist, x axis - y axis - x axis symmetry is again performed. Thereafter, a 45 degree z axis rotation is attempted, followed by x axis - y axis - x axis symmetry, if necessary. If an interference continues, the Interpret Formula routine calls a FindNext routine that is part of the Formula String Processing procedure. The FindNext routine selects a new bond orientation between the fictitious outliaison atom and the string atom to which it is connected. Interpret Formula terminates when there are no remaining interferences. 
     In cases where there are two outliaisons, Interpret Formula determines the ratio of the distance between the two outliaison atoms as measured in the graphics space (gd), and the same distance as measured in the table space (td). If gd/td&lt;0, the symmetry is performed about the median extending between the two outliaison atoms in the table space. If gd/td&lt;0.07 or gd/td&gt;1.4, one or both of the string fictitious outliaison atoms are not in their correct positions relative to the remainder of the string. The FindNext routine of Appendix J is called to reorient the first outliaison atom TOut1 and, if necessary the second outliaison atom TOut2, by selecting a new bond orientation between the outliaison atom and the string atom to which it is bonded. 
     Following the FindNext procedure, or if gd/td is &gt;1.4, a scaling factor of gd/td is applied to the string coordinates. The string is rotated so that the angle between horizontal and a line extending through the two outliaison atoms is equal. Thereafter, the string is translated so that the graphics space and table space positions of the first outliaison atom are coincident. If there is no graphics structure within the rectangle circumscribing the string, and there are no bonds intersecting the edge of the rectangle, Interpret Formula ends. If an interference exists, the procedure incrementally translates the string along a line perpendicular to the line extending between the two outliaison atoms. Each translation increment in the positive and negative direction is one half the value used to define one bond length. If the string is translated eight times at each position of the outliaison atom, two symmetric configurations are tested. User interfacing is employed to resolve any remaining interference. 
     Appendix J sets forth a detailed description of a Formula String Processing program for processing the character strings input by the Interpret Formula routine. The Formula String Processing program analyzes character strings representing atoms or molecules and represents them by an appropriate atom list and connection table. 
     The String Processing program is utilized for those portions of the molecule which are more conveniently defined as symbol strings rather than graphical structures. The program applies the rules and conventions used by chemists to represent chemical structures in string form. Utilizing these rules of chemistry, the String Processing program can deal with the most complex strings in organic chemistry and is able to determine the connection table of almost all atom strings found in the literature. Where ambiguities or other errors are detected the errors are flagged and displayed on the monitor so that a user may resolve the ambiguity using the keyboard or mouse input. This may occur, for example, in the case of repeated branched parentheses. 
     It will be appreciated that a variety of approaches could be employed to obtain a structural representation of a chemical string using the rules of chemistry. For example, a rule-based programming language would be well suited to such a task. Other approaches will no doubt also be apparent in light of the teachings herein and it is contemplated that such approaches may be employed without departing from the scope and spirit of the present invention. 
     In a preferred embodiment of the present invention, the String Processing program parses the unknown string using a series of routines which isolate molecular group or &#34;front&#34; information from the atoms of the string and which divide the remaining string components into one or more defined substrings for separate processing of each substring into individual connectivity tables. State machines are utilized to perform various actions depending on the character read from the string and the previous state of the state machine. Using one state machine, the program places the front information on a dedicated stack for subsequent use in determining the connectivity between substring groups. 
     The program also utilizes a general state machine that evaluates and places on a general stack the substring atoms, their valence, information about substring group structure including single and double bond connectivity between elements of the group, the number of inliaison bonds between substrings or substrings, the number of outliaison bonds between the substring and the structure to which the string is attached, the probability that another valence applies for the atom, and pointers to other previously created substring connectivity tables, if any. The general stack data is used together with the substring group information to connect the chemical substring elements in a connectivity table. The substring or elementary substring connectivity table is joined with other substring or elementary substring connectivity tables, if any, until the entire chemical string is represented by a complete table. As each substring or elementary substring is processed the program tests the generated substring connectivity table to insure that all the atoms are fully connected and that all the atoms are in the same molecule. If the testing procedure shows an error, a series of recovery processes commence. The recovery processes are used to change the bond connections between atoms, change the position or number of inliaison bonds (e.g., in the case of repeating parentheses), add triangular bonds, find the atoms that receive an ending valence of a string and modify valences for atoms which may have more than one usual valence. Following testing, a drawing procedure is used to evaluate the substring or elementary substring and determine the coordinate positions of the atoms thereof in a table space coordinate system. Optionally, the drawing procedure can be used to draw string components on the monitor 30 for user evaluation. 
     As shown in Appendix J, the String Processing routine recognizes certain characters and character structures conventionally used to describe chemical strings. The program recognizes upper and lower case letters, digits, &#39;+&#39; and &#39;-&#39; signs, parentheses &#39;-&#39; separators and commas. It also utilizes the characters &#39;.&#39; and &#39;=&#39; during processing to indicate inliaison and outliaison bond connections between elementary substrings or substrings of the chemical string undergoing processing and between an atom of the chemical string and the structure, respectively. 
     The program recognizes five general types of chemical strings. They are S0, S1, S2, S4, S5 and S6. The string type S0 is designated as an &#34;elementary substring&#34; that does not include parentheses. The string type S1 is designated as a &#34;substring&#34; that may include parentheses. String types S2-S6 are formed by various combinations of S1 substrings and molecular &#34;front&#34; information. String type S3 (see Appendix J) is not a separate string type. It represents an intermediate step used to generate other string types. As indicated, to simplify the chemical string recognition process, the program divides the input chemical string into substrings and elementary substrings and processes them separately, generating a connectivity table and atom position coordinates for each. As processing proceeds, the connectivity tables are combined to form a composite connectivity table representing the entire string and a list of atoms with their coordinates. 
     In determining the structural connectivity between the atoms of the chemical substrings, the program tests for the number of repeating carbons therein. Depending on that number, as well as other information (see Appendix J), the program assigns the molecule to one of five (more can be added) chemical structure group types. The group identifications are used to assign certain bond connections between the atoms. 
     The first recognized group type is the linear group. Chemical strings having more than two but not six repeating carbons are considered linear groups. Such groups may have additional elements or molecules of valence 1 attached thereto as well as one or more &#34;S1&#34; substrings. Another form of linear group may contain six repeating carbons but more than six adjacent hydrogens or other repeating atoms. Finally, another form of linear group may contain two repeating carbons and more than four adjacent hydrogens and another repeating atom of valence 1. The second recognized group type is the cycle group or benzene ring. Cycle groups have exactly six repeating carbons and not more than six adjacent hydrogens or repeating atoms of valence 1, and may have one or more &#34;S1&#34; substrings. The third recognized group is the double linear or ethyl group. Substrings in this group include exactly two repeating carbons together with &#34;front&#34; or group information, or include exactly two repeating carbons and no more than four adjacent hydrogens or another repeating atom of valence 1. The fourth recognized group is the Sulfur group. Substrings in this group include a sulphur atom of valence 2, or a sulphur atom of valence 4 and one oxygen atom connected to the sulphur by a double bond, or a sulphur atom of valence 6 and a maximum of 2 oxygen atoms connected to the sulphur by a double bond, and up to 2 additional oxygen atoms connected to the sulphur by a single bond. The fifth recognized group is the Nitrogen group. Substrings in this group include a nitrogen atom of valence 3 and one oxygen connected to the nitrogen by a double bond, or a nitrogen atom of valence 3 and two oxygens in a form S1(N+)(0-)-0, where there is allowed a double bond between the nitrogen and one oxygen, or a single bond between the nitrogen and the second oxygen and a single bond between the nitrogen and S1. It is anticipated that additional groups could be added as desired. 
     Front information consists of alpha-numeric characters in the string used to impart information about molecular structure. The chemical string recognition program assumes the well known symbols i, iso, n, s, sec, t, tert, cis, trans, p, para, m, meta, o, ortho, and various digits associated therewith, represent front information. The program ignores the notations 1 and d because this information pertains to three dimensional molecular representations. The program also ignores the characters L, D, R, S, CIS and TRANS. These characters can be used to represent existing atoms and may create an ambiguity between atomic symbols and front information. 
     The output of the String Processing program is an atom list and a connectivity table. The atom list is a list of the atoms of the string and their coordinates (except hydrogen) together with outliaison information indicating how the structure is bonded to other molecular components. The connectivity table is a two dimensional array referring twice to each of the listed atoms. The elements of the array are integers that represent the valence bond between two atoms of the molecule. An example of the output for the molecule CH2CHOH would be as follows: 
     
         ______________________________________                                    
Atom List   C(1)         C(2)   O(3)                                      
Outliaison  0            0      0                                         
Connectivity table                                                        
            C(1)         C(2)   O(3)                                      
C(1)        X            2      0                                         
C(2)        X            X      1                                         
O(3)        X            X      X                                         
______________________________________                                    
 
    
     A flow diagram of the String Processing program is shown is FIG. 12. The program Initializes by reading a user generated valence table from a file which contains a list of atoms and their usual valences. If an atom has more than one possible valence, a valence probability may be assigned. Predefined compounds may also be considered, such as Me for CH3 or Ph for C6H5. These compounds may be declared in the valence table. A preferred compound may be detected directly with a formula string, or indirectly with the name of a molecular structure file. Their names must start with an upper case letter followed by a lower case character. If an atom name is not found in the valence table, the program returns to the character recognition step and attempts correction depending on the context. 
     The program proceeds to the Input-String procedure wherein the string is input together with any outliaison information indicating connection to the graphics portion of the molecule. The string is input to the Separate routine whose function is to separate front (i.e., &#34;group&#34;) information from the substring components representing atoms. As a rule of chemistry, only strings having more than one substring (of type S1 or S2) will include digital front information. The Separate routine utilizes a state machine to generate a stack identified as GSTACK and separate the different substrings of type S1. The state machine has 20 different states, 0-19. The Separate routine initializes the state machine to the zero state and creates an empty GSTACK. The program then successively reads the characters in a substring to be treated and performs certain actions depending on the character type and the current state of the state machine. As shown in FIG. 13, the state machine also changes state after the action is taken depending on the type of the new character read from the string. The actions taken by the separate program are as follows: 
     1. Push--Push digital front information to the GSTACK. 
     2. Readinfo--Read the front information, and if the front information is not ignored, push the front information to the GSTACK. 
     3. Readstring--Read a substring, and loop through the Treat-One-String, Create-Stack, Find-Group, Connect and Test routines, wherein the substring is the initial input and a connectivity table for that substring is the final output. 
     4. Copytable--Create a new connectivity table identical to the connectivity table created during the readstring sequence. The copytable action is used for long strings of the type S6 wherein a substring occurs twice in the molecule. 
     The process of separating front information from the immediately following substring, and thereafter treating the substring to form a substring connectivity table, repeats until the end of the input string is reached. In the case of multiple substrings with digital front information, the digits report the position of previous substrings relative to the last substring of the string. The program is thus able to modify connectivity tables previously created. 
     As indicated, after separating the front information from a substring, the Separate routine calls the Treat-One-String routine, which in turn calls the Create-Stack and Connect routines, and the Draw Molecule Procedure, in order to generate an atom list with coordinate positions, and a connectivity table for the substring. The Treat-One-String routine, however, attempts to further divide the substring into elementary substrings (of type S0). If elementary substrings are found within the substring, they are treated separately and their connectivity tables are successively combined. Treated elementary substrings are replaced by a &#39;. &#39; in the substring in which they were located. The presence of &#39;. &#39; means that there exists one or more elementary substrings already treated with a combined connectivity table pointed to by a pointer WT. As each elementary substring and substring is encountered during the Treat-One-String routine, successive calls are made to the Create-Stack and Connect routines and the Draw Molecule procedure. 
     The Create-Stack routine parses the input elementary substring one character at a time. The output is a stack with all atoms composing the molecule (except hydrogen) and various information related thereto. As discussed above, this information is the atom&#39;s valence, structural information about the substring, the number of in- and outliaison bonds, the probability that the atom has another valence, and a pointer to a connectivity table to insert (in case there is a &#34;.&#34; in the elementary substring). This information is used to assemble the connectivity table, Test the table and Recover in case of error. If the character read by Create-Stack is a defined compound symbol, such as Me for methane, atoms of the compound are placed on the stack with parentheses. 
     The Create-Stack routine uses a state machine having 9 different states, 0-8, to perform a variety of stack manipulations and other actions depending on the character read from the string and the existing state of the state machine. As shown, in FIG. 14, the state machine also changes state when an action is taken. The actions taken by the Create-Stack routine as it reads each string character are as follows: 
     1. Push--Push the character and its most likely valence on the stack. 
     2. Combinlia--Add inliaison information with a previously treated elementary substring by executing an addpush action and then pushing the atom(s) from the connectivity table of a previously treated elementary substring having an inliaison value that is not null. The valence of each atom pushed to the stack during the combinlia action is the value of the inliaison for the atom and not its valence. 
     3. Comblia--Add outliaison information with another substring. 
     4. Addpush--Combine the valence of the character with the valence of the last element on the stack to generate a new resultant valence for that element. 
     5. Pushlow--Combine the character (a lower case letter) with the last element of the stack to generate a new element having a new valence. 
     6. Adddnewval--Combine the character (a digit) with the valence of the last element of the stack. 
     7. Suppush--Delete () from the stack and push the character to the stack. 
     8. Repeat--pull the last element of the stack (a digit d), duplicate the previous element (d-1) times and push the present character to the stack. 
     9. Suprep--Pull the last element of the stack (a digit d), delete () from the stack, duplicate the characters that were between the () d-1 times and push the present character to the stack. 
     10. Mult--In case of a digit, combine the tens and units digit to create a correct numeric value. 
     Following the Create-Stack routine, the program initiates the Connect routine. The Connect routine, in turn, makes calls to the Find Group and Test routines, and if necessary, to various Recovery routines. Before calling Find group, Connect adds an inliaison bond to the first atom of an elementary substring that is partial having a valence greater than one. If the substring is not partial, Find group is called without the introduction of inliaison information. 
     The stack generated by Create-Stack and the applicable front information identified during the Separate routine are input to the Find Group routine. The output will be a modified stack which may have its atoms rearranged, additional atoms inserted from other tables (in case digital front information is present), and new valences reflecting the connections between the atoms, or the attachment of Hydrogen, and structural information modified in accordance with the front information and the type of group recognized. If the substring is determined not to contain a group, no action will be taken. 
     As previously discussed, the String Processing program utilizes conventional rules of chemistry to recognize linear groups, ring groups, double linear groups, nitrogen and sulfur groups. If a linear group is found, the Find Group routine alters the carbon valences to reflect the assignment of hydrogen atoms to the carbons to fill up each carbon in sequential order. It also determines which non-carbon atoms should be arranged on the stack before the first carbon and after the last carbon. The routine interleaves the remaining atoms between the carbons. If a ring group is found, the Find Group routine alters the carbon valences to reflect the assignment of the Hydrogens and modifies the structural information to assign single and double bonds between the carbons. It also determines the number of atoms occurring before the first carbon and after the last carbon, or between two carbons, depending on the number of hydrogens and other atoms in the group. If a double linear group is found, the routine alters the carbon valences to reflect the assignment of the Hydrogens, and modifies the structural information to assign the double bonds between the carbons. Ambiguities encountered during group formation are flagged out. Similar valence and structural information changes to reflect bond placement determinations are performed by the nitrogen group and sulfur group routines, as shown in the pseudocode listing of Appendix J. 
     From the modified stack output of Find Group, the Connect routine creates a connectivity table using a Connect Bond routine. The Connect Bond routine loops through the stack three times. During the first pass, the routine connects all atoms of valence 1 to the preceding atom if its valence is greater. During the second pass, the routine connects the group atoms in accordance with the connections determined during the Find-Group routine. During the third pass, all remaining atoms are connected so that all of the atoms are connected. 
     The Connect routine then calls a Test routine wherein the connectivity table is tested to determine that all atoms are fully connected and that the atoms of the substring are all in a single molecule. If an error is discovered, one or more of the Recover, New valence and Othersol Recovery routines are called by Connect. Otherwise, the program implements the Draw Molecule procedure. 
     The Recovery routines cut and add different bonds depending on the location of the atom in the string, or add or move inliaison bonds. In some cases, a Recovery routine adds triangular bonds. In other cases, an ambiguity in string nomenclature may be reported. In still other cases involving atoms having more than one usual valence, the valence may be modified and the Connect process repeated. 
     In the New Valence routine, the valences of partially connected atoms, or their neighbors, having more than one possible valence, are modified and the program returns to Find Group with the modified stack as input. A first Process 1 is used when an atom i is not fully connected. The process tries to find a smaller valence for i, or an atom j before i with a new valence higher than used in the first treatment. A second Process 2 is used when the string has been arbitrarily cut such that there is more than one apparent molecule and the Recover process has been used on one of the apparent molecules. The process finds a new higher valence for an atom j before i. Following Process 1 and Process 2, Find Group is recalled. 
     In the Othersol routine, connectivity errors are corrected in strings ending with &#34;t&#34; or &#34;-&#34; sign by adjusting the connectivity of atoms that can support the sign. The procedure is used when a molecule has an ending sign and no solution is found when the sign is reported to the last atom of the string. The process goes through the string to find the atom that can support the sign. If there is more than one solution, the ambiguity is reported to the user. The result of Othersol is a modified stack that is input to Connect Bond in order to generate a modified connectivity table. 
     In the Recover routine, four processes are used for ensuring full atom connection. Recover generates a modified connectivity table for input to the Test Procedure. A first Process 1 of the Recover routine, is used when there is an elementary substring between parentheses followed by a digit, and the last atom of valence&gt;1 is not fully connected, a value of 1 is left over, and the molecule is not cut. Process 1 modifies the connectivity table by adding an inliaison value of 1 to the last atom not fully connected. A second Process 2 of the Recover routine is used when there is an elementary substring between parentheses at the beginning of the string having a last atom of valence &gt;1 not fully connected, a value of 2 is left over, and the molecule is not cut. The process modifies the connectivity table by adding an inliaison value of 1 to the last atom, deleting the inliaison from the first atom, and adding a bond connection between the first and last atoms. A third Process 3 of the Recover routine, is used when one atom is not fully connected, an even number of valences are left over, and the molecule is cut just before i. The process modifies the connectivity table by cutting the bond between the two previous atoms and connecting each previous atom to the not fully connected atom. It may form a triangular bond. A fourth Process 4 of the Recover routine is used when there is more than one apparent molecule that is not fully connected. In the second molecule the process finds the first carbon (firstC) and the last atom (lastA) in the string connected to it. The process then finds a carbon (lastC) between the FirstC and LastA that is connected to firstC. The process modifies the connectivity table by disconnecting FirstC and LastA, FirstC and LastC, and connecting LastC and LastA. If FirstC is not fully connected Process 3 of Recover is used to provide the connection. 
     Following the Connect routine, the Draw Molecule procedure commences. The purpose of this procedure is to define the coordinate positions of all atoms of the connectivity table generated during the connect routine. With the connectivity table(s) generated by Connect as input, the Draw Molecule procedure determines the coordinate positions of the atoms in each substring or elementary substring treated by Treat-One-String and creates an atom list including coordinate positions. The substring atom lists are combined until an atom list representation of the entire chemical string substructure is created. The final atom list output is returned to Interpret Formula for positioning from a table space to a graphics space for orientation with existing graphical structure, if any. The molecule drawing program utilizes three procedures: Draw Molecule, Find Structures, and FindNext Position. Draw Molecule makes calls to Find Structure in order to determine information regarding the structural characteristics of the input string. Draw Molecule prioritizes the string components using these structural characteristics. As each string structure is processed, a selected routine in Draw Molecule is activated. The selected Draw Molecule routine makes calls to FindNext Position, which determines the positions of the string atoms undergoing processing. Given the position of a first atom a, the FindNext Position procedures determine the positions of atoms b extending from a. Each atom is assigned 8 possible directions to its neighbors. These directions are 45 degrees apart and are represented by integers (0 to 7). If an initially selected next atom direction is unavailable, one or more additional directions are tested until an open direction is found. A mask is associated with each atom to memorize the directions filled with bonds. The position of an atom b determined to lie at a selected direction from an atom a is found by performing a translation following the selected direction from the position of atom a. An atom position is in the form (x, y, b1) (normalized representation) where b1 is the bond length unit because all translations will be given in b1 multiples. This representation allows rotation, translation and symmetry to be performed using matrix operations. Thus, the drawing procedure utilizes a grid having x and y gradations of one b1 each. In case of error, a backtracking mechanism is used until the critical point is reached. At that point, a new direction is used to position the next atom, and the structure is rebuilt. 
     When Draw Molecule is called in Treat-One-String, it first creates an atom list called ALLATOM in which the atoms of the treated substring are classified in decreasing order by the number of other atoms to which they are connected. Each atom is initialized with a MASK value of 0, indicating that all bond directions are open. If an atom in the table contains a pointer to another table, indicating an inliaison connection, the table pointed to is checked. If the inliaison atom a in the table pointed to was assigned BZ or ET structure information, that information is transferred from the table pointed to and assigned to the stack variable Str(m) in the table being treated. 
     Draw Molecule then calls a Find Clist routine in the Find Structures procedure. Clists are linear lists of repeating carbons joined by single bonds and not part of an ethyl group. The Clist routine is a conventional deep first search algorithm of the type commonly used to find all of the paths in a tree having multiple roots and bidirectional branches. In this case, the tree is adapted to the connectivity table generated by Connect. The only loops possible are formed by triangular bonds or benzene rings which are marked as a node having no further paths. The Clist routine starts from a first carbon atom as a root node and finds a path of connected carbon atoms extending to a leaf node or to a triangular bond or benzene structure. These atoms are represented as a list of atoms Path{i}, indexed by i. This list is copied as a List{n} and the path is retraced from the leaf node to the next previous node. The program tests for branches from that node. If branches are found they are followed to a leaf node and copied in List{n}. If there are no branches from the previous node, the node is marked. Clist continues until all possible paths have been tested and lists List{n} generated. 
     Unusable lists, such as duplications in inverse order, etc. are deleted, and Clists ending with benzene rings are inverted, by Draw Molecule. Draw Molecule assigns a linear list (LL) structure designation to all atoms that are not assigned a benzene (BZ) designation. Draw Molecule then calls Find Triangular Bond in the Find Structures procedure. This routine assigns a triangular bond (TB) structure designation to all atoms that are part of a triangular bond. 
     Draw Molecule selects a first Clist to treat. The selection process is performed in a prioritized manner wherein carbon lists starting and ending with a benzene ring are selected first, beginning with the longest such list. Carbon lists starting with a benzene ring are selected next, beginning with the longest such list. Carbon lists without attached benzene rings, but having the greatest length, are selected as the final priority, beginning with the longest list. Assuming there is a list starting and ending with a benzene ring, or a list starting with a benzene ring, the Draw Molecule procedure assigns the first atom fa a position POS(fa) (0, 0, b1). It also sets the variable PROCESSLIST{i} to fa. PROCESSLIST is a list of atoms that have been drawn and is used for backtracking in the event of a positioning error. Draw Molecule then calls a DrawRing routine, which is part of the Find Next procedure (set forth in detail in Appendix J). The DrawRing routine determines the position of the benzene ring atoms after fa. Initially, however, if fa is an atom having an inliaison connection to another table previously created and drawn, DrawRing searches for a table to insert at the position of the first atom fa. If such a table is found, DrawRing terminates. If no table is found, DrawRing initializes two fictitious atoms f1 and f2 inside the benzene ring. 
     DrawRing commences a loop that searches for a next atom b after each atom a (f1 and f2 being treated as the final atoms b of the sequence). For each atom b after a, DrawRing calls the FindNextRing routine of the FindNext Position procedure. FindNextRing positions each atom b, tests for interference with previously drawn structure, and modifies mask values MASK{a} and MASK{b} to reflect the new positioning assignment. The direction of a ring atom b relative to its previously drawn neighbor a is found by a direction variable DR1 having a value 0-7. The value of DR1 represents the number of 45 degree increments taken in a counterclockwise rotational direction from a base line direction DR{a} extending from the preceeding atom a. Once the atom b is drawn using an available direction DR1, a new baseline direction DR{b} is set at 180 degrees from the direction DR1 used to draw the atom b. The next atom is drawn using the new baseline direction DR{b}, and the process repeats. Each baseline direction DR{m} and direction variable DR1 has one of eight values, 0-7. The values for DR{m} and DR1 represent the following table space directions: 0 for east, 1 for north-east, 2 for north, 3  for north-west, 4 for west, 5 for south-west, 6 for south, 7 for south-east. 
     Draw Molecule sets DR(fa) to an initial value (e.g., DR(fa)=0=East). To find the direction DR1 of the next atom, a NEXTRING (CHOICE, RANK) value is added to the baseline direction DR{fa} using modulo 8 addition. The variable CHOICE corresponds to a selected orientation of the benzene ring having a selected direction of the first atom fa thereon. For each CHOICE selection, there is an array of seven values corresponding to the RANK of each atom in the ring including the two fictitious atoms f 1  and f 2 . There are 0-6 direction CHOICES tested sequentially by DrawRing and FindNextRing. For CHOICE=0 and DR(fa)=0, the ring atom directions are found by an array of NEXTRING (CHOICE) values of (3, 5, 5, 6, 5, 6, 6), as shown in Appendix J. Interpreting this sequence, the second atom of the ring has a NEXTRING (CHOICE, RANK) value of 3 starting from the baseline direction of the first atom (DR{fa}=0). Its direction DR1=0+3 (modulo 8) =3. This is northwest of the first atom. A new baseline direction DR{b} is selected at 180 degrees from DR1 or 3+4 (modulo 8) =7. The third atom in the ring has a NEXTRING (CHOICE, RANK) value of 5 from the baseline direction 7 (southeast) indicating that its direction DR1=5+7 (modulo 8) =4. This is west from the second atom. The new baseline direction DR{c} is 180 degrees from DR1, or 4+4 (modulo 8)=0. The fourth atom also has a NEXTRING (CHOICE, RANK) value of 5 indicating that DR1=0+5 (modulo 8)=5, and that the atom lies in a south-west direction from the third atom. The new baseline direction DR{d} is 180 degrees from DR1, or 5+4 (modulo 8) =1. The fifth atom has a NEXTRING (CHOICE, RANK) value of 6 indicating that DR1=1+6 (modulo 8)=7, and that the atom lies in a south-east direction from the the fourth atom. The new baseline direction DR {e} is 180 degrees from DR1, or 7+4 (modulo 8)=3. The sixth atom has a NEXTRING (CHOICE, RANK) value of 5 indicating that DR1=3+5 (modulo 8)=0, and that the atom lies in an east direction from the fifth atom. The last two NEXTRING (CHOICE, RANK) values, 6 and 6, are used to position the fictitious atoms f1 and f2 in the interior positions of the ring. 
     If the selection CHOICE=0 cannot be drawn, successive CHOICE arrays will be tried. By way of example, if the baseline direction of the first atom a, DR{fa}=east, CHOICE=0 assumes that the benzene ring is oriented on its side with the first atom fa at the rightmost central position. Thereafter, the orientation positions tried are: (1) upright with first atom at upper righthand position; (2) upright with first atom at lower right hand position; (3) upright with first atom at bottom central position; (4) upright with first atom at upper central position; (5) sideways with first atom at lower righthand position; and (6) sideways with first atom at upper righthand position. 
     Each direction value DR1 is tested before that value is used to position the next atom b. To illustrate, assume a next atom b after the first atom a is positioned by calling FindNextRing with CHOICE=0, RANK=0 and the baseline direction DR{a}=0. A NEXTRING (CHOICE, RANK) value of 3 is selected. DR1 is equal to DR{a}+NEXTRING {CHOICE, RANK} or 0+3=3. The availability of this direction is confirmed by testing MASK{a}. The test is a logical one in which the value of MASK{a} is compared logically with a direction mask corresponding to the selected direction. MASK{a}, which is formed by eight bits, is initially at value {00000000}. A value MDR{DR1} is a mask at atom a corresponding to the direction of DR1=3, having 8 bits of value 1 except in the DR1 direction. MDR{DR1} thus equals (11111011}. MASK{a} is logically ORed with MDR{DR1} to obtain {11111011}. Had the result been a FULLMASK, {11111111}, the program would have returned to DrawRing, the PROCESSLIST would have been cleared of (RANK+1) atoms and a new CHOICE value of 1 would have been tried, resulting in the use of (3, 6, 5, 5, 6, 7, 2) as the values for NEXTRING {CHOICE} in FindNextRing. 
     In the example above, a FULLMASK does not result, indicating that the direction DR1 selected for atom b is potentially available. However, where RANK=0, the FindNextRing routine does an additional test to determine that the position from the first atom a in the opposite (clockwise) direction is available. For CHOICE values of 0, 3 and 4, this direction has a value of {DR1+2}. For CHOICE values of 1, 2 and 5, 6, this direction has a value of {DR1+3}. Accordingly, this test is performed by the logical equations MASK{a} OR MDR{DR1+2}, for CHOICE values 0, 3 and 4, and MASK{a} OR MDR {DR1+3} for CHOICE values 1, 2 and 5, 6. If a FULLMASK results, the program returns to DrawRing to test the next CHOICE value. 
     Assuming the above-described tests do not result in an error, the coordinate position POS{b} of atom b is determined by multiplying the coordinates POS{a} of atom a by a rotation/translation matrix R{DR1}. If an atom already exists in that position, an error results and the program returns to DrawRing. Otherwise, the position POS{b} is accepted. MASK{a} is modified using the logical OR operation MASK{a} OR INV (MDR{DR1}) to {00000100}. The values of DR{b} and MASK{b} are set. DR{b} is set to (DR1+4) module 8=7 and MASK{b}=MASK{b} OR INV (MDR{DR{b}})={00000000} OR (01000000}={01000000}. The program returns using the above-described procedure. Assuming DrawRing and DrawNextRing successfully draws atoms &#34;a-f&#34; of a benzene ring using an initial baseline direction DR(a)=0 and CHOICE=0, the resultant configuration will appear, as follows: 
     
         ______________________________________                                    
              c        b                                                  
       d                        a                                         
              e        f                                                  
______________________________________                                    
 
    
     Following the DrawRing routine, the remainder of the Clist is drawn so as to extend to the right of the benzene ring. The baseline direction DR{fa} is set to 4 or west and CList is drawn to the East of the ring. The Draw Molecule procedure calls a DrawList routine which is also part of the FindNext Position procedure. 
     DrawList first determines whether a Table{a}=Table{a+1} exists in the position of atoms a and a+1. These Tables indicate a case of repeating parentheses and Table (a) is inserted. Otherwise, DrawList tests atom a and a next atom b to determine whether their structures Str{a} and Str{b} TB. If not, the DrawList routine calls the FindNext routine in the FindNext Position procedure. FindNext finds the position of atoms b next to atom a. The directions of the atoms relative to their previously drawn neighbors are found by a second direction variable D2 having a value 0-7 representing the number of 45 degree increments taken in a counterclockwise direction from a first direction variable D1. Direction D2 is found by adding a series of NEXT (CHOICE) values to DR1 until an open direction is found. NEXT (CHOICE)=4 is 180 degrees counterclockwise from the direction DR1; NEXT (CHOICE)=6 is 270 degrees from DR2; NEXT (CHOICE)=2 is 90 degrees from DR1; NEXT (CHOICE)=5 is 225 degrees from DR1; NEXT (CHOICE)=1 is 45 degrees from DR1; NEXT (CHOICE)=3 is 135 degrees from DR1; NEXT (CHOICE)=7 is 315 degrees from DR1; and NEXT (CHOICE)=0 is 0 degrees from DR1. 
     The value of the first direction variable used to calculate DR2 depends on the baseline direction DR{m} of the previously drawn atom. If DR{m}modulo 2=0, which is true for DR{m}=0, 2, 4, and 6, DR1=DR{m}. Otherwise, DR1=(DR{m}+1)modulo 8 or 45 degrees counterclockwise from DR{m}. This holds true where DR{m}=1, 3, 5 and 7, i.e., where DR{m} extends at a 45 degree angle from the horizontal and vertical directions. Thus, FindNext first tries to draw the atoms in a horizontal or vertical direction. Once an atom is drawn, a new baseline direction DR {m+1} is set at 180 degrees from the value of DR2 used to draw the atom. The next atom is drawn using the new baseline direction DR{m+1}, and the process repeats. 
     Assuming a first atom a having a baseline direction DR{a}=4, and CHOICE=0, then DR1=DR{a}=4, NEXT{CHOICE}=4, and FindNext calculates the direction of atom b using the equation DR2=(DR°+NEXT {CHOICE}) modulo 8=(4+4) modulo 8 =0, or East. A mask test is performed by means of the logical OR equation MASK{a} OR MDR{DR2}, where MDR is an eight bit mask having bit values of 1, except in the direction DR2. If a FULLMASK results, the value of CHOICE is incremented and a new DR2 is calculated. In the present example, assume Mask{a}={00010000} and MDR{DR2}={11111110}. The result of the logical OR operation is {11111110}. Because DR2 is available, the position of atom b POS{b} may be calculated by multiplying the position of atom a, POS{a} by the translation/rotation matrix R{DR2}. Assuming no atom exists at this position, the value of MASK{a} is changed to {00010001} using the logical OR operation MASK{a}=MASK{a} OR INV (MDR{DR2}). The baseline direction value for atom b DR{b} is set to (DR2 + 4)modulo 8 =(0+4) modulo 8=4 and MASK{b}=MASK{b} OR INV (MDR DR{b}) ={00000000} OR {00001000}={00010000}. FindNext terminates and the program returns to DrawList to draw the next atom in the list. If there exists an atom of the list indicating a case of pendant parentheses or digital front information, DrawList inserts all tables in PROCESSLIST{i} not previously inserted. DrawList then terminates and the program returns to Draw Molecule. Assuming DrawList and FindNext are able to draw a linear list of atoms &#34;a-e . . .&#34; using an initial baseline direction DR{a}=4 and a value of CHOICE=0, atoms &#34;a-e . . .&#34; will be drawn as follows: 
     a b c d e . . . 
     If in DrawList, atoms a and b having Str=TB (triangular bond) are found, DrawTb is called. DrawTB draws a triangular bond between atoms a, b and c. Knowing atoms a and b, DrawTB first finds an atom c connected to atoms a and b. It then initializes a fictitious atom f. In the triangular bond a, b and c, the distance between a and b will be two bond lengths (2bl) to allow atom c to be positioned at the midpoint distance between atoms a and b but at a distance of 1bl from the line connecting a and b. To position these atoms, FindNext (a, f) is first called and fictitious atom f is positioned at a distance of lb from atom a. If FindNext returns an error, the program returns to DrawList and the atoms drawn since the last call to DrawList are cleared from PROCESSLIST. Assuming no error occurs and atom f is drawn, MASK{a} is modified to allow b to use the direction DR2 used for atom f in DrawList. Mask{a} is modified using the logical operation MASK{a}=MASK{a} AND MDR {(DR{f}+4) modulo 8}/ where MDR is an eight bit mask having bit values of 1 except in the direction {{ DR{f}+4}modulo 8}. Thus, if DR{a} is 4, Dr{f} is 4 and MASK{a} is {00010001}, then MDR{{DR{f}}+4}modulo 8={11111110} and MASK{a} is freed using MASK{a}={00010001} AND {11111110}={00010000}. The position bond length of atom a is modified to 2*bl. DrawTB then calls FindNext (a, b). If an error is reported, the program returns to DrawList. Otherwise, DR{b} should be the same as DR{f}, and because the bond length of a is 2bl, the calculated position of atom b, POS{b}, will be 2 bond lengths from atom a in the direction of fictitious atom f. If DR{b} does not equal DR{f}, 2 atoms are cleared from PROCESSLIST and DrawTB is reexecuted. The position bond length of atom a is set back to 1bl. 
     The direction of atom c from atom a is calculated using the equation DR1=DR{a}+(NEXT{CHID{b}}+CHID{c}+8) modulo 8. CHID represents a direction choice identification variable. NEXT{CHID{b}} is determined from FindNext. The variable CHID is initialized by Draw Molecule to -1 for all atoms in ALLATOM. DrawTB sets CHID{b} to an initial value of 0. Thus, CHID{b} will be 0, NEXT{CHID{b}} will be 4 and CHID{c} will be -1. DR1=DR{a}+(NEXT{CHID{b}}+CHID{c} +8)modulo 8)=4+(4+-1+8)modulo 8=7 or 45 degrees in the clockwise direction from DR{b}. However, because the position bond length of atom a was reset to 1bl, atom c is halfway between and 1bl below atoms a and b. DrawTB tests MASK{a} for interference in the direction DR1 and if full, clears 2 atoms from PROCESSLIST and reexecutes DrawTB. If MASK{a} is not full, and no atom coexists in the selected direction, POS{c} is assigned to atom c. DrawTB then calculates a second direction DR2=(DR1+2*CHID{c}+8) modulo 8. With DR1=7, and CHID{c}=-1, DR2=(7+2(-1) +8) modulo 8=5, or 90 degrees in the clockwise direction from DR1. This is the direction required to move from atom b to atom c. DR2 is used to modify MASK{b} in accordance with the logical OR operation MASK{b}=MASK{b} OR INV(MDR{DR2}), where MDR{DR2} is an eight bit mask having bit values of 1, except in the direction DR2. DR1 is used to modify MASK{a} in accordance with the logical OR operation MASK{a}=MASK{a} OR INV (MDR{DR1}). The DrawList completes the triangular bond drawing process by resetting the DR{c} attribute for atom c and filling the positions of atoms a, f and b in MASK {c}. Thus, DR{c}=(DR1+4) modulo 8; and MASK{c}=MASK{c} OR INV (MDR{DR{c}}) OR INV (MDR{DR2}) OR INV (MDR({DR2+DR{c}/2}), where MDR{DR{c}} and MDR{(DR2+DR{c})/2}, are eight bit masks having bit values of 1, except in the directions DR{c} and (DR2+DR{c})/2, respectively. DrawTB terminates and the program returns to DrawList. Assuming atoms a, b and c having Str{m}=TB, and DR{a}=4, DrawTB will draw these atoms, as follows: 
     
         ______________________________________                                    
          a               b                                               
                 c                                                        
______________________________________                                    
 
    
     When the list has been drawn, the program returns to Draw Molecule. In the Draw Molecule procedure, the program tests whether a second benzene ring is attached at the end of the atom list, and if so, the DrawRing routine is called to determined the position of those ring atoms. 
     Thereafter, the Draw Molecule procedure commences a BenzeneRing loop that finds lists of atoms not yet drawn that start or end with a benzene ring that is drawn. These atoms are drawn using the DrawList routine and attached to the previously drawn benzene ring. If the list ends with a benzene ring, that ring is also drawn using the DrawRing procedure. 
     If, among the Clists, there are no lists connected to a benzene ring, the Draw Molecule procedure selects the longest list and jumps to the NoLiString routine. That routine affects the coordinate position of the first atom of the list to (0, 0, bl). It then calls the DrawList routine of the FindNext procedure to draw these linearly aligned atoms. 
     Following BenzeneRing, or NoListRing, Draw Molecule executes a ListBegin routine. ListBegin attempts to find a list not yet drawn having a first or last atom that is drawn. If such a list if found, the atoms are drawn using the DrawList routine. If the list ends with a benzene ring the DrawRing routine is used and the BenzeneRing routine thereafter. 
     If there are no lists not drawn having a first or last atom that is drawn, or, if no Clists are found at the start of Draw Molecule, the Neighbor loop is commenced. 
     The Neighbor loop looks through the listing of atoms initially classified in decreasing order by their number of connections in ALLATOM. The Neighbor loop searches through the ALLATOM list until it finds an atom that has been drawn. If none have been drawn, a New routine is called that affects the coordinates of the first atom in ALLATOM to (0, 0, bl), and then calls the DrawRing routine if the first atom is part of a benzene ring, and the DrawNeighbor routine if the first atom in the atom list is not part of a benzene group. Following New, or if the atom list considered in Neighbor included a previously drawn atom, the procedure calls a DrawNeighbor routine in the FindNext Position procedure. The DrawNeighbor routine determines the coordinates of all atoms that have not yet been drawn that are connected to an identified drawn atom. The DrawNeighbor routine first attempts to insert a table for the considered atom a. In cases where the neighboring atom b is part of a benzene ring or a Clist, DrawNeighbor calls FindNext to draw the atom b. The program then returns to Neighbor. In Neighbor, if Str {PROCESSLIST{i} }=BZ (last atom drawn), the ring is drawn by DrawRing and the process returns to the BenzeneRing loop. If Str {PROCESSLIST{i}}=LL, the list is cut into two lists starting at the last drawn atom. Both Clists are drawn using DrawList. If one ends in a benzene ring, the ring is drawn using DrawRing. DrawList is then called for the new PROCESSLIST{i}. If, after DrawList, Str {PROCESSLIST{i}}=BZ, DrawRing is again called. If a ring was drawn, the process returns to the BenzeneRing loop; otherwise the process returns to ListBegin. 
     If in DrawNeighbor Str{a}=TB and DrawTB Str{b}=TB, Drawing is called. If in DrawNeighbor the atom b adjacent the drawn atom a is a member of an ethyl group, the DrawNeighbor routine calls a DrawET routine that determines the correct position of the undrawn atoms forming the ethyl group. DrawET draws an ethyl group where a is drawn, b is a carbon of the group and Str{b}=b. If a carbon atom of structure ET has an inliaison, the inliaison is replaced by a fictitious atom f. DrawET first attempts to insert a Table{b} connected to atom a at the fictitious atom connected to b in TABLE{b}. If such a Table is found DrawET terminates. 
     DrawET finds the positions of 5 atoms b, c, d, e and g extending from the first atom a. It determines their positions using a FindET routine that tests up to 10 CHOICES of NEXTET {CHOICE, RANK} having 5 values for each atom. 
     Each atom is drawn and its position tested using MASK values in a manner similar to FindNextRing, FindNext and DrawTB. Thus, starting from a baseline direction for atom a, DR{a}, a direction DR1 is calculated using a NextET {CHOICE, RANK} value in the equation DR1=(DR{a}+NextET {CHOICE, RANK} modulo 8. MASK{a} is then tested using the logical OR operation MASK{a}=MASK{&lt;} OR MDR{DR1}, where MDR{DR1} is an eight bit mask having bit values of 1 except in the direction DR1. The position of atom b is POS{b}, selected by multiplying POS{a} by a translation/rotation matrix R{DR1}. MASK{a} is then reset using the logical operation MASK{a}=MASK{a} or INV (MDR{DR1}). The atom b attributes are set to DR{b}=(DR1+4) modulo 8 and MASK{b}=MASK{b} OR INV(MDR{DR{b}}). 
     DrawET selects the CHOICE and RANK values used by FindEt in drawing the atoms b-g. Starting from a value of CHOICE=0, and assuming DR{a}=0, atom b is drawn by calling Find ET (a, b, 0, 0). In FindET, this corresponds to a NEXTET value of 5, such that DR1=(0+5) modulo 8=5, and atom b is 225 degrees counterclockwise from DR{a}=0 degrees. Draw{b} is set to (DR1+4) modulo 8=1. DrawET then finds a undrawn atom c of Str{c}=ET, connected to b by calling FindET (b, c, 0, 1). in FindET, this corresponds to a NEXTET value of 3, such that DR1=(1+3) modulo 8=4, and atom c is 135 degrees counterclockwise from DR{b}=45 degrees or 180 degrees from Dr{a}=0 degrees. DR{c} is set to (DR1+4) modulo 8=0 . DrawEt then searches for an undrawn atom d connected to b. If not found and b has an inliaison&gt;0, the inliaison is decremented and a fictitious inliaison atom f is initialized. It is assumed that an atom at insert table will be later positioned at f. DrawET then finds the position of atom d connected to b by calling FindEt (b d, 0, 2). In FindEt, this corresponds to a NEXTET value of 6, such that DR1=(1+6)modulo 8=7, and atom d is 270 degrees counterclockwise from DR{b}=45 degrees or 315 degrees from DR{a}=0 degrees. DR{d} is set to (DR1+4)modulo 8=3. DrawET then searches for an undrawn atom e connected to atom c. If not found and inliaison {c}&gt;0, a fictitious inliaison atom f is connected to c at the position of atom e. DrawET then finds the position of undrawn atoms e and g connected to c. If atom g is not found and inliaison {c}&gt;0, a fictitious inliaison atom f is connected to c at the position of atom g. The process assumes that atoms marked cis and trans are on the same or opposing sides, respectively, of the double bond connection between the carbon atoms. 
     If any call to FindET results in an error, a BACKTRACK procedure is called that clears 1-4 atoms from PROCESSLIST and reexecutes DrawET using a new CHOICE value. Assuming DrawET successfully draws atoms b-g using CHOICE=0 and DR{a}=0, the resultant cis and trans configurations will appear, as follows: 
     
         ______________________________________                                    
e                    a        g           a                               
         c     b                  c   b                                   
g                    d        e           d                               
cis(a,e), trans(a,g), null                                                
                    trans(a,e), cis(a,g)                                  
______________________________________                                    
 
    
     Following DrawET, the program returns to DrawNeighbor. In the event of an error in DrawNeighbor, a Backtrack routine is called for error recovery. Thus, DrawNeighbor attempts to draw the atom adjacent to atom a. If a is not in a structure, all atoms drawn are cleared and a new position for a is found. Otherwise, if the position of atom a cannot be modified, a Resolve Conflict routine finds a position for atom b corresponding to the position of an adjacent atom c. A new position for c is found. Following the DrawNeighbor and Neighbor loops, when all atoms are drawn, the Draw Molecule procedure terminates. 
     The chemical string has now been completely defined by the position of its atoms in an atom list and their connectivity in a connectivity table. The atom list and connectivity table information are then translated into the graphics coordinate system of the graphic structure and combined with that structure in the interpret formula routine. 
     Having reference now to the program flow diagram of FIG. 12, and the state machine diagrams of FIGS. 13 and 14, the String Recognition program will be discussed in greater detail in connection with the following examples: 
     EXAMPLE 1 
     C6H5(OH) 
     Following program initialization and the Input-String procedure, the string C6H5(OH) is input to the Separate routine. Starting from the zero state, and with the GSTACK set to empty, the program reads the character &#34;C&#34;, recognizes it as an uppercase character and not front information, and performs a Readstring action on the entire string C6H5(OH). The state machine changes to state 7. 
     During the Readstring operation, the character string C6H5(OH) is input first to the Treat-One-String program. This routine searches for elementary substrings of the type S0, which are defined by the routine as being disposed between parentheses. Thus, the Treat-One-String program identifies the elementary substring OH in the string C6H5(OH). The program separates the (OH) elementary substring as a partial string to treat (TST) and replaces the elementary substring by a &#34;.&#34; in the whole substring (WST) to form &#34;C6H5.&#34;. 
     The program then tests the partial string TST to determine whether there are any existing &#34;.&#34; therein, meaning that there exists elementary substrings within the elementary substring TST for which connectivity tables have already been generated and which are identified by an array of pointers WT. If such elementary substring connectivity tables have already been created, the program creates an array of pointers PT formed by the last connectivity tables in WT and deletes them from WT. The connectivity tables represented by PT will be subsequently combined with the connectivity table for the substring TST and the combined table added in WT. 
     With respect to the elementary substring OH, there are no previously existing elementary substrings already treated. The next instruction is to create a connectivity table for TST. The program thus jumps to the Create-Stack routine with the string OH as input. The Create-Stack program parses through the elementary substring, one character at a time. The output is a stack with all atoms composing the molecule, together with the atoms&#39; valence, structure group type, in and outliaison information and the indice of any connectivity table to insert based on an inliaison with another substring. 
     Applying these actions to the elementary substring OH, the state machine first initilizes itself to the zero state. The routine then reads the uppercase &#34;0&#34;. A &#34;push&#34; action is performed. The &#34;0&#34; character is pushed on the stack together with its valence information, which for oxygen is 2. The state machine then changes to state 1. The program reads the character &#34;H&#34;. This causes the program to take the action &#34;push,&#34; wherein the character &#34;H&#34; and its most likely valence (i.e., -1 for hydrogen) are pushed on the stack. The state machine then changes to state 3 and the program reads the final character of the elementary substring, &#34;null&#34;. Upon reading this character, the program performs an &#34;addpush&#34; operation wherein the &#34;H&#34; element is pulled from the stack, and its -1 valence is combined with the valence +2 for oxygen. The resulting +1 valence is associated with the oxygen atom &#34;0.&#34; The state machine then changes to state 1. At this point, since there are no further characters of the elementary substring OH, the state machine changes to state 8. Because the elementary substring OH is known to be part of a larger substring, an inliaison value of 1 is added to the first element in the stack whose valence is greater than 1 (or equal to 1 if reduced to 1 atom), in this case oxygen. The inliaison information indicates that the oxygen connects the OH substring to the remainder of the string. The Create-Stack routine then terminates and the Find-Group routine commences operation. The stack output of the Create-Stack routine is as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
0        1        /        1      0      /                                
______________________________________                                    
 
    
     where &#34;At&#34; identifies the atom, &#34;Val&#34; is the valence, &#34;Str&#34; is the group type, Il is the inliaison value, O1 is the outliaison value and Nt is a &#34;next table&#34; pointer to any previously created elementary substring table. 
     The purpose of the Find-Group program is to modify the stack created during the Create-Stack program in accordance with the nature of the group and any front information existing in the GSTACK. The Find-Group routine tests for the presence of a &#34;group&#34; by searching for duplicated carbons (i.e., duplicated by a &#34;repeat&#34; action in the Create-Stack routine). In the case of the OH elementary substring, the Find-Group program terminates without modifying the stack once it determines that OH does not contain a repeating carbon &#34;group.&#34; 
     The program then executes the Connect Routine, which generates a connectivity table T 0  for the elementary subgroup OH. Because there is only one non-hydrogen atom, i.e., oxygen, there is only one molecule in the connectivity table T 0 , as shown below: 
     
         ______________________________________                                    
            T.sub.0                                                       
                   O                                                      
            O      /                                                      
______________________________________                                    
 
    
     The program then executes the Test routine. Because there is only a single non-hydrogen atom in the elementary substring OH, the Test routine results in an &#34;ok&#34; output and the program returns to the Treat-One-String routine. The Draw Molecule procedure is called. Because no benzene rings or Clists are found, the Neighbor routine searches for an atom already drawn. Because there are no drawn atoms, the procedure jumps to New where the coordinates of &#34;0&#34; are determined to be (0, 0, bl). The procedure then calls DrawNeighbor, where no adjacent atoms to &#34;0&#34; are found. A counter p is set to p+1 and the program exists Draw Molecule and returns to Treat-One-String. 
     In the Treat-One-String routine, the program searches for previous connectivity tables PT to combine with the Table T 0 . Since there are none, the program adds a pointer to T 0  in the last position in WT. Since the whole string is not empty, the program returns to the start of the Treat-One-String routine to treat the whole string &#34;C6H5&#34;. 
     Having input the whole substring C6H5., the Treat-One-String routine determines that there are no remaining elementary substrings. The program then jumps to the Create-Stack program with the string &#34;C6H5.&#34; as input. 
     The Create-Stack program begins with state zero and reads initially the first carbon &#34;C&#34;. The action taken by the Create-Stack routine is to push the carbon atom onto the stack, together with its valence +4, and to change the state of the state machine to state 1. The program next inputs the digit 6, pushes that digit onto the stack and changes the state machine to state 7. The program then reads the hydrogen atom &#34;H&#34; and commences a repeat action which pulls the last element of the stack (i.e., the character &#34;6&#34;), duplicates the previous character &#34;C&#34; five times to form C 1 , C 2 , C 3 , C 4 , C 5  and C 6 , and pushes the H and its -1 valence to the stack. The state machine changes to state 3. Upon reading the next character of the substring, i.e., &#34;5&#34;, the program commences an &#34;addnewval&#34; action which combines the value 5 with the -1 valence of the H to change that valence to -5. The state machine changes to state 4. The next character input into the Create-Stack program is the &#39;.&#39; previously generated by the Treat-One-String program and representing the elementary substring (OH) previously treated. In response to this input, the program executes a combinlia action which calls addpush. Addpush causes the last element of the stack, H, to be popped and its -5 valence to be added to the valence of the last carbon C 6  such that the resultant valence of that carbon is -1. A &#34;(&#34; is pushed to the stack. Then the atom &#34;0&#34; from table T 0  in WT is pushed to the stack, together with a pointer to T 0  and a valence 1 equal to the inliaison value. The &#34;)&#34; character is then pushed to the stack. The state machine changes to state 5, and following input of a null character, a suppush action is performed that deletes &#34;(&#34; and &#34;)&#34; from the stack. The new state is 1. No new characters are found in the string and the Create-Stack routine terminates. The resultant stack is as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.1   4                0      0      /                                
C.sub.2   4                0      0      /                                
C.sub.3   4                0      0      /                                
C.sub.4   4                0      0      /                                
C.sub.5   4                0      0      /                                
C.sub.6  -1                0      0      /                                
O         1                0      0      T.sub.0                          
______________________________________                                    
 
    
     The program then executes the Find-Group routine. This routine changes the carbon valences to their initial valence table values +4. The Find-Group routine then determines that the number of carbons equals six and therefore identifies the substring as a benzene or phenol ring. The &#34;Benzene Ring&#34; portion of the Find-Group routine tests the number of hydrogen atoms in the C6H5 substring. Finding that the number of hydrogens (NH) equals 5, the routine changes the valence of C 1  -C 5  from +4 to +3 to reflect the attachment of one hydrogen to each carbon, and adds double and single bond connectivity information to the stack. The valence of C6 is not changed because no hydrogens are attached to that carbon. The Find-Group routine then terminates having generated a modified list of the six carbon atoms and the single oxygen atom together with updated valence and structure information. The resultant modified stack is as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.1  3        BZ       0      0      /                                
C.sub.2  3        BZ       0      0      /                                
C.sub.3  3        BZ       0      0      /                                
C.sub.4  3        BZ       0      0      /                                
C.sub.5  3        BZ       0      0      /                                
C.sub.6  4        BZ       0      0      /                                
O        1                 0      0      T.sub.0                          
______________________________________                                    
 
    
     The program then executes the Connect routine to generate a connectivity table T 1  comprising the atoms C 1  -C 6  and 0 from the modified stack generated by the Find-Group routine. A first pass through the stack connects all atoms of valence 1 to the previous atom if possible. In this case, 0 is connected to the last C, C6. A second pass connects the carbons in accordance with the group structure connectivity information (BZ) in the stack. Thus, single and double bonds are added between the carbons at the appropriate locations. A third pass connects any remaining unconnected atoms. In this case there are no such atoms. 
     The connectivity table T 1  is as follows: 
     
         ______________________________________                                    
T.sub.1                                                                   
       C.sub.l C.sub.2 C.sub.3                                            
                             C.sub.4                                      
                                   C.sub.5                                
                                         C.sub.6                          
                                              O                           
______________________________________                                    
C.sub.1                                                                   
       /       2                         1                                
C.sub.2                                                                   
       /       /       1                                                  
C.sub.3                                                                   
       /       /       /     2                                            
C.sub.4                                                                   
       /       /       /     /     1                                      
C.sub.5                                                                   
       /       /       /     /     /     2                                
C.sub.6                                                                   
       /       /       /     /     /     /    1                           
O      /       /       /     /     /     /    /                           
______________________________________                                    
 
    
     The Test routine determines that all atoms are fully connected and are in one set. The Draw Molecule procedure classifies the carbon atoms in the string in decreasing order based on the number of connections to other atoms. The atoms are placed in ALLATOM. The selected order is C 6 , C 1 , C 2 , C 3 , C 4 , C 5 . No Clists are found and the Neighbor routine is called. Because no previously drawn atom is found in the string, the New routine is performed. The first atom considered, fa, is C 6 . Its coordinates are set at C 6  (0,0,bl). Because C 6  is an element of a benzene ring DrawRing (C6) is called using the first direction choices (3, 5, 5, 6, 5, 6, 6), C1, C2, C3, C 4  and C 5  are drawn, at the following coordinates: C 1  (-bl, +bl, bl), C 2  (-2bl, +bl, bl), C 3  (-3bl, 0, bl), C 4  (-2bl, -bl, bl) and C 5  (-bl, -bl, bl). The string is arranged as follows: 
     
         ______________________________________                                    
              C.sub.2  C.sub.1                                            
       C.sub.3                  C.sub.6                                   
              C.sub.4  C.sub.5                                            
______________________________________                                    
 
    
     When the ring is drawn, DR{C 6  } is set to 4 and Draw Molecule returns to the Neighbor loop. The atom counter p is equal to 0. The Neighbor loop calls the Draw Neighbor routine. The first atom drawn with neighbors that are not all drawn is C 6 . The neighbors of C 6 , C 1  and C 5 , are drawn. The neighbor 0 is not drawn. FindNext (C 6 , 0) is called. 0 is put at coordinates (+bl, 0, bl) using an initial direction DR{C 6  }=4 (See New). The molecule appears as follows: 
     
         ______________________________________                                    
            C.sub.2  C.sub.1                                              
C.sub.3                       C.sub.6                                     
                                     O                                    
            C.sub.4  C.sub.5                                              
______________________________________                                    
 
    
     Because there are no further undrawn neighbors of C 6 , the program returns to Draw Molecule in the Neighbor loop. All neighbors of C 6 , C 1 , C 2 , C 3 , C 4 , and C 5  are drawn. The program calls DrawNeighbor for 0. Table {0} is not null. Insert Table {0} is called. Insert Table translates the &#34;0&#34; of T0 at position (0, 0, bl) to the position (+bl, 0, bl). Because there is only one atom in T0, no conflict is found and &#34;0&#34; in T1 will have the position (+bl, 0, bl). The Insert Table routine ends. Because there are no undrawn neighbors of &#34;0,&#34; DrawNeighbor ends. Because there are no further atoms to draw, the Draw Molecule procedure ends. Following the Draw Molecule procedure, the 1×1 dimension table T0 is added to the connectivity table T1 and the stack is modified to remove the pointer to T0. The Connect routine then terminates and the test routine commences. The Treat-One-String program terminates after attempting to operate on an empty string. 
     The program then returns to the Separate routine, whereupon the program ends because the input string is now empty. 
     EXAMPLE 2 
     2-cis-C2H2Cl,C3H7 
     Following program initialization and the Input-String procedure, the string is input to the Separate routine. With the state machine set to state 0 and the GSTACK set to empty, the program first reads the digit 2. The action taken is to push the 2 onto the GSTACK and change the state machine to state 1. The next character read is the &#39;-&#39;. No action is taken in response to this character, but the state machine changes to state 2. The next characters read represent the lower case &#34;c&#34; in the notation &#39;cis.&#39; The action taken is readinfo, which causes the cis notation to be pushed onto the GSTACK. The state machine changes to state 3. The next character read is the &#39;-&#39;, in response to which no action is taken, but the state machine changes to state 4. The next character read is the upper case C representing a carbon atom. The action taken is readstring, which causes the program to read the entire substring, C2H2C1, and input that string to the Treat-One-String, Create-Stack, Find-Group, Connect and test routines. The state machine also changes to state 5. The GSTACK is as follows: 
     
         ______________________________________                                    
              cis                                                         
              2                                                           
              NULL                                                        
______________________________________                                    
 
    
     The first routine, Treat-One-String, searches for but will not find any elementary substrings (i.e., substrings within parentheses). 
     The substring C2H2C1 is in elementary form and is next input to the Create-Stack routine. With the state machine set to state 0 and the stack set to empty, the Create-Stack routine first reads the character &#34;C&#34; representing carbon. The action taken is to push the character &#34;C&#34; and its most likely valence (i.e., +4) onto the stack. The state machine changes to state 1. The program next reads the digit 2. The action taken is to push the 2 character onto the stack and to change the state machine to state 7. The next character read is the &#34;H&#34; representing hydrogen. The action taken is repeat, which pulls the last element from the stack, i.e., the 2 character, duplicates the previous character &#34;C&#34; one time to form C 1  and C 2 , and pushes the H and its -1 valence onto the stack. The state machine then changes to state 3. The next character read is the digit 2. The action taken is addnewval, which combines the value 2 and the - 1 valence of the hydrogen for a resultant valence of -2. The state machine then changes to state 4. The next character read is the &#34;C&#34; of the chlorine atom. The action taken is addpush, which pulls the last element from the stack and combines the -2 valence of the hydrogen with the valence +4 of the preceding carbon C 2  such that the resultant valence for the last carbon is +2. The new C is pushed to the stack. The state machine changes from state 4 to state 1. The final character of the substring is the &#34;1.&#34; The action taken is pushlow, which combines the character &#34;1&#34; with the last element of the stack (i.e., the &#34;C&#34;) and obtain a new element cholorine of valence +1. The state machine remains in state 1. No new character is found in the string. The next state is 8 and the create-stack routine terminates. Because the string is known to be partial, the first atom of the stack having a valence greater than 1, i.e. Cl, receives an inliaison value of 1. The result of the Create-Stack routine is a list of the carbon and chlorine atoms, their valence and their in- and outliaison values, as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.1  4                 1      0      /                                
C.sub.2  2                 0      0      /                                
C.sub.1  1                 0      0      /                                
______________________________________                                    
 
    
     Following termination of the Create-Stack routine, the output thereof is input to the Find-Group routine. The Find-Group routine resets the carbon valences to 4. The routine then recognizes the substring C2H2C1 as a double linear group because there are two carbons. This results in commencement of the Ethyl-Group subroutine. This subroutine determines that the number of hydrogens in the substring equals 2 and confirms that the information on the GSTACK is related to a double linear group. The Ethyl-Group subroutine then pops the &#34;cis&#34; group information from the GSTACK. If the information on the GSTACK is not related to a double linear group, a flag is set indicating that the substring is ambiguous. Thereafter, assuming the substring is not ambiguous, the Ethyl-Group subroutine changes the values of each carbon atom from 4 to 3 to reflect the attachment of one hydrogen to each atom. The subroutine then adds double bond information between the carbons, and the Ethyl-Group subroutine and the Find-Group routine terminate. 
     The resultant modified stack is as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.1  3        Cis      1      0      /                                
C.sub.2  3        Cis      0      0      /                                
C.sub.1  1                 0      0      /                                
______________________________________                                    
 
    
     The program then executes the Connect routine which generates a connectivity table T 2  for the atoms C 1 , C 2  and C1, as follows: 
     
         ______________________________________                                    
       T.sub.2                                                            
              C.sub.1  C.sub.2  C.sub.1                                   
______________________________________                                    
       C.sub.1                                                            
              /        2                                                  
       C.sub.2                                                            
              /        /        1                                         
       C.sub.1                                                            
              /        /        /                                         
______________________________________                                    
 
    
     The program then executes the Test routine which tests the connectivity between the atoms in the table T 2 . 
     Following the Test routine, the program calls the Draw Molecule procedure. Draw Molecule classify the atoms in the file called ALLATOM in decreasing order depending on the number of connections to each atom. Thus, ALLATOM will contain C 2 , C 1  and C1. No Clists are found and Draw Molecule jumps to the Neighbor loop. There being no atoms previously drawn, the program jumps to the New loop. The New loop assigns C1 the first atom in ALLATOM that is not part of an ethyl group to coordinate position (0, 0, bl). DrawNeighbor (C1) is called. In DrawNeighbor, the undrawn neighbor C 2  is recognized as a member of an ethyl group. FindET is called and draws C 1 , C 2  and C1 at C 1  (-2bl, bl, bl), C 2  (-bl, bl, bl) and C1(0, 0, bl). It creates a fictitious ethyl atom at (-3bl, 0, bl). The string is drawn as follows: 
     
         ______________________________________                                    
              C.sub.1  C.sub.2                                            
       f                        Cl                                        
______________________________________                                    
 
    
     Because there are no remaining undrawn neighbors of C 2 , the program returns to the Neighbor loop in Draw Molecule, which then terminates and the Draw Molecule routine ends. 
     Following the Draw Molecule procedure, program control returns to Treat-One-String and then to the Separate routine in state 5. The Separate routine reads the first character of the remaining substring &#34;,C3H7&#34;. The routine skips the &#34;,&#34;, sets the state to 6 and reads the &#34;C.&#34; The program executes a Readstring action wherein execution of the Treat-One-String, Create-Stack, Construct-Group, Connect and Test routines commences. 
     In the Treat-One-String routine, the routine treats the entire string and jumps to the Create-Stack routine. 
     In Create-Stack, the first action in response to reading the &#34;C&#34; of the substring is to push the &#34;C&#34; onto the stack and to change the state machine to state 1. The routine next reads the digit 3. The action taken is to push the 3 onto stack and change the state machine to state 7. The next character is the hydrogen atom &#34;H&#34;. The action taken is repeat, which pulls the character &#34;3&#34; from the stack, duplicates the character &#34;C&#34; two times to create the characters C11, C12 and C13, and pushes the H and its -1 valence to the stack. The state machine changes to state 3. The final character &#34;7&#34; causes an addnewval action to be taken wherein the value 7 is combined with the -1 valence of the hydrogen character &#34;H&#34; such that the resultant valence for the hydrogen becomes -7. The new state of the state machine is 4. A null character is entered and an addpush action is performed by combining the -7 valence of H with the valence of C13, causing that character to have a valence of -3. Thus, the result of the create-stack routine is to create a stack listing the three carbon atoms and their valences, as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.11  4                0      0      /                                
C.sub.12  4                0      0      /                                
C.sub.13 -3                0      0      /                                
______________________________________                                    
 
    
     Following the Create-Stack routine the program commences execution of the Find-Group routine. The input is the stack created by the Create-Stack routine. In the Find-Group routine, the carbon values are reset to their valence table value 4, and the substring C3H7 is recognized as a linear group. Thereafter, the program tests the information on the GSTACK to determine whether it is related to a linear group. The group information remaining on the GSTACK is the digit 2. Because the group is linear, a single bond connection is provided between each carbon. In assigning the hydrogens, the Find-Group routine takes into account the previously assigned carbon bonds, the in- and outliaison values and the group connectivity information. In this case, because the group information consists of the digit 2, the routine recognizes that the second carbon C 12  will be connected with the previously treated substring as well as other carbons in its own substring, and will keep three valences open for that connection. The valences of C 11  and C 13  are thus changed to 1, and the valence of C 12  is changed to 3, as the hydrogens are assigned to fill up these carbons. The resultant modified stack is as follows: 
     
         ______________________________________                                    
At       Val      Str      Il     Ol     Nt                               
______________________________________                                    
C.sub.11 1        Lg       0      0      /                                
C.sub.12 3        Lg       0      0      /                                
C.sub.1  1                 0      0      T.sub.2                          
C.sub.13 1        Lg       0      0      /                                
______________________________________                                    
 
    
     In addition, the atom C 1  from the connectivity table T 2  (which has an inliaison value of 1) is introduced after C 12 , together with a pointer to T 2 . If any ambiguity occurs in determining this connectivity, a flag is raised and the user may interact with the program. 
     The program then commences execution of the Connect routine which creates a connectivity table T 3  for the carbons C 11 , C 12 , C 1 , and C 13 , as follows: 
     
         ______________________________________                                    
T.sub.3     C.sub.11 C.sub.12 C.sub.1                                     
                                     C.sub.13                             
______________________________________                                    
C.sub.11    /        1                                                    
C.sub.12    /        /        1      1                                    
C.sub.1     /        /        /                                           
C.sub.13    /        /        /      /                                    
______________________________________                                    
 
    
     Thereafter, the program commences execution of the Test routine which tests the connectivity of the table T 3 . 
     Draw Molecule first transfers the Ethyl structure information to C 1 , then classifies the atoms in ALLATOM as C 12 , C 11 , C 1 , C 13 . A Clist C 11 , C 12 , C 13  is found. Their structural information is replaced by the linear designation LL. Draw Molecule jumps to No Listring. The first atom C 11  is assigned coordinates (0, 0, bl). NoListring then calls DrawList (C 11 ). DrawList draws C 12  and C 13  using FindNext. The coordinates assigned by FindNext are C 12  (1, 0, bl) and C 13  (2, 0, bl) as follows: 
     
         ______________________________________                                    
          C.sub.11                                                        
                 C.sub.12 C.sub.13                                        
______________________________________                                    
 
    
     The program returns to DrawLIst and thence to the ListBegin loop in Draw Molecule. No other Clist is found and the Neighbor loop is started with C 12  as the first atom from ALLATOM. The Neighbor routine calls DrawNeighbor (C 12 ). It is determined that C 11  is already drawn. C 1 , however, is an undrawn neighbor of C 12  having ET structure information and a NextTable (T 2 ). Accordingly, FindET is called, followed by InserTable, which makes correspondence with C 12  and the fictitious inliaison in T 2 . Translation will be from fictitious inliaison (-3bl, 0, bl) to (1bl, 0, bl). The translation matrix T is as follows: 
     
         ______________________________________                                    
             1         0         +4/bl                                    
T =          0         1         0                                        
             0         0         1                                        
______________________________________                                    
 
    
     The molecule is drawn as follows: 
     
         ______________________________________                                    
                     C.sub.1  C.sub.2                                     
C.sub.11    C.sub.12 C.sub.13        Cl                                   
______________________________________                                    
 
    
     No overlapping is detected. C 13  is the last neighbor of C 12  and is already drawn. DrawNeighbor terminates and because all atoms are drawn, Draw Molecule ends. 
     The program then returns to Treat-One-String and the tables T 3  and T 2  are combined to obtain a complete connectivity table T 4  comprising all of the atoms of the string, as follows: 
     
         ______________________________________                                    
T.sub.4  C.sub.11                                                         
                 C.sub.12                                                 
                         C.sub.1                                          
                               C.sub.2                                    
                                     C.sub.1                              
                                           C.sub.13                       
______________________________________                                    
C.sub.11 /       1                                                        
C.sub.12 /       /       1                 1                              
C.sub.1  /       /       /     2                                          
C.sub.2  /       /       /     /     1                                    
C.sub.1  /       /       /     /     /                                    
C.sub.13 /       /       /     /     /     /                              
______________________________________                                    
 
    
     The Treat-One-String routine then attempts to read an empty substring. This causes the Treat-One-String routine to terminate and the program returns to the Separate routine. The Separate routine also reads an empty string, at which point the entire program terminates. 
     As an alternative to the Interpret Formula routine, the character codes obtained by OCR may be reformatted in conformance with the associated images found on the diagram (i.e., COCH3 or C1) and a procedure involved to search through template files stored in memory to see if such a character string is a common chemical substructure (e.g., COCH3). If so, its representation in the template file is rotated, translated, and scaled into place in the molecular structure file. If no template is found, the program assumes the line to be a simple atom type (e.g., C1). The resulting molecular structure can be visually checked by displaying the chemical structure with commercially available programs. 
     At the conclusion of the Structure Recognition stage, the system has produced all information needed to create a complete molecular structure file, including a list of nodes plus a connection table defining the bonds between nodes. FIG. 10 shows the resultant recognized structure. 
     I. AGGREGATION 
     The Aggregation procedure is set forth in detail in pseudocode form in Appendix K hereto. Interpret Formula produces a complete description of the molecule by combining the molecular substructure file created during the Interpret Formula routine with the molecular structure file information previously generated during the Atoms-Recognition and Interpret-Circle routines. Then, the Aggregation procedure forms the completed molecular description of the molecule extract in a required format to be memorized in a file. The Aggregation procedure can be customized to fit various output formats. 
     J. POST PROCESSING 
     The memory clean up procedure is shown in detail in pseudocode format in Appendix L hereto. As shown and described therein, a check is made of the validity of the final molecular structure file as a molecule description. Can it be drawn? Does it conform to chemical laws? It is at this stage, moreover, at which modifications and refinements of the software system could be added, for the chemical context permits validity to be checked to an extremely high degree of confidence. If a chemical balance law is violated, for example, indicating an error in the translation process, the structure can simply be displayed on a screen to be completed manually in a graphics editor mode. More complex post-processing, which can also be investigated, would seek to pinpoint the error and propose modifications that might satisfy the validity checks. 
     Accordingly, a novel procedure for optical recognition of chemical graphics and chemical string parsing has been disclosed having broad applicability in fields that handle chemical publications and databases, such as governmental regulatory agencies, in-house safety departments, chemical marketing industries, and publishers. Although various embodiments have been shown and described, it will be understood that many more modifications may occur to those skilled in the art and the invention, therefore, is not to be limited except in accordance with the spirit of the appended claims and equivalents thereof. ##SPC1##