CA2190164A1

CA2190164A1 - A real time handwriting recognition system

Info

Publication number: CA2190164A1
Application number: CA002190164A
Authority: CA
Inventors: Alexander Jourjine
Original assignee: Individual
Current assignee: Wang Laboratories Inc
Priority date: 1995-06-07
Filing date: 1996-03-27
Publication date: 1996-12-19
Also published as: JPH10504126A; WO1996041300A1; AU699966B2; AU5374596A; US5991441A; EP0774141A1

Abstract

A handwritten character recognizer having an input cluster buffer and a point buffer with dynamic and static stroke feature extraction and segment analysis byconical boundaries for identification of stroke segments (dynamic stroke featureextractor, static stroke feature extractor). A stroke recognizer compares single copies of idealized stroke representations with hierarchically approximated multiple scaled topological representations of a current stroke, followed by stroke proportion discrimination comparing a selected topological representation of the current stroke with boundaries defined by linear combinations of features of direct and reversed ideal stroke prototypes to provide a stroke identification. A cluster recognizer maintains a time ordered current stroke buffer and previous stroke buffer and constructs a per stroke area of influence list. The time ordered buffers are scanned to generate a spatially ordered window buffer. A position discriminator assigns character meanings to clusters of strokes in the window buffer. The buffer scanner is responsive to a current stroke having spatial coordinates located between previous strokes for reordering the stroke buffers and determining a new cluster meanings. An editor is responsive to an editing gesture or combination of two strokes for directing the stroke buffer controller to modify the strokes in the stroke buffer accordingly.

Description

~ WO 96/41300 2 1 9 ~ ~ 6 4 PCT/1~5~041~6 A REAL TIME HANDWRITING RECOGNITION SYSTEM
Related Patent A,, " ' ~l The present Patent Application is related to U.S. Patent Serial No.
08/484,630, filed on June 7, 199~ with the present Application and to Wang LdUUId~UI ies, Inc.
Field of the Invention The invention relates to a real time handwriting ,~c~"ilion system.
Background of the Invention The advent of affordable touch sensitive tablets and pens as computer input devices and the availability of more powerful Illi~,lU,UlUbC~55UI::- and lower cost memory has resulted in increased use of computer systems wherein the primary user input interface is hand fûnmed ~.1 Idl d~ or symbols through a touch tablet, often referred to as "tablet computers" and "clipboard computers".
Although such lldl I ~ character input systems offer a more convenient and intuitive user interface for many purposes, the methods and apparatus used for lldl .rM. i~ character l~c~y, liliùl, have imposed many CUI 1:.1l dil ll5 which have prevented such systems from realizing their full potential. For example, and although much i"~ I~ IdliOI I for identifying ldl l ~ n ul ,d~ d~ , is contained in the individual strokes ~""~ ,i"U the 19 Idl d~ , many system of the prior art are not effective at extracting and using stroke i"ru", IdliUI 1, either as part of a dynamic and therefore faster process for, c~ ;"~ ,l Idl dUI~l ~ or in, t~C~ ;"~ the constituent parts of the ~ dldUIt:la. For example, many handwritten character It:.,oyl,ili~" system of the prior art have difficulty in ~lt,l " ,i"i"g whether a curved or angled stroke in a character is a single stroke or two or more strokes.
As a consequence, many such systems of the prior art typically can perform character It~.u~llilioll only upon completed ~,lldld~ , thereby either slowing the pt:, ru", Idl ,ce of the systems or requiring that the systems be il l l,ul~ only with the very fastest and most powerful " ,i.,, u,u, uc~su, ~ inorder to keep up with the user input.

WO 96/41300 ~ ., ' '0 1156 219~164 Another severe problem of the prior art is that most systems of the prior art identify an input character by uu,, I,Udl il l9 the c~",,ul~led input character to possible matching character configurations stored in the system, usually either in a database or generated as required. The very large ran0e of variations in character position, ~ , lldL;UIl, size, and stroke configuration and proportion that can occur with ~ldl Id~ ,1 Idl dl..Lt:l ~ thereby again either severely limits the system p~:,ru""a,~,e or requires the use of very powerful lI~i~,lU,UlU~:55UI~ with large memories and high capacity disk drives to store or generate and process the libraries of possible character configurations.
Yet another problem of the prior art systems for I Idl I !\.. iLLe:l~ character , ~c~," ,itiu" is that, because of the complex ~, u.,~ i"~ required for t,coy",itiu" of lldll '\ .ilLt:ll I.lldld~ , many such systems impose l~:,LIi~.liulla upon the user interface in order to reduce the u, u~,essi"g requirements.
For example, many such systems require that the ,1 Idl d~ . be written only into ,u,~ ri"ed spaces, often referred to as "combs", and in r~ certain order, and some systems of the prior art even require that the ~.1 Idl d~ be limited to certain stroke configurations, such as block capital letters. Such systems, for example, do not permit a user to go back to an earlier part of a line of .,1 Idl d~,lCI :~ to enter a new character or symbol or to rewrite, modify or edit an already entered character or string of ~1 Idl dULe~
A related problem is the entry of system or r, ~ ' .1 .,u, "" lal Ida, such as "save file" or "open file" or "spelling check", and the entry of editingUUI l ll l ldl Ida, such as "insert", "delete", or "insert space". Because of the complexity of ~,, uues~il ,g required to distinguish such CUl l ll l ldl nl~ from ildnCI~; iLL~I I text, however, many systems of the prior art require that ~" ' " I and system cu, "" lal Id:~ and editing c~" ", Idl Id:~ be entered into specially desi~u,, Idt~d areas of the tablet, and even that the system or ,, " ' ~ UUI 1 1l 1 lal Ida and the editing cu" ", Idl 1~ . be entered in separate areas.

WO96/413U0 219~164 PCT/[1596/04156 As such, the systems of the prior art do not allow the full, ~dli~d~iul, of a hdl Id~ input system. Such systems do not, for example, permit a user to enter ~1 Idl dul~l ~ in a natural, free fomm style, or to enter a system or I command through a gesture or symbol or c~",I,i, IdliUI, of symbols entered at any convenient place on the tablet, or to directly edit text by symbols or marks written directly into the text, such as deleting a character bydt~,l lil ,g out" the character.
The method and appatatus of the lldl, ~ n character, ~uuu, ,i~iu,, system of the present invention provides a solution to these and other problems of the prior art.
Summary of the Invention The present invention is directed to a method and apparatus for handwritten character Ie:~yl,;~iu" in a data ,u,u~ ing system including a tablet and pen for user entry of I Idl ~d~. . illl:l, ~,1 Idl d~ , and a ,u, U~,~5Sil ,g unit cu, " ,e"l~d from the tablet and pen for operatlng upon the user input under control of the character It:~,Uy~ iul~ system. The character It:c~y"ilio,~ system includes a pen input detector for detecting and indicating user inputs through the tablet and pen, wherein the user inputs including pen strokes and pen states, an input cluster buffer cul " ,e~tt:d from the pen input detector fûr storing stroke descriptor i"rul " IdtiUI, of a current stroke as the current stroke is entered by the user, and a point buffer cc ,~"eu~t,d from the input cluster bufferfor storing the stroke descriptor i,,ru,,,,dliù,~ of the current stroke. Apoint detector is uu, " ,eult:d from the input cluster buffer and, ~,uo, ,s; ic to the pen states for lldl ,~rt:" i"g the stroke descriptor i"ru, Illdliol, of the current stroke into the point buffer. The system further includes a stroke feature I ~Uuyl ,i~w co, 1l le~ d from the point burfer and responsive to the pen states for extracting stroke, eccyl ~i~iull features from the stroke descriptor i~ ~fu~ dtiu~ of the current stroke and assigning a meaning to the current stroke and a cluster, t:cùy~ er cu""e.,l~d from the stroke feature, C:Cuyl ,i~, W096/41300 2 1 9 0 1 64 P~ 6 ~

and ~,uu~ c to the meaning assigned to each stroke for ,~c~y"i~i"g and assigning a character meaning to a cunrent cluster of strokes.
In the preferred ~" ,~o-li" ,~"l, the stroke feature I t:l,uyl ,i,~, includes a dynamic stroke feature extractor connected from the point buffer and responsive to the pen states, such as the pen dowrl state, for extracting stroke, t:~,uyl ,i~iu,~ features from the stroke descriptor i"ru", ,c,~iu,, of the cunrent stroke as the cunrent stroke is entered by the user. A static stroke feature extractor is cu", Ic7ul~d frûm the point buffer and, t~ UI ,~ to the penststes, such as the pen up state, for extracting stroke, t:~yl ,;~ia,~ features from the stroke descriptor i, If ul " IdliOI ~ of the current stroke when ~he cunrent stroke is completed.
The input stroke descriptor i, If ul " IdliUI I includes, for each stroke, a sequence of coo, di, ' points along the line of the stroke, including at least the first and last points of the line of the stroke, and a direction string indicating, for each point of the string, the direction of movement of the line of the stroke at the point.
in further aspects of the present invention, the stroke feature r includes a segment analyzer for identifying segments of a stroke wherein a segment of a stroke includes at least a beginnin3 point of the segment and an end point of the segment and wherein a seygment does not contain a change in direction of movement of the line of the stroke. The segment analyzer includes a direction analyzer for identifyin~ changes in the direction of movement of the line of a stroke wherein a change in direction of movement of the line of a stroke occurs when an angle between two lines ~,u""euli~y three consecutive points along the stroke exceeds a ~,~d~ ""i"ed boundary defined by a cone defined by lines extending from any one of the three points. The cone lines extend from that point in the direction of movement of the pen at that point and the angle between the cone lines is defined by ~ d~,. " ,;"ed di~pldCel l lt~ along the cc,u, -li, Idltl 2 1 9 0 ~ 6 4 PCr~US96~04156 axis ~, ll ,u~u, Idl to the co~, di".~t~ axis along the direction of movement of the pen at that point.
The segment analyzer may further include a segment constnuctor le:apOI15;./e to the direction analyzer for inserting an additional point at a change in direction of the line of a stroke, the additional point being located at the end point of the segment before the change in direction of the iine of the stroke and operating as the beginning point of the segment following the change in direction of the line of the stroke.
In the preferred ~,,,i u~i,,,~, ,l, the stroke, t: ;~yl ,i~r includes a stroke I e:uO~u,l l;~ feature data structure for storing the stroke, ~u"ilio,~ featuresextracted from the current stroke, wherein the stroke, ~, ,iliu,, features desuibe the cunrent stroke with variable degrees of l ,i~l dl ul liUdl d~,UIU~;III '' 1, beginning with a direction string indicating, for points alongthe line of the stroke, the direction of movement of the line of the stroke at eaGh point. The stroke It,~"ili~", features may further include the UuUI .li, ' - of at least the beginning and end points of the line of the strokeand an array of co~, di" ' - of all points along the line of the stroke as received as input co~,~i" ~ from the tablet.
In a further aspect of the present invention, the character, C~-,UUI li~
stores a single copy of each of a plurality of idealized I -IJI e:ael l~dtiUl)s of strokes and generates multiple versions of a current input stroke for CUI l)~Jdl i:~UI~ to the idealized, ~ s~, ItdLiUI la to identify the current input stroke. For this purpose, the stroke feature I L~ y"i~er inGludes a multiple scale stroke, ~ ael lldliUI I generator for reading the stroke, t:.,O~U" litiUI)features from the stroke, ~ U~ ~iliu~) feature data structure, 9t~11e~ dlil 19 aplurality of scaled 1 ~l~nl~U;~ u, e:at:l lldliUI ~5 of the current stroke, eachscaled ~ ,olou; ~ .lts~llldliull being a l~luul~sai~'y smoothed It:,UI ~Sl~:l lldliUI I of the current stroke generated from the stroke, t"., t,st:, lldliU
features. The multiple scale stroke ,~ a~ dtiUn generator then selects a scaled 1-,I,ol~u;~ ,u, ~::a~ dlidl~ of the current stroke wherein the scaled _ _ _ _ . . . . . .. . .

WO96/41300 21 qOl 64 r~l,u ~.~1156 I[ pol- 9; ~ se~ ~dliù~ of the current stroke is selected to provide the maximum signal to noise ratio of the stroke, ~ ae, lldliu".
The character l~ u~"i~l further includes a stroke proportion , i" ,i, IdLul that stores a list of ideal prototype, t ~ se"LdLions ~" ~a~ul l.lil 19 to possible meanings of the current stroke from a plurality ofideal prototype, ~ s~, ILd~iur ,s of strokes. A strûke boundary ~i~u, i" ,i"dtur is JUI ,r,. ~/~ to the scaled 1~ olou;~ ., tla~ dLiull of the current stroke and to the ideal prototype I ~,ultlael l~dliol ,s of the list of ideal prototype ,~p,~a~llldliul,:. for cc."I~Jdli"~ the scaled ~ Jlou;~ u, _5cn l~dLiùl~ of the current stroke and boundaries of the ideal prototype, t~ se, lldliul ,s of the list of ideal prototype 1 ~ 5~:1 lld~iul la wherein the boundaries of the ideal prototype ,ts~ at~ dLiul la are ~ ",i"ed by linear c~",~i, Idliùl ,s of featuresof the ideal prototype Itl~ s~ dliulls. The stroke boundary di~l lillli then assigns to the current stroke an ide, lliri~ dLiu" of an ideal prototype at:l lldliul l having boundaries including the scaled l I olou;~ ~l c~ a~l lldliul~ of the current stroke the assigned id~l ,ti.'i~dLio,1 of the matching ideal prototype l~ a~ dLiùl~ s~"Li"~ a stroke meaning assigned to the current stroke.
In the presently preferred ~I l lL,~il l lea ,L the stroke proportion ,i",i,IdLul further~ , s foreachidealprototype,t,~ s~,ILdLiul, a cull~auolldill9 reversed ideal prototype l~ul~st~llldliull having a reversed direction string for use in the cu,,,l-d,i~u,) of features of the l~ olQu;
, ~pl~a~l ILdliulls of the current stroke and of the ideal prototype , ~,, ~s~, lldliol-s.
The cluster ,~c~u"i~t:r includes a stroke buffer including a current stroke buffer for storing the strokes of a current cluster of strokes in the time order of their entry and a previous stroke buffer for storing the strokes of a cluster of strokes illlln~didlt ly preceding the current cluster of strokes a window buffer for storing a contiguous group of strokes in spatial order according to the coo,d;" of the strokes of the group.
. . . _ . . . _ . . _ . _ . _ _ _ . . . _ _ _ _ _ ~ WO 96/41300 2 ~ S ~ 1 6 4 F~ 6 The cluster It:uu_"i~ also includes a stroke buffer controller It~,UOI~ to the stroke feature l~ "i~t,r for constructing an influence list l,U~ lldil lil l~ an i~ iri~,d~iUI~ of an area of influence of each stroke of the current cluster of strokes, receiving a current stroke, and dt:L~I " ,i"i"g an area of influence of the current stroke. When the area of influence of the current stroke indicates that the current stroke is a part of the current cluster of strokes, the stroke buffer controller writes the current stroke into the currentstroke buffer, and, when the area of influence of the current stroke indicates that the current stroke is not a part of the current cluster of strokes, the stroke buffer controller transfers the strokes of the current cluster of strokes into the previous stroke buffer and writes the current stroke into the current stroke buffer to begin a new cunrent cluster of strokes.
The cluster l ~ "i~:, includes a stroke buffer scanner for scanning the influence list and writing the strokes of the current stoke buffer into the window buffer in spatial order and a position Ji~ i" ,i, Id~UI for storing a cluster data structure c~ dil lil Ig a plurality of cluster meanings, wherein each cluster meaning I t,,u, t:5t~ a cluster of strokes and a ~u" ~S,U~ di"~ meaning assigned to the cluster of strokes.
The position ~ " i" ,i, ' reads cu" IL il IdliOrls of strokes from the window buffer, compares the c~" "~i, IdliOl IS of strokes from the window bufferwith the cluster meanings stored in the cluster data structure, and d~etl " ,i"es whenaculll~illdliul~astrokesfromthewindowbuffercullt~p~lld~toa cluster meaning. The position Ui"~,lilllilld[UI then provides as an output an id~ iri-,dliul~ of the cluster meaning ~,u" ~u~"ùi"9 to the co" ,L,i, Idliul) ofstrokes from the window buffer, removes the cu" ,ui, Idliul, of strokes from thewindow burfer, and transfers the cu" Ibil IdliUI I of strokes from the current cluster buffer to the previous stroke buffer.
The stroke buffer controller is also responsive to a current stroke having spatial cc u, di, Idl~S located between strokes which are previous in time for, c,u, d~l il ,g the strokes in the current and previous stroke buffers and , . . ~

WO96/41300 21 901 64 r~_l/U~ o~ls6 the stroke buffer scanner is responsive to the reordering of the current and previous stroke buffers for rewriting the strokes of the current stoke buffer into the window buffer in a cu, ~ r,di"~ new spatial order. The position di~l,lilllilla~ul is then responsive to the rewriting of the window bufferfor . " ,i";, 19 a new cluster meaning from the new ,u" ,L,i, IdliUI 1~ of strokes in the window buffer, thereby allowing a user to write new strokes into any location along a previously entered series of strokes, or .,1 Idl d~
The new stroke may be an editing gesture and the lldl, ',~.. itLt:l, character, t:U~yl ,iLiu" system further includes an editor responsive to the editing gesture for directing the stroke buffer controller to modify the strokesstored in the stroke buffer as indicated by the editing gesture. Further, in certain instances an editing command may be a c~" l~i, IdLiul, of two consecutive strokes and the position d;~ i",i" is responsive to the Cul I IUil IdliUI I of two consecutive strokes cu, "~,, i ,i"g an editing command for providing an output indicating the editing command and the editor is .u, ._;JC to the editing command for directing the stroke buffer controller to modify the strokes stored in the stroke buffer as indicated by the editing command.
Other dd~/dl ~ta~s and features will become apparent from the following des~., i,uLiùn of the preferred ~" ,uu.ii, "t" ,1 and from the claims and from the drawings, wherein:
Brief D~ ,liv.. of the Drawings Figs. 1 and 2 are dia,u,ldlllllldLic ,~,ul~sellLdLiu"s of a system il l lult~ l ILil ,9 the present invention;
Fia. 3 shows the 'COUNT~ data structure;
Fi3. 4 shows the <RECPT> data structure;
Fig. 5 presents the pseudo-code for the PenlSR() routine;
Fig. 6 presents the pseudo-code for the CheckRingBuffer() routine;
Fig. 7A shows the <DOWNRET> data structure;
Fia. 7B shows the ~BEGSEG> data structure;

~ WO 96141300 2 ~ 9 0 1 6 4 PCT/US96/~41~6 Fig. 7C shows the ~OLD~ data structure;
Fig. 7D shows the <SEGS~ data structure;
Fig. 7E shows the <COORD> data structure;
Fig. 8 presents the pseudo-code for the PenDown() routine;
Fig. 9 presents the pseudo-code for the PenMoved() routine;
Fig. 10 shows the <BINFO> data stnucture;
Fig. 11 presents the pseudo-code for the PenUp() routine;
Fig. 12 presents the pseudo-code for the ExeCom() routine;
Fig. 13A shows the <SEXTR> data structure;
Fig. 13B shows the <SEGSC> data structure;
Fig. 1 3C shows the <SEGM> data structure;
Figs. 14A-B present the pseudo-code for the Stroke() routine;
Fig. 15 presents the pseudo-code for the InsertSeg() routine;
Fig. 16 presents the pseudo-code for the LastSeg() routine;
Fig. 17 presents the pseudo-code for the SymRec() routine;
Fig. 18 shows the <protTbl[PROTNUM]~ data structure;
Fig. 19 presents the pseudo-code for the FindProt() routine;
Fig. 20 shows the <PROT> data structure;
Fig. 21 shows the <PINFO> data structure;
Fig. 22 presents the pseudo-code for the MatchFound() routine;
Fig. 23 presents the pseudo-code for the PropDisc() routine;
Fig. 24 shows the arrays for ,t:p,~el,Ii"g the static proportion features;
Fig. 25 presents the pseudo-code for the SymBoundXX() routine;
Fig. 26 presents the pseudo-code for the FindSyms() routine;
Fig. 27A shows the <BUFF> data structure;
Fig. 27B shows the ~SYMPROT> data stnucture;
Fig. 27C shows the ~ONEBUFF> data structure;
Figs. 28A-B presents the pseudo-code for the PutList() routine;
Figs. 29A-D present the pseudo-code for the FindBPts() routine;
_ _ _ _ _ . . .

WO96/41300 2 1 90 ~ 64 PCI/US96/~4156 ~

Fig. 30 presents the pseudo-code for the ScanBuff() routine;
Fig. 31 shows the <jNF> data structure;
Figs. 32A-D present the pseudo-code for the InterList() routine;
Fig. 33 presents the pseudo-code for the InterBuff() routine;
Fig. 34 presents the pseudo-code for the StkBoundXX() routine; and Figs. 35A-C present the pseudo-code for the OverlapAnsr() routine;
D~."-, t; of a Preferred E. ' ~
Refenring to Fig. 1 the ~ u"i~iù, ~ system described here includes a tablet 10 and pen 12 i"' rd.,i"3 with host Personal Computer (PC) 14 that inciudes a display screen 16 and a keyboard 17. While a userwrites on tablet 10 using pen 12, a I ~ ~ul ,iliù" program that which is running on PC 14 (i.e.,the,t,ccu"i~ y, li~a theindividual.,l Idl d~ a writtenbytheuser and displays both the I lal ,cl~ . ilL~I~ character and the I ~u~ d character ondisplay screen 16.
Fig. 2 in tum is a ~iaul dl1111IdLi~ ISe~ d~iUI, of the character :COUI liuiul, system executing on the system illustrated in Fig. 1. As ~,ult:a~ ,d in Fig. 2, the character ~:c~y"iliul1 system of the present invention includes Pen 10 and Tablet 12 which provide inputs to a Points Buffer 20, which in turn provides character stroke i, If ul " IdliUI I to Dynamic Features 22, which dy, Idl 11' 'Iy extracts rtl-,uU~ iOI~ features from the character strokes. Dynamic Features 20 in turn provides extracted stroke i~ lru~ dliUI I to Proportion Di~., i, ni"dliu" 24, which also receives User Defined Symbols 26 as inputs, and performs a proportion di~ ,i, IdliUI I operation upon the received stroke il lru""d~iu~. The position llia~.l jn'lil ld~iUI I results are provided in turn from Proportion Di~" i" ,i, IdliOI I 24 to Position D;~,ul i" ,i, IdliUI I
28, which again receives as inputs User Defined Symbols 30, and performs a position dia~,l illlil ,dliùn operation. The output of Position Dis.,, i" li, IdliUI I 28 is rpovided to Input Seu,,,~,,ldLiu,, 32, which also receives User Defined Gestures 34 as an input, and provides outputs to User Editor 36, which also interacts with User Defined Symbols 26, User Defined Symbols 30 and User Defined Gestures 34. Although not shown in Fig. 2, the character I ~yl ,i~, also includes a main() routine which itself includes i, lilidli~dliu" routines, two of which are InitRec( ) and InitializeDrivers().
The following concepts and L~" "i, l~l~y; are used to describe the operation of the ,~-,uyl ,i~t7, . Touching the stylus to the tablet initiates a pen down event, which continues until the stylus is lifted off rf the tablet for thefirst time after the initiation of the pen down event. As soon as the pen is lifted off of the tablet, the pen down event te""i" 'u~. The input generated by the user who is writing on the tablet during the pen down event is a stroke. A
stroke is a set of points, t:,UI ~s "li"y the sampled pen positions d~5l,l ibi"gthe user's input during the pen down event. A stroke is typically made up of segments, each of which is an object that is : ' with part of the input image obtained while the pen is traveling in one direction. A stroke commonly changes direction more than once; thus, a stroke often includes more than one segment.
The user's input usually consists of a sequence of strokes which make up a particular character. The, W,~yl ,i~t:, produces a cluster from some or allof strokes entered by the user. A cluster is a collection of strokes with a listof meanings assigned to the collection by the, t:~yl ,i~t:, . The collection is ordered according to some measure of success of the assiy"" le:l ,I by the yl ,i~r.
Note that in future ~r~ ces all actual routines will be followed by pdl tll ILI ~e5i5 ( ), whereas lines of pseudo-code will be made of verbal des.,, i,uliu" of the function. When a potential confusion may arise the actual variables and data structures used in the software are enclosed in angle ~rackets such as in cpennow>, <penwas>.
InitializeDrivers() calls the graphics, clock, and tablet drivers and links them to the main() routine. These routines are not part of the, C:~,Uyl liliul, software and thus are not described in detail. The interface between graphic, tablet and clock routines and the, C:.,Uyl ~iLiul ~ software is done through calling WO 96/41300 , P~ 10 1156 2~ 901 64 each of the routines from within I~LUyl liLiul, software defined routines. This ensures portability and modularity of the, ~cc,.,, ,i~iu, ~ software. For example, the routine for drawing a black line of thickness 1 from (xbeg,ybeg) to (xend,yend) which is provided by the graphic driver is FG_Line(xbeg, ybeg, xend, yend, 1, FG_BLACK). Instead of calling this routine, a new, tlLOL,I liliul, specific routine is defined void RecDrawLine(short xb, short yb, short xe, short ye) {FG_Line(xb,yb,xe,ye, 1, FG_BLACK);} and is used instead of FG_Line(). All of the routines which provide such an interface are collected in a single module. As a result, the, ~LOyl l;~iUI I software can be quickly reconfigured from one set of extemal drivers to another.
The InitRec() routine initializes a certain set of counting variables which are instances of a structure COUNT defined by the typedef struct shown in Fig. 3. The meaning and the use of these variables are described in detail later.
The i, litidli~liol- is followed by an infinite do...while() loop whose t~l Illil IdliOl~ is ac~,c",l~,li~l ,ed by the user either through keyboard 17 or by a stylus gesture.
The infinite loop calls the main l~ .rili,,~ ,eLu~llitiol1 routine referred to as CheckRingBuffer() 2û. The infinite loop is pe, iULliL~.~y interrupted ~,ul u,~i" ,~ 'y every 5 I l l " -- Ids by the tablet TSR driver, referred to asroutine PenlSR() 22 (short for Pen Internupt Service Routine 22). During each interrupt a new position and height or pressure of the pen on the tablet are sampled. No sampling occurs if the pen is further away from the tablet than a certain distance (e.g. ~ I u~ t~lJ 1 inch).
If the infinite loop is Ic~llllill~e:d, the system collects diagnostic il IrUI 11 IdliOll and closes the diagnostic files opened by the routine InitRec() .
This is acculll~ lled by the routine PostProcess. Finally, the system di~"ga~es from the graphic, clock, and tablet drivers and retums to the DOS
operating system prompt.

WO96/41300 21 qO 1 64 Pcr/uss6/04ls6 ~ 13 During the loop interrupt the state of all variables related to all DOS
processes is saved. After the interrupt is w~ d all saved variables are restored. The PenlSR() routine 22 furnishes the new variables which describe the state of the stylus variables and performs the following functions:
1 ) displays ink on the screen by drawing lines of specified thickness between consecutive sampling points;
2) ~ L~ ,es the state of the pen and its transition state; and 3) copies the position of the stylus into a circular FIFO array of structures referred to as ~ringBuffer[l~, which serves as a circular buffer 24.
There are three possible pen states, namely, <PEN_AWAY>, ~PEN_UP>, and <PEN_DOWN> and a set of transition states. These pen and Il dl l~i~LiUIl states are defined as follows:
#define PEN_AWAY 0 #define PEN_UP
#define PEN_DOWN 2 #dehne TRANSITION (3~penwas + pennow) #define AWAY_AWAY (3~(PEN AWAY) + (PEN_AWAY)) ll = 0 #dehne AWAY_UP (3~(PEN_AWAY) +(PEN_UP )) Il= 1 #define AWAY_DOWN (3~(PEN_AWAY) t (PEN_DOWN)) ll = 2 #define UP_AWAY (3~(PEN_UP ) +(PEN_AWAY)) Il= 3 #define UP_UP (3~(PEN_UP )+(PEN_UP )) Il=4 #define UP_DOWN (3~(PEN_UP ) +(PEN_DOWN)) Il=~
#define DOWN_AWAY (3~(PEN_DOWN) + (PEN_AWAY)) Il=6 #define DOWN_UP (3~(PEN_DOWN)+(PEN_UP )) Il=7 #define DOWN_DOWN (3~(PEN_DOWN) + (PEN_DOWN)) ll = 8 In the above definition, <pennow> and <penwas> takes one of the three values <PEN_AWAY>, <PEN_UP>, <PEN_DOWN>.
., ., . _ , _ _,, ,,,,,,,, , _, . ... ... . . . .... .

WO 96f41300 2 ~ 9 0 ~ 6 4 PCTIUS96/04156 The state ~PEN_AWAY> is accorded to the stylus if the pen is above a certain distance from the tablet, about one inch, and as a result the tablet ceases to detect the stylus in its proximity for a certain period of time (e.g.
200 msec). The state <PEN_UP> is declared if stylus is above the tablet, or the pen was in PEN_UP state at previous interrupt and is touching the tablet but its pressure does not exceed a certain threshold value. The state <PEN_DOWN> is declared if the stylus is touching the tablet or the pen was in <PEN_DOWN> state at previous interrupt and the height above the tablet is not exceeding a certain threshold value.
The introduction of the threshold values in the d~ttsl " ,i, IdliUll of the stylus state is done to eliminate "skipping" for the stylus, i.e., r, dyl I le~ dliUI I of a line into a set of d,scu, " ,e~ ;l lines whose ends are in close proximity andfor a user may have a look ûf an unbroken line.
A routine referred to as AddPoint() copies the positions of the stylus into circular buffer 24. Each element of the <ringBuffer[]> array as well as theinput of AddPoint() is a structure ~RECPT> defined as shown in Fig. 4. The first two entires in <RECPT> are the x and y locations of the stylus on the tablet at the time of the sample. TRANSITION is denoted by instance <.t> of the structure and its value is as defined above.
The ûp I dliUI 15 performed by the pen interrupt service routine are shown in Fig. 5. When invoked, PenlSR() 22 first gets the new values for the position of the pen on the tablet as well as its pressure on the tablet or its height above the tablet (step 100). Then, PenlSR() d~'~""i"es the state of the pen (step 102) and it ~ 5 the value of the <TRANSITION>
variable by using the state of the pen at the last sample and the state of the pen for the current sample (step 104). Depending upon the transition state of the pen, PenlSR() 22 performs a set of uu~, d~iUI~5 defined in a switch statement (step 106).
If the transition state is <AWAY_UP> (i.e., the pen has just come into contact with the tablet but the pressure does not exceed the threshold), . , _ _ _ _ _ _ _, _ _ . . . .

WO96141300 21 9~1 64 I~,J~ 5'~1~s~

PenlSR() 22 quits without doing anything (step 108). If the transition state is either 'AWAY_ DOWN> or ~UP_DOWN> (i.e., pen has come into contact with the tablet and the pressure exceeds the threshold), PenlSR() 22 draws the first point of contact on the display and adds the wu, ~i, IdLt:s tû the ring buffer array (step 110). If the transition state is ~UP_UP> (i.e., the pen has remained ûn the tablet but its pressure has not exceeded threshold), then PenlSR() 22 erases the old cursor and redraws a new cursor at the location of the pen on the tablet (step 112). If the transition is <DOWN_UP> (i.e., the pen is being lifted from the tablet but has not yet left the tablet), PenlSR() 22 redraws the cursor at the new location and records this last point in the ring buffer array (step 114). Finally, if the transition is <DOWN DOWN> (i.e., the pen has remained on the tablet), PenlSR() 22 checks whether the pen has moved more than the width of one screen pixel (step 116). If it has, PenlSR() 22 draws a line on the screen cu"ne~,Li"g the current pen location with the previous pen location and adds the current point to the ring buffer (step 118).
If it has not moved more than a screen pixel since the last point, PenlSR() 22 l~""i"~ . and waits for the next sampie. if the transition is any other than the above-",~"li."~d ~Idll~iliulla, PenlSR() 22 l~llllill ~,s3 without doing anything (step 120).
The pseudo-code for CheckRingBuffer() 20, the main, ~ , liliul, routine, is shown in Fig. 6. CheckRingBuffer() 20, which has no input, produces as its output the meaning of the last entry in a cluster buffer which describes the assi~,,,,,,c:,lLa of meaning to a particular clustering of the group of strokes the system considers at that particular moment. The returned value is used primarily for diay, IOali~,a of, t:W~ iul~ rate of isolated , i.e., v"hen there is only one cluster in the cluster buffer.
The circular buffer <ringBuffer[]> serves to u'i~ ag~ the collection of tablet points and their p, uCc:aail ,9 by the, t:l,U_I liliol~ software. The CheckRingBuffer() routine removes all of the points from the circular buffer in the order in which they came in. A RemPoint() routine within the .. ... . _ . ~

WO96/41300 2 1 9~ 1 64 1 -"J~ ~t~tc~ ~

CheckRingBuffer() routine perfomms the removal of points from the circular buffer. RemPoint() has void output and its input is a pointer to the structure <RECPT> (see Fig. 4), which describes current position and transition value for the current sampled point.
In order to allow manipulation of the points describing the image of the input on the screen, each point which is being removed from <ringBuffer[]> is stored in another ring buffer referred to as a point bu~fer and denoted by <pntArr[]>. Just like <ringBuffer[]>, it is a circular array of structures of dimension <RBUFNUM> (defined to be equal 2048), each element of the array being a structure <RECPT>. The storage is a~u" I~ . ,ed by another routine within CheckRingBuffer() refenred to as Slu, ~rui"t~(), which has no return value and whose input is a pointer to the structure <RECPT>. The storage occurs every time the transition is of the type <AWAY_DOWN>, <UP_DOWN>, <DOWN_DOWN>, ~DOWN_AWAY>, or <DOWN_UP>.
The <pntArrt]> array is closely tied with other features describing the input and may itself be wl~idt~ as a feature of the lowest order. Its use allows manipulation of the image of the input and consistent manipulation of the data objects d~s.., il il ,u the image.
In addition to storage of the points retrieved from <ringBuffer[j>, the CheckRingBuffer() routine perfomms feature extraction and, tl.,~UI ,itio". As a process, feature extraction may be put in two broad classes, namely, dynamic feature extraction and static feature extraction. Dynamic feature extraction means that features are extracted while each stroke is being cu,,l,u!~'ud, whereas static feature extraction means that the system has to wait until the wl I ,,UI_IiUI I of the stroke in order to extract a feature. Recc,u"iliu" refers to a55i~u~ IL of the meaning to each stroke and d~ l 11 of meanings to clusters of strokes out of the total number under cul l~id~l dliull by the system.
Every dynamic feature can be extracted statically if the necessary il l~UI 11 IdliUI I is stored, but as a rule, a static feature cannot be extracted dynamically. The advantage of extracting features dyi~dllli~lly is that certain W096/413U0 2 ~ 64 r~, .tll56 strokes can take a very long time to complete and it is desirable to use that time for ,u, ucesai"g. The dynamic features are extracted by the routines within CheckRi"yr~uffer() referred to as PenDown() and PenMoved(). Both routines have no output, while the input of the routines is a pointer to a structure ~DOWNRET> and a stnucture cCOORD>, shown in Figs. 7A and 7E.
Referring to Fig. 6, CheckRingBuffer() 20 calls RemPoint() to take a point from the ring buffer <ringBuffer[]> (step 130). Then, depe"di"u on the state of the transition variable for the stored point, it performs one of several different sequences of u~.~, dliUI 1:~ selected through a switch statement (132).
If the transition state is ~AWAY_AWAY>, cAwAy-up>l <UP_AWAY>, or <UP_UP>, indicating that no samples points are being generated, the switch statement exits (steps 134). If the transition state is either <AWAY_DOWN>
or <UP_DOWN>, indicating that it is the first point of a stroke, the switch statement calls a StorePoints() routine to store the point in the point buffer <pntArr[l> ",e:l ,liu,)ed above (step 136), calls a PenDown() routine to initialize ~;W~ ;u" structures and some counting variables (step 138) and then l~llllilldlt:s. If thetransitionstateis<DOWN_DOWN>,indicatingthatthere are other points of that stroke already in the <pntArr[]> point buffer, the switch statement calls the StorePoints() routine to store the new point in the point buffer <pntArr[]> (step 140) and then calls a r~,..r~.v~l() routine to extract dynamic features from the points in the point buffer (step 142). After PenMoved() retums its result, the switch statement ~""i"d~ta (step 144). If the transition state of the stored point is <DOWN_AWAY> or <DOWN_UP>, the switch statement calls StorePoints() to store the point in the point buffer <pntArr[]> (step 146) and then calls a PenUp() routine to complete the iliu~l process by p~,ru""i"g clustering and texUcu"""d"d ~irrt, t, llidliUI) (step 1 48). PenUp() returns the rightmost cluster in the cluster buffer as a variable, <theSym~. For any other transition state, the switch statement ends without pC:I ru" "i"g any operation. After the switch statement WO96/41300 21 qOl 6~ PCT/US96/04156 ends, CheckRingBuffer() 20 returns the ,t:CO~ d cluster <theSym> (step 1 50).
The routine PenDown() performs i, liLidli,dlio,- of certain variables relating to the dynamic feature extraction. PenMoved() is the main dynamic feature extraction routine and it uses the variables intialized by PenDown().
PenUp() is the final feature i"' ~ dliun routine. It returns the meaning of the rightmost cluster in the cluster buffer. PenDown() is called whenever the transition is <AWAY_DOWN~ or <UP DOWN>, PenMoved() is called when transition is <DOWN_DOWN> and PenUp() is called whenever the transition is <DOWN_AWAY> or <DOWN_UP>.
The pseudo-code describing the operation of the routine PenDown() is shown in Fig. 6. The only function of this routine is initializing the variablesused in the dynamic feature extraction. PenDown() initializes certain variables in.<~ret~, which is a structure cDOWNRET>, and receiYes the location of the pen through a variable called pen, which is a structure <COORD>. Referring to Fig. 7E, the input structure <COORD> describes x-y- position of a point removed from the <ringBuffer[]>. Referring to Fig. 7A, the input structure ~DOWNRET> describes a segment at various scales.
The scale is d~ l " ,i, l~d by the number of samples used for the el lldLiUI I of the segment. For example, if the tablet provides a sample every 200 msec, the highest resolution scale may take every sarrlple point, a next lower scale may take every other sample point, an even lower scale may take every fourth sample point, etc.
The structure <DOWNRET> includes two entries, namely, oneSeg, which is a structure <BEGSEG>, and prevPt, which is a structure <OLD>.
The structure <BEGSEG>, shown in Fig. 7B, describes the segment and the structure ~OLD>, shown in Fig. 7C, contains the cuu, di, IdL~s of the point before the current point and the co~, ui, ,,.'~ of the point before the current point once removed. The sturcture <BEGSEG> contains three other arrays, namely, <curDir[SC]>, which is a character type, <firstP[SC]>, which is an .. .. , _, .

W0 96/4~300 2 1 9 ~ ~ 6 4 ~ 56 unsigned character type, and ~inseg[SC]~, which is a structure ~SEGS>.
<CurDir[SC]> specifies for each scale the actual direction of the se~ment.
<FirstP[SC]~ specifies for each scale whether the point is the first point for the segement for that scale, and <inseg[SC]> contains pdl dl 1l_~.. b for the actual segment.
As shown in Fig. 7D, the structure <SEGS> includes fvur entries, namely, <Dir>, <Len>, <Pos>, and <Neg>. <Dir> specifies the virtua~
direction for the segment. In the I ~,u, ~ae,)tdli~" used herein, there are fourpossible directions: up, down, right, and left. <Len> specifies the length of the segment in tablet co~,ui" ' <Pos> and <Neg> specify the maximum positive and negative ~ ",, Itb, respectively, of the segment with reference the beginning point of the segment. The positive and negative ,,Jld~l l l~l ll are measured pt:~ ,u~ ,ular to the direction of the segment.
Referring again to Fig. 8, PenDown() first initializes a count of the number of segments in the input to zero (step 160). Then, for each scale, it initializes the contents of oneseg[SC] and sets the co~, ~i" ' of both points within prevPt equal to the coo,~i" of the current point (step 162). The following i, lilidli~ vl, occurs. The number of segments for the scale is set tozero and the current point is declared as the first point of the segment. Since the point represent the first point of the segment, the direction for the new segment is set to unknown. The length of the new segment is set to zero, and both the positive and negative diolJId~el 1 l~l lla of the new segment are also set to zero.
The pseudo-code for the routine PenMoved() is shown in Fig. 9.
PenMoved extracts the dynamical features of the input. The function of this routine is to arrange calling the main dynamic feature extraction routine Stroke() at d,U,UlU,UI times for different scales. There are <SC>+1 (i.e., 4) sets of frequencies with which Stroke() is called. Each set of calls It:,UI ~st~ a an original input spatially smoothed at certain scale. The meaning and the WO96/41300 1~ J.. 6.'01~;6 21 ~Ot 64 use of smoothing is described below in the section on dynamic feature extraction.
Like PenDown(), PenMoved() also takes as input an instance of the structure <DOWNRET~ and an instance of the structure ccOORD~. First, r~, ~r ~ () initializes a scale suLlad~ 9 ye"e, d~ variable, called factor, to one (step 170). Then, for each scale, PenMoved() d~ ",i"es whether to perfrom feature extraction at the current point. It does this by first ,. " ,i"i"g the ,,o~, .li"..~i dir~ ces, de.x and de.y, between the current point and the last point of this scale (steps 172-174). Then, it ~ . " ,i"es a cutoff threshold (called spacing) for testing if the current point belongs to this particular scale (step 176). The cutoff threshold is equal to 6400/(factor)2. Ifthe square of the distance between the current point and the last point of this scale exceeds the cutoff threshold, PenMoved() calls a Stroke() routine to extract dynamical features for this scale (step 178). After calling the Stoke() routine, PenMoved() sets firstP[SC] equal to FALSE to make sure that only the first point of the stroke is treated as such (step 180); it saves the scale point before current scale point to prevPt.Two[scale] (step 182) and it saves the current scale point to prevPt.One[scale] (step 184).
After cu, "plc:lil ,9 the above-described sequence of u,ue, dliUI ,5 for the current scale, PenMoved() multiplies the variable factor by 2 and then moves onto the next scale (step 186). As noted above, there are four scale "ldlidl1s (i.e., SC equals four). The minimum sepd,dliù,~ between points for the lowest resolution scale is 80. For the next three hi3her resoiution scales, the minimum sepd, dlidl1 between points is 40, 20 and 5, respectively.
The routine PenUp() is primarily used to separate cu, "" Idl ,~s and text entry of the user interface. ~n general, there are three functions one can assign to an input through the tablet, namely, a", luldliol~, text entry and command execution.

WO 96/41300 2 ~ 9 ~ 1 6 4 PCTIUS96/04156 Annotation is a function where the image of the last stroke is integrated with the image of the screen before the input entry. This function is useful for storing users drawings, diagrams, or handwriting which does not need to be I ~;~u~ d by the system.
The text entry function allows the, t~ y~ to recognize all written symbols as strings of meaningful text. In the present invention this d~iUI I is displayed on the screen as a string of ASCI I .,l Idl d~
printed u"d~", ", each meaningful cluster of strokes.
The command execution function is necessary for any pen based user interface. It is used to change a mode or a function of ,, ' , software operation, or to perform an operation on the image of the input on the screen such as erasure of the screen image, or to perform error correction editing functions such as insertion of a space in a line of l~dl ~ lI symbols or correction of a sey",t:, Itd~iO~ error, or deletion of some of the I Idl I
symbols on the screen.
Because of the different functions of dl 11 IU~dliUI~ text entry, and command execution one needs to separate among them using pen based inputs. In the current invention, a se~d, dliUI, between text entry and command execution is effected. The sepd, dliUI, of dl 11 lU~dliOI~ from the other two functions is a~" ,~ d by d~aiyl Idlil 19 special dl 11 lU~d~iUI I areas on the screen. These~,d,d~iunof lUlllllldll~S andtextisperformedbytheroutine PenUp().
The input to PenUp() is a pointer to the i, li~idli~dliul, structure <DOWNRET> and a pointer to a cluster buffer structure ~BINFO> (for cluster Buffer INFOrmation). The cluster buffer structure <BINFO~ which describes clustering and i"~t:, ,u, I:~d~iUI~s of the clusters is shown in Fig. 10.
Each instance of the structure <BINFO~ is an linear array of size <BUFFNUM~ (= 32), except for the instance <.Frm~ which is a double array with <STRKNUM~ (= 4) dt~ iL,i"g the maximum allowed number of strokes WO96/41300 2 1 90 1 6~ PCT/US96/~4156 per bu~fer. <BUFFNUM~ giYes the maximum number of clusters in the cluster buffer.
The <.Sym~ instance describes the meaning of each cluster, the .Siz~ and <.Pos~ instances give their size and position in screen ~o,~ii" ' s The ~.Len~ instance is the combined screen length of all ciuster's constituent strokes, <.Prt~ is the prototype number of the best fit ofthe cluster, and the <.Frm~ instance describes the clustering. For a given value of its first index (i.e., BUFFNUM), <.Frm~ gives the numbers of the strokes in a <timeBuffD~ array of stnuctures which make up the cluster.
A stroke buffer <BUFF timeBuff[BUFFNUM]~ is an object which contains i"ru, I~ld~iOIl about the group of strokes which are being ~,,u~esaed by the, t:wyl ,iiiun system. More thorough ~i~s.., i~uliu,~ of this object is given in a later section on clustering and position ~ii..~,, i" ,i, IdtiUI I and the routine PutList(). Some of the other concepts introduced by the structure ~BINFO~
are also discussed in greater detail later. For example, Prototype numbers are defined and discussed in detail in a section WI-c~ proportion iis~.lilllilld~iOI~. In addition, the c.Prt~ and <.Frm~ arrays are explained in more detail below in sections on single stroke, ~,,uy, ,i~iùn and on clustering.The pseudo-code for the routine PenUp() is shown in Fig. 1 -i . When invoked, PenUp() calls another routine called SymRec() to obtain the meaning of the Isst stroke in the ciuster buffer (step 1 9û). If the number of clusters in the cluster buffer is equal to two, PenUp() sets the meaning of the last stroke equal to the second entry in the ~.Sym[]~ array and sets the meaning of the previous stroke to the first entry in the <.SymD~ array (steps 192 and 194). Then, PenUp() checks whether an editing flag (i.e., ModeFlag()) is turned on (i.e., TRUE), indicating that the system will recognize user entered editing gestures (step 196). If the mode flag is TRUE, PenUp() calls an ExeCom() routine to check whether the w,,,ui, ,~iun of two strokes, t:p, u~._. ,L~ a potential editing gesture (i.e., a single stroke enclosed in a circle) and if it does, which command to execute (step 198). If the mode , WO 96/41300 2 1 9 C 1 6 4 ~ v L.'01156 flag is FALSE, PenUp() prints the meanings of the clusters on screen (step 200).
The method of S~dl dlil 19 ~.UI 1111 Idl l~a and text entry consists of detecting of certain spatial 'i~"" ,,v, ,ts of certain symbols. That is, the system interprets any of a ~,~dut~.,,,i,~ed set of stroke shapes followed by a circularstroke which completely encircles the shapes as a command d~""i"ed by the shape, unless such a culllbil Idliul~ forms a meaningful cluster. The encirclement is d~t~ ""i"ed by the routine ModeFlag() which has boolean output and has a pointer to the cluster buffer structure as the input. If outputof ModeFlag() is zero then no ~",,i, ~ l "~"l by the last stroke was detected.
If its output is one, an ~:"~,i"vl~",d"lwas detected. The dll~vil/vldlll~ is d~'~. " ,i"dd by deciding whether the smallest rectangular box which contains the previous stroke input is contained in the similar rectangular box for the last stroke input and if the last stroke has meaning of letter 'O'.
For example, a single stroke lower case letter 'a' encircled by a single stroke letter '0' is i, l~, ~ d as a command provided the letter 'a' was writtensufficiently far away from all previous strokes.
As a result instead of treating 'O' as a meaningful symbol the system uses the routine ExeCom() to determine which command must be executed.
The pseudo-code for this routine and for this gesture is shown in Fig. 12. As indicated, ExeCom() receives as its input the meaning of the current stroke ~nowSym>, the meaning of the previous stroke <prevSym>, the current cluster buffer stnucture <buf>, and the cluster buffer structure before the gesture ~oldbuf>. As will be described below in more detail, the cluster buffer structure is initialized (emptied) whenever a new stroke input is sufficiently far away from the previous strokes.
Within ExeCom(), a variable <reject> is used to determine whether both <nowSym> equals "O" and <prevSym~ equals "a". If both conditions are true, the variable <reject> will be FALSE and ExeCom() will call the command routine C~ d with the encircled letter "a". For any other case, the value .. _ _ , . .. . . . . _ _ _ _ _ _ _ _ . _ _ .

WO96/41300 21 901 64 PCT/US96104156 ~

of the reject variable will be TRUE and ExeCom() returns without calling a command routine.
If no gesture was found then the system augments the cluster buffer and prints all the meanings of meaningful clusters on the screen ~, Idèl ~
the cluster using routine PrintCom(). Before the ASCII ~,I Idl dl,~ are printed all the previous answers are erased to avoid printing the new meanings on top of old ones.
Having described the overall structure of the, ~cuu, ,ili~, system we now turn to the detailed d~s~ liu" of feature extraction, beginning with the dynamic feature extraction.
Dynamic Feature Extraction:
As " lel ,liu,~ed earlier, dynamic feature extraction implies the extraction of the features while a stroke is being created. In addition to dynamic features, the, eCuul ,itio" system extracts static features which include the features that can be dehned only after each stroke is completed. An example of a dynamic feature is the coo, ~i, Idl~5 of a sample point, these ~,uu~ dindtes can be stored before the stroke is completed. An example of static feature is the size of the stroke.
Instead of recomputing the size of the stroke with every new sampling point, it is computationally more efficient to wait until the stroke is indeed completed, i.e., a transition cDOWN_UP> or cDOWN_AWAY> has occurred.
Multiple Input Re,u,~se,,ldliul~
An important feature of the present invention is the use of multiple e,ul ~Sel l~dliol~s of the input. If the general problem of pattem, e~,Oul ,iLio-, is coll~ eled, in many instances it may be reformulated as a process of exact matching of some form of, e,ul eael l~dliu11 of the input with a similar form of,ule:,el l~dliUI I of allowable outputs. Since in realistic problems the input has a large number of dea ~es of freedom (between 2 to 1000 degrees of , ~ WO 96141300 2 1 9 0 ~ 6 4 PCT/US96,04,56 freedom in the case of lldl, ~\, . ili"g, e~,~yl ,iLiu, ,) and the amount of noise present in an input is directly related to the input's number of degrees of freedom, the main problem of pattern lecoyl,iLiu" is the construction of internal I e,ul t:~el Itdliol la of the desired outputs which can be matched to as noisy inputs as possible under the constraint of fixed amount of memory allowed for storage of internal, ~,u, ~se, ILdLiul la. One way to effect the matching is to store as many noisy inputs as possible. Thus if 1(0) is an ideal input without noise and noise N acting on the ideal input produces noisy inputs l(k) = N (1(0),k), k = 1, 2, ..., M, where N(.,k) means ~ , of some noise operator for the "k"th time, one can store M pattems in hope that the actual input I will match one of intemal e~ 5t~ elLiUI 1;:- I(k). Such a method is used in prior art by Ward. This method, however, becomes ineffficient if a large number of outputs is required because storage requirements grow faster than any poly"u"lidl with that number of degrees of freedom.
The dlLel, Idli~/., used in the present invention, in effect, trades space for time. Instead of matching noisy input to noisy intemal, e,ul ~ael ,LdLiùn ofthe output, the noisy input is injected with more noise by making multiple copies or, e~n C:5el ItdLiUI la of the input. Thus, instead of l(k) we obtain J(k) =
N(l,k), k = 1 , 2, ..., M
where the noise operator is applied to the actual input, rather than to internaleselltelLiull of ideal input.
Furthermore, instead of storing a multitude of internal I ~ 5t:1 ILdliUl~5, only the ideal I e~ dLiUI 15 are stored. Thus, instead of trying to match actual input to a noisy version of the ideal input, one tries to match a noisy version of the actual noisy input to an ideal le,ul t,ael ILdLiol~.
One advantage of this method is that only (M - 1 ) additional copies of the actual input are lel "~u, dl ily generated, while in the prior art method of WO96/41300 2 1 qO 1 64 P~5/.~ 6 ~

Ward K~(M-1) copies, where K is the number of outputs, are pe", Idl lell~ly stored in the memory.
Another advantage of the present invention is that the method is well suited for parallel i"I~ l"t~ d~iull. After the muitiple copies are generated, their further p, oces~i"g is i"dei,e~de"l of each other until the final step of choosing which of the noisy copies of the actual input was closest to some ideal ,t~ l ItdliUI~.
Multiple Scale F~ "Ld~ion In ac~u, ddl ,ce with the idea of multiple input, ~ se, l~d~iUn the features extracted from the sample pen positions are generated in two forms of multiple, ~ , Itd~iUI~. The hrst form is referred to as a scale multiple ,~p~est:, Itd~iUI I and the second form is referred to as ~p~JIu~ multiple se, I~d~iUI 1.
Scale l ~ l ltdliun is obtained by extracting sets of features from different subsets of sample points of each stroke. The subsets are obtained as follows. The first and the last point of a stroke are included in each subset. The second and subsequent points, except for the last, of a subset "n" n = O, 1, 2, 3, are obtained from the sample points of the input by the inductive rule:
if point p(k) was included in the subset "n", then the next point p(k') of the subset must be at distance at least LID, where D is 2 to the "n"th power.
The lar3est "n" is chosen so that the distance between subsequent points is one screen pixel. Making scale copies of the input amounts to a successive 511 loUtl lil l~ of the original input beginning with the highest "n" which el lla the finest resolution down to n = û for the roughest resolution of the, t~ s~, ItdliUI 1.

~ WO 96/41300 2 1 9 û l 6 ~ PCT/US96/04156 For a given scale feature extraction is effected by the previously " ,c:, llivl ,ed routine Stroke() called by PenMoved() (see Fig. 9). The features extracted by the routine Stroke() for each scale I t~ 5t~ dliOI I are given by the array of stnuctures <SEGM> one for each scale used. The structure <SEGM> and its cu~uullell~ structures are shown in Figs. 13A-C.
The dynamic features extracted by routine Stroke() are a sequence of directions of movement of the pen quantized to two bits plus i"rul ~Idliùl~
des., iL,i"g the stroke during each direction of movement. The quantized directionsareUP DOWN LEFT RIGHTcu"~a~ull~ 9 to",u./~."e:l ILa within the cones. They are defined numerically by:
#define UP 2 ll UP
~ define LE 4 ll LEFT
#define DO 6 ll DOWN
#define Rl 8 ll RIGHT
Thus for example the sequence of two points xo and X1 is part of a segment of direction R. The next point x2 is also part of that same R
segment if it falls with the RIGHT cone with respect to X1.
The dynamic features are grouped in the <SEGM> anray with each element of the array (i.e. <SEGSC>) c~" e ~,uùl "ii"~ to a particular direction of movement. Changes in the direction of movement occur when the two lines cu",~e- li"g three subsequent points lie in different cones. Such groups of features u I ~dl dU~ il IU parts of the stroke are referred to as segments and are described in the structures ~SEGSC> (see Fig. 1 3B).
Each segment is l~,u,tat:"~ed by:
1. the <.End~ instance is the coo, .li, IdLt:s of the endpoint of the segment;
- 2. the <.Bef> instance is the cucldi,l - of the point before the endpoint of the segment;

WO 96141300 l '~
Z ~- 9 0 1 6 4 3. the ~.Aft> instance is the ~,UUIdi~ .3 of the point after the endpoint of the segment;

4. the ~.Ext> instance, which is the structure ~SEXTR> shown in Fig.
1 3A, specifies the ~uul .li, IdLt s of the maximum and minimum ~ Oiuns of the segment in directions normal to the direction of the segment which is useful ul Idl ~:n,Le~ il l9 the curvature of the segment;

5. the ~.Dir> instance identifies the direction of pen movement for that segment;

6. the ~.Len> instance is the maximum screen extension of the segment in the direction of movement;

7. the ~.Pos> instance specifles the screen positive dio~Jld~ l II of the segment;

8. the ~.Neg~ instance specifies the screen negative uiOplac~ l lL of the segment;

9. the ~.Pti> instance identifies the number of the point in the point array ~pntArr[]~ which is the first point of the segment; and 10. the ~.Pto> instance identifies the number of the point in the point array ~pntArr[]> which is the last point of the segment.
The <SEGM> array includes SEGSNUM + 1 structures ~SEGSC>, i.e., one more entry than there are segments. In the described ~" ,L,odi" ,~, IL, SEGSNUM equals 25, it was selected to be equal to the largest number of segments likely to be found in the most complex stroke (13 segments) plus six segments on either end of that stroke.
A set of successive directions is referred to as the direction string of a particular scale I~JI U3~. ILdLiUIl of the input in the present invention, there is a restriction on the possible form of the direction string. The first restriction, which follows from the nature of feature extraction, is that two similar directions in the string cannot be next to each other. In other words, a string of the form RRR (i.e., Right, Right, Right) does not occur. The second restriction, which is introduced in order to reduce space needed to store ideal ~ WO96/41300 21 9~1 64 ~ ,'0~156 s~, lldliul ,:, of the input and to provide consistent multiple 1. ,1 .ol~
dtiOI ls of the input, is that all changes in the direction string must proceed in units of one. Thus, a string of the type DUDU is not ~
That is, changes in direction must be described by a l~ 1 Ibul i"g cone.
To insure that the second restriction is observed, whenever a change occurs from UP to DOWN or from LEFT to RIGHT, etc. in the original set of sampling points, an additional fictitious sampling point is added whose COul ~il Idlt:5 are identical with those of the point where the change of directions occurred. This results in an additional segment, which is referred to as an inserted segment. The choice of the direction for the inserted segment is such that the image wou~d have no loop, had the fictitious point moved a small distance in the chosen direction.
As was ",~, ,liu,~ed above, routine Stroke() extracts features fûr each of the <SC> number of scale, t~ t~JI la. Each cù~, di, Idlt: pair received by the routine PenMoved() is checked as to whether it belongs to a particular scale according to the algorithm described earlier. What follows is a detailed des~ i~JtiUI, of the dynamic feature extraction for a particular scale I t:,UI 1:55~1 lld~;UI 1.
Procedure Stroke() has void output and its input is a pointer to the structure <DOWNRET> described above, the cûc,,ui,, ", pair des-,, il.i"~ the particular scale point (i.e., <COORD> pen), the cou, di, Idl~ difference between current and preceding scale points (i.e., <COORD> de), and the value of the scale <scale>.
Routine Stroke() is summarized by the pseudo-code shown in Figs.
1 4A-B. In the following des,,, i~ lion, the the right cone is composed of all vectors Iying in the cone defined by x > û, y 5 x, and y 2 -X, the left cone is defined by x < 0, y s x, and y 2 -x, the upper cone is defined by y < 0, x < y, and x > -y, and the lo_r cone is defined by y > 0, x < y, and x > - y.

WO 96/41300 2 1 9 0 ~ 6 4 PCI/US96/04156 Note that the cones cover the whole plane except for the point (0,0). A
vector <de> of value (0.0) never occurs as input to routine Stroke() because the routine is called only if the value of the maximum ~,,,,uu, ,~"l of <de>
exceeds a threshold value <TBLT_SCRN>, which is the ratio of tablet to screen resolution. Such a cutoff is useful because tablets typically have better resolution than screens and by using the cutoff threshûld, features are extracted which describe the image the user actually observes thus reducing the amount of necessary computations.
When Stroke() is Galled by PenMoved(), it checks the direction of movement of the pen from the previous scale point and the current scale point <de> (steps 210-216). Depending upon the direction of movement, Stroke () then records the current direction, the length of <de>, and the positive and negative d;~,laG~",~"~ of <de~. Then, Stroke() checks whether the current sGale point is the second scale point of the current sGale (step 218). Note that the first scale point is identified by setting the instance <.oneSeg.firstP[SC]> of the structure <DOWNRET> to TRUE for that point.
If the current scale point is the second point for that scale, Stroke() begins to constnuct i, If olllldliul, for the new segment. In particular, Stroke() performs the following steps:
1. assigns a direction to the first segment;
2. assigns a length to the first segment;
3. assigns positive and negative ~i ".lac~",~"ts to the first segment;
4. assigns a beginning point number to the first segment;
5. records the uuu~ ~i, Idl~ of the first point of the first segment;
6. records the uuu~ d~"dles of the ,ur~wedi"~ point;
7. records the ,,o~, di~ Id~5 of the subsequent point;
8. assigns initial values of segment extrema for the first segment; and 9. recomputes the values of the segment extrema for the first segment;

WO 96/41300 2 ~ 9 ~ ~ 6 4 ~ ~

If the current scale point is not the second scale point, Stroke() checks whether the direction of the vector <de~ is the same as the direction of the current scale segment (step 220). If it is the same direction, Stroke() augments the existing i"rul " IdliUIl for the segment. In particular, Stroke() performs the following steps:
1. augments the length of the segment by the length of <de>;
2. augments its positive ui~Jla~, lel ll by the positive ~ia,ula~,, lel ,l of ~de~;
3. augments its negative di;.~la~" lel ll by the negative di~place" lel ,~
of <de>; and 4. recomputes the cou,.li, ' of maxima and minima in the X and Y
~il é-,liuns, if the direction of the vector <de~ is not the same as the direction of the current scale segment, Stroke() checks whether the total number of segments exceeds the maximum allowable number (i.e., whether the number of segments has reached SEGSNUM +1 ) (step 222). If the maximum number of permitted segments has not been reached, Stroke() creates a new segment structure. In doing so, it perfomms the following ol,c:, d~iu1)5.
1 assigns direction to the new segment;
2. assigns length to the new segment;
3. assigns a positive dialJlaGel, l~ ,l to the new segment;
4. assigns a negative .li~.,ulac~,, ,, ll to the new segment;
5. assigns an end point number to the old segment;
6. augments the count of segments by one;
7. assigns a beginning point number to the new segment;
8. assigns initial values of segment extrema for the new segment;
9. recomputes the values of segment extrema for the new segment;
10. records the coc" di, ldlès of the first point of the new segment;

11. records the UUUldilldlés of the ple~,éedill~ point; and 12. records the c~u, ~i, Idl~ of the subsequent point.
_ _ _ _ . _ _ _ _ _ WO96141300 ~ 9~ ~,q PCTIUS961~4156 ~, Stroke () then checks whether the change in direction between the last segment and the current segment was greater than one quadrant (step 224).
If it was greater than one quadrant, Stroke() calls an InsertSea() routine that inserts a null segment of the dU,UI upri~ , direction to separate the two segments. Finally, Stroke() saves the curent values of the segment direction lenaths and ~i~.ylac~l"~"~:, (step 226).
Cul laid~l il lg the insertion of a fictitious segment, three consecutive sampling points x(0), x(1), x(2) are drawn such that the point x(1 ) is at the center of the co~, .li"dle system. The original direction string of the input isDU since the pen first travels in the lower cone and then in the upper cone.
Because the x cou, di~ IdL_ of x(0) is larger than that of x(2), InsertSeg() augments the direction string DU by inserting a segment with direction L
(left). The resulting direction string is DLU. The inserted segment is provided with null attributes: zero lengths and .liO~.lact:",~nla, same beginning and end etc., to make the insertion u~u, "~t, i~'!y consistent. For an original direction string of UD, InsertSeg() adds an i" ",edi~.~ segment having a direction R to produce URD. For an original direction string of RL, InsertSeg() adds an i" ", " segment having a direction D to produce RDL. Finally, for an original direction string of LR, InsertSeg() adds an i"L~""edi~te segment having a direction U to produce LUR.
The remaining four cases of insertion may be readily obtained by il ILtll ul1dl ,~i"g x(0) and x(2).
The upe~ dliUI ,s of InsertSeg() are shown by the following pseudo-code in Fig. 15. After being called, InsertSeg() checks whether the total number of segments found thus far does not exceed the maximum allowable number (step 3ûO). If the number of segments is not yet at that maximum level, InsertSeg() generates a new "fictitious" segment and assi3ns to it the relevant data. In particular, InsertSeg() assigns the new segment a direction in aCCUI ~dl ,ce with the approach described above (step 302); it assigns values of ~ero to the length and the extrema (steps 304-306); it assigns an end point ~ WO96/41300 2 1 9~ 1 64 P ~ 01156 number (i.e., an index into the point array) to the segment before the fictitious segment (step 308); it assigns begin and end point numbers to the fictitious segment (step 310); it augments the total number of segments by one (step 312); and it assigns a begin point number to the segment after the fictitious se3ment (step 314).
The actual extraction of the dynamic features is ~"~ d by a routine 1~",i, Idr~ r referred to as LastSeg(). The output of the routine is null, the input of the routine is the pointer to the structure DOWNRET. This routine rJIu~,eaaes the last sample point of each stroke. The pseudo-code for this routine is shown in Fig. 16.
When the last point of the stroke is reached, LastSeg() completes the data structures which fully describe the dynamic features of the stroke. First, LastSeg() checks whether the maximum number of permitted segments has been reached (step 320). If not, LastSe3() completes the structure for the last segment. To do this, it per,'orms the following functions for each scale ofthe SC scales:
1. assigns a direction to the last segment;
2. assigns length to the last segment;
3. assigns a positive ~ iJlac~l l lt:l ll to the last segment;
4. assigns a negative di~iJlace~ l lL to the ~ast segment;
5. assigns an end point number to the last segment;
6. augments the count of segments by one;
7. records the ,.uu, li, Idlt:a of the last point of the last segment;
8. records the co~"~i, Id~t:5 of the p,~uee,li"g point; and 9. records the cou"~i"~ of the subsequent point.
The end process of extraction is a l~ie,d,ul liCdl data structure des.,, i,.i"g the input stroke with variable degree of d~l,JI UA;I I IdliUI 1. The crudest d J~Iu,~illldliul ~ is the direction string of the stroke. The next level of JI U~il I IdliUI~ involves d::~aiUI 1l l l~::l l1 of lengths and ~ lac~ to each segment of the stroke. The following level involves the i"ru, Illd~iUI~ about WO96/41300 . I/ . 6.~1 i6 21~0164 position of extrema of cou, di, IdLt:s of the sample points of each segment, andfinally the last level of d )~IUf~;llldliUI I is the pointer to the array of Cool~i, Idl~S
of all sampling points of the segment. The last level of the des., i~llur, contains all the i"ful " Id~iUI I about the stroke as it was obtained from the tablet.
These data structures are referred to as graded input Itl~ at~ diiUI)S. They are computed for variable degree of al lloull ,i"g of the image of the input stroke where al~ luu;l ,i"y is done by removing some sampling points as described above. S~ Ihse~ ently the system selects only one level of a~ I lùu~l lil 19 or scale as the best, t:~,r~ d~iUI I and uses that for further, ~co~" ,. The precedure for making the selection of the best scale , ~p, t~se, Itdliul, is descnbed next.
Selection of the Best Scale Re~,c:s~"~d~iùn The selection of the best scale is based on a conceptually simple criterion with i, If ul " IdliUI~ 11 leu, I:li dl meaning. Ignoring for now the details of the process of, ecoul ~i~iu~) of a particular input assume that the system can assign meaning to subsets of the input and assume also that the system can measure the "volume of space" each i"l~ ld~iUI I occupies. Then the rule for choosing the best i, l~e~ d~iUI I is to pick the i" ~,, tl~d~iUI I with the largest "volume of space". In the described c:"lbodi",~"~ the "volume of space" occupied by an input subset is defined as its screen length.
The i, If ul Irld~iUI I tl ,eù, ~ dl il l~el ~ ldliUI I is as follows. One can think of the volume of the input as the volume of the signal mixed with noise and the volume of a meaningful subset as the volume of the signal only. Then choosing the i" ,u, ~Id~ with the largest volume amounts to choosing the il l~C~I UI t:ld~iUI I with the largest signal to noise ratio.
In the described ~IIlI.OUi,,l~lll the process of selection is performed by a routine referred to as SymRec(). This routine is called within the routine WO 96/41300 2 l 9 0 1 6 4 p,~ S96/04~56 PenUp() whenever the pen <TF~ANSITION> is cDOWN_UP~ or cDOWN_AWAY>.
The inputs of this routine are pointers to a <DOWNRET~ structure and two <BINFO> structures. Both structures have been previously described.
The two <BINFO> structures are used to describe two cluster buffers, namely, a current buffer and the buffer which existed before the current. The use of the additional cluster buffer is needed for ~_~dl d~il l9 of ,u~ dl lda and text, and will be described in more detail in a later section on the Editor UserInterface. The output of SymRec() is an unsigned character which is used for diagnostic purposes only.
The operation of SymRec() is described by the pseudo-code in Fig. 17.
After being called, SymRec() finishes u, u~.es~i~ ,9 the last samplin point of the stroke (step 33û) and then finds the correct range of scales (step 332).
Finding the correct range of scales refers to finding the roughest scale for which the selection of best scale is COI~a;-leled. Limiting the range of scales is done to increase the speed of ,u, u~:5~ in the case when the size of the input is much smaller than some of the rough scales. In the described elllu~d~lllelll, the rule for inclusion of a scale "k" in the range is that the maximum tablet size of the input in x- y- direction is more than <GRIDSZ>
times 2 to the "k+1 "th power. Presently, <GRIDSZ> = 4û.
SymRec() checks whether the scale range contains only the finest scale (step 334). If it turns out that only the finest scale is in the range, the system treats such an input as very small and assigns to it the default meaning of the period, or comma de,ce"di"g on the proportion of its vertical size with regard to its horizontal size (step 336).
If the range includes more than the finest scale, for all scales SymRec() finds all meaningful prototype matches and it sorts them by length (step 338). The process of finding and sorting all meaningful prototype matches is referred to as proportion d;:,-,l illlil IdliUIl. This is the process of assi!J, ll l lel ll of meaning to each individual stroke and it is done within the _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 21~0164 routine referred to as FindProt(). FindProt() and proportion d~ dliul l are described in greater detail in a later section.
SymRec() checks for the prototype match with the best ht that has the greatest length and chooses the dynamic features for that scale (step 340).
Then, for the selected scale, SymRec() hnds the best meaning for the cluster of strokes (step 342). The process of assigning meaning to clusters of strokes is done within the routine referred to as FindSyms() and is also referred to as position ~ ,IilllilldLiUII. Position di~ dtiun is described in greater detail in a later section.
After FindSyms() has assigned meanings to the cluster of strokes, SymRec() returns the meaning of the first entry in the answer buffer that was generated by FindSyms() (step 344).
Proportion Di~lilllill ' , Flupulliol~ ~i..c,i",i,ldliùl, is the process of assigning meaning to subsets of single strokes based on relative length ,u, u,o~, liu"s of their parts.
The process results in compiling a multiple input, ~,u, ~ , ItdLiul I where the input is now a particular scale, t:,UI ~ dliOI) of the tablet input. Such a I t:pl ~5~ dliOIl is referred to as a ~ uI.,~ ,u, t:Se~ dliUI I.
To compile a l"1 ~ulo ~ y~S~l lldlk~l, of a given input the present invention uses a list of l~l)olo~ 1 prototypes. Each entry in the list is a direction string for a certain frequently occurring shape of an ideal input. Forexample, the direction string or prototype for capital L would be <"DR">.
Note that each input image is ul Idl dUI~ d by two different direction strings.
One string ul ,a~ dl~ 5 the input if written in one direction and the other string ul Idl d~ 5 the input if it written in the reverse direction. Thus, for example, <"LU"> is the prototype for a capital L written in the reverse direction. The list of prototypes, however, encodes only one of the two equivalent prototypes. At nun time, the direction string of the input is reversed to ensure that both ways of traversing the image are covered.

~ WO96141300 21 9û 1 64 r~ 6 The process of compiling involves matching the ~ u~u~yi~es against any contiguous subset of the direction strin3 of the input or its reverse.
Whenever a match of a prototype occurs, the system attempts to assign a meaning to the match. This is done by a tree-based neural network which will be described in detail below. If meaning cannot be assigned to a prototype, the system rejects it and attempts matching with other subsets of the input direction string and other prototypes.
When the match is "~ed"i, ~ the number of the matched prototype is put in the list to3ether with the screen length of the matched portion of the input and i"ru, Illdliul, about position, size, and meaning of the matched part.The list is sorted with each match so that the matched portions of the input with the largest screen length are at the top of the list. Such sorting is useful because it Illd,~;llli ~5 the signal to noise ratio for a l,d"a",;~_;o,~ of noisy signals where the value of the signal is the screen length of the input and the noise is the difference between the input screen length and the length of a meaningful subset of the input.
The process of compiling a ~ .u; ~ ;st:, lldlil.)ll is repeated for each scale of the scale ~ Sel lldliOI~ and the scale with the largest signal to noise ratio is cu"~id~l ~d as the best i"~ ,, tlldliUI I of the input.
Referring to Fig. 18, the list of meaningful i,, u~ul~pes in the present invention is described by an array of structures protTbl[BRCHNUM], one per prototype. The instance <.longProt[PROTLEN]~ of the structure is the character string ~ atll ILil 19 the direction string of the prototype and the array <.symbols[BRCHNUM]> is a list of possible meanings of the prototype.
In the described e",iJodi",t~ , <PROTLEN~= 8, <BRCHNUM~ = 9. The structure is defined as shown in Appendix A. The character string RESV
indicates that the particular prototype is not used by the system. The entries whjch do not have a character strin3 on the same line are not part of the structure.

WO 96/41300 PCI/U596/041~6 21~0164 The routine which compiles the ~ ol~ UI~S~I IIdliUI I is referred to as FindProt(). Its inputs are a pointer to the structure <SEGM> which describes dynamic features for a particular scale, a pointer to a structure ~PINFO> which describes the l~ ol~u; ,~ ,e"~dl;ol1 of the stroke described by the structure 'SEGM>, and an integer scale which is used for diagnostic purposes only. This routine has no output.
The pseudo-code for the routine FindProt() is shown in Fig. 19.
FindProt() acuc ",yl;sl ,es the following things. It reduces the noise in the dynamic features due to passage of the pen near the diagonal lines St:~Jal dlil 1~ the cones of the four directions in the direction string of the stroke (step 35û). It initializes the structure describing the l..rol~u;~l ,~u,~s~, lldlio,1 (step 352). It computes new static features, i.e., the angles between successive and once removed segments quantized to four bits (step 354) It computes the dynamic and static features for the stroke with reversed direction of movement (step 356). And it scans the list of prototypes and tries to find an exact match between prototypes and a connected subset of the direction string of the input stroke both for original and reversed stroke (step 358). For each match of a prototype, it call a Match Found() routine which computes the screen length occupied by the subset of the stoke image whose direction string matched the prototype, tries to assign meaning to the matched prototype, and compiles the l~l'l~u; ~ dliOII, i.e., the list of all meaningful matched prototypes sorted in order of their screen length (step 360).
The inputs to the MatchFound() routine are a pointer to the structure <PROT> which describes a single matched prototype, a pointer to the stnucture <SEGM> which describes the stroke's dynamical features for a particular scale and direction, and a pointer to the structure cPlNFO~ which describes sorted lists of meaningful, matched prototypes. The output of this routine is an integer which is u~d for diagnostic purposes.

219~164 The structure ~SEGM> has been described in an earlier section on dynamic feature extraction. The structure <PROT> is shown in Fig. 20 (where UCHAR means an unsigned character). The instance <.Sym> of this structure is the meaning of the matched prototype. The instance <.Prt> is the number of the matched prototype in the prototype list. Thus, for example, if the matched string is "DRUL", <.Prt> is 16 (see Appendix A). The instance <.Off> is the offset of the matched prototype from the beginning of the complete direction string clt:s~ i~i"g the users input stroke. The instance <.Bit> is the number of directions in the matched prototype. In the case of "DRUL" that number would be 4. The instance <.Len> is the number of directions in the complete input stroke. The instance <.Rol> has value 0 or 1 dt:,u~ il lal on whether or not the input string had to be reversed for this prototype to match. The instance <.Fit> is the screen length of the matched prototype. The instances <.Pti> and <.Pto> are indexes into the point array pntArr[]. In particular, the instance <.Pti> is the point number of the first sampling point of the prototype in the point array pntArr[]; and the instance <.Pto> is the point number of the last sample point of the prototype in the point array. The last two instances are for the Editor User Interface. In principle, the h. .vk,d~e of these sampling points allows one to manipulate the image of the subset of the input stroke which cu,, ~a,uul l~a to the matchedprototype.
The structure <PINFO>, which is shown in Fig. 21, describes sorted arrays of meaningful prototypes. There are <ALTSNUM> (= 16) entries, each of which (except for the first one) co" ~a,uul Ida to a matched meaningful prototype. The instance <.Sym[ALTSNUM]> refers to the meaning of the prototype. The instance <.Prt> is the structure <PROT> described above.
The instance <.Siz~ is the screen size of the matched prototype. And the instance <.Pos> is the position of the matched prototype. The entries of the first array in the stnucture 'PINFO> describes the input string itself accordingto the following example:

W096/41300 2!90.164 P~ 5'tl~6 {
PINFO str;
str.Sym[0] = HAPY_SYM;
str.Prt[0].Bit = Number Of Directions In The Input String;
str.Prt[0~.Fit = Screen Length Of Input String;
str.Prt[0].Pti = First Sample Point Of Direction String At This Scale;
str.Prt[0].Pto = Last Sample Point Of Direction String At This Scale;
}

In this example <HAPY_SYM> = 1. Such an ~ssiy"",e"l of the first entries is useful for ~t:uuy"i~i"y clusters of strokes.
If for some reason there are less than <ALTSNUM> - 1 matched prototypes then the remaining entries of the arrays are initialized so that for the entry with Entry Count entry count value they have the following values:
{

str.Sym[Entry Count] = NULL_SYM;
str.Prt[Entry Count].Prt = 0;
str.Prt[EntryCount].Off = 0;
str. Prt[Entry Count].Bit = 0;
str.Prt[Entry Count].Rol = 0;
str.Prt[Entry Count].Fit = 0;
str.Pos[Entry Count].x = 10;
str.Pos[Entry Count].y = 10;
str.Siz[Entry Count].x = 0;
str.Siz[Entry Count].y = 0;

~ WO 96/41300 21 9 0 1 6 4 PCT/USg6~04156 These two dS:~iy~ el It~ (i e., of the first array and the remaining entries forempty matched prototypes) are done within the routine FindProt().
The pseudo-code for MatchFound() is presented in Fig. 22.
MatchFound() first computes the length of the matched prototype (step 370) and then compares it to the length of the input stroke (step 372). If the computed length is less than a specified fraction of the total length of the input strins, the prototype is rejected from further uol~side~d~iu~ In the described ~" Ibo,ii, "t" ,l, the fraction is equal 1/4. This proves useful because "short" prototypes do not carry much i"ful" Id~iOI~ about the whole input string.
One can therefore save computation time by ~ 9dl dil l9 them.
If the total length of the matched prototype exceeds the threshold, MatchFound(), by calling a routine referred to as PropDisc(), extracts more illrUlllldliull about the prototype (step 374). PropDisc(), which is presented in pseudo-code in Fig. 23, perfonms what shall be referred to as PROPortion DlSCrilll;, Idliul ,. The inputs to PropDisc() are pointers to the structures <SEGM>, <PINFO>, and <PROT>, which have been described above. The routine has no output.
The PropDisc() routine extracts static proportion features (step 380), static curvature features (step 382), and the overall size of the prototype (step 384). Static proportion features refer to lengths and pe, ~e"~icular di~,ulac~" ,~"~, of the prototype, together with the same features which describe segments extending from the beginning and the end of the prototype. The static proportion features are stored in arrays (<LOOK> = 3, <PROTLEN> = 9, <SEGSNUM> = 2~) of variables relating to a particular prototype. Presenting features in such a form proves convenient for use in the nsural net~vorks which assign meaning to prototypes and which will be described later.
The static proportion features are I t:p~ ~s~, l~d by the arrays listed in Fig. 24. The i"ru", Idliol~ that is stored in each of those data stnuctures will ,, . _ _ _ _ _ _ _ , . . . ..

WO 96/41300 2 ~ 9 0 ~ 6 4 PCT/US96/~4156 ~1~

now be described with the aid of the input string "URDRU", represent a hd~ luwi iLIc:l, "U". In this example, it is assumed that the matched prototype spans the points A to B ("DRU").
1. direct[PROTLEN] is the direction of the cu" ~a,uOI Idil Ig segment of the prototype, i.e., "DRU".
2. bseg[PROTLEN] is the screen length of the segment in the direction of movement without inciuding ~i~plac~" l~rl~a of l~ei~ u, i"~, segments (e.g. see bseg[0]) 3. pseg[PROTLEN] is the screen length of maximal positive ,lau~"lel,lpt:,,u~ ulartothedirectionofmovement(e.9.seepseg[2]).
4. nse3[PROTLEN] is the screen length of maximal negative ~i~,,lac~ p~, ,uel ,diu.llar to the direction of , , ,ù ~ ~,., ,t:, ,l.
5. fseg[PROTLEN] is the screen length of segment in the direction of movement including the di~,lac~",~,lta of the neiu~llbu,i"~ segments.
6. chdsg1[SEGSNUM] is the change in angle between two successive segments (e.g. see chdsg1 [I) 7. chdsg2[SEGSNUM] is the change in angle between two once removed segments (e.g. see chdsg2[0]).
8. segpos[PROTLEN+1] is the screen cooldil~dl~s of the endpoints of the segment.
9. COORD pext is the screen size in pixels of the prototype.
10. befd[LOOK] is the same as direct[PROTLEN] except that it applies to the segments which come before the first segment of the prototype. The count begins with the first preceding segment up to LOOK preceding segments.
11. befb[LOOK] is similar to bseg[ ], but applies to the segments before the hrst segment of the prototype.
12. befp[LOOK] is similar to pseg[ ], but applies to the segments before the first segment of the prototype.

~ WO96/~1300 2 I q~ ~ 64 PCT/U596~04l56 13. befn[LOOKl is similar to nseg[ ], but applies to the se3ments before the first segment of the prototype.

14. aftd[LOOK] is the same as direct[PROTLEN] except that it applies to the segments which follow the last segment of the prototype. The count begins with the first successive segment and proceeds to <LOOK>.

15. aftb[LOOKl is similar to bseg[ ], but applies to the segments after the last segment of the prototype.

16. aftp[LOOK] is similar to pseg[ ], but applies to the segments after the last segment of the prototype.

17. affn[LOOK] is similar to nseg[ ], but applies to the segments after the last segment of the prototype.
Extracted static curvature features are described by an array <ULONG
devit[2]~. This array of two elements measures the segments curvature by computing the squared distance between the sampling point with the largest and the smallest coc" di, Idl~ (i.e., the locations of the extrema) and the line~u, ,ne-,Li, ,9 the ends of the segment. Thus, for example, if the prototype is tilda, then the positive and negative extrema are points labelled C and D, respectively and the line ~", ,~u~;. ,9 the end points A and B of the segment isthe dashed line cc""euli"y points A and B. In that case, devit[0] is the p~",t:"di~,ular distance from point C to the the dashed line AB and devit[1 ] isthe pt:"Ut~ i.,ular distance from point D to the the dashed line AB.
Since extracting the curvature requires double precision computation, it is done only for some segments of particular prototypes, namely the prototype for which curvature is the .li~,l i" ,i, Idlil ,g feature, such as thecurvature of the single segment which allows to tell '(' from ')'. Other examples are "2" and "Z", and "6" and "G". The curvature of the first segment distinguishes a "2" from a "Z". And the curvature of the last segment distinguishes a "6" from a "G".
After PropDisc() extracts the static features, it assigns meaning to the prototype (step 386). The actual assiy"",~"l of the meaning to prototypes is . , . . _ _ _ _ .

WO96141300 r~ ,C.'01156 21~01~4 4~
done by an array of routines SymBoundXX(), where XX is two digits, the hrst of which varies between 0 and 8 and the second of which varies between 0 and 9. In all, there are 90 routines of this type. The input of each routine is a pointer to the stnucture <PROT>, which describes features of a single prototype. This structure was described above. The output of each routine is an integer <3count~ with values between -1 and <BRCHNUM> or <NULL_SYM> (where <NULL_SYM> = 254). The routines are called within the routine PropDisc() by using an array of pointers to them referred to as "short (~pSymBound[PROTNUM])(PROT 7", where <PROTNUM> = 90.
The particular value of the index to the <PROTNUM> array is d~:~. " ,i, l~d by the number of the prototype on the prototype list given as aninstance of the structure <protTbl>. Each pointer of this array points to a routine SymBoundXX() with XX cu" ~a~JUI~dil ,~ tû the index of the pointer.
If the retum value of the routine SymBound() is <NULL_SYM>, the meaning of the prototype is defined as null and this prototype is excluded from further cu"sidt:, dliUI, and is not included in the 1. .~ lo~
n e:at~ dliUI I described by the structure <PINFO>. If the return value is not <NULL_SYM> and is positive, it indicates the assiy"",~r,~ of the meaning as "<gcount>"th value of the ~protTbl[]> array of meanings:
meaning = <protTbl.sy,,~ cuunt]>.
In this case, the meaning of the prototype is assigned within the routine PropDisc(). Finally, if the retum value is -1, then the meaning of the prototype is assigned within the routine SymBoundXX(), as described below.
Referring again to Fig. 23, if the meaning of the prototype is d~l~l",i"ed not to be null (i.e., the prototype was not rejected), PropDisc() recomputes the size of the prototype (since it may have been augmented within the SymBoundXX() routine) (step 388); it recomputes the position of the prototype (step 39û); it adds the new entry to the prototype list (step 392);
and it sorts the prototype list by screen length with the longest first (step 394).

,~ WO96141300 21 90164 r~ C1l~6 Tree Structured Neural Networks:
In addition to the inputs described above, the data structures used by SymBoundXX() are:
1. False and true boolean boundaries which are initialized <fbound[i] = FALSE~, i = 0,1, ...,BRCHNUM-1, ~ tbound[i] = FALSE>, i = 0,1, ...,BRCHNUM-1, where ~BRCHNUM> = 9.
2. Feature boundaries that take integer values and are initialized to be zero:
<bnd[i]> = 0, i = 0,1, ..., BNDRNUM-1, where ~BNDRNUM> = 80.
The false boundaries are used to reject the prototype from as ,i~"" ,~l ll of any meaning. If any of the false boundaries are true, the prototype's meaning is null. The tnue boundaries are used to assi3n meaning from the prototype table <protTbl[]>. The index of the first true boundary in the array ~tbound[]> is used as an index into the cprotTbl[j> array.
The feature boundaries are linear cu, "~i, IdliUi IS of static proportion features. They are used to draw the boundaries in the feature space between symbols with different meanings.
A single boundary is a hyper-plane defined by ~bnd[k]> > 0, where <bnd[k]> = G~bseg[0] + H~bseg[1 ] + ... is an integer valued linear cu",bi"~liun of features. The integers G, H, ..., referred to as weights, all typically vary in the range between 1 and 16 and are thus quantized to 3 or 4 bit level.
On average there are between two to three weights involved in the definition of each feature boundary. The low precision of the co~rri.,i~"ls and their small number offers a significant advantage. In C~lll,ud~iso,~ to conventional d,U,~ I Udl,l 1-.3S, it leads to reduced requirements on memory andgreater speed of the I ,c,l, -'~.. ili, ,9,~5JI liliul, system. The described WO96141300 r~ .J.. ,''01156 ~
21 9G1 6~

~" ,L odi" ,~"1 employs about five thousand weights to distinguish between about a hundred c~ u, ies.
In the described ~Illbodi~ l feature space is subdivided into regions with assigned meaning. Assigning meaning to a particular prototype is done by searching for the d,U,UI U~l idlel region in the feature space as defined by the feature boundaries. In the real-time handwriting ~ uu~ iu~ system it is important to make such a search computationally efficient so in the described ~" ~uoùi" ,c:, 1l a concept of tree-based, ~u, ~a~l lldliUI I is used. Tree-based data structures are known in prior art ~Friedman Cld~iricdlioll Treesl under the name of Cld ~ ~iri- dliUI, trees. Because of successive subdivision oFthe feature space, ~ ;r ~ " trees pemmit a loyd, i " "ic time access to the data. These stnuctures are also very cul "/. .~ "~ for constnucting the data I ~ul uae, ILdliu~s in an inductive way without a priori assumptions on the final detailed fonm of the architecture of data, t:UI t:s~, ,Idliun. They may be described as data driven data, ~p, ~a~nldliu, la.
The tree structured network of the present invention may also be thought of as a tree based feedforward neural network, where the nodes and depe,~dt:"- i~s of the tree are treated as nodes and i, .'~ ~ u, " ,~. liu, 15 of the neural network.
The root of the tree is a null node. All subsequent nodes are assigned an integer value of laYer. The nodes of the first layer are the ~u~olo ~
prototypes and they are the children of the root node. The children of each prototype node are in one-to-one c~"~suond~ e with the regions in the static feature space obtained by its initial subdivision. Each successive subdivision of the initial region produces children of each subdivided region with a consecutively assigned value of the layer. The terminal nodes of the tree are in one-to-one u u" ~uo"~el~ce with the finest subdivision of the staticfeature space (i.e. they represent the assigned meaning to the prototype).
The process of constnucting the data, t~ s~ dliUI I consists of finding the errors in ~ S;r~ " for each terminal node and its subsequent ~ WO 96/41300 2 1 9 0 1 6 4 PCT/US96/04156 subdivision in such a way as to reduce the error by the largest amount. The process of assigning oF meaning to an input comprises a traversal of the tree until a terminal node is reached. In the described ~",uodi",~"l, both of the ,u,ucesses are i"cu,yul ' ~ in the routines SymBoundXX(), which assigns meaning to a single stroke. Similar routines are used for as:.iy"" ,t "~ of meaning to multiple strokes and they will be described in a later section on position di~ulilllilldliull.
The pseudo-code for all SymBoundXX() routines except SymBoundûO() and SymBoundO1 () is shown in Fig. 25. The pseudo-code for routines SymBoundOO() and SymBoundO1() is the same as that shown in Fig.
25 except that for these two routines the .,u" ~ap~l Idil l9 prototypes cannot be rejected, hence there is no false boundary a5~i~l 1lll~l 1~. Thus, for SymBoundûO() and SymBoundO1 () the first three lines of the pseudo-code shown in Fig. 25 are absent.
Vvhen called, the SymBoundX)(() routine first assigns values to the false boundaries (step 400). If any of the false boundaries for a given SymBoundXX() is true, then that indicates that none of the meanings ~,o~.: ' d with that prototype could be true and the prototype can be rejected. The false boundaries enable the system to quickly eliminate "junk"
and avoid assigning meaning to it.
Assigning values to the false boundaries is done with code of the following fonm:
<fbound[O]> = A~feat[O] + B~feat[1] + ... < O;
<fbound[1 ]> = C~feat[O] + D~feat[1 ] + ... < O;
. .
<fbound[k]> = E~feat[O]+F~feat[1]+... <O;
where A, B, C, D, E, and F are integer .u~rrici~ a and feat[i] are some c~,,,ui, Idliul, of features (e.g bseg[ ], nseg[ ], pseg[ ], etc.). The index k ranges from O to <BRNCHNUM> -1 (i.e., O to 8).

W096/41300 21 90 ~ 64 r~ 1156 ~

If any false boundary is TRUE, SymBoundXX() rejects that prototype and returns a NULL_SyM (step steps 402-404). On the other hand, if none of the false boundaries is true, SymBoundXX() assigns values to feature boundaries (step 406). The pseudo-code for pt:, ru" "i"g that function is as follows:
<bnd[0]> = G~feat[0] + H~feat[1] + ...;
<bnd[1]> = l~feat[0] + J~feat[1] + ...;
<bnd[m]> = K~feat[0] + L~feat[1] + ... ;, where G, H, I, J, K, and L are integer .ù~rricit:i ,t~ and as before feat[i] are some cu" ,~i, IdliUrl of features. The <bnd[ ]> variables are also referred to as the linear boundaries of the prototype neural network. The index m ranges from 0 to <BNDRNUM>. The linear boundaries define h~p~"uldlles that divide feature space into regions. In the described ~" ,uo~i, "~, IL, only a maximum of 80 hy,u~, IJIdl ,as were required to successfully and accurately assign meanings to ~,, ululy,ue5.
After SymBoundXX() has assigned values to the feature boundaries, it then assigns values to the tnue boolean boundaries on the second layer of the neural network tree (step 408). The pseudo-code for p~, ru" "i"~ that function is as follows:
<tbound[0] = bnd[i] > 0;>
ctbound[1] = bndD] ~ ;' -<tbound[n] = bnd[k] > 0;>,where the index n ranges from 0 to <BRCHNUM> -1. The variables ctbound[
]> cc 1 1 ~uo~cl to the possible meanings of the prototype.
After the values for ctbound[ ]> are assigned, SymBoundX)<() splits the nodes of the neural network tree and, if needed, augments the prototype (step 410). The code for p~ru"";"~ those functions (including a~ ",~ dliOIl) has the following form:
-~ WO 96/~.1300 r "" ~ ç~

if(tbound[i]
&&(bndD] ~ ) &&(bnd[k] > O) &&(bnd[p] > O) ){tbound[i] = FALSE;
tbound[q] = TRUE;
iProt[q].Bit += M;
iProt[q].Off-= N;
iProt[q].Fit += P~bseg[0] + Q~bseg[1] + ...;
}

where M, N, P, and Q are integers. In particular, M equals the total number of augmented segments, N equals the number of augmented segments which come before the prototype, and <.Fit> is increased by an amount equal to the combined length of augmented segments.
The process of au!J"~e~ ,Ldliun occurs when any of the <bndD]>, <bnd[k]>, ..., <bnd[p]> has one of the following forms:
<bndD]> = ~befd[s]> == DIR;
<bndD]> = <aftd[t]> == DIR;
where <befd[ ]> and <aftd[ ]> refer to the directions of segments illlllladidlt:ly next to prototype's segment directions, and DIR is one of the four directions <DO,UP,RI,LE>.
Prototype a~y",t~ d~iUIl is employed because the augmented prototype string may be occurring too infrequently to be included in the prototype table <protTbl[ ]>. Or, though the augmented prototype is in the <protTbl[ ]>, the stnucture of the subtree whose root is the augmented prototype is more c~",, ' ' ~' than that of the subtree with its root in unaugmented prototype and, therefore, it is easier to construct the error-free WO 96/41300 2 ~ 9 0 ~ 6 ~ PCT/US96/041~6 data l~,ul~at~ dliUI, beginning with an unaugmented prototype. If auyl,,~ dliul~ does occur, then the d~,UlU,Ulidl~ Lulle~ iulls must be made in the detected prototype's length of direction string, its offset, and screen length. This is done by adding d,U~,llU,UI id~ quantities to the instances of the array of stnuctures <iProt[]>, each element of which is a structure <PROT>, described above. The structure <iProt[ ]> describes a single prototype and is introduced in cù, " ,e.;ti~l- with a~y" ,~ dliUI~.
In the above dtssul i,uli~n~ all integers (the weights of the neural network) are quantized to three to four bits precision, and on average only between two to three weights are used to connect a node of the network to the subsequent layer. In others words, each node of the tree has on average between two to three children.
The procedure to reject a prototype, namely, RejectSym() (shown in step 404 of Fig. 25), delt:l I l lil ,es if any of the false boundaries is true. If any of the false boundaries is true, the prototype is assigned a null meaning <NULL_SYM>. The pseudo-code describing the operation of RejectSym() is as follows:
bool RejectSym(PROT ~aProt) {

for(count = 0; count < BRCHNUM; count++){
if(fbound[count]) return(TRUE);
iProt[count] = ~aProt;
}

retum(FALSE);
}

The procedure to find the first true boundary searches through all true boundaries until it finds one to be true (step 412). When this happens, the index of the first true boundary is returned and the possibly augmented attributes of the prototype are copied to the structure <PROT~ whose pointer ~ WO 96/41300 2 1 ,~ O 1 6 4 . ~i,. '0~156 ~aProt> is the input of both the routine Assi3nSym() and SymBoundXX(), otherwise null meaning is assigned to the prototype (step 414).
The pseudo-code ddS~ ibil ~g the operation of AssignSym() is as follows:
short AssignSym(PROT ~aProt) {

for(count = 0; count < BRCHNUM; count++) if(tbound[count]){
*aProt = iProt[count];
retum(count);
return(NULL_SYM);
}

This proceedure is used for assigning those meanings of the prototype which are contained in the cprotTbl[ ]> table. There are instances when there are more meanings of a prototype than <BRCHNUM> ( = 9). In that case, meaning ~ss;~"",t:"l is done by assigning a meaning to a global variable <sym> within the routine SymBoundXX() as in:
SymBoundXX() {

<sym> = ASCII code;
return(-1 );
-WO 96/41300 ~ .'0 ~ ' C6 219016~

where .. stands for other code described above. If the SymBoundX~(() routine retums -1, then in the routine PropDisc(), instead of <protTbl[l> the variable <sym> is used for dsai""",e"L of meaning.
This concludes the des ., i,uLiù" of compiling of the l~ I ~ol~ l feature up, t:st:, Itd~iUI, of the " ,ed";, _ I' subsets of the input stroke where one lou;~ ,Ul ~::a~l lldLiùl, is compiled for each spatial scale of the scale ~,UI~s~,,tdliu,, of the input. As was described above these l lllolou;l~l ~ Ul ~o~l ltdliUIlS are compared on the basis of the screen length occupied by the largest Illt:dll;ll~ td~iUII at each scale and the scale forthe largest i, ll~l ,u, ~IdliUIl is ,u"Oide, I:d the best, ~,U~St:, ItdliUI, of the single stroke image. From then on, only the 1- I ~ol~u;~ ,u, ~Del lld~iul ~ for the winning scale is used for further ,u, uces~;, ,u, namely, for clustering of groups of strokes into Ill~dllil _ ~l clusters.
Position Dio~illl;lldLiùll and Clustering Position ~iO~ l i" ,i, Id~iUI, and clustering refers to assigning meaning to multiple strokes. Similar to what was described in the ,u, t:cee.li"g section ofproportion dio~lilllilldliulll assigning of meaning to a single stroke is done in the routine SymRec() by cdlling another routine, namely, FindProt() (see Fig.
17). The result of the proportion d;o~l i",i, IdliUI, is a list of matched meaningful prototypes together with the i"ru", Idliûl, on the meaning, position,size, etc. The returned i"rul " Id~iUI1 is described by the stnucture PINFO (seeabove).
In practice, typically more than one stroke is needed to make a symbol or a command. As a result the meaning of a group of strokes is typically a character string with more than one character in the string. To assign a character string to a group of strokes it is therefore necessary to subdivide itinto meaningful subgroups or clusters in some optimal way. One can force a user to do the clustering by requiring that only one meaningful symbol (possibly with more than one stroke) is entered into a single special area .

WO96/41300 2 1 90 f 64 P~ .L'l'~lik demarked from others Commonly, in prior art such areas take the form of boxes or combs on the computer screen. Such devices are cu" ,~ ,u, "e to use for they take much space, and interfere with the visual pe,ue,uIiu,1 of the image of the input.
In the described ~" IL,oui" ,t:"I, a minimum of, ~:~t, i~Liu, ,~ are put on the user and the user can write free form so long that he iifts the pen between two separate symbols. This is achieved by two ~, u~esse~. clustering and position ~i~.,, i" ,i, Id~;UI~. Clustering relates to a process of 5~Jdl d~iOI~ of a given group of strokes into clusters each of which has a meaning of a single character. An sxample would be a se,ud, dliùl, of a group of six horizontal and two vertical strokes into two clusters, each cull~ai, li, ~ù three horizontal and one vertical stroke, each of the two clusters having strokes in a particular spatial relations, so that each cluster could be assigned meaning 'E' and the whole ~roup could be assigned meaning of a character string "EE".
The phrase position ~ ., i",i, Id~iUI ~ refers to a process for assigning a single character meaning to a given group of strokes in the case when the group can be assigned a single meaning An example of such process would be assiU, " "~"~ of 'E' to three horizontal and one vertical strokes in a certain spatial positions.
Clustering and position Ui~Ulilllilld~iUII are accul,,pli~l~ed by calling a number of routines from within the routine FindSyms(). This routine is called from within the routine SymRec() after the best scale (~,u, t::,e, lldliUI, is obtained with regard to a ~ d~ I",i"e~ signal-to-noise ratio (see step 342 of Fig. 17).
The pseudo-code d~5~,l ibi, 19 the operation of the routine FindSyms() is shown in Figs. 26A-B. FindSyms() has void output and its inputs are a pointer to structure cSEGM>, which describes the best scale l~,UI~5Ul lldliUI 1,a pointer to structure <BINFO>, which describes clustering and d:lSiUI 111 lel 1~ of meaning to cunrent group of strokes, a pointer to structure cBlNFO>, which describes clustering and meaning a~ ,iu"" ,t:"I to previous group of strokes . . _ . . . _ _ _ _ _ _ _ .

WO96/41300 2 1 90 1 64 PCT/US961~41~6 (see below on the definition of the current and the previous group of strokes), and a pointer to structure <PlNFO>,which describes the possible as~i~u,"",t:"t~ of meaning to the last stroke entered on the tablet.
The main functions of the routine FindSyms() are:
1. Determine if the new stroke belongs to the current stroke buffer (i.e., the current group of strokes).
2. If the new stroke does belong to the new stroke buffer, increment current stroke buffer, provided that the number of strokes in the buffer does not exceed a certain number (<BUFFNUM~= 32). If the number of strokes does exceed that threshold number, remove the leftmost entry before putting in a new entry.
3. If the new stroke does not belon3 to the new stroke buffer, save the current stroke buffer as the old stroke buffer and intitialize a new current stroke buffer. Then, add the last stroke as the first entry into the new currentstroke buffer. Note that the system ~ "Ibt:~:, two buffers in the past. That is, it maintains i, If ul " IdliUI I about current stroke, about the stroke before current stroke and the stroke that is before the previous stroke. The need for two step memory is n~ ' d by the gesture based editor user interface.
4. Scan the current stroke buffer left to right and do clustering and meanin3 d~ to the buffer.
The stroke buffer ",t:"~iù,)ed in the above cl~ ioll is the principle data structure which describes the current 3roup of strokes. It contains necessary il lru~ dtiull about each stroke, their spatial relations and point counts of the be3inning and the end of each stroke and each stroke's segments which allow image manipulation of the strokes and their segments by the Editor. This data structure is used by a number of variables that are relevant to FindSyms():
1. <BUFF timeBuff[BUFFNUM]> - this is an array of <BUFFNUM> (i.e., 32) structures, each of which describes a single stroke of the current 3roup of strokes.
.

~ WO96/41300 21 9~164 Pcr/uss6/o4ls6 2. <BUFF oldTimeB[BUFFNUM]> - this is a time ordered array of structures each of which describes a single stroke of the group of strokes before the current group of strokes. (It is also referred to as a time ordered stroke buffer descriptor.) 3. <BUFF olOlTimeB[BUFFNUMJ~ - this is an array of structures each of which describes a single stroke of the group of strokes before the group of strokes ,tlUI~s~" ~ by <oldTimeB[ ~>.
4. <BUFF windBuff[STRKNUM]~ - this is an array of 'STRKNUM> (i.e.
4) stnuctures which is a subset of the timeBuff structures. It is called the window stroke buffer. The strokes of this array constitute a contiguous group of strokes in the sense of their x~ou, di~ Idlt: position. This structure is used in left to right scanning and subsequent clustering of the current group of strokes (to be described);
5. <ONEBUFF typeBuff[STRKNUM]~ is an array of structures each of which describes one meaningful matched prototype a:,~iu"",e:,ll to strokes of the window stroke buffer ~WindBuff[]>. This data structure is used in proportion di:~ lilllilldli~ll. There is an instance <.Olp> of this structurewhich is described below.
The details of these structures are shown in Figs. 27A-C. The <BUFF>
structure is an anray of <SYMPROT> structures. The <SYMPROT> structure contains ill~Ulllldliull about a matched prototype. The <.Sym~ instance gives the meaning of the prototype; the <.Siz> instance is a <COORD> structure specifying the size of the prototype; the <.Pos> instance is another <COORD> structure specifying the position of the prototype; the <.Prt~
instance is <PROT> structure containing i"rul Illclliul, about the prototype; and the <.Bpt[ ]> instance is a <COORD> structure specifying the prototypes binding points (to be described later).
The <PROT> structure which was described previously is shown in Fig. 20. Recall that it describes a single matched prototype and contains i"ru, Illdliull about its meaning its number in the prototype table its offset ... , . _ . . . _ . .... . . . . . _ _ _ _ _ _ . .

WO96/41300 21 ~ ~ 64 .~ u~ _.011!;6 J~
~i6 within the direction string, its bit length, the bit length of the input direction string, and pointers to the beginning and end of the prototype within the point array.
The <ONEBUFF> structure shown in Fig. 27C is a structure that describes one ",ed"i"_' 11 matched prototype assi~"",~"l. The <.Sym>
instance is a <SYMPROT> stnucture cu, lldil iil 19 il If ul " IdliUI I about a selected one of the prototypes from the <typeBuffi ]> array. The ~.Olp> instance identifies the number of the largest prototype on the iist from which the prototype described by <typeBuffi ]> was chosen. This is used by some of the neural networks for position di~ i",i, Id~ioll~
The FindSyms() operates on a <COUNT> structure called <tick>. The <COUNT> stnucture, which is shown in Fig. 3, contains global counting variables and editor i, If ul IlldLiUI 1. FindSyms() also keeps track of a current and two prior cluster buffers. To do so it maintains three data structures, namely, <buf~ (a buffer holding i"ru, IlldLiUI~ about the current cluster), <oldBuf> (a buffer holding i"ru,,,,dLiùn about the previous cluster) and <olOlBuf> (a buffer holding i"rul, lld~iUI~ about the cluster before the previous cluster). Similarly, Findsyms() maintains three counting structures of the type ~COUNT> ,,u, l~dil lil 19 giobal counting variables for each of the cluster buffers. The structures are referred to as <tick>, <oldTick> and <olOlTick>.
And it maintains three points arrays, one for each of the cluster buffers. The points arrays are desiy~ ~ ' <pntArr[]>, <oldArri]>~ and <olOlArLl>, respectively.
The manner in which FindSyms() uses these data structures will now be described in greater detail.
Upon being called, FindSyms() invokes a routine named BindNewStroke() which dl:lLell I l lil ,es whether the new stroke, up, t:~e, ILI~d by the <PINFO> structure is close to any strokes in the stroke buffer It~ d by the <BINFO> structure (step 420). BindNewStroke() accepts as input <SEGM>, 'BINFO> and <PINFO> structures. Based upon how close the ~ WO96141300 2 1 90 ~ 64 PcT/us96/u~s6 new stroke is to the previous strokes, FindSyms() assigns the output of BindNewStroke() to <tick.Bind~, the instance of the <COUNT> structure that indicates closeness BindNewStroke() outputs one of three values, namely, -1, 0, or 1. If <tick.Bind> equals -1, this means that the stroke is the first stroke of the user's session with the R~c~y~ r. If <tick.Bind> equals 0, this means that the last stroke is spatially far away from each of the strokes of the current group of strokes in the stroke buffer. And, if <tick.Bind> equals 1, this means that the last stroke is spatially close to at least one of the strokes of the current group of strokes.
NewBindStroke() ~,t~. ",i"es closeness by computing (1 ) the average size of the clusters in the cunrent group of strokes and (2) the smallest distance between the last stroke and all the clusters in the current group of strokes and then cu~ ldlill~ the two. When du'u""i"i"9 the distance between strokes, the center of a box boundins the stroke is used as the location of the stroke. If the distance bet~veen strokes is more than a certain multiple of an average size of a character, then the last stroke is co, 15id~ d far, otherwise it is cul, ,ide, ~d close. Different multiples may be used for distance in x-direction (horizontal) and y-direction (vertical).
It is the first stroke If the last stroke is duh" "i"ed to be the first stroke of the user's session (steps 422 and 424), the, t:r,~yl ,i~t:, only needs to perform i, li~idli~ JI ,. FindSyms() sets the number of strokes on the current stroke buffer (i.e., <tick.Buff>) to zero (step 450); sets the number of clusters on the current cluster buffer (i.e., <tick.AnsP) to zero (step 452); and calls another routine to initialize the cluster buffer (step 454). After the cluster buffer <buP
is initialized, FindSyms() sets the number of strokes on the old stroke buffer (i.e., oldTick.Buff> to ze-o WO 96/41300 2 1 ~ O 1 6 4 F~,l/u.,. ~.'01156 (step 456); sets the number of strokes on the old cluster buffer (i.e.,<oldTick.Ansr~) to zero (step 458); sets the number of points of the old points burfer (i.e., <oldTick.Pnts>) to zero (step 460); and then calls the previous routine to initialize the old cluster buffer (step 462). FindSyms() then repeatsthe last sequence of steps for <olOlTick~ and <olOlBuff~ (steps 464-470).
The last stroke was close:
If the last stroke was close to a previous stroke in the cluster buffer, FindSyms() calls a PutList() routine that puts the prototype list for that stroke into the stroke buffer (step 472). After the stroke buffer has been updated, FindSyms() calls another routine ScanBuff() that scans the updated stroke buffer and performs clustering and position d;~ i" lil IdliUI I (step 474). BothPutList() and ScanList() will be described in greater detail shortly.
The last stroke was far If the last stroke is far from the other strokes in the cluster buffer, FindSyms() saves the current and old cluster burfer and prepares to generate a new cluster burfer. In other words, FindSyms() shifts the contents of <oldBuf~ to <olOlBuf~ (step 426) and shlfts the contents of ~buP to <oldBuP
(step 428). FindSyms() also saves the contents of <oldTick~ in <olOlTick~, replacing any i"ru", IdLiUI I that had been stored there from before (step 430).Before storing <Tick~ into <oldTick~, FindSyms() updates the <.Pnts~
instance of <olOlTick~ (i.e., the number of points in the cluster buffer) with the value of the index to the last point of the last stroke of the cluster buffer, namely, oldTimeB[oldTick.Burf-1].Sym.[0].Prt.Pto (step 432). Note that the index to this i"ru""dliu" is contained in <oldTick.Burf~ and must be used before <oldTick~ overwritten with new i"ru",Idliul~.
After updating the i"r.,IlldliOIl in <olOlTick~, FindSyms() stores the contents of <buP and <Tick~ in <oldBuf~ and <oldTick~, respectively (steps 434-436).

WO 96/41300 2 1 ,~ O 1 6 4 r~l~u.., ~.o ll~6 Then, FindSyms() saYes the contents of the points arrays (step 438 and 440).
After storing the contents of the old structures, FindSyms() computes a new point count for the current cluster buffer by using the contents of a structure <strArr> (step 442). There are two instances of <strArr>, namely, <strArr.x> and <strArr.y~, both of which are indexes into the point array co, Iklil ,i"g the actual points of the input. The <strArr.x~ instance is an index of the first point of the most recent stroke and the <strArr.y> instance is an index of the last point of the most recent stroke. The total number of points for the stroke is equal to the difference between these two numbers plus 1.
Then, FindSyms() recomputes a new point array for the new stroke in the cluster buffer (step 444). This is done by shifting the i"ru", IdliUII in the point array up by <strArr.x>, the actual first point of the most recent stroke.
After recomputing the new point array, FindSyms() recomputes new pointers to the point array in PINFO stnucture (step 446). It does this for each of the meanings or i"' ~ LdliOI 15 in the PINFO structure. Before recomputing the new pointers, FindSyms() checks whether the pointer in the PINFO structure to the end of the prototype is set equal to zero. If it is, indicating that there is no stroke for that entry, FindSyms() exits this loop. If FindSyms() dt:le""i"es that there is a actual entry in PINFO, it clt:u t:" ~"L:, the pointers to the beginning and the end of the prototype by an amount equal to the location of the first point of the most recent stroke. p,t:ru""i"q a ccùldi" ' ~dll~r~lllldLiull After co",,ul_Li"g the update of all of the entries in the PINFO
structure, FindSyms() saves the old stroke buffer and the current stroke buffer (steps 448-449).
Recall that if the stroke is close to another stroke in the current cluster buffer, FindSyms() calls PutList() to place the prototype list for that stroke into the stroke buffer. PutList() performs the following functions:
1. It makes room in the stroke buffer array for new strokes.

WO 96/41300 2 1 9 0 1 6 ~ .1 1156 2. It assigns values of the stroke descriptor ~PINFO ~str> to the time ordered stroke buffer desuiptor ~timeBuff[STRKNUM]~, converting tablet cuUI dil Idl~:5 of features into screen coul .li" ' 3. When editing is on (i.e., ~tick.Edit> = TRUE), it assigns certain types of strokes null meaning for use in seu",e,lldliu" error correction and space insertion functions of the Editor.
4. It assigns a value to an array which is a pointer from the time ordered stroke buffer to the position ordered stroke buffer.
5. Calls a procedure FindBPts() which calculates and assigns to the time stroke buffer entries values of features used in position di~ i" ,i, laliul 1.
6. Il l~ "ts stroke buffer count (~tick. Buff>) for each stroke added to the time stroke buffer.
The inputs of the procedure PutList() are a pointer to the stnucture SEGM, which describes the dynamic features of the last stroke and is used for computation of proportion di~u, i" ,i, IdliOI I features, a pointer to the structure PINFO, which describes the list of meaningful matched p, ulutypes of the last stroke and is in large part copied into an entry of the time stroke buffer ~timeBuff[l> for further use in position dia~ lil IdliOI~, and a pointer ot the structure BINFO v,~hich contains i, ,~u, " IdliUI I about clustering of the current group of strokes. The procedure has no output.
The details of the operation of Putlist() are shown in Figs. 28A-B.
Initially, PutList() removes from the time stroke buffer ~timeBuff[]~ all the entries that are necessary to make room for new stroke(s) (step 5ûû).
After making room for the new stroke, PutList() prepares to store the stroke's matched prototype list in the time stroke buffer. Before storing each matched prototype, however, PutList() first ~ " "i, l~a whether the matched prototype is i"l~"u, u'ud as either '/' or '\" (step 5û2). Note that there are six prototypes that can have those meanings. PutList() simplihes the subsequent :uoul liliUI I process by forcing the ,u, ulvl~ es having these meanings to be either prototype 00 or prototype û1. It does this by ~,u,, l~dl il l9 the horizontal . . ~ . ._ ., ._.

WO 96/41300 PCT/llS96/041!;6 ~ 2190164 size of the stroke with its vertical size (step 504). If the horizontal size is larger than the vertical size, PutList() sets the prototype number for the stroke to '01 ' (step 506); otherwise, it sets the prototype number to '00' (step 508).Afler :.i",, ';.'iy;. ,y the ~ nl~,U;~ l yl ~d~iul l of the stroke if possible, PutList() records the i"rul " IdliUI I about the most recent stroke's matched prototype in time stroke buffer (steps 510-20). In doing this, PutList() performs a 1, dl l:: rUI 11 IdliUI I from tablet screen c o~, di~ Id~t:5 to pixels for the size and position i"' Illd~iUII.
Recall that the locations of points for any stroke on the matched prototype list are locations of scaled points, i.e., they reflect suLsd", ' ,9 at different scales. For image manipulation by the Editor, however, the actual first and last points of the stroke are required. This i, If ul " Id~iUI I is contained in the <strArP structure since it records the point number of the beginning and the end of the last stroke at the time when these points are retrieved from the nng buffer of points. PutList() uses the i"ru", IdliUn in <strArr> to replace the locations of the first and last sampled points with the locations of the actual first and last points of the stroke.
To perform this update, PutList() first checks whether it is close to another stroke in the cluster buffer (i.e., is tick.Bind = 1). If it was added to a cluster buffer with other strokes, the PutList() sets the location of its first point equal to <strArr.x> and the location of its last point equal to <strArr.y> (step522-54). On the other hand, if it, ~ a the first stroke of a new cluster buffer, PutList() sets the location of its first point equal to zero and the location of its last point equal to <strArr.y> - <strArr.x> (step 526-528).
If user is in the editing mode, then certain strokes are not co, 15ii~ d as meaningful but are cc, l~id~l ~d to be gestures that control editing. For example, a single tick mark is used to tell the system not to consider a clusterof strokes as meaningful. This is done by assigning a special HAPY_SYM
meaning to the first and second prototype list entries into the time buffer of the tick mark.

WO96/41300 i~ .J.. .'C1)~
~190164 In the case of the tick mark editing gesture, if ~tick.Edit> indicates that editing mode is turned on (step 530), PutList() checks whether the first prototype on the list of prototypes for the stroke is number zero (i.e., the first prototype in the prototype table) and has one of the following " ledl l::-il IyS: '/', '\', or '1' (step 532). If those conditions are satisfied, indicating that the stroke is an editing gesture, PutList() stores the HAPY_SYM symbol as the meaning of the prototype for that stroke in the time stroke buffer (steps 534-536). The presence of HAPY_SYM eliminates printing of the gesture. PutList() then stores a NULL_SYM as the meaning for all remaining meanings of that prototype of that stroke in the time stroke buffer (step 538).
Another gesture used in the editing mode is an L shaped stroke (e.g.
A). Such a stroke is used to insert an empty space in a line of symbols.
PutList() checks for the presence of these editing gestures. The L-gesture is used to determine the extent and position of space insertion. After this has been de~ ,ad the gesture is removed from all buffers by an Overlap() routine described later.
When editing mode is tumed on, to detemmine whether the user has requested a space insertion, PutList() checks if the meaning of the first entry on the prototype list is either 'L' or 'A' (step ~40). If either of those two meanings are indicated, PutList() stores a HAPY_SYM as the meaning of the stroke in the time stroke buffer (step 542-544). Doing this ensures that no subpart of the editing gesture will be treated as part of any ",ed"i"~
cluster. Than, as before, PutList() stores a NULL_SYM as the meaning of all of the remainder of altemative meanings of the stroke in the time stroke buffer (step 546).
After checking for editing gestures, PutList() assigns a time order to the last stroke (step 548). To store the time order i"ru, IlldLiul 1, PutList() uses an array called timeOrder[]. It keeps track of which stroke is which after timeBuff array is later sorted according to x-positions of its entries.

~ WO 96/41300 2 1 9 0 ~ 6 4 PC'r/U596/0~156 Then, PutList() d~ il ,es the c~u, ~in~ , of the special points (i.e., the binding points) on each matched prototype in the stroke buffer (step 550).
The distances between the binding points will later be computed and used as position .Ji~,, i",i"dlion features. PutList() calls another routine called FindBPts() to determine the c~o, ~i"~'~,s of the binding points of the matched prototypes. After computing the binding points, PutList() i"u,~",~"l~ the global variable which counts the total number of strokes in the current stoke buffer (step 552).
The features computed by the FindBPts() procedure (i.e., the binding points) are needed for proportion dia~ il, " I and clustering. For each matched prototype, the binding points are the screen coo, di, IdLe:s of special points of the matched part of the stroke. For the different prototypes, the location of the binding points depends on the ~ u;~ complexity of the prototype.
The location of the binding points for the different Cdl~:yul i~s of prototypes are defined as follows.
For prototypes consisting of one segment, the binding points are:
1. the cou, di"..~.r, of the beginning of the matched portion of the stroke;
2. the cc,~, ~i, of the end of the matched portion of the stroke; and 3. the co~"~i" ' of the center of the smallest rectangular box surrounding the matched portion of the stroke.
For prototypes consisting of two segments, the binding points are:
1. the cou, di, IdLt:s of the beginning of the matched portion of the stroke;
2. the uuu, di~ IdLt s of the end of the matched portion of the stroke; and 3. the ,uu, di~ IdL~s of the end of the first segment of the matched portion of the stroke.
For prototypes consisting of three segments, the binding points are:
1. the cou,~i"dles of the beginning of the matched portion of the stroke;
2. the coo,ui".~t~,o, of the end of the matched portion of the stroke; and W0 96/41300 2 1 9 0 1 6 4 ~ s6 3. the "uo,di" ~ of the point on the middle segment of the matched portion of the stroke where the value of x~o~, .li, ItlL~ achieves minimum for prototype LDR, or where the value of x-cuul di~ Idl~ achieYes maximum for prototype RDL, or where the value of y-cou, ~i, Idl~ achieves minimum for prototype DRU, or where the value of y--,uu, di"..~ achieves maximum for prototype URD or for any other three segment prototype the co~, .li, Idte: of the smallest rectangular box surrounding the matched portion of the stroke.
Finally, for ,u~utu~ypes with fûur or more segments, the bindins points are the cc u, di" ,t~ of the comers of the smallest rectangular box surrounding the matched portion of the stroke.
These features are used at later stage to derive features used by a collection of neural networks each of which assigns meaning to a collection of strokes of a particular topology. Additional features may be computed within each neural network.
As indicated earlier, the binding point features are stored in instances of the structure ctimeBuff>, namely, COORD timeBuf'lBUFFNUM].Sym[ALTSNUM].Bpt[BlNDNUM]
Feature computation is done for each matched prototype of the input and up to BINDNUM (= 4) ouu! ~i, Idl~S are used. The choice of binding points as features is particularly useful because of their small number, their partial invariance with respect to rotations of the input strokes and the simplicity of their computation.
The routine FindBPts() operates as shown by the pseudo-code of Figs.
29A-D. It receives as input two structures, namely, ~SEGM> containing i, ,~u, Illdliull about the dynamic features of the segments within the stroke and <PINFO~ containing the t~ fJIo~ ult~aelILdliUIl of the stroke. First, FindBPts() assigns to an i~ idly variable 'len' the number of segments in the matched prototype (step 600). This i, If ul ~, Idliul, is found within the ~.Prt[0].Bit> instance of the <PINFO> structure.

wos6/4l300 2 1 901 6~ r~,l/1J",C,~o~lC6 Afier this initial assiy"",c:"l, FindBPts() then enters a for-loop in which it goes through all matched prototype on the list (except the first one which describes the input itself) and assigns position di~ i",i, IdliUI I features (i.e., binding points) to the matched prototypes (step 602).
Within the for-loop and for the given matched prototype, FindBPts() assigns to various i"~t" ", " variable values obtained from the <PINFO>
structure, ~stP. To a variable 'off' it assigns the offset of the first segment of the matched prototype from the beginning of the input direction string (step 604). To another variable 'bit' it assigns the number of segments of the matched prototype (step 606). To yet another variable 'prt' it assigns the number of the matched prototype on the prototype list protTbl[l (step 608).
To another variable 'rol' it assigns the value of the input string raversal value for that matched prototype (step 610). These variables are used elsewhere in the FindBPts() routine.
After making the as~iy"" ,t:"~ to the il ll~:l l l l ' variabies, FindBPts() enters another for-loop in which it first initializes the values of the binding points for the given matched prototype within the stroke buffer <timeBuffi]> to fictitious values (step 612).
Depending upon the number of segments within the matched prototype, FindBPts() then executes a segment of code which makes the assi~"",t:"~ of actual values to the binding points. If there are less than foursegments in the matched prototype, FindBPts() assigns the beginning and the end of the matched prototype as first and second entries in the feature array (i.e., Bpt[]). To determine whether there are less than four segments, FindBPts() checks the number of the prototype in the protTbl[] (i.e., the prototype list) (step 614). Note that the prototypes are ordered in protTbl[] inorder of i"~ a~i"~ cu" I,~JIeAi~y and a number of less than 14 on the prototype list (i.e., protTbl[]) indicates that there are less than four segments in the prototype.

W096/41300 2 1 90 1 64 ~ C6 If the input string was not reversed to match this prototype (i.e., 'rol' equals zero - step 616), FindBPts() assigns the first point of the first segmentand the end point of the last segment to Bpt[0] and Bpt[1], respectively (steps 618-620). If the input string was reversed (step 622), FindBPts() takes this into account and makes the assi~ llel IL~ of the values to Bpt[0] and Bpt[1], ,Ul dil Iyly (step 624-626). In either case FindBPts() also assi~ns an i"'~" "~ value to a variable 'midpos' cu" ~:"uo, Idi"g to the location of the first segment plus one (step ~ and ~).
If for some reason 'rol' equals neither 1 nor 0, indicating an error, FindBPts() assigns zero values to both Bpt[0] and Bpt[1 ] (steps 628-634).
After assinging values to the first and second features (i.e., Bpt[0] and Bpt[1]), FindBPts() checks if the prototype number is less than 2, indicating that it has only one segment (step 636). If there is only one segment, FindBPts() sets Bpt[2], the third feature, equal to the position of the prototype (step 638).
If the prototype has more than one segment, FindBPts() checks whether it has only two segments (640). It will have only two se~ments if its number on the prototype list at least as great as two but less than six. If the matched prototype has only two segments, FindBPts() sets Bpt[2] equal to the location of the first segment as identified by the variable 'midpos' (step 642).
If the prototype has more than two segments, FindBPts() checks whether its prototype number is equal to 6, 7, 8, or 9 (steps 644, 648, 652, and 662). If the prototype number is equal to 6, FindBPts() sets Bpt[2] equal to the x-y c~u, lil ~ of the point of minimum extension of the middle segment in the y direction (step 646). If the prototype number is equal to 7, FindBPts() sets Bpt[2] equal to the x-y cou, di~ Idle5 of the point of maximum extension of the middle segment in the y direction (step 650).
If the prototype number is equal to 8, FindBPts() checks whether the prototype meaning is a left bracket (i.e., '[') (step 654). It the prototype , W096141300 ~ 1 qQ 1 6 4 PC1r/uss6~u~ls6 meaning is a left bracket, FindBPts() sets the x cou, di" of Bpt[2] equal to the average of the sum of the x c~, .li, Id~S of the end points of the second and third segments (step 656) and it sets the y cc u, di~ ~ ~ equal to the average of the sum of the y cou, di" ~ of the second and third segments (step 658). Otherwise, if the prototype meaning is not a left bracket, FindBPts() sets Bpt[21 equal to the x-y cuu, li, IdLe~ of the point of minimum extension of the middle segment in the x direction (step 660).
Finally, if the prototype number is equal to 9, FindBPts() sets Bpt[2]
equal to the x-y wu, .li, ~ of the point of maximum extension of the middle segment in the x direction (step 664).
For all other three segment prototypes, FindBPts() sets Bpt[2] equal to the x-y ,uu,di, ,dles of the position of the prototype (step 666).
FindBPts() treats prototypes having the meaning of either ~r or '~' as a special case (step 668). If any of the ,u, utut~/pt~ meaning is ~r or '\', then,r~yd~ s of the number of segments, FindBPts() sets Bpt[2] equal to the prototype's position (step 670). Then, FindBPts() checks the u~ i~, IIdliul, of the prototype and assigns values to Bpt[0] and Bpt[1] to properly reflect the 01 iC~ dLiUI I of the segment (steps 672 and 682).
For all prototypes having less than four segments, FindBPts() then makes the fourth feature (i.e., Bpt[3]) equal to the second feature (step 684).
Though Bpt[3] is not used for such prototypes, this step makes sure that the il lru~ dliUI I stored in the fourth feature is known il lru""di;c" ,.
With one exception for all other matched prototypes (i.e., those having more than three segments), FindBPts() chooses the four locations of the comers of the box surrounding the ptototype as the four features. It begins by setting Bpt[0] to the cu~, li"dle:s of the upper left corner and then moves clockwise around the box setting Bpt[1], Bpt[2] and Bpt[3] accc" di~ I!Jly (step696-71 0).

WO 96t41300 2 1 q 0 1 6 4 PCTtUS96tO4156 The one t ,~ lioll is prototype number 20 in the protTbl[l. For that matched prototype FindBPts() computes the binding points as shown in steps 688-694 of Fig. 29D.
After computing the binding points, FindBPts() rescales the values to convert them from tablet values to screen values (steps 712-714). This allows the program to use 16 bit instead of 32 bit precision later on.
Scanning:
Once the matched prototypes features are assigned to the time stroke buffer and additional position ~ ;, i",i, IdliUi ~ features has been computed, the system performs scanning of the current stroke buffer left to right. The purpose of this is to separate the current stroke buffer into clusters of strokes and assign meaning to each cluster in some optimal way. In order to save time, some of the possible clusters are ruled out. This is achieved by scanning. For example, whenever a new stroke is close to the current stroke buffer, the system orders the new buffer so that the x coo, .li, Idlt:S of the entries increase ",o".~t." lically and then .1~,. ",i"es a potential area of influence of the new stroke within the space ordered stroke buffer.
Thus, the system makes a list of strokes that it considers to be close to the new stroke and then scans the list left to right to cluster and assign meaning. The area of influence of a stroke in the space ordered stroke buffer is defined as the first and the last entry in the stroke buffer such that all the strokes in between may potentially change meaning with addition of the last stroke.
Since the maximum number of strokes in a meaningful cluster is STRKNUM (= 4), the system creates an influence list and puts on that list all the strokes that are up to STRKNUM places ahead or behind of the most recent stroke in the space ordered stroke buffer. In addition, if any of the strokes on this list are members of meaningful clusters whose members are not on the list, these missed members are also added to the list.

~ WO96141300 21 qOl 64 r~ ollsc Once the influence list is created, the system scans the list by taking the first STRKNUM entries from the list and putting them into the structure named <windBuff> which is analogous to ctimeBuff> except that the array of structures has STRKNUM (= 4) entries and not BUFFNUM (= 32) entries.
Since the elements of the list are ordered by their position's x-cuu, d;"- '~, the entries in the <windBuff> structure are always contiguous on the screen.
After loading the strokes into the window buffer, the system finds the best cluster within the window, removes the elements of the found cluster from the window buffer and adds more elements from the influence list, if any.
By successive asa~ of the clusters, the system scans all the strokes in the influence buffer and reassigns the clusters meanings.
Searching for a cluster within the window buffer is done by calling a routine InterList(), to be described below.
The advantage of this method of scanning is that it allows one to enter new strokes I t Udl dless of the position of the previous strokes. That is, the user is not cu, lall~il ,ed in only one ,u, ~a-,l iLed order (e.g. from left to right).
This enables the user to have greater flexibility in i"t~, c,u~i, ,g with the computer via a tablet.
The pseudo-code cl~.,, il;~il ,~ the operation of ScanBuff() is shown in Fig. 30. The input to ScanBuff() is the stroke buffer. When called, ScanBuff() assumes that the laât stroke is part of a separate cluster and puts it as such into the cluster buffer (step 750). Then, ScanBuff() checks whether there is only one stroke in the stroke buffer and returns to the calling routine if there is (step 752). Next, ScanBuff() checks if there are exactly two strokes in the stroke buffer (step 754). If there are exactly two strokes and one is a gesture while the other is a circle around (i.e., if ModeFlag() is true), ScanBuff() treats this as a gesture and stops scanning.
If neither of the conditions of steps 752 or 754 are satisfied, ScanBuff() proceeds with scanning by calling a routine PosnOrder() which reorders the entries in the stroke buffer in order of increasing x-coo,di"~ of their position , . .. .. .. _ . _ . . .... _ . . ... . _ _ _ _ _ _ _ _ . _ WO 96~41300 ~ 1 9 0 1 6 4 PCT/US96/04156 (step 756). Then, ScanBuff() calls an InitRem() routine that finds the beginning and the end elements of the region of influence of the last stroke (step 758). Recall that the region of influence is defined as spanning the stroke buffer from four strokes before the current stroke to four strokes after the cunrent stroke.
After locating the ends of the region of influence, ScanBuff() performs a number of i, ,ilidli~d~iu,, steps. It initializes a variable 'scanCnt' to begScan, the index of the first stroke in the region of influence (step 760). The variable 'scanCnt', which is used to control the progress of scanning, is i"~,~",~"[ed during scanning. When it reaches 'endScan', the index of the last stroke in the region of influence, scanning stops.
ScanBuff() also initializes another variable 'foundFeet' to zero (step 762). The variable 'foundFeet' is used during scanning to count the number of strokes that are found to be within a cluster. If the cluster is accepted, then 'foundFeet' d~l~""i"es the number of strokes from the influence region that are to be removed to make room for new strokes.
ScanBuff() calls an InitWind() routine to initialize the window buffer (step 764), which is a subset of the stroke buffer. Its size is the maximum number of strokes in a cluster (i.e., 4). InitWind() sets the contents of the window buffer to zero. ScanBuff() then calls a LoadWind() routine to load the window buffer from the scan buffer (step 766) and calls an InitClust() routine to initialize certain variables describing the window cluster (step 768).
After cu" Ipl~il ,9 the i, liLidli~dliul ~ steps and loading the window buffer, ScanBuff() enters a while-loop in which it scans so long as there is something within the scan buffer (step 770). At the beginning of the while-loop, ScanBuff() again initializes 'foundFeet' to zero (step 772) and initializes certain variables describing the window cluster (step 774).
Then, ScanBuff() calls the InterList() routine to find the "best" cluster from the strokes in the window (step 776). InterList() retums a new value for cfoundFeet~ indicating the number of strokes in the found cluster.
.

_ InterList(), which will be described in greater detail shortly, finds the largest meaningful cluster among the strokes of the window buffer. If the best cluster has only one stroke, ScanBuff() assigns that cluster values from the window buffer. If the window cluster's strokes are part of a cluster contained in the cluster buffer, Scan~uff() removes that cluster from the cluster buffer by calling a CleanBuff() routine (step 778). CleanBuff() removes all meanings for all clusters from the cluster buffer that were used by the routine InterList() to constnuct the largest ~ l ledl lil 1~ cluster. After CleanBuff() returns, ScanBuff() calls a PutClust() routine to put the found cluster into the cluster buffer (step 780). That is, it assigns the cluster d~s.., i~Liul, of the window cluster to the cluster des.,, i~,Li~" in the cluster buffer.
After L~ F~I ~ i"g the found cluster to the cluster buffer, ScanBuff() i".,, ~" ,~"t~ the scan count variable (i.e., scanCnt) by the number of the strokes in the best window cluster (i.e., foundFeet) (step 782). Then, ScanBuff() calls the InitWind() routine to shift the strokes in the window buffer to the left thereby removing the strokes in the best window cluster (step 784).
This, of course, oniy occurs if the strokes that are removed from the window buffer are the hrst strokes in the window buffer. If the found cluster does not include the first strokes in the window buffer, shifting cannot occur until ScanBuff() during a later cycle of the while-loop identifies the first strokes in the window buffer as part of the best window cluster.
After calling InitWind(), ScanBuff() checks if strokes were removed by InitWind() (step 786). If strokes were removed, ScanBuff() calls LoadWind() to load more strokes into the window buffer filling the space left by removing the other strokes (step 788).
Then, ScanBuff() ~ ,iliali~a the window cluster descriptor (step 790) and retums to the beginning of the while-loop to continue scanning.
Upon r,u",~ Liul ~ of scanning, ScanBuff() calls a BufOrder() routine to reorder all the entries in the cluster buffer in order of increasing x~ , di, Id~C:
of their position on the screen (step 792). Note that the oreder in which the .... .. _ . _ _ .. . _ _ . . . .... . _ _ _ _ _ WO96/41300 2~ 9~ 6~ r~ olls6 clusters are added to the cluster buffer is in an order ~ ",i"ed by a measure of which cluster is most meanin3ful. Thus, affer scanning the cluster buffer is not spatially ordered and a, ~:u, ~, i, ,9 must occur.
Affer, ~uld~l i"g, ScanBuff() calls an OverlapAnsr() routine to determine if there is any overlap between the surrounding boxes of the strokes in the old stroke buffer and the surrounding box of the last stroke (step 794). Note that an overlap of clusters typicaily identifies an editing command. Thus, if there is overlap, the system detects it through calling the OverlapAnsr() routine and performs whatever editing functions are indicated by the editing gesture. The OverlapAnsr() routine is the interfac3 between the, ~coy"i~;.," system and the editor functions.
Affer checking for overlap and pe~ rul I l lil l9 whatever editin3 funcitons are ~,,u, u~, , ScanBuff() restores default values to editing flags (step 796-8û0).
The routine InterList() which is called by ScanBuff() ~t~""i"es the "best" cluster from the strokes in the window buffer. In principle, the routine operates by cu, laidel il l9 the sorted prototype lists of the strokes and finding the largest meanin~qful cu" Ibi~ ,~iu" of parts of the strokes. The system searches for a meaningful cluster having the largest signal-to-noise ratio (S/N). The definition of the S/N ratio is similar to that used by th3 proportiondia~,l il l lil IdliOll portion of the system. The S/N ratio is defined as the ratio of the length of the image divided by the length of the meaningful part of the image.
interList() has as its inputs a pointer to a structure <INF> and a pointer to the integer shiff cshiff~. Structure <INF> is shown in Fig. 31. This structure describes a single cluster. The <.Sym> instance identifies the meaning of the S~"~e:" ' part of the cluster. The c.siz> and ~.Pos>
instances specify x-y size of the cluster and its position, respectively. The <.Len> instance specifies the length of the cluster which is equal to the total length of the constituent strokes. The <.Prt> instance identifies from what ~ WO 96t41300 2 1 9 0 1 6 4 F~~ '`4156 multiple stroke prototype the cluster came from. And the c.Frm[l> instance is an anray identifying the strokes in the window buffer that make up the cluster.
The variable ~shifl> denotes the number of the first stroke of the cluster in the window buffer. if this number is zero, then a variable <scanCnt> is augmented by the number of strokes in the cluster in the routine ScanBuff() and the window buffer is loaded with additional strokes from the scan buffer. If ~shift> is not zero, then there is no additional loading. This is done to ensure that strokes of any cluster are contiguous, i.e, for any two strokes of the cluster 'A' there are no strokes from another cluster 'B' whose x-c~ul di, l ' is between x-uuo, .li" ' g of the strokes making up cluster A.
This assumption is based on assuming that the user's input will consist of lines of text with symbols Iying along a horizontal line. If that assumption is true, then the any current stroke buffer will be organized similarly.
The output of the routine InterList() is an integer which indicates how many strokes are contained in the found cluster. The default cluster is a single stroke cluster consisting of the first stroke of the window buffer.
InterList() perfomms the following u~, dliul ,~.
1. It I~,t~. " ,;"es H any of the strokes in the window buffer is an erasure gesture.
2. If a stroke is an erasure gesture, the system does no clustering, assigns TRUE to the value of editing flag ~tick.Erase> and exits. Note that ~tick.Erase> is an instance of the structure ~COUNT tick> which contains global counting variables. It is shown as shown in Fig. 3.
3. It makes up all possible cc ,,,ui, ,.,liu, ,:, of the single stroke prototypes on the single stroke prototype lists. This includes cu,, ,ui, IdliOI ,:. with less than maximal number of strokes in the window buffer.
4. It throws away all LUlllbil IdliUI IS which have gaps, i.e., which would have a cluster such that another stroke of the window buffer under l,UI l~id_l d~iUI I would have an x-cuu, u'i, Idlt: between the l,uo, ~i"~t~,~ of some of the strokes of the cluster.

WO 96/41300 . ~ '0 ~156 5. It loads each a.d~"issiL,le CU~ ld~iOl) into a structure <ONEBUFF
typeBuff[STRKNUM]>. The <typeBuff[]~ structure is similar to <BUFF
timeBuff[l> except it contains illrUlllldliUn not about prototype lists but about prototypes themselves.
For contrast both structures are defined below.
typedef struct buff{
SYMPROT Sym[LlSTNUM];
~BUFF;
typedef stnuct oneBuff{
SYMPROT Sym;
UCHAR Olp;
}ONEBUFF;
Here the instance <.Olp> refers to the number of the largest prototype on the list from which the prototype described by <typeBufft]~ was chosen from.
This is a feature used by some of the neural networks for position l il l lil IdtiOI 1.
6. It orders each u,,,~i, IdliUI, in <typeBuff> in a canonical way according to complexity-spatial criterion to obtain a input multiple stroke prototype. This is done by calling a routine TypeOrder().
7. It checks if any of the CUIllbi~ldliUI~s are meaningful by co~,ual i"g each input multiple stroke protoytpe with a list of canonical multiple stroke prototypes. This is done by calling a routine InterBuff(). To do checking the routine assigns a value to variable <typeCode> which is obtained by making up a long integer from the up to eight digits of the decimal numbers of the constituent prototypes on the canonical prototype list protTbl[].
The type code is i, Id~pt~ l ,1 of the order in which the strokes were entered. This eliminates the need to specify in which order the strokes of a ~ WO96/41300 2 ~ 90 1 64 PCr/US96~04156 symbol are to be entered by a user, in contrast with other systems where an order of strokes is essential.
8. It chooses a meaningful multiple stroke prototype with largest screen length, or for two choices with the same length it chooses the one with the least distance between constituent parts (this distance is explained below in section on multistroke neural networks).
9. It declares the cluster of the largest and most compact multistroke prototype as the winning cluster and stores i"ful ",c,Li~ about it in structure ~INF>.
The pseudo-code des~,, iL,i"9 the operation of the InterList() routine is shown in Figs. 32A-F and its operation will now be described in detail.
InterList() first initializes a set of variables that it will use (steps 850).
The variables are: totFit, winFit, winDist, shift, winShift, winFeet, and typeFit.
The variable totFit records the total length of the strokes in the window buffer.
The variable winFit records the length of the largest cluster. The winDist variable records the closeness or c~""~,l"ess of the most compact cluster.
The shift variable records the count of the first stroke of the cluster in the window buffer. The variable winShift records the previous count for the winning cluster. The variable winFeet records the number of strokes in the winning cluster. And the variable typeFit records the length of a cluster.
InterList() initializes all of these variables, except winFeet to zero; it initializes winFeet to one.
After initializing variables, InterList() forms a single cluster with the first stroke in the window buffer (step 852) and saves that cluster to a temporary variable, temClust (step 854). Then, InterList() enters a for-loop in which it computes the total length of the strokes in the window buffer (step 850).
Within the for-loop, InterList() goes through each of the <tick.Wind> entries within ~windBuff[l> and uses the totFit variable to add up the screen lengths of the found prototypes as recorded in the c.sym[1 ].Prt.Fit> instances of the cwjndguffLl> array stnucture (step 858).

WO 96/41300 . ~ 1156 After computing the total screen len3th of the contents of the window buffer, InterList() sets a skip variable to FALSE and then proceeds to determine whether any of the strokes within the window buffer is an erasure gesture. There are several erasure gestures, e.g. a back and forth scratch over an entry, a scribble over an entry, or a long line through an entry. The variable skip is used by InterList() to indicate whether any of these erasure gestures is found during the search of the window buffer. The specific tests that InterList() performs to find such entries will now be described.
If any of the strokes of the window buffer have the meaning of '-' and its y-size is less than 1/4 of its x-size and its %-size is less than 1/2 of the total screen length of the '-' stroke, then it is an erase gesture (i.e., it is a forward and back scratch gesture). InterList() enters a for-loop in which it again goes through each of the entries in the window buffer and checks whether any of the entries meets these criteria (steps 860-862). If such a gesture is found, the variable skip is set to TRUE (step 864) and InterList() exits the for-loop (step 866).
After searching for a short erasure gesture, InterList() finds the size and count of the largest stroke in the buffer. It uses two variables, maxSize and maxCount, to record the size and count of the largest stroke found.
Before beginning the search, InterList() initializes maxSize and maxCount to zero (steps 868 and 870). Then, InterList() enters another for-loop in which it looks for the stroke entry which has the largest x or y dimension (step 872). Itsets maxSize to the largest x or y dimension found and sets maxCount to the index of the entry (steps 874 and 876).
Then, using a similar procedure InterList() finds the size and count of the second largest stroke in the buffer (steps 878-884). During this search, InterList() uses two other variables, nextSize and nextCount, to identify the found stroke.
If the largest stroke is '-' and its size is 2 times the size of the next largest stroke and the :ext largest stroke prototype number (i.e., its WO 96/41300 2 1 9 ~ 1 6 4 PCT/US96/04156 complexity) is more than 6, then the stroke '! j5 an erase gesture. InterList() checks whether the largest found stroke meets these criteria (step 886) and if it does, InterList() sets the variable skip to TRUE (step 888).
If the largest stroke is '-' and its size is 4 times the size of the next largest stroke and the next largest stroke prototype number (i.e., its complexity) is less than or equal to 6, then the stroke '-' is an erase gesture.InterList() checks whether the largest found stroke meets these criteria (step 890) and if it does, InterList() sets the variable skip to TRUE (step 892).
After searching the window buffer for strokes that meet the above-described criteria, InterList() checks whether the skip variable is TRUE, indicating that an erasure gesture was found. If an erasure gesture was found, then InterList() performs no clustering, it sets <tick.Erase> to one (step 894), alerting the user interface (i.e., the editor) that an erasure is to occurand it exits, returing the value of winFeet (which equals 1 ) to the pregram which called InerList() (step 896).
If no erasure gesture was found (i.e., if skip is FALSE), InterList() initializes an array of indexes to input multistroke prototypes, protCode[count], where count ranges from zero to STRKNUM (i.e., 4) (step 898). Then, InterList() sets the value of a variable <DEPTH> (step 900). The variable <DEPTH> ealdLliOI ,es the maximum number of cor"L,i, Id~iUI la of elements from the prototype list that InterList() will examine to construct the input muitistroke prototype. In the described ~ udi~ ,l, InterList() looks only four deep in the list of prototype meanings. That is, InterList() looks at only the four best meanings in the sense of the length which they occupy.
Thus, the search is restricted to the most likely Cdl Idi.ld~t:a for the multistroke prototype. With <DEPTH~ set to four, the total number of F: ~ ' "" S iS 44 =
2~i6.
After setting the depth of the search, InterList() then enters a for-loop in which it examines all of the 256 possible multistroke u u" ,~i, IdliOrls (step 902). For a selected .;u, "~i, IdliUI 1, it sets the number of strokes in a cluster ... _ _ . _ . . _ . . .... ... _ .. _ . _ .... .. _ . . . . .. . .

WO96/41300 2 1 ~ 4 r~~ G~o~c6 (specified by a variable feet) to zero (step 904) and it sets skip to FALSE
(step 906). Then, InterList(j initializes a variable, symFit, that is used to measure the length of the input multistroke prototype (step 908).
After initializing symFit, InterList() arbitrarily numbers the ~,UI I ILi, IdliUI 15. It does this by picking a stroke and computing a number for it as shown in step 910. Then it checks whether the cu" t:a,uul ,di"g meaning (which is one of the best four meanings of the prototype) is NULL_SYM (step 912) or whether the prototype is identified as NULL_SYM (step 914). If either of these is true, InterList() does not consider the ~" ,ui, Idliul~ but moves on to the next of the 256 possible ,u,,,ui, ,dlions.
If neither the selected meanings for the four strokes nor the prototypes are identified as NULL_SYM, then InterList() checks for the presence of a gap among the strokes. First, InterList() checks for the presence of two strokes separated by a HAPY_SYM symbol (steps 916-918). Then, InterList() checks four stroke window buffers for the presence of two strokes separated by two HAPY_SYM symbols (step 920). Finally, InterList() also checks for the presence of a HAPY_SYM symbol at the beginning of the buffer window (steps 920). If any of these situations are detected, InterList() skips the cul I ILi, la~iùl~ and moves on to the next of the 256 possible ~" lui, ldlions If the cu" Ibil la~;OIl is not skipped, InterList() sets the shift variable to zero (step 924) and enters a for-loop in which it uses the shift variable to count the number of strokes that are in the cluster (steps 926). InterList() counts all strokes that are not assigned the meaning of HAPY_SYM.
After counting the number of strokes, InterList() sets the skip variable to FALSE (step 928) and then enters another for-loop in which it performs three tests on each stroke of the current cu, "~i, IdliUI I (step 930). The three tests compare different measures of the size of the current matched prototype (i.e.,thematchedprototypebeingcu,,a;clt:,~dforthecurrentcu,,,ui,,dliu,,) with a COI l~a~OI l~il Ig measure of the size of the most meaningful matched prototype for that stroke (i.e., SYMl1]) (steps 932, 938, and 944). If any of , ~ WO 96/41300 2 ~ 9 ~ 1 6 4 PCT/US96/04156 these tests establish that the most meaningful i"' ,ul ~dLiul I of the stroke isaiyl ,iril,d, Illy larger (as defined by the specific tests) than the i"t~, ~u, ~ d~iOIl being cu, l~id~l ~d, InterList() sets the skip variable to TRUE (steps 930, 94û,and 945) and breaks out of the for-loop (steps 930, 942, and 948) and moves on to the next one of the 256 cu" ,L,i, Id~iUI la (step ~).
If the stroke of the current cu" ,L,i, Id~iUI I passes the size .,u, lI,Udl i~l;)l~
tests, the skip variable remains set to FALSE and InterList() checks whether the current stroke of the current cluster is a gap (i.e., is assigned the meaning HAPY_SYM) (step 950). If it is not a gap, InterList() finds which stroke of the time stroke buffer c~ auOI l.Ja to the current stroke and loads the meanings of its prototype into the ~typeBuff> array of structures (steps 952-954).
InterList() also loads the number of the largest prototype for that stroke into the instance <typeBuff.Olp> (step 956), i"~ t", le:l l~a the value of symFit by the length of the stroke (step 958) and i"..",",~, Ita the feet variable (step 960).After the for-loop has looked at all of the strokes ofthe cluster, symFit will contain the total length of the strokes in the cluster.
In the event that the stroke has the meaning HAPY_SYM, InterList() simply loads NULL_SYM into the ~,u" ~a,uurldil ,~ element of the ~.Frm[]> array in the <INF> structure (step 962).
To simplify s~ ~hse~ Pnt u~ u~.es~il ,y, Interlist() assigns the same single stroke prototype number to all round prototypes within the current c~",~i" ~;~", (steps 964-970). It does this v/ith the aid of a routine called ProtFilter(). Notice that there are four p~u~uLypes that have the meaning of 'O', namely, prototype numbers 14,15,16, and 17. Forall round ~u~u~ypes~
ProtFilter() converts the prototype number to 14 and this value is stored in the<.Sym.Prt.Prt> instance of <typeBuff>.
After converting the round prototypes to a standard prototype number, InterList() orders all prototypes according to the following rule:
the more complex prototype comes ahead (i.e., to the right of) of less complex prototypes a-d, if there are two prototypes of the same WO96/41300 2 1 90 1 64 .~ 0~56 comp1exity, order them by their x-co~, ~ii, Id~ , unless they are '-'prototypes, in which case order them by their y-~,uo, ii, Idt~.
This rule is i,,,,ul~,,,t:nl~d by a routine called TypeOrder() (step 972).
After ordering the ,u, ututypes according to the above-identified rule, InterList() i~_""i"~s a type code for the cunrent cu",Li"dliul, of prototypes.
The type code will be used to assign meanings to the CUIllbil ,dliûn of strokes.The code is a iong integer where each two digits of its decimal fonm are the protûtype numbers of the single stroke prototypes of the cu, "~i, IdliUI I ordered ,dl IUI li~:!y by the routine TypeOrder(). Before ~ . " ,i, lil 19 the type code, InterList() initializes two variables, namely, ~typeCode~ and <faclor>. Both variables are used to compute the type code for the cu,, l~il IdLiul 1. InterList() initializes ctypeCode> to zero (step 974) and ~factor~ to one (step 976).
Then InterList() enters a for-loop in which constructs the type code from the prototype numbers of the w"ul~ica ~y ordered strokes within the CC I l~bi~ Idli (step 978).
Next, InterList() calls an InterBuff() routine to assi3n meaning to this uu,lllJil IdLiUI I of single stroke prototypes (step 980). InterBuff() interprets the cluster buffer <INF> using a neural network that will be described shortly.
InterBuff() retums a value, t:,UI e:,~, Itil ,9 the total length of the prototypes of the cluster. Interlist() stores the output of InterBuff() in the <typeFit> variable.
InterList() checks if <typeFit> is equal to zero (step 982). If it is, Interlist() skips that .,c,,,lL,i,~dliùn and moves onto the next one. If typeFit is not zero, Interlist() checks whether the new cu, "~i, IdliUI I is larger than previous ~.ulll~ dliol~s (step 984). If it It:plt:ser,~:, the largest uulll~ dlion examined thus far, Interlist() declares the new cluster the winner and records its values in the variables <winFit>, ~winFeet>, <winShift> and <temClust>
(step 986).
If, however, the current cluster has the same length as the largest cluster examined thus far, InterList() ~ ,es the winner by cu" I,Udl il ~g their CUIII,Ud~,~l ,ess (step 988). The cluster with the closest combined WO 96/41300 2 1 9 0 1 6 4 PCr/~TS96~04156 distances between the binding points (as recorded in a variable <pminDist>) is declared the winnner. The variable <pminDist> is computed by InterBuff() as will be described shortly.
- If the current cluster is smaller than the largest cluster examined thus far InterList() skips this particular c~" Ibil IdliUI I and moves onto the next one.
After evaluating all of the 256 possible cu,, IL,i, I~At;JI la, InterList() records the winning cluster (step 990) records the number of the first stroke of the winning cluster in the window buffer (step 992) and returns the number of the strokes in the winning cluster (step 994).
The routine InterBuff() assigns meaning to a single cluster of matched prototypes described by the stnucture <ONEBUFF typeBuffLl>. Its inputs are a pointer to structure <INF> which describes an isolated cluster (see above) an integer which describes the number of strokes in the cluster, and a pointer to unsigned integer which describes how close the strokes of the cluster are compared to their ideal position. This last input will be described in more detail in context of position .li~ l i" ,i, Id~iUI I neural networks. The output of the routine is an integer which is the total length of the ~ulutypes of the cluster. The InterBuff() routine performs the following u~ e, d~iùn~.
1. It d~Lel I l lil ,es the x- and y- sizes of the cluster under cu, ,~i.le, dliUI I and its x- and y- wul di"..'es.
2. It scans the list of multistroke prototypes and detel ll lil ,es if the type code of the cluster under cu"~ ,dliUI, matches a type code on the list of multistroke prototypes described by structure symsTbl[l defined by:
struct bundle {
ULONG typeCode;
UCHAR syms[BRCHNUM];

WO96/41300 21 90 l ~4 r~ T~

The first instance of the structure is the type code of a canonical cu",L,i, IdliOI~
of the strokes, the second is the list of up to BRCHNUM (= 9) meanings which can be assigned to a particular multistroke prototype. For example the type code 101 means that the cluster contains one stroke whose prototype number is 0--a "I ,u, i~u, lldl'' stroke and another stroke whose prototype number is 1 -a "vertical" stroke. Such a cluster potentially could have meanings of 'X', 'Y','~, "`', '1', '~, or 'D'. Zero values in the array oF meaning signify a null meaning.
3. If a match of the input type code was not found, the routine retums zero as the value of the combined length of the strokes of the cluster and the cluster is declared not meaningful.
4. Once a type code match is found, InterBuff() computes squares of distances between binding points of each prototype in <typeBufl[l~ and computes how large the distances are compared to the maximum size of strokes in the cluster. This is done by calling a routine DistArr().
5. If the smallest of the distances is large compared to the size of the strokes, the system rejects this multistroke prototype and continues with matching type codes.
6. If the cluster's strokes are declared "close", the routine calls a neural network routine StkBoundXX() which attempts to assign meaning to the cluster.
7. If a non-null meaning has been assigned to the cluster by the neural network, the routine computes the screen length of the cluster and assigns i"rul " IdliUI I about cluster to structure <INF ~clust> by calling a routine MakeClust().
The InterBuff() Routine:
The pseudo-code describing the operation of the InterBuff() routine is shown in Fig. 33.

WO 96141300 2 1 9 0 1 6 4 PCr/US96/04156 First, InterBuff(0) calls a SizeAndPos() routine to determine the size and position of the current cluster (step 1000). Then, it loops through all multistroke p, ululypes in symsTbl[] and tries to match the input prototype withone of the canonical p~ututypes (step 10û2). If the type code of the entry in the prototype table does not equal the type code of the input, InterBuff() moves on to the next entry in the table (step 1û04).
As soon as InterBuff(0) finds a match in the table, it initializes a tbound[] array which points to the meaning of the muiitstroke prototype (step 1 û06). It sets all entries of the array to FALSE.
Then, InterBuff() d~l~l ",i"as whether the protûtypes are "close"
enough to represent a valid multistroke prototype. It does this by calling a DistArr() routine (step 1008). DistArr() computes the squares of distances between the binding points of each prototype, finds the smallest distance and compares the smallest distance to the maximum size of the cluster's strokes.
DistArr() retums a boolean value indicating whether the closeness criteria are met and InterBuff() sets an intemal variable <close~ equal to the retumed value from DistArr().
InterBuff() then checks the value of close (step 1010). If close is FALSE, InterBuff() returns a zero for that cu,,,ui, ~d~iun. If close is TRUE, InterBuff() finds what meaning is assigned to this cluster prototype (step 1012). It does this by by calling the neural rletwork routines StkBound[]().
The routines retum an index into the array structure ~sysmTbl[j.Sym[]~ which InterBuff() saves in a variable ~scount>.
After obtaining an index into the array of multistroke prototypes, InterBuff() d~ ,es how close the actual distance between strokes is as compared to the canonical distance (maxSize/2) (step 1014). If the actual distance between strokes is less than the canonical distance, InterBuff() considers that mulitstroke further. Otherwise, InterBuff() rejects the prototype, rétums a zero to the calling routine and exits.

WO96/41300 2 1 90 1 64 ~ 6 If InterBuff() accepts the multistroke prototype, it then computes the screen length of the meaningful cluster and assigns position, size, and other i"ful " Id~iUI~ about the cluster to the cluster descriptor <INF ~clust>. First InterBuff() checks whether <scount> is a valid index to a meaning entry in the multistroke prototype table (step 1016). If it is, InterBuff() initializes the value of typeFit to zero (step 1018) and enters a for-loop in which it computes the screen length of the cluster (step 1020). The variable <typeFlt> is used to accumulate the lengths of the strokes making up the multistroke prototype.
When the for-loop is cu",~ ,t~ (i.e., all of the strokes of the multistroke prototype have been examined), InterBuff() records the i, If ul IlldL;Ul, about the cluster into structure <INF clust> by calling a M ' ~ Cl~ Ict() routine (step 10æ).
After the cluster i"ru, IlldtiUI, has been recorded, InterBuff() retums the value of <typeFit~ and exits (step 1024).
In the event that scount is not a valid index into the meanings in the prototype table (e.g. it is equal to -1 or NULL_SYM), InterBuff() continues the search for a multistroke prototype match (i.e., a type code match).
The StkBoundX)(() Routines:
The routines StkBoundXX() are encodings of tree based neural networks which assign meaning to multistroke ~ututy~es given by the table in the structure <bundle symsTbl[l>. XX stands for a number between 0 and COMPNUM (= 1 19).
The routine is called from within the routine InterBuff(), using an array of pointers pStkBound[COMPNUM], each of which points to one of the StkBound() routines. The input of the routines is a pointer pminDist to the unsi3ned integer, which describes the distance between the strokes in the cluster.
The output of StkBound() is an integer <scount> which could take value -1, or between 0 and BRCHNUM (=9). If the value is more than -1 then the assiu"")~ of meaning is done by using <scount> as an index into the ~ WO96/41300 2 ~ 90 1 64 PCT/US96/04156 ~symTbl[]> array inside the routine InterBuff(), otherwise the meaning is assigned inside the routine StkBound() by direct assiy"",e"l to a 310bal variable ~sym>.
The typical structure of the StkBoundX)(() routines is shown by the pseudo-code in Fig. 34. The neural networks that impiement the StkBoundXX() routines are similar to those previously described except that they use different features, namely, the squares of the distances between the binding points of the prototypes being cù" ,;~e,ed. In general, a StkBoundXX() routine checks whether the cluster whose strokes were found to meet the rough closeness criterion of InterBuff() is indeed tight enough to be ,1 Idl duLel i~t:d as a meaningful cluster. The StkBoundX)(() routine finds the pair of binding points with the least distance between them and records this smallest distance in <~pminDist~ (step 1030). It does this by calling a routine IsClose(). IsClose(), however, only looks at certain pairs of bindins points.
For each pair of prototypes, there are a maximum of 16 possible distances that can be computed between the four binding points of each prototype. The DistArr() routine that was called by InterBuff() generates a 16 element anray for each pair of prototypes in a cluster and each element of this array records the computed distance for a cu,, t~,UUI ,~;"y pair of binding points. In the described e,,,l,u~i,,,e, ,I, the entries in this array are indexed as follows:
1st prototype 2nd prototype index binding point bindin3 point O O O

WO 96/41300 . ~ ' 'C 1 ~ C6 It has been found that certain distances within this array provide the most useful i"ru", IdliUI I for ~ ., i" ,i, IdliI I~ between alternatiYe meanings and for assigning meaning. The distances of most i",p~, Idl I-,~ are identified in the array of 16 distances by indexes 0, 6, 10, and 2.
After finding the smailest distance, StkBoundXX() sets the value of tbound[] array for the index with the smallest c~" ILi, IdliUI~ to TRUE. This creates an initial as .;u"",a"l of meanings in the neural network tree. As before, the variables <tbound[ ]~ cu" ~a~Jul Id to the possible meanings of the muitistroke prototype. StkBoundX~(() contructs a ~ Siri.~l;..., tree by extracting i,lru, IIIdliUII from the l~dl1~ il19 database (i.e., the <typeBuff[]>
array) and assigning values to the elements of the true boundary array tbound[BRCHNUM] (steps 1 032-1034). The general fonm of the, t:ldliUI Is~ us within the ulasaifi-,dliu" are shown in Fig. 34. The details, however, depend upon the particular multistroke prototype being evaluated. In general, the r; ,11iu,~ criteria include locations of binding points and the locations and sizes of the p, ululypes. The specific I tlldliUI 1~ can be readily developed by one skilled in the art.
-~ WO96/41300 2 1 90 1 64 1~.l/Vv~5~ ;6 StkBoundX~C() dv~ ",;"es the first element of the tbound array which istnue and uses the index of this element as the index into the array symsTbl[COMPNUM].syms[BRCHNUM] (step 1050). If no tbound variables arQ true, it assigns a null meaning to the cluster (step 1052).
Once scanning of the stroke buffer is ~.u~ tlvd, the system calls two additional routines, BufOrder() and OverlapAnsr().
The first routine reorders the entries into the cluster buffer <BINFO
~buf> in order of i".., ea~i"y x-cou, ~i"_~, of the clusters The second routine,which is used for user interface with the Editor, d~v. " ,i"es whether there is an "overlap" between different clusters of the cluster buffer.
Resolution of Ambiguities Using Spatial Context:
Up to now the d~ -iyl 111 Ittl 1~ of meaning to a cluster did not depend on the presence of other clusters in the cluster buffer. There are a number of cases, however, where the meaning of a symbol is ambiguous and the presence of other nearby clusters provides additional i"ru" lldtiUI ~ that resolves the ambiguity. For example, a round stroke could mean both upper case'O'andlowercase'o'. If noadditionali,,fu,,,,d~;u,,isprovidedthis ambiguity cannot be resolved. HoweYer, when a round stroke is close to another unambiguous meaningful symbol, the meaning of the round stroke can be inferred from the relative size of the two symbols.
In the case when the meaning of the cluster is ambiguous, the upper case meaning is assigned where ~ . In the case where a single downward stroke could mean '1', 'I', 'i','j', the default meaning is 'I' if the stroke follows and preceeds a letter, and is '1', otherwise.
The following symbols are inherently ambiguous in terms of the case of the letter:
.

'C' WO 96141300 2 19 0 16 4 r~ o4l~fi 'E' (if written with one stroke) '~
'M' 'm' 'O' 'S' 'U' '~
'X
'Z' The case of these symbols is disambiguated by a routine SpatContext() which is called by a routine PrintCom() which is in tum called called by the routine PenUp(). The inputs of the routine SpatContext() are a pointer to structure <BINFO ~buf>, which describes the clusterin~ of the stroke buffer, and an integer which is an index into the array of clusters.
In addition, in a number of cases a single stroke has a meaning used only for purposes of clustering, and by itself does not have a meaning of a character in the ASCII set. For example, taken by itself a single downward stroke can have a meaning of '(', ')', or '1'. Yet, when taken in conjunction with a single horizontal stroke which crosses it, it is s~ li",~s useful to assign to it the meaning 'f (an extended ASCII charcter set 159), which allows the system to tell 't' from 'f but in itself is not an adl"issil,le printed character. Therefore, before printing such a charcter on the screen, it is desirable to convert such a meaning into a closest meaning from the ad~";s~ible set of ~,lldl~ b.
The routine SpatContext() perfonms the following ~pe, dliOllb.
1. It converts clusters or single strokes with meanings described by the extended ASCII set into the meanings described by the standard ASCII
character set.

~ WO96/41300 21 901 64 P~ u.,,S,r~c6 2. It delul ",i"es if the character ,u, e~eedil ,g or following the ambiguous character under uu, I:~idt:ldliul~ belongs to the class of tail letters (i.e., capital letters and letters 'b', 'd', 'f', '9', 'h', 'j', '1', 'p', 'q', 't', 'y', script 'z'), or to the ciass of short letters (i.e., the remaining letters of alphabet).
3. it assigns the ambiguous letter to a short or tall class 4. If an ambiguous letter follows a short letter whose size does not exceed a certain threshold, the Amhjgl ml ~c letter is declared to be lower case;
otherwise, it is declared to be upper case.
5. If an ambiguous letter is being followed by a short letter whose size does not exceed a certain threshold, the ambiguous letter is declared to be lower case; otherwise, it is declared to be upper case.
6. If the ambiguous letter is '1', then it is converted to 'i', or to 'j' using the ~JI euee~il Iy algorithm.
7. The threshold of the ~, e~e~ algorithm is adjusted depel "~i"~ on whether or not the ambiguous letter is short or tall.
The Editor - An Interactive Pen-Based User Interface The role of the Editor is twofold. First it allows to determine if the user's input should be i":u, ~ as text or as a command. Second it allows the user to actively Interact with the, el,uyl ,i~t:, to correct enrors or manipulate Image of the input to insert spaces in the lines, delete groups of strokes, etc The following is a cl~ Jliul, of the enror correction and input image manipulation functions of the Editor. It allows for the following u~,eldliulls on the input:
1 ) Overwrite cluster(s) 2) Insert space 3) Delete cluster(s) 4) Modify clustering WO96/41300 ~ /Uv~L~C1156 The overwrite operation provides a way for the user to replace a meaningful cluster or clusters in the cluster buffer by writing a stroke oF
sufficient ~nl,ul~u;,~l complexity over the image of the cluster desired to be replaced. Both the image and all data structures describing the overwritten cluster are deleted. The 1~ .olou;~.,.1 complexity is described by the number ofthe directions in the direction string of the largest meaningful part of the stroke. The requirement of l..l-olou; Al complexity is necessary because strokes of low complexity may actually modify meanings of the clusters.
The insert space operation provides the user with the ability to widen the horizontal space between two clusters by writing an 'L' shaped gesture between the two clusters. The position of the vertical leg of the 'L' gesture ~el ",i"es where the space insertion is to occur, while the length of the horizontal leg d~vLel ",i"t:s the horizontal extent of the inserted space. This operation results in erasure of the images of all strokes in the current buffer whose x-co~, di, IdL-v is to the right of the center of the vertical leg of the 'L'-gesture, changing the x-positions of all such strokes by the amount equal to the length of the horizontal le3 of 'L' - gesture and re-drawing all such strokes in the new, shifted position.
The delete cluster(s) operation provides the user with the ability to use a gesture to remove images and all data structures describing one or more clusters in the current stroke buffer. This operation can be d~ liol ,ed by two gestures: the long horizontal line gesture which removes itself and all clusters it overlaps from the system - this is used primarily to remove three ormore clusters; and a horizontal scratch gesture made by repeated continuous horizontal stroke where the stroke includes at least three back and forth horizontal pen movements, which removes itself and all clusters it overlaps -this being used primarily for removal of two or less clsuters from the current stroke burfer.
The cluster Illudirivdtul ~ operation provides for correcting errors in clustering. The user can enter vertical tick mark gestures to indicate to the ~ WO96/41300 2 l 9~ l 64 P~,IJL).";~

Reco~"i~e, that the strokes on the different sides of a tick mark should not be cul l~id~l ~d as a part of a single cluster.
All of the described functions involve d~t~,""i"i"g whether or not the latest stroke entry in the current stroke buffer overlaps any of the strokes of the clusters in the before current stroke buffer. As noted above, checking for O ./''';ld,Uil 19 is dt:l~l " ,i"ed by the routine OverlapAnsr(). This routine has void output; its input is a pointer to the cluster buffer cBlNFO ~buP, which was described earlier.
The pseudo-code des~,, iuil ,9 the operation of OverlapAnsr() is presented in Figs. 35A-E. In general, OverlapAnsr() performs the following functions. It checks whether the last cluster is overlapping anything else. If it does overlap another symbol, it checks if its total size is small compared to the size of the underlying symbol. If it is large as compared to the underlying symbol, then OverlapAnsr() removes the underlying strokes from the stroke buffer; it removes the underlying clusters from the cluster buffer and erases the displayed text of underlying strokes; and it removes the points of underlying strokes from the points buffer and erases displayed points of the underlying strokes.
The details of the operation of OverlapAnsr() are as follows.
OverlapAnsr() initiaiizes an array ~underCount[]~ which holds the number of clusters that have been overlapped by the last stroke (step 1 û70). Then, it enters a double nested for-loop in which it identifies the cluster which contains the latest stroke (step 1û72). This cluster potentially can be the cluster which overlaps another cluster. The overlapping cluster will be identified h~ i, Idfle:l as the "overlappe~' and the underlying cluster will be identified as the "overlapped" cluster. Note that coldTimeordr[tick Buff-1]> is the number of the last stroke in the array of space ordered strokes of the current stroke buffer. OverlapAnsr() d~ llllil ,es which cluster in the cBlNFO
buf> structure contains the latest stroke. It uses a variable coverCount> to store an index into the cluster buffer identiyFlng the possible overlapper.
,, _ _ .. .. _ .... . _ . ... . _ . .. . . .. . . . . .

W0 96/4~300 2 1 9 0 1 6 4 , ~ .'0 1156 When OverlapAnsr() finds the potential overlapper, it stores the position of the cluster's center and the cluster's x and y size (step 1080).
Then, OverlapAnsr() enters a for-loop in which it goes through the cluster buffer and dc~ ",i"es the cluster buffer indexes of the overlapped clusters, if any (step 1084). Before enering this for-loop, OverlapAnsr() initializes a variable <underNum~ that will be used to count the total nunber of the overlapped clusters that are found (step 1082).
Within the for-loop, OverlapAnsr() first checks whether the index of the cluster equals the index of the possible overlapper (step 1086).
OverlapAnsr() ignores the overlap of the overlapper on itself (i.e., self-overlapping) so if the indexes are equal, it moves on to the next cluster index.After checking for self-overlapping, OverlapAnsr() stores the position and size of the potentially overlapped cluster (i.e., the cluster identified by index count) (step 1090). Then, it d~lel " ,i"es whether the overlapper's position is inside a box boundin~ the potentially overlapped cluster (step 1092). If it is inside the bounding box, OverlapAnsr() records the cluster buffer index of the actual overlapped cluster in array <underCount[l~ (step 1094) and augments the count <underNum~ of the total number of ~,ld,uped clusters (step 1096).
If the O~ ld~ y~:l'S position is not within the box bounding the potentially cv~,. Id~ ped cluster, OverlapAnsr() dt:~l ",i"es whether potential overlapped cluster's position is inside a box bounding the overlapper (step 1098). If it is inside the bounding box, OverlapAnsr() records the cluster buffer index of the actual o~, Id~ ed cluster in array <underCount~l~ (step 1100) and au3ments the count <underNum~ of the total number of overlapped clusters (step 1102).
If either the overlapper or the potential overlapped cluster are "thin"
(i.e., its x-size is much more than its y-size), then it is enough to check overlapping of the x-bounds of the cluster position with the bounding boxes.
This is needed for detecting erasure gestures (e.g. a tick over the symbol to ~ WO96/41300 2 ~ 9 01 64 r~ 1156 be erase). These tests are performed in steps 1104 and 1110 which are similar to the previously described steps 1092 and 1098 but they only look at the x di,,,~ .iu,,~.
After .,u, "~.l~lil ,~ the search through the entire cluster buffer, if it is .ic:L~I I l lil ,ed that there are no overlaps, OverlapAnsr() retums to the routine v,/hich called it, namely, the ScanBuff() routine (step 1112). On the other hand, if one or more overlaps were found, OverlapAnsr() proceeds to determine the nature of the editing gesture(s).
After locating the overlappin3 clusters, OverlapAnsr() checks whether the system is in the edit mode, the last stroke is 'L' shaped and it is declaredto have HAPY_SYM meaning (step 1114). If those conditions are satisfied, OverlapAnsr() proceeds with space insertion by first declaring an insertion variable ~tick.lsrt> to be TRUE (step 1116). Then OverlapAnsr() calls an ErasePoints() routine to erase the ima~e of all strokes in the stroke buffer (step 1118). After erasing the points, OverlapAnsr() ~ ""i"es the amount of shift that will be required for space insertion (steps 1120 and 1122). To do this it looks at the x size of the overlapper (i.e., the 'L' editing gesture). Once the amount of x shift has been d~'~"",i"ed, OverlapAnsr() enters a for-loop in v~hich it adds this amount to the x-coul ~i" ' of all points in the point array (step 1124). Note that <timeBuff~]~ positions are in tablet coo,di"' - and the point anray positions are in pixel locations. Thus, the i, If ul " Id~iUI I from the cluster burfer must be ~, dl ,~ru""ed before adding them to the positions in thepoint array.
After shifting the points in the point array, OverlapAnsr() erases all text printed for current cluster buffer (i.e., cansrBuff[l>) (step 1126). Then, it recomputestheshiftinscreenuuuldilld~s(step1128)andde~ lllillesthe x~ou,~i" ' of the vertical leg of the 'L'-shaped space insert gesture (step 1 1 30).
Once the vertical le3 of the 'L' gesture has been located, OverlapAnsr() enters a for-loop in which it shifts the x-~,uo,di" ' - of the WO 96141300 2 1 ~ O 1 6 4 . ~1/~ L ~1156 ~

d,U,UI U~UI id~ clusters (step 1132). First, it u~, " ,i"es the x-cou"li, IdL~ of the left vertical leg of the bounding box of each cluster in the cluster buffer (step 1134). If the cluster is posiliu,~ed to the right of the insert gesture (step 1136), Overlap Ansr() (1 ) adds shift.x to the x-coo~.ii, Id~ of the the cluster(step 1138); (2) adds shift.x to the x-co~, ~i, Idl~ of each stroke of that cluster as l e:l~l es~ d in the prototype lists of the stroke buffer (step 1142); and adds shift.x to the x-cou, di, Id~e of each binding point of that cluster as , ~,u, ~st:"t~ in the prototype lists of the stroke buffer (step 1144).
After the d,Uf:n U,UI i ' clusters have been shifted by the amount shift.x, OverlapAnsr() calls a routine RecDrawBox(buf) to draw a new bounding box around the shifted stroke buffer (step 1146) and calls another routine PrintCom(buf) to print new cu, " ~,uul ,~i"g text on the display (step 1148).
Then, OverlapAnsr() removes the 'L' gesture from the current stroke buffer (step 11 5û) and calls a routine Dl "rui, Its() to draw new shifted images of all strokes in th~ stroke buffer (step 1152).
At this point, OverlapAnsr() checks if system is in editing mode (step 1154) or if the overlapper is less cu,,,, ' ' ~ than a circle and more CU~ dlt:d than the most c~":, ' i prototype on the prototype list (step 1156). If either of these conditions exists, OverlapAnsr() returns to the calling routine. Otherwise, OverlapAnsr() sets an overwriting variable <tick.Over~ to TRUE (step 1158).
The rest of the code in the routine relates to overwriting or erasing Editor functions. IF either the overwrite or edit mode are on, OverlapAnsr() erases the images of all overlapped clusters (step 116û). If it is in overwrite mode, then it redraws the remaining strokes (step 1û66) or if it is in erasure mode, it erases the image of the erasure gesture (step 1064).
Next, OverlapAnsr() enters a while Loop in which it updates the data structures for removed objects (step 1070). In particular, it calls a routine TakeList() that (1) removes points from the <pntArr[]> structure; (2) removes point counts from array of co" ~i"..~,, of stroke endpoints (i.e., in the <strArr~

~ WO96/41300 2190164 ~ '01156 structure); (3) removes strokes (lists) from stroke buffer <timeBuff[]>; and (4)removes clusters from cluster buffer <buf>.
Examples of Actual Character Processing The following are examples of actual character ~, uce ,~il ,g for a two stroke input consisting of a 'U' followed by a downward stroke to represent the numeral '4'. The desu, i~lion will follow the p, uCeS ,il ~y of the strokes by the various al~ " "~ " ,t:"~;ui ,ed above and will present the values taken on by the above-identified data structures during ~, uces;~il ,g Single Stroke The first input into the, ~.,uyl ,ilio,~ system is a U-shaped stroke written in the lower right corner of the 10000x10000 resolution tablet and seen on 1000x1000 resolution screen. There are a total of 68 sampling points with the following c~u, di, l~ and transition values.
pen.x = 8439 pen.y = 8637 TRANSITION = 5 pen.x = 8440 pen.y = 8635 TRANSITION = 8 pen.x = 8438 pen.y = 8637 TRANSITION = 8 pen.x = 8438 pen.y = 8639 TRANSITION = 8 pen.x = 8438 pen.y = 8641 TRANSITION = 8 pen.x = 8438 pen.y = 8652 TRANSITION = 8 pen.x = 8438 pen.y = 8661 TRANSITION = 8 pen.x = 8440 pen.y = 8679 TRANSITION = 8 pen.x = 8439 pen.y = 8687 TRANSITION = 8 pen.x = 8442 pen.y = 8698 TRANSITION = 8 pen.x = 8445 pen.y = 8709 TRANSITION = 8 pen.x = 8450 pen.y = 8720 TRANSITION = 8 pen.x = 8453 pen.y = 8732 TRANSITION = 8 pen.x = 8457 pen.y = 8743 TRANSITION = 8 WO96/41300 21 90 1 64 PC'I~US96/04156 ~

pen.x = 8461 pen.y = 8756 TRANSITION = 8 pen.x = 8465 pen.y = 8767 TRANSITION = 8 pen.x = 8469 pen.y = 8780 TRANSITION = 8 pen.x = 8474 pen.y = 8793 TRANSITION = 8 pen.x = 8481 pen.y = 8807 TRANSITION = 8 pen.x = 8489 pen.y = 8820 TRANSITION = 8 pen.x = 8496 pen.y = 8831 TRANSITION = 8 pen.x = 8506 pen.y = 8840 TRANSITION = 8 pen.x = 8514 pen.y = 8850 TRANSITION = 8 pen.x = 8523 pen.y = 8860 TR~NSITION = 8 pen.x = 8532 pen.y = 8869 TRANSITION = 8 pen.x = 8539 pen.y = 8878 TRANSITION = 8 pen.x = 8547 pen.y = 8882 TRANSITION = 8 pen.x = 8558 pen.y = 8886 TRANSITION = 8 pen.x = 8568 pen.y = 8890 TRANSITION = 8 pen.x = 8578 pen.y = 8892 TRANSITION = 8 pen.x = 8587 pen.y = 8896 TRANSIT~ON = 8 pen.x = 8598 pen.y = 8898 TRANSITION = 8 pen.x = 8606 pen.y = 8903 TRANSITION = 8 pen.x = 8616 pen.y = 8902 TRANSITION = 8 pen.x = 8625 pen.y = 8904 TRANSITION = 8 pen.x = 8634 pen.y = 8903 TRANSITION = 8 pen.x = 8644 pen.y = 8898 TRANSITION = 8 pen.x = 8654 pen.y = 8896 TRANSITION = 8 pen.x = 8662 pen.y = 8892 TRANSITION = 8 pen.x = 8670 pen.y = 8888 TRANSITION = 8 pen.x = 8692 pen.y = 8874 TRANSITION = 8 pen.x = 8700 pen.y = 8864 TRANSITION = 8 pen.x = 8713 pen.y = 8852 TRANSITION = 8 pen.x = 8722 pen.y = 8841 TRANSITION = 8 ~ W096/4~300 21 9bl 64 r~l" -~OllC6 pen.x = 8729 pen.y = 8830 TRANSITION = 8 pen.x = 8737 pen.y = 8816 TRANSITION = 8 pen.x = 8744 pen.y = 8804 TRANSITION = 8 pen.x = 8753 pen.y = 8789 TRANSlTiON = 8 pen.x = 8759 pen.y = 8775 TRANSITION = 8 pen.x = 8764 pen.y = 8761 TRANSITION = 8 pen.x = 8767 pen.y = 8750 TRANSITION = 8 pen.x = 8770 pen.y = 8739 TRANSITION = 8 pen.x = 8770 pen.y = 8728 TRANSITION = 8 pen.x = 8773 pen.y = 8715 TRANSITION = 8 pen.x = 8773 pen.y = 8701 TRANSITION = 8 pen.x = 8771 pen.y = 8686 TRANSITION = 8 pen.x = 8771 pen.y = 8669 TRANSITION = 8 pen.x = 8767 pen.y = 8653 TRANSITION = 8 pen.x = 8767 pen.y = 8635 TRANSITION = 8 pen.x = 8764 pen.y = 8620 TRANSITION = 8 pen.x = 8762 pen.y = 8609 TRANSITION = 8 pen.x = 8762 pen.y = 8599 TRANSITION = 8 pen.x = 8759 pen.y = 8592 TRANSITION = 8 pen.x = 8757 pen.y = 8583 TRANSITION = 8 pen.x = 8756 pen.y = 8581 TRANSITION = 8 pen.x = 8757 pen.y = 8582 TRANSITION = 8 pen.x = 8757 pen.y = 8586 TRANSITION = 7 Note that the first point is identlfied by TRANSITION = 5 cu" t:a,uol1dil ,9 to an UF~_DOWN event (i.e., pen brought into contact with the tablet) and the last point is identified by TRANSITION = 7 .,u" t:a,uul)ds to a DOWN_UP event (i.e., pen lifted off of tablet). For all illtt~ didle: points, TRANSITION = 8 ~u" c:~,uorldil ,~ to a DOWN_DOWN event (i.e., pen remains on tablet). The coc" ~i, IdL~s are stored in the ring buffer ~rinsBuffer[l> and in the point buffer ..... _ . _ . _ .... _ . ... . .. . _ _ _ .. _ _ _ _ _ _ _ _ _ _ _ WO96/41300 21 9~1 64 .~ .,.56 ~

<pntBufF[]~. The extraction and storage of the sampling points occurs in routines CheckRingBuffer() and PenlSR().
Dynamic Feature Extraction Dynamic feature extraction occurs in routines PenDown(), PenMoved() (which calls subroutine Stroke()), and PenUp() (which calls subroutine SymRec() which, in turn, calls subroutine LastSeg()). Dynamic feature extraction results in ds~iU"",e"l of values to instances of structure <SEGM>
for 4 different scales. The printout below was obtained using the following code.
for(scale = O; scale < SC; scale++) printf('~nscale %d\n",scale);
for(count = O; count <= tick.Segs[scale]; count++) x[1 ] = segs[scale].Seg[count].Bef.x/TBLT_SCRN;
x[2 ] = segs[scale] Seg[count].Bef.y/TBLT_SCRN;
x[3 ] = segs[scale].Seg[count].Aft.x/TBLT_SCRN;
x[4 ] = se~c[sr,~le].Seg[count].Aft.y/TBLT_SCRN;
x[5 ] = se~c[sr~le].Seg[count].End.x/TBLT_SCRN;
x[6 ] = se~c[sr~le].Seg[count].End.y/TBLT_SCRN;
printf("B %3d %3d A %3d %3d E %3d %3d ~n", x[1], x[2], x[3], x[4], x[5], x[6]);
if(count == tick.Segs[scale]) break;
x[7 ] = segc[sr~l~].Seg[count].Ext.min[O].x/TBLT_SCRN;
x[8 ] = segc[sr~l~].Seg[count].Ext.min[O].y/TBLT_SCRN;
x[9 ] = s~c[sr~l~o].Seg[count].Ext.min[1].x/TBLT_SCRN;
x[10] = segs[scale].Seg[count].Ext.min[1].y/TBLT_SCRN;
x[11] = ce~s[srAle]~seg[count]~Ext max[o].xlTBLT-scRN;
_ ~ WO 96141300 2 1 9 0 1 6 4 PCr~US96/04156 x[12] = segs[scale].Seg[count].Ext.max[O].y/TBLT_SCRN;
x[13] = segs[scale].Seg[count].Ext.max[1].x/TBLT_SCRN;
x[14] = segs[scale].Seg[count].Ext.max[1] y/TBLT_SCRN;
prinff("l %3d %3d %3d %3d A %3d %3d %3d %3d ~n", x[ 7], x[ 8], x[ 9], x[10], x[11], x[12], x[13], x[14]);
x[15] = segs[scale].Seg[count].Dir;
x[16] = se~s[sc~lQ].Seg[count].Len;
x[17] = se~c[sc~l~].Seg[count].Pos;
x[18] = se~c[s~ ].Seg[count].Neg;
x[19]= se~c[sc~l~].Seg[count].Pti;
x[20] = se~[s.~le].Seg[count].Pto;
printf("D %d L ~3d P %3d N %3d 1 %d O %d\n", x[1 5],x[1 6],x[1 7],x[1 8],x[1 9],x[20]);
}
}

There are three segments for scale 0, 1, 2. There are 9 segments for scale 3. The increase in the number of segments for flne scale is due to angle boundary noise. The data stored in the <SEGM~ structure is presented below.
Scale 0 In the following columns of data:
B stands for the sampiing point before the first (begin) point of the segment;
A stands for the sampling point before the last (end) point of the segment; and E stands for the first sampling point of the segment (note that its last point is the first point of the next segment).

WO 96/41300 2 1 ~ O 1 6 4 ~ ~ 01156 ~

Since there are three segments, there are four sets of X-y-~,Oul di~ Idl~S
of before, after and end points.
B: 843 863 A: 845 872 E: 843 863 B: 848 880 A: 860 890 E: 853 886 B: 860 890 A: 874 880 E: 869 887 B: 877 872 A: 876 863 E: 876 863 In the following columns stands for the uOu~i" '~ of maxima (two numbers) and minima (two numbers) for x-direction; and C stands for the uo~ ùi"..~ of maxima (two numbers) and minima (two numbers) for y-direction;
1: 843 863 843 863 C: 853 886 853 886 1: 853 886 853 886 C: 869 887 860 890 1: 869 887 876 863 C: 877 872 869 887 In the following columns D stands for the direction of the segment L stands for the tablet length of the segment;
N stands for the tablet length of the negative ~ia~,law~ "l of the segment;

~ W096/41300 2 ~ 901 64 ~ JV,Crl'li6 P stands for the tablet length of the positive div,ulaG-v,,,~v"~ of the segment; and J stands for the index of the first point of the segment at this sGale in the point array, pntArr[].
D: 6 L: 234 P: 93 N: 0 J: 13 O: 34 D: 8 L: 160 P: 34 N: 29 J: 34 O: 48 D: 2 L: 239 P: 78 N: 3 J: 48 0: 69 SGale 1 B: 843 863 A: 844 867 E: 843 863 B: 850 884 A: 857 889 E: 853 887 B: 867 888 A: 873 881 E: 871 885 B: 876 863 A: 875 859 E: 875 859 I: 843 863 843 863 C: 853 887 853 887 I: 853887 871 885 C: 871 885 862890 I: 871 885 875 859 C: 877 868 871 885 D: 6 L: 243 P: 100 N: 0 J: 9 O: 31 D: 8 L: 174 P: 26 N: 52 J: 31 O: 47 D: 2 L: 260 P: 58 N: 12 J: 47 O: 69 Scale 2 B: 843 863 A: 843 866 E: 843 863 B: 851 885 A: 855 888 E: 853 886 B: 865 889 A: 871 885 E: 869 887 WO 96141300 2 19 0 16 4 r~ ro/ls6 ~

B: 876 860 A: 875 858 E: 875 858 I: 843 866 843 863 C: 853 886 853 886 I: 853 886 853 886 C: 869 887 862 890 I: 869 887 875 858 C: 877 870 869 887 D: 6 L: 234 P: 94 N: 1 J: 8 0: 29 D: 8 L: 160 P: 35 N: 30 J: 29 O: 44 D: 2 L: 291 P: 81 N: 16 J: 44 O: 69 Scale 3 B: 843 863 A: 843 865 E: 843 863 B: 848 882 A: 850 884 E: 849 883 B: 849 883 A: 851 885 E: 850 884 B: 851 885 A: 853 886 E: 852 886 B: 852 886 A: 853 887 E: 853 886 B: 853 886 A: 855 888 E: 853 887 B: 867 888 A: 870 886 E: 869 887 B: 869 887 A: 871 885 E: 870 886 B: 870 886 A: 872 884 E: 871 885 B: 876 859 A: 875 858 E: 875 858 I: 843 865 843 863 C: 849 883 849 883 I: 849 883 849 883 C: 850 884 850 884 I: 850 884 850 884 C: 852 886 852 886 I: 852 886 852 886 C: 853 886 853 886 I: 853 886 853 886 C: 853 887 853 887 I: 853 887 869 887 C: 869 887 863 890 I: 869 887 870 886 C: 870 886 869 887 ~ WO 96/41300 2 ~ 9 0 ~ 6 4 PCTlUSg6/041~6 I: 870886 871 885 C: 871 885 870886 I: 871 885 875 858 C: 877 870 871 885 D: 6 L: 196 P: 58 N: 1 J: 7 O: 23 D: 8 L: 10 P: 9 N: 0 J: 23 O: 24 D: 6 L: 20 P: 17 N: 0 J: 24 O: 26 D: 8 L: 9 P: 9 N: 0 J: 26 O: 27 D: 6 L: 9 P: 7 N: 0 J: 27 O: 29 D: 8 L: 153 P: 25 N: 29 J: 29 O: 43 D: 2 L: 10 P: 8 N: 0 J: 43 O: 44 D: 8 L: 13 P: 0 N: 12 J: 44 O: 45 D: 2 L: 269 P: 60 N: 16 J: 45 O: 69 To give an example of position di~ i" ,i, IdliOI), a second stroke wili be needed. Therefore, it will be assumed that the second stroke is a single downward stroke written in proximity and to the right if the U-shaped stroke so that the whole cullll,i, IdliUI, looks like the number 4. The pen sampling UUUI ~il Idl~ for the second stroke are:
pen.x = 8789 pen.y = 8501 TRANSITION = 5 pen.x = 8790 pen.y = 8501 TRANSITION = 8 pen.x = 8789 pen.y = 850û TRANSITION = 8 pen.x = 8790 pen.y = 850û TRANSITION = 8 pen.x = 8789 pen.y = 8501 TRANSITION = 8 pen.x = 8790 pen.y - 850û TRANSITION = 8 pen.x = 8789 pen.y = 8500 TRANSITION = 8 pen.x = 8790 pen.y = 8500 TRANSITION = 8 pen.x = 8789 pen.y = 8501 TRANSITION = 8 pen.x = 879û pen.y = 8501 TRANSITION = 8 pen.x = 8788 pen.y = 8500 TRANSITION = 8 .. _ .. _ ...... _ . .. _ .. .. .. _ 2190164 ~

pen.x = 8790 pen.y = 8501 TRANSITION = 8 pen.x = 8788 pen.y = 8502 TRANSITION = 8 pen.x = 8790 pen.y = 8499 TRANSITION = 8 pen.x = 8790 pen.y = 8501 TRANSITION = 8 pen.x = 8789 pen.y = 8501 TRANSITION = 8 pen.x = 8790 pan.y = 8500 TRANSITION = 8 pen.x = 8789 pen.y = 8499 TRANSITION = 8 pen.x = 8790 pen.y = 8501 TRANSITION = 8 pen.x = 8789 pen.y = 8501 TRANSITION = 8 pen.x = 8790 pen.y = 8502 TRANSITION = 8 pen.x = 8789 pen.y = 8501 TRANSITION = 8 pen.x = 8790 pen.y = 8501 TRANSITION = 8 pen.x = 8788 pen.y = 8501 TRANSITION = 8 pen.x = 8790 pen.y = 8502 TRANSITION = 8 pen.x = 8788 pen.y = 8502 TRANSITION = 8 pen.x = 8790 pen.y = 8506 TRANSITION = 8 pen.x = 8789 pen.y = 8508 TRANSITION = 8 pen.x = 8790 pen.y = 8510 TRANSITION = 8 pen.x = 8793 pen.y = 8525 TRANSITION = 8 pen.x = 8796 pen.y = 8531 TRANSITION = 8 pen.x = 8801 pQn.y = 8542 TRANSITION = 8 pen.x = 8801 pen.y = 8552 TRANSITION = 8 pen.x = 8805 pen.y = 8562 TRANSITION = 8 pen.x = 8804 pen.y = 8571 TRANSITION = 8 pen.x = 8805 pen.y = 8583 TRANSITION = 8 pen.x = 8807 pen.y = 8594 TRANSITION = 8 pen.x = 8808 pen y = 8599 TRANSITION = 8 pen.x = 8807 pen.y = 8605 TRANSITION = 8 pen.x = 8807 pen.y = 8610 TRANSITION = 8 pen.x = 8808 pen.y = 8621 TRANSITION = 8 ~ WO96/41300 21 90 l 64 r~ l." 'CI156 pen.x = 8810 pen.y = 8626 TRANSITION = 8 pen.x = 8811 pen.y = 8632 TRANSITION = 8 pen.x = 8813 pen.y = 8643 TRANSITION = 8 pen.x = 8813 pen.y = 8653 TRANSITION = 8 pen.x = 8815 pen.y = 8663 TRANSITION = 8 pen.x = 8815 pen.y = 8671 TRANSITION = 8 pen.x = 8816 pen.y = 8680 TRANSITION = 8 pen.x = 8816 pen.y = 8691 TRANSITION = 8 pen.x = 8817 pen.y = 8704 TRANSITION = 8 pen.x = 8819 pen.y = 8712 TRANSITION = 8 pen.x = 8819 pen.y = 8724 TRANSITION = 8 pen.x = 8820 pen.y = 8731 TRANSITION = 8 pen.x = 8822 pen.y = 8741 TRANSITION = 8 pen.x = 8822 pen.y = 8751 TRANSITION = 8 pen.x = 8823 pen.y = 8760 TRANSITION = 8 pen.x = 8822 pen.y = 8771 TRANSITION = 8 pen.x = 8822 pen.y = 8781 TRANSITION = 8 pen.x = 8823 pen.y = 8792 TRANSITION = 8 pen.x = 8824 pen.y = 8800 TRANSlTiON = 8 pen.x = 8823 pen.y = 8811 TRANSITION = 8 pen.x = 8824 pen.y = 8820 TRANSITION = 8 pen.x = 8826 pen.y = 8830 TRANSITION = 8 pen.x = 8826 pen.y = 8841 TRANSITION = 8 pen.x = 8829 pen.y = 8852 TRANSITION = 8 pen.x = 8827 pen.y = 8861 TRANSITION = 8 pen.x = 8830 pen y = 8871 TRANSITION = 8 pen.x = 8829 pen.y = 8881 TRANSITION = 8 pen.x = 8830 pen.y = 8884 TRANSITION = 8 pen.x = 8831 pen.y = 8890 TRANSITION = 8 pen.x = 8832 pen.y = 8903 TRANSITION = 8 WO 96/41300 1 ~ ~ 0 ~ ' ~6 ~ 90~ 64 ~

pen.x = 8832 pen y = 8912 TRANSITION = 8 pen.x = 8835 pen.y = 8920 TRANSiTlON = 8 pen.x = 8838 pen.y = 8930 TRANSITION = 8 pen.x = 8839 pen.y = 8940 TRANSITION = 8 pen.x = 8839 pen.y = 8952 TRANSITION = 8 pen.x = 8840 pen.y = 8956 TRANSITION = 8 pen.x = 8840 pen.y = 8962 TRANSITION = 8 pen.x = 8843 pen.y = 8971 TRANSITION = 8 pen.x = 8845 pen.y = 8981 TRANSITION = 8 pen.x = 8845 pen.y = 8990 TRANSITION = 8 pen.x = 8847 pen.y = 9001 TRANSITION = 8 pen.x = 8847 pen.y = 9010 TRANSITION = 8 pen.x = 8848 pen.y = 9020 TRANSITION = 8 pen.x = 8850 pen.y = 9024 TRANSITION = 8 pen.x = 8847 pen.y = 9026 TRANSITION = 8 pen.x = 8849 pen.y = 9030 TRANSITION = 8 pen.x = 8850 pen.y = 9033 TRANSITION = 8 pen.x = 8849 pen.y = 9035 TRANSITION = 8 pen.x = 8850 pen.y = 9035 TRANSITION = 8 pen.x = 8850 pen.y = 9040 TRANSITION = 8 pen.x = 8850 pen.y = 9041 TRANSITION = 7 Its dynamic features are as follows:
Scale 0 B: 879 850 A: 880 858 E: 879 850 B: 883 893 A: 884 901 E: 884 901 I: 879 850 879 850 C: 884 901 884 901 WO 96/41300 2 1 9 0 ~ 6 4 PCT/US96~D4156 D: 6 L: 509 P: 57 N: 0 J: 105 O: 162 Scale 1 B: 879 850 A: 880 854 E: 879 850 B: 884 897 A: 884 902 E: 884 902 I: 879 850 879 850 C: 884 902 884 902 D: 6 L: 519 P: 58 N: 0 J: 101 0:162 Scale 2 B: 879 850 A: 879 852 E: 879 850 B: 884 900 A: 885 902 E: 885 902 I: 879 850 879 850 C: 885 902 885 902 D: 6 L: 523 P: 60 N: 0 J: 99 O: 162 Scale 3 B: 879 850 A: 879 852 E: 879 850 B: 884 903 A: 885 904 E: 885 904 I: 879 850 879 850 C: 885 904 885 904 D: 6 L: 539 P: 61 N: 1 J: 99 0:162 WO 96141300 . ~ ).,, 'Q ~

Proportion Di~ul i" ,i, IdliU
Having extracted the dynamic features, the, ec~"ilio" system performs proportion .li~v, i",i, Id~iOI~. The end result of the proportion dia~,l il l lil IdLiUI~ is a list of meaningful prototypes assigned to each of the two the strokes. The example will be given only for the U-shaped stroke.
~ efore the dynamic features are used in proportion ui~ i" ,i, IdliUIl, the noise induced by passage of the pen close to one of the two dia30nal directions is reduced. The resulting features have the following values:
Scale 0 (direct) (length) (pos displ) (neg displ) (angl 1 ) (angl_2) R 1 6û 34 29 6 -1 Scale 1 (direct) (length) (pos displ) (neg displ) (angl_1 ) (angl_2) Scale 2 (direct) (length) (pos displ) (neg displ) (angl_1 ) (angl_2) WO 96141300 PCT/US96~04156 Scaie 3 (direct) (length) (pos displ) (neg displ) (angl_1) (angl_2) Note that instead of 9 segments the scale 3 dynamic feature Jrt:Sel l~d~iul I has 3. This is a result of angle boundary noise reduction.
The variables angl_1 and angl_2 are the 4 bit quantized values of angle difference between pairs of adjacent segments and the pairs of once removed segments.
Angle values vary bet~veen 0 and 15. The value -1 is assigned when angle computation is not possible. Angle variables are computed as static features during proportion .li:.-,, i" ,i, IdliUI 1.
Proportion d;.,~ i",i, IdliOrl proper begins with matching prototypes to .,~""e~ d subsets of the direction strings, and proceeds further with computing the length of the match, and then using tree structured neural networks to assign meaning to each matched prototype.
In this example, there are four lists of prototypes, one for each scale.
In the following data, the columns mean the following:
0 the meaning of the stroke; the first line contains i"ru, IlldliOll about the stroke as seen at this scale, therefore, the meaning is null as signified by the @ symbol;
this column can have either 0 - when the stroke did not have to be reversed to match this prototype, and 1 - when reversal was needed;
2 the prototype number on the list of all prototypes;

WO 96/41300 I'CT/US96/04156 ~931~4 3 the offset of the beginning of the matched prototype relative to the beginning of the direction string ,e:yl~se"li"~ the input stroke;
4 the total number of sesments in this prototype;
5 the total tablet length of the matched portion of the input stroke;
6 the x-size of the matched portion;
7 the y-size of the matched portion.
Scale o @~ O O 0 3 633 o O

Scale 1 @ 0 0 0 3 677 o o WO96/41300 2 1 90 1 64 .~., '.'0~156 Scale 2 @~ O O 0 3 685 0 0 \ 0 3 0 2 394 25 26 Scale 3 @~ O O 0 3 689 0 0 ,,, .. .. .. _ WO 96/41300 I ~ .'Q I 1 C6 2190164 - ~

This i"ru, Illdliul, about the prototype lists is stored in a structure 'PINFO~.
One observes that the tablet length of the prototype on the top of the list achieves maximum for scale equal to 3. This scale is therefore declared the scale with the best graded input I t~ 5e~ dliUI I for a single stroke. From now on, only the i, If ul Illdliul, coming from scale 3 is kept for further u,ocessi"g. The remaining scales are discarded.
On the level of the b~ of meaning by the neural networks, the neural networks have the following choices for meanings of the matched prototypes #7, 3, 1, 0. These are taken from the structure <protTbl[]> (see Appendix A).
7- "DRU", 'I', '~, 'U', 'O', 'j', 0, 0, 0, 0, 3- "DR", '\', '<', '~, 'L', 'A', 'h', 'n', 'r', 'c', 1- "R", 'r, ~ , 'r', 0, 0, 0, 0, 0, 0 - "D", '~, '\', '1', '(', ')', ' r~ . Y. 'J'.
Amon3 these p~ ' "' , the neural networks #7,3,1,0 have the following values of the true boundaries ctbound[j~. Here 'T' stands for tbound[count] = TRUE, and "." stands for tbound[count] = FALSE.

WO96/41300 21 901 64 r.l,l 01156 Scale O
tbound[l =
# length countO 1 2 3 4 5 6 7 8 7 633 . . T
3 394 . . . T
160 . . T
O 234 . . T
Scale 1 tbound[] =
# length count 0 1 2 3 4 5 6 7 8 7 677 . . T
3 417 . . . T
1 174 . . T
O 243 . . T
Scale 2 tbound[l =
# length count 0 1 2 3 4 5 6 7 8 7 685 . . T

_ _ .

WO 96/41300 PCT/~JS96/04156 2190164 - ~

160 . . T
0 234 . . T
Scale 3 tbound[l =
# len3th count 0 1 2 3 4 5 6 7 8 7 689 . . T
3 397 . . . T
1 201 . . T
0 196 . . T
This concludes proportion di~ i" ,i, IdliOIl~ The next step is to store the prototype lists for strokes in a structure which describes a group of strokes and then perform clustering and position d;~.,li",i"dlio,).
Clustering and Position Dis~i,,,i,,dliu,, The flrst step in clustering is loading the dynamic features into the stroke buffer ~BUFF timeBuff[BUFFNUM]>. In addition to copying the values of dynamic features from structure <PINF0> into array of structures <BUFF>, the system extracts the static features needed exclusively for position di.~,l il l lil IdliO~l. These features are called the binding points. There up to ~BINDNUM> of them, and for this particular example there are exactly three.
These binding points are d~L~I ",i, l~d for every meaningful prototype on the list.
Here the binding points will be presented for the largest prototypes.
For the example of U-shaped stroke, the c~u, di"_'~.s of the binding points for the prototype "DRU" are:

WO96141300 21 901 64 . .,. ~.~1156 point # x~oord y-coord 0 843 863 cou,~i" of the be3inning of the prototype 875 859 cou,.li,Id~ oftheendoftheprototype 2 863 890 cou"~i, IdLt:s of the y-maximum of the middle segment of the prototype For the example of the downward stroke the co~, ~i"~.t~,o, of the binding points for the prototype "D" are:
point # x-coord y-coord 0 879 850 cuu, di, Idl~ of the beginning of the prototype 885 904 ~u,.~i" - of the end of the prototype 2 882 877 cou"li, ~ of the middleof the prototype The multistroke prototype of type code number 108 is matched by the u U~ il IdLiul~ of the strokes in this example. This is the multistroke prototype # 7 on the list of mulitstroke prototypes It has the following possible "ed"i"y~.
type # code meanings #7108, 'K', '4', '~, 'u', 'N', '~, 0, 0, 0 WO96/41300 1~,1/1 /01156 2190l64 The next matched multistroke prototype is # 3. This prototype is made up from one L-shaped stroke and one downward stroke. Its possible meanings are given by:
type # code meanings 3 104 '4' 'u' 'd' 'K' '4' '~ 'K' 'X' '~
For a given group of up to <STRKNUM> strokes the system computes squares of up to <BINDNUM~BINDNUM> distances between the binding points of each two strokes in the group. In this example there are only two strokes with three binding points each therefore one obtains:
x[00] = 1465 x[10] = 80 x[20] = 1856 x[ 01 ] = 3445 x[ 1 1 ] = 2216 x[21] = 680 x[02] = 1717 x[12] = 410 x[22]= 560 In general for stroke of more ~". '; i shapes one could have <BINDNUM> = 4 binding points.
One observes that among the nine distances the smallest is between the rightmost tip of the U-shaped stroke and upper tip of the downward stroke. This results in as~i~,,,,,c:,,l of <TRUE> to variable tbound[1] and ~ WO 96/41300 2 t 9 0 1 6 4 P.~ 0 1156 <FALSE> to <tbound[0]>. Consequently the meaning of the multistroke prototype is declared '4'.
The process of clustering results in one cluster, described by the cluster buffer <BINFO ~buf>. The non null entries in this buffer are given by:
(~bufl.Sym[0] = '4';
(~buf).Siz[0].x = 41;
(~buf).Sym[0].y = ~2;
(Abuf).Pos[0].x = 864;
(~buf).Pos[0].y = 877;
(~buf).Len[0] = 1228;
(~buf).Prt[0] = 107;
(~buf).Frm[0][0] = 0;
(~buf).Fmm[0][1] = 1;
Scanning The process of scanning the cunrent stroke buffer for this example may be su" ", Idl i~d as follows.
1. After the dynamic features were extracted from the most recent stroke call ScanBuff().
2. In ScanBuff(): order all strokes in the current stroke buffer left to right. In this example, the strokes are already in this order because the second stroke was written to the right of the first one.
The variable <timeOrdr[l> contains the order of strokes after ~ t:UI .1_1 il Iy.
timeOrdr[0] = 0 timeOrdr~1] = 1 WO 96/41300 2 ~ q O 1 6 4 PCT/US96/~4156 The following chart lists all clusters and their cu" I,UOai~iul 1. The first on the line is the meaning of the cluster, then follows the list of the indexes of the constituent strokes in the stroke buffer. The value 254 is an i, lilidli~d~iul, value NULL_SYM.

The variable <oldTimeOrdr[]> contains the order of strokes before reordering.
In this case, it is identical to the <timeOrdr[]~:
oldTimeOrdr[0] = 0 oldTimeOrdr[1] = 1 3. ScanBuff() d~it~. " ,i"es the region of influence for the most recent stroke. The variable <begScan> is the index of the leftmost stroke of the influence zone and the value of the variable <endScan> is the index of the rightmost stroke in the influence zone. All indexes are into the stroke buffer CBUFF timeBuff[]>.
In this example, the influence zone contains all the strokes of the stroke buffer. The size of the zone in the present e"~Lo~i",~"l does not exceed twice of STRKNUM. It should be noted, however, that, in general, the influence zone could be as large as the number of strokes in the stroke buffer. Such an event is extremely rare.
begScan= 0 endScan= 2 WO 96/41300 2 1 9 a 1 6 4 PCT/US96/04156 The following chart contains the results of loading strokes from the stroke buffer into the window buffer:
~BUFF windBuff[STRKNUM]~
windB: put in wind= 0 sym= U
windB: put in wind= 1 sym= 1 In this example, both of the two strokes are loaded into the window buffer. In general, there could be at most STRKNUM strokes loaded because we assume that there are at maximum four strokes in each meaningful symbol.
4. The scanning loop in the ScanBuff() begins:
O TOP OF WHILE LOOP
4.1 The variables relevant to the scanning loop are as follows. The variable <buff> is the number of strokes in the stroke buffer, ~feet> is the number of strokes in the largest cluster found within the strokes of the window buffer, <scan> is the scanning loop 1~""" Id~iU~ variable, and <wind> is the number of strokes in the window buffer. Note that this is the top of the scanning loop and the position di~,,i,,,i,,c,Lio,, has not been used yet. The values for the above-identified variables are:
buff= 2 feet= 0 scan= O wind= 2 4 2 The variable <clustSym> is the meaning of the best cluster within the window buffer. At this stage it is null because the system has not tried to interpret the window buffer yet.
clustSym= @
4.3 The following line lists all the strokes from <timeBuff[l> which make up cluster found in <windBuff[l>. At this stage there are no strokes because there is no cluster.
,, .. , ,, , .. , . , . ... , . .,, . _, frmO= 254 frm1= 254 frm2= 254 frm3= 254 4.4 The following line lists the strokes that remain to be ~l ucess~d during scanning of this region of influence.
rmnO= O rmn1 = 1 rmn2= 254 rmn3= 254 wndO= U wnd1= 1 wnd2= wnd3= -4.5 The following chart lists the stroke buffer entries. There is aU-shaped stroke and a downward stroke in the stroke buffer.
U[O] posx 860 0 254 254 254 1[1 ] posx 882 1 254 254 254 4.6 The system found that the multistroke prototype #108 matches a C~ dliu11 of two prototypes on the two prototype lists co~ .oll~i"g to the entries to the stroke buffer.
typeCode = 108 4.7 At this point, the routine InterList() is called to determine the cluster's c~ .usil;oll, meaning, etc.
in InterList: frmO= O frm1 = 1 frm2= 254 frm3= 254 bundSym= 4 typeCode= 108 typeFit= 1228 4.8 The entries from the stroke buffer prototype lists which make up the # 108 cluster are:
Prt= 7 Len= 3 Fit= 689 px= 860 py= 860 sx= 33 sy= 32 sym= U
Prt= O Len= 1 Fit= 539 px= 882 py= 882 sx= 6 sy= 53 sym=1, where ~.Prt> is the single stroke prototype number, <.Len> is the number of directions in its directions string, <.Fit> is its length, <.px> is its x-position, ~ WO96/41300 21 901 64 r~ t~'46 <.py> is its y-position, <,sx> is its x-size, <.sy> is its y-size, and <.sym~ is the meaning of the prototype.
4.9 The next multistroke prototype matched is #104, which is made from one downward stroke and one L-shaped stroke. This prototype is also accepted as meaningful.
4.10 InterBuff() is called and the system dt~ ",i,~es that the #104 cluster in the window buffer has the following meaning, multistroke prototype number, and length:
bundSym= 4 typeCode= 104 typeFit= 936 4.11 The entries from the stroke buffer prototype lists which make up the # 104 cluster are:
Prt= 3 Len= 2 Fit= 397 px= 856 py- 856 sx= 25 sy= 26 sym= L
Prt= O Len= 1 Fit= 539 px= 882 py= 882 sx= 6 sy= 53 sym= 1 This cluster also uses all the strokes in the window bu~fer.
in InterList: frmO= O frm1 = 1 frm2= 254 frm3= 254 4.12 Because the cluster#108 is 1228 tablet pixels long and cluster #104 is only 936 pixels long, the first cluster is chosen as the most l~,u, ~s~"ld~ive. Note however that the meaning of the second cluster is also '4'. If for some reason the system would have rejected the first prototype it would have still, ~,,, li~d the input as '4' but with less uu, ,ride,~ce.
4.13 The system returns from InterList() back to ScanBuff() and prints the i"rul " ldliun about the best cluster found in the window buffer:
1 LIST IN l tKPr~t I tL) buff= 2 feet= 2 scan= O wind= 2 clustSym= 4 frmO= O frm1 = 1 frm2= 254 frm3= 254 rmnO= O rmn1 = 1 rmn2= 254 rmn3= 254 wndO= U wnd1= 1 wnd2= wnd3= -U[O] posx 860 0 254 254 254 1[1] posx 882 1 254 254 254 4.14 At this point, the system d~ ""i"es which of the strokes need to be removed form the window buffer to proceed with scanning. It d~ ",i"es that strokes # O and # 1 should be removed:
remove[O]= O
remove[1 ]=
remove[2]= 254 remove[3]= 254 4.15 Now the cleaning of the window buffer begins:

buff= 2 feet= 2 scan= O wind= 2 clustSym= 4 frmO= O frm1 = 1 frm2= 254 frm3= 254 rmnO= O rmn1= 1 rmn2= 254 rmn3= 254 wndO= U wnd1= 1 wnd2= wnd3= -After cluster stroke removal there is nothing left:
[0] posx 10 254 254 254 254 ~ WO 96/41300 2 1 9 C 1 6 4 PCT~Sg6/04l56 [1]posx10 254 254254254 remain[O]= 254remain[1]= 254 remain[2]= 254 remain[3]= 254 4.16 Now the found cluster is put into the cluster buffer.

buff= 2 feet= 2 scan= 2 wind= 2 clustSym= 4 frmO= O frm1 = 1 frm2= 254 fmm3= 254 rmnO= 254 rmn1 = 254 rmn2= 254 rmn3= 254 wndO= U wnd1= 1 wnd2= wnd3= -4[0] posx 864 0 1 254 254 [1] posx 10 254 254 254 254 4.17 The system attempts to load into the window buffer anyremaining strokes from the influence zone of the stroke buffer. In this example, there are none.

buff= 2 feet= 2 scan= 2 wind= O
clustSym= 4 frmO= O frm1 = 1 frm2= 254 frm3= 254 rmnO= 254 rmn1 = 254 rmn2= 254 rmn3= 254 wndO= wnd1 = wnd2= wnd3= -WO96/41300 P~ O~IS6 4[0] posx 864 0 1 254 254 [1] posx 10 254 254 254 254 4.18 The single cluster descriptor for the window buffer isre-initialized.

buff= 2 feet= 2 scan= 2 wind= O
clustSym= @
frmO= 254 frm1 = 254 frm2= 254 frm3= 254 rmnO= 254 rmn1 = 254 rmn2= 254 rmn3= 254 wndO= wnd1 = wnd2= wnd3= -4[0] posx 864 0 1 254 254 [1] posx 10 254 254 254 254 4.19 End of scanning.

WO 96141300 2 1 ~ O l 6 4 1 ~-, .'01156 APPENDIX A
struct protTbl{
char longProt[PROTLEN];
UCHAR symbols[BRCHNUM];
}protTbl[PROTNUM]3 = {
1~00~/ "D", ~r,~ f, ~y~, ~J~, 1~01~1 "R", ~r,~ , 'r', 0, 0, 0, 0, 0, 1~02~1 "DL", ~r, 'J', 'U', 'S', 0, 0, 0, 0, 0, ro3~1 "DR", '\','<', '\/, 'L', 'A', 'h', 'n', 'r', 'c', 1~04'~1 "LD", ~r,~r~,~r~, o, o, o, o, o, o, t.05AI ~RD~, '\'.'7'. 'c'. '1 '. . . . . .
1~06~1 "URD", '1', 'A', 'f~', 'f, '1', '7', O, O, O, ro7~1 "DRU", '~', '\1, 'U', 'O', 'j', 0, 0, 0, 0, 1~08~1 "LDR", '<', '[', 'C', 'L', 'v', 0, 0, 0, 0, 1~09~1 "RDL", '~', ')', ']', '7', 'S', 'y', O, O, O, 1~10~1 "RDR", '~', '2', 'Z', 'N', 'M', 'L', 'n', 'u', 'h', r11 ~1 "LDL", 'S', '5', 'J', '{', 'v', 0, 0, 0, 0, 1~12~1 "DRD", '-', 'n', 'h', 'y', 'M', 0, 0, 0, 0, 1~13~1 "DLD", '-', 'N', ~r, o, o, o, o, o, o, 1~14*1 "URDL", 'P', 'D', 'O', 'l', 'A', '1', 'S', 'j', '7', r15~1 "ULDR", 'C', '9', 'O', 'e', 'I', '~', 'b', '~, 'x', 1115 '4', '7', 'G', 'a', '&', '9', 'S', 1~16~1 "DRUL", 'D', 'b', 'k', '6', 'O', '&', 's', 'j', 'q', 1~17~1 "LDRU", 'L', 'j', 'r', 'O', '~', 'a', 's', 'y', '2', 1117 'd', 0, 0, 0, 0, 0, 0, 0, 0, 1~18~1 "RDLD", 'T', 'U', '7', 'J', '?', 0, 0, 0, 0, 1~1911 "LDRD", 'r,'7','9','a','G','S','n', 0, 0, 1~20~1 "DRDL", 'b', 'J', '1', 'h', 'y', 'n', 0, 0, 0, /~21~1 "DLDR", 'c~', 'd', '1', 'C', 0, O, O, O, O, 1~22~1 "DRUR", 'r', 'v', '8', '~1', 'V', 'h', 'w', 0, O, 1~23~1 "URDR", 'r', 'i', 'a', 'k', 'q', 0, 0, 0, 0, 1~24~1 "RESV", 0, 0, 0, 0, 0, o, o, o, o, 1*25~1 "LDRDR", 'q', 'h', 0, 0, O, O, 0, 0, 0, 1~26*1 "RDLDL", '3','}', 0, 0, 0, 0, 0, 0, 0, 1~27~1 "URDRU", '-','&','N','v', 0, 0, 0, 0, 0, 1~28~1 "LDRDL", 'J', 'G', 'S', '9', '5', 'h', 0, 0, 0, 1~29~1 "RDLDR", '=', 'k', '2', 'Z', 's', 'q', 'h', 'c', 0, 1~30~1 "RDLUR", 'Z', '2', 'J', 'G', '6', 'O', 'r', 'I', 's', /130 'b', '~, 'S', '8' 1~31~1 "DRURD", '4', 'h', 'n', 'u', '7', 'r', 'Y', 'G', 'A', 1131 'm', 'N', 'y', 's', 'k', 'R', '~, 1~32~1 "DLURD", 'h', 'n', 'r', '7', 'A', 'N', 'o~', 'D', '~, 1132 '9', 'x', 'b', 1~33~1 "DRULD", 'u', '6', 'y', '4', 's', 'd', 0, O, O, 1~34~1 "LURDL", '9', 'O', 'e', 'I', '1', 'b', '~, 'i', 'C', 1134 'q','p','4', 0, 0, 0, 0, 0, 0, 1~35~1 "RDRDL", '3', 'M', 0, 0, 0, o, 0, O, 0, 1~36~1 "LDRUR", '8', 'o', 'G', 'f, 'F', 'S', '~', 'J', 0, 1~37~1 "DRULU", '8', 'S', 0, 0, 0, O, 0, 0, 0, 1~38~1 "DLURU", '8', 0, 0, 0, 0, 0, 0, 0, 0, 1~39~1 "RDRUL", 'A', '8', 0, 0, 0, 0, 0, 0, o, 1~40~1 "ULDRD", '8','9','k','h', 0, 0, 0, 0, 0, 1~41~1 "LULDR", '~', '{', '8', '&', 0, 0, 0, o, 0, 1~42~1 "URULD", '8', 0, 0, 0, 0, o, o, o, o, 1~43~1 "RURDL", '8','s','}', 0, 0, o, o, o, o, 1~44~1 "URDLD", 'R','k','7', 0, 0, 0, 0, 0, o, ~ WO96141300 2 t 90 1 64 ~ 4~i 1*45*1 "RESRV", 0, 0, 0, 0, 0, 0, 0, 0, 0, ~*46*/ "RESRV", 0, 0, 0, 0, 0, 0, o, o, 0, 1*47*1 "ULDRUR", 'b', '~, 'G', 'F~, 0, 0, 0, 0, 0, 1*48*1 "LDRURD", '9', 'a', 'G', 'd', 'q', '4', 's', 'u', '~, 1*49*1 "LDRULD", '6', '9', 'a', 'G', ~d~, 'O', 'Q', 'q', '4', 1149 'b', 's', 'u', 1*50*1 "DRURDL", 'y', 'b', 'P', 'D', '7', 'R', 'k', 'j', 'A', 1*51*1 "DRULDL", 'y', '~', 'G', '}', 0, 0, 0, 0, 0, 1*52*1 "DLURDL", 'b', 'P', 'D', '7', 'A', 'k', 'f, '9', 0, 1*53*1 "DLULDR", 'd','A','C','a', 0, 0, 0, 0, 0, 1*54*1 "DRULDR", 'd', 'A', 'C', 'q', 0, 0, 0, 0, 0, 1*55*1 "URDRDL", 'B', '13', '3', 'z', 'y', 'M', 0, O, O, 1*56*1 "URDLDR", '&', 's', 'R', 'A', 'k', 'K', O, O, O, 1*57*1 "RDLURD", 'b', 'f, '2', '0','s', 0, 0, 0, 0, 1*58*1 "RESRVD", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1*59*1 "RESRVD", 0, 0, 0, 0, 0, 0, o, o, o, 1*60*1 "RESRVD", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1*61*1 "URDRURD", 'M','m','z','R','B','u','h', 0, 0, 1*62*1 "DRURURD", 'H', '4', 'K', 'k', O, O, O, O, O, 1*63*1 "DRURULD", 'H','4','K','k', 0, 0, 0, 0, 0, 1*64*1 "DLURURD", 'H', '4', '~, 'k', 0, 0, 0, 0, 0, 1*65*1 "DLURULD", 'H','4','K','k', 0, 0, 0, 0, 0, 1*66*1 "DRURDRU", 'q', 'N', '~, 'w', 'm', 'h', 'n', 'u', '@~', 1166 'H', 'A', 1*67*1 "RDLDRDL", 'z', 'B', '3', '{', '}', 'y', 0, 0, 0, 1*68*1 "RDLURDL", 'z', 'B', '3', '~', 0, 0, 0, 0, 0, 1*69*1 "LDRDLDR", '~', 'E', 'a', 'q~, '9', 'u', 0, 0, '@', 1~70*1 "LDRULDR", 'E', 'd', 'a', 'q', '~, 'G', '6', 'o', '2', /*71*/ "LDRULUR", '~, 'G', '8', '9', 'q', 0, 0, 0, 0, WO96141300 2 1 90 1 64 ~ 01ls6 1~72~1 "DRDLURU", 'b', '8', 0, 0, 0, 0, 0, 0, 0, 1~73~1 "URULDRD", '8', 0, 0, 0, 0, 0, 0, 0, 0, 1~74~1 "URDLDRD", 'B', 'R', 'k', 0, 0, 0, 0, 0, 0, 1*75~1 "URDLURD", 'R', 'm', 'M', 'n', 'k', 'd', 0, 0, 0, 1~76~1 "LDRURDL", '&', '9', '5', 'y', 'G', 'b', 0, 0, 0, 1~77~1 "LDRULDL", 'g','G', 0, 0, 0, 0, 0, 0, 0, 1~78~1 "LDRURDR", 'q', 'd', 'a', 'G', 'u', 0, 0, 0, 0, 1~79~1 "DRULDRU", '~, 0, 0, 0, 0, 0, 0, 0, '@', r80~/ "DRURDLD", 'R', 'F', 'k', 0, 0, 0, 0, 0, 0, 1''81~1 "DLURDLD", 'R','F','k', 0, 0, 0, 0, 0, 0, 1*82~1 "DLURDLDR", 'B', 'R', 'k', 'F', 0, 0, 0, 0, 0, 1~83~1 "DRURDLDR", 'B', 'R', 'k', 'F', 0, 0, 0, 0, 0, 1~84~1 "URDLDRDL", 'B', 'R', 'm', 0, 0, 0, 0, 0, 0, 1~85~1 "URDLURDL", 'B','~','m', 0, 0, 0, 0, 0, 0, 1~86~1 "LDRURDLU", 'q', '9', '5', 'G', 0, 0, 0, 0, 0, 1~87~1 "LDRULDLU", 'q', '9', 'G', 0, 0, 0, 0, 0, 0, r88*/ "LDRURDRU", 'q', 'd', 'a', 'G', '~, 0, 0, 0, '@', 1~89~1 "LDRULDRU", 'E', 'd', 'a', 'q', 'f, 'G', '6', 'o', '2' 1189 '@', 'w', };
struct bundle {
ULONG typeCode;
UCHAR syms[BRCHNUM];
} symsTbl[COMPNUM] = {
00~1 101, 'X, '~, 'V', '~', '1', 'K', 'D', 0, 0, 01~/ 102, '+', 'Y', '1', 'T', 'L', 'U', '7', 'X', 't', 02~/ 103, 'D', 'X', 'Y', 'Y', 'D', 'N', 'H', 0, 0, 03~/ 104, '4', 'u', 'd', 'K', '4', '~, 'K', 'X', 'Y', 04~/ 105, '~', 'Y', 'K', 'K', 'X, 'k', 0, 0, 0, 05~/ 106, 'n', 'h', 'Y', 'X', 0, 0, 0, 0, 0, .

~ WO96/41300 21901 64 r~".J~ 0~56 06*/ 10i, 'n', 'h', 0, 0, 0, 0, 0, 0, 0, 07~/ 108, 'K', '4', 'Y', 'u', 'N', 'Y', 0, 0, 0, 08~/ 109, 'K','4','d','9','e', 0, 0, 0, 0, 09~/ 110, 'P', 'b', 'D', 0! ~ ~ ~ l l 10~/ 111, '4','U','P','R','X', 0, 0, 0, 0, 11~/ 115, 'Q', '0', '9', 'P', 'd', 'b', 'H', '4', 'K', 2~ 16, 'Q', '0', '9', 'P', 'd', 'b', 'H', '4', 'K', 3'1/ 117, 'Q', '0', '9', 'P', 'd', 'b', 'H', '4', 'K', 4~/ 118, 'Q', '0', '9', 'P', 'd', 'b', 'H', '4', '~, 5~/ 127, 'B', 0, 0, 0, 0, 0, 0, 0, 0, 6~/ 134, 'M', 0, 0, 0, 0, 0, 0, 0, o, 7~/ 123, 'K', 'Y', 'N', ;4', 'H', 0, 0, 0, 0, 8~/ 1 29, '$', 0, 0, o, o, o, o, o, o, 19~/ 130, '4', 0, 'R', 'I', 0, 0, 0, 0, 0, 20~/ 131, '4', 0, 'R', 0, 0, 0, 0, 0, o, 21~/ 132, 'M', 0, 0, 0, 0, 0, 0, 0, 0, Z~/ 133, 'M','K', 0, 0, 0, 0, 0, 0, 0, 23~/ 136, 'B', 0, 0, 0, 0, 0, 0, 0, o, 24~/ 162, 'M', 0, 0, 0, 0, 0, 0, 0, 0, 25~/ 1 68, '8', 0, 0, 0, 0, 0, 0, 0, 0, 26*/ 169, 'B', 0, 0, 0, 0, 0, 0, 0, 0, 27~/ 202, 'X','~','<','=','Y~, 0, 0, 0, 0, 28~/ 203, 'J', ']', '5', 'T', O, O, O, O, O, 29~/ 204, '[','t','t','4', 0, 0, 0, 0, 0, 30~/ 205, 'F', 'f, '[', 0, o, 0, 0, o, 0, 31~/ 206, '7', '1', ']', '5', 0, 0, 0, 0, 0, 32~/ 207, 'A', '~, '7', '1', 't', 0, 0, 0, 0, 33~/ 208, 'J','5', 0, 0, 0, 0, 0, 0, 0, 34~/ 209, 'E', 't', '4', 'G', 0, 0, 0, 0, o, 35~/ 211, 'Z', 0, 0, 0, 0, 0, 0, 0, 0, .. .. ..

WO96/41300 .~_1/u~ .'0~1i6 219al64 36*/ 212, 'J','5','f, 0, 0, 0, 0, o, o, 37*/ 215, '0', 'Q', 'f, '5', 'G' , 'J', 0, 0, 0, 38*/ 216, '0', 'Q', 0, 0, o, 0, 0, 0, 0, 39*/ 219, 'F', 0, 0, 0, 0, 0, 0, 0, 0, 40*1 220, '7', 0, 0, 0, O, 0. 0, 0, 0, 41*/ 221, '3', '5', '1', 'J', 0, 0, 0, 0, 0, 42*/ 2Z, '1', 0, 0, 0, 0, O, 0, 0, 0, 43*/ 223, 'F', '~, 0, 0, 0, O, 0, 0, 0 44*/ 232, 'A', '7', '1', 'F', 0, 0, 0, 0, O, 45*/ 233, 'A', '7', 'F', 0, 0, 0, 0, 0, 0, 46*/ 235, 't', 0, 0, 0, 0, 0, 0, 0, 0, 47*/ 237, 'G', 'H', 0, 0, 0, 0, 0, 0, 0, 48*1 315, '0', '9', 0, 0, 0, 0, 0, 0, 0, 49*/ 408, 'u', 0, 0, 0, 0, 0, 0, 0, 0.
50*1 409, 'd', O, 0, 0, 0, 0, 0, 0, 0, 51*/ 415, 'a', 'q', 'd', '0', 'Q', 0, 0, 0, 0, 52*/ 506, 'M', 0, 0, 0, 0, 0, 0, 0, 0, 53*1 515, '0', 0, 0, 0, 0, 0, 0, 0, 0, 54*1 532, 'm', 0, 0, 0, 0, 0, 0. 0, 0.
55*1 533, 'm', 0, 0, 0, 0, 0, 0, 0, 0, 56*/ 606, '3', 0, 0, 0, 0, 0, 0, 0, o, 57*1 615, 'Q', '0', 'G', 0, 0, 0, 0, 0, 0, 58*/ 707, 'M', 0, 0, O, 0, 0, 0, 0, 0, 59*/ 808, '~, 0, 0, 0. 0, 0. 0. , , 60*1 909, 'E','4', 0, 0, 0, 0, 0, 0, 0, 61*/ 910, 'x', 'O', 0, 0, 0, 0, 0, 0, 0, 62*1 911, 'a', 0, 0, 0, 0, 0, 0, 0, 0, 63*/ 1010, '3', 0, 0, 0, 0, 0, 0, 0, 0, 64*/ 1515, '8', 0,'9', 0, 0, 0, 0, 0, 0, 65*/ 10101, '~, '*, 'N', 'Y', 0, 0, 0, 0, 0, .. . , .. . _ . _ . .

WO 96/41300 PCT/US96/041!;6 66~/ 10102, 'A', '~, 'K', '4', '1', 'Y', 'H', 'U', 0, 67~/ 10108, 'M', 'K', 0, 0, 0, 0, 0, o, 0, 68~/ 10110, 'R', 'P', 0, 0, 0, 0, 0, 0, 0, 69~/ 10129, '$', 0, 0, 0, 0, o, o, o, o, 70~/ 10202, 'F', 'I', '~, '[', '1', 'K', '~', '0', 0, 71~/ 10210, 'R', 'P', 0, 0, 0, 0, 0, 0, o, 72~/ 10606, 'm', 0, 0, 0, 0, 0, 0, 0, o, 73~/ 10707, 'm', 0, 0, 0, 0, 0, 0, 0, 0, 74~/ 11010, 'B', 0, 0, 0, 0, 0, 0, 0, 0, 75~/ 1 1 51 5, '%', 0, 0, 0, 0, 0, 0, 0, 0, 76~/ 20202, '~, 'H', 'A', '=', 0, 0, 0, 0, 0, 77~/ 20204, 'E', 0, 0, 0, 0, o, 0, 0, 0, 78~/ 20205, 'E', 0, 0, 0, 0, 0, 0, 0, 0, 79~/ 20223, 'E', 0, 0, 0, 0, 0, 0, 0, 0, 80~/ 1020202, 'E', '~, 0, 0, 0, 0, 0, 0, 0, 81~/ 1010202, '#', 'M~, '~, 0, ~O', ~, 0, o, 0, 82~/ 230, 'Z', 0, o, o, 0, o, o, o, o, 83~/ 231, 'Z', 0, o, 0, 0, 0, 0, 0, o, 84~/ 10104, 'K', 0, 0, 0, 0, 0, 0, 0, 0, 85~/ 10204, 'K', 0, 0, 0, 0, 0, 0, 0, 0, 86~/ 120, 'K', 0, 0, 0, 0, 0, 0, 0, 0, 87~/ 1 22, '~, '4', 0, 0, 0, 0, 0, 0, 0, 88~/ 809, 'K', 0, 0, 0, 0, 0, 0, 0, o, 89~/ 10205, '~, 'A', 0, 0, 0, 0, 0, 0, o, 90~/ 170, '&', 0, 0, 0, o, o, o, o, o, 91~/ 171, '&', 0, 0, 0, 0, 0, 0, o, o, 92~/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93~/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 94~/ 112, '$', 0, 0, 0, 0, 0, 0, 0, 0, 95~/ 1010101, 'M', 'V\l, 0, O, O, 0, 0, O, O, . . , ~ . .

W0 96141300 2 1 9 ~) 1 6 4 . ~ 156 96~/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97~/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 98~/ 1112, '}', 'x', 0, 0, 0, 0, 0, 0, o, 99~/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100~/ æg, 0, 0, 0, 0, 0, 0, o, o, o, 101~/ 609, 'G', 0, 0, 0, 0, 0, 0, 0, 0, 102~/ 304, 'Y', 0, 0, 0, 0, 0, 0, 0, 0, 103*/ 119, 'R', 0, 0, 0, 0, 0, o, o, o, 104~/ 158, 'R', 0, 0, 0, 0, 0, o, o, o, 1057 151, 'R', 0, 0, 0, 0, 0, o, o, o, 106~/ 10115, 'R', 0, 0, 0, 0, 0, 0, o, o 107~/ 210, '7', '2', '5', '1', 'A', 0, 0, 0, 0, 108~/ 430, 'E', 0, 0, 0, 0, 0, o, o, o, 109~/ 191, 'i', '!', 'j', ';', 0, 0, 0, o, o, 110~/ 391, 'j', 0, 0, 0, 0, 0, o, o, o, 111~/ 491, 'i', 0, 0, 0, o, o, o, o, o, 112~/ 1991, '?', '?', 0, 0, 0, 0, 0, o, o, 113~/ 9191, ':',';', 0, 0, 0, 0, o, o, o, 114~/ 691, '?', ';', 0, 0, 0, 0, 0, o, o, 115~/ 1091, '?', 'j', ';', 0, 0, 0, 0, o, o, 116~/ 991, 'i', 0, 0, 0, 0, o, o, o, o, 117~/ 10206, 'A', 0, 0, 0, 0, 0, 0, o, o 118~/ 249, 'G', 0, 0, 0, 0, 0, 0, 0, o, 119~/ 1591, j, 0, 0, 0, 0, o, o, o, o .

Claims

What is claimed is:

1. A handwritten character recognition system for use in a data processing system including a tablet and pen for user entry of handwritten characters and a processing unit connected from the tablet and pen for operating upon the user input under control of the character recognition system, the handwritten character recognition system comprising:
a pen input detector for detecting and indicating user inputs through the tablet and pen, the user inputs including pen strokes and pen states, an input cluster buffer connected from the pen input detector for storing stroke descriptor information of a current stroke as the current stroke is entered by the user, a point buffer connected from the input cluster buffer for storing the stroke descriptor information of the current stroke, a point detector connected from the input cluster buffer and responsive to the pen states for transferring the stroke descriptor information of the current stroke into the point buffer, a stroke feature recognizer connected from the point buffer and responsive to the pen states for extracting stroke recognition features from the stroke descriptor information of the current stroke and assigning a meaning to the current stroke, and a cluster recognizer connected from the stroke feature recognizer and responsive to the meaning assigned to each stroke for recognizing and assigning a character meaning to a current cluster of strokes.

2. The handwritten character recognition system of claim 1 wherein the stroke feature recognizer comprises.
a dynamic stroke feature extractor connected from the point buffer and responsive to the pen states for extracting stroke recognition features from the stroke descriptor information of the current stroke as the current stroke is entered by the user, and a static stroke feature extractor connected from the point buffer and responsive to the pen states for extracting stroke recognition features from the stroke descriptor information of the current stroke when the current stroke is completed.

3. The handwritten character recognition system of claim 2 wherein:
the dynamic stroke feature extractor is responsive to a pen down state for dynamically extracting stroke recognition features from the stroke descriptor information of the current stroke as the current stroke is entered by the user.

4. The handwritten character recognition system of claim 2 wherein:
the static stroke feature extractor is responsive to a pen up state for statically extracting stroke recognition features from the stroke descriptor information of the current stroke when the current stroke is completed.

5. The handwritten character recognition system of claim 1 wherein the stroke descriptor information comprises:
for each stroke, a sequence of coordinate points along the line of the stroke, including at least the first and last points of the line of the stroke, and a direction string indicating, for each point of the string, the direction of movement of the line of the stroke at the point.

6. The handwritten character recognition system of claim 5 wherein the stroke feature extractor further comprises:
a segment analyzer for identifying segments of a stroke wherein a segment of a stroke includes at least a beginning point of the segment and an end point of the segment and wherein a segment does not contain a change in direction of movement of the line of the stroke a direction analyzer for identifying changes in the direction of movement of the line of a stroke wherein a change in direction of movement of the line of a stroke occurs when an angle between two lines connecting three consecutive points along the stroke exceeds a predetermined boundary defined by a cone defined by lines extending from any one of the three points the cone lines extending from that point in the direction of movement of the pen at that point and the angle between the cone lines being defined by predetermined displacements along the coordinate axis orthogonal to the coordinate axis along the direction of movement of the pen at that point.

7. The handwritten character recognition system of claim 6 wherein the segment analyzer further comprises:
a segment constructor responsive to the direction analyzer for inserting an additional point at a change in direction of the line of a stroke, the additional point is located at the end point of the segment before the change in direction of the line of the stroke and operating as the beginning point of the segment following the change in direction of the line of the stroke.

8. The handwritten character recognition system of claim 1 wherein the stroke feature recognizer further comprises:
a stroke recognition feature data structure for storing the stroke recognition features extracted from the current stroke wherein the stroke recognition features describe the current stroke with variable degrees of hierarchical approximation, and include the direction string indicating, for points along the line of the stroke, the direction of movement of the line of the stroke at each point.

9. The handwritten character recognition system of claim 8 wherein the stroke recognition features further include:
the coordinates of at least the beginning and end points of the line of the stroke.

10. The handwritten character recognition system of claim 8 wherein the stroke recognition features further include:
an array of coordinates of all points along the line of the stroke as received as input coordinates from the tablet.

11. The handwritten character recognition system of claim 1 wherein the stroke feature recognizer comprises:
a multiple scale stroke representation generator for reading the stroke recognition features from the stroke recognition feature data structure, generating a plurality of scaled topological representations of the current stroke, each scaled topological representation being a progressively smoothed representation of the current stroke generated from the stroke representation features, selecting a scaled topological representation of the current stroke, the scaled topological representation of the current stroke being selected to provide the maximum signal to noise ratio of the stroke representation, a stroke proportion discriminator responsive to the scaled topological representation of the current stroke for storing a list of ideal prototype representations corresponding to possible meanings of the current stroke from a plurality of ideal prototype representations of strokes, and a stroke boundary discriminator responsive to the scaled topological representation of the current stroke and to the ideal prototype representations of the list of ideal prototype representations for comparing the scaled topological representation of the current stroke and boundaries of the ideal prototype representations of the list of ideal prototype representations wherein the boundaries of the ideal prototype representations are determined by linear combinations of features of the ideal prototype representations, and assigning to the current stroke an identification of an ideal prototype representation having boundaries including the scaled topological representation of the current stroke, the assigned identification of the matching ideal prototype representation representing a stroke meaning assigned to the current stroke.

12. The handwritten character recognition system of claim 11 wherein the stroke feature recognizer further comprises:
a stroke recognition feature data structure for storing the stroke recognition features extracted from the current stroke wherein the stroke recognition features describe the current stroke with variable degrees of hierarchical approximation, and include the direction string indicating, for points along the line of the stroke, the direction of movement of the line of the stroke at each point.

13. The handwritten character recognition system of claim 12 wherein the stroke proportion discriminator further generates, for each ideal prototype representation, a corresponding reversed ideal prototype representation having a reversed direction string for use in the comparison of features of the topological representations of the current stroke and of the ideal prototype representations.

14. The handwritten character recognizer of claim 1 wherein the stroke feature recognizer is responsive to the stroke recognition features for assigning a meaning to each current stroke and the cluster recognizer comprises:
a stroke buffer, including a current stroke buffer for storing the strokes of a current cluster of strokes in the time order of their entry, and a previous stroke buffer for storing the strokes of a cluster of strokes immediately preceding the current cluster of strokes, a window buffer for storing a contiguous group of strokes in spatial order according to the coordinates of the strokes of the group, a stroke buffer controller responsive to the stroke feature recognizer for constructing an influence list containing an identification of an area of influence of each stroke of the current cluster of strokes, receiving a current stroke, determining an area of influence of the current stroke, when the area of influence of the current stroke indicates that the current stroke is a part of the current cluster of strokes, writing the current stroke into the current stroke buffer, and when the area of influence of the current stroke indicates that the current stroke is not a part of the current cluster of strokes, transferring the strokes of the current cluster of strokes into the previous stroke buffer, and writing the current stroke into the current stroke buffer to begin a new current cluster of strokes, a stroke buffer scanner for scanning the influence list, and writing the strokes of the current stoke buffer into the window buffer in spatial order, a position discriminator for storing a cluster data structure containing a plurality of cluster meanings, each cluster meaning representing a cluster of strokes and a corresponding meaning assigned to the cluster of strokes, reading combinations of strokes from the window buffer, comparing the combinations of strokes from the window buffer with the cluster meanings stored in the cluster data structure, determining when a combination a strokes from the window buffer corresponds to a cluster meaning, providing as an output an identification of the cluster meaning corresponding to the combination of strokes from the window buffer, removing the combination of strokes from the window buffer, and transferring the combination of strokes from the current cluster buffer to the previous stroke buffer.

15. The handwritten character recognition system of claim 14 wherein:
the stroke buffer controller is responsive to a current stroke having spatial coordinates located between strokes which are previous in time for reordering the strokes in the current and previous stroke buffers, the stroke buffer scanner is responsive to the reordering of the current and previous stroke buffers for rewriting the strokes of the current stoke buffer into the window buffer in a corresponding new spatial order, and the position discriminator is responsive to the rewriting of the window buffer for determining a new cluster meaning from the new combinations of strokes in the window buffer.

16. The handwritten character recognition system of claim 15 wherein the new stroke is an editing gesture and the handwritten character system further comprises:
an editor responsive to the editing gesture for directing the stroke buffer controller to modify the strokes stored in the stroke buffer as indicated by the editing gesture.

17. The handwritten character recognition system of claim 14 wherein a combination of two consecutive strokes comprises an editing command and wherein:

the position discriminator is responsive to the combination of two consecutive strokes comprising an editing command for providing an output indicating the editing command, and the handwritten character recognition system further includes an editor responsive to the editing command for directing the stroke buffer controller to modify the strokes stored in the stroke buffer as indicated by the editing command.

18. In a data processing system including a tablet and pen for user entry of handwritten characters and a processing unit connected from the tablet and pen for operating upon the user input, a method for recognizing handwritten characters, comprising the steps of:
storing stroke descriptor information of a current stroke in a stroke buffer as the current stroke is entered by the user, responsive to the pen states, transferring the stroke descriptor information of the current stroke into a point buffer, extracting stroke recognition features from the stroke descriptor information of the current stroke and assigning a meaning to the current stroke, and recognizing and assigning a character meaning to a current cluster of strokes.

19. The method for recognizing handwritten characters of claim 18, further comprising the steps of:
extracting stroke recognition features from the stroke descriptor information of the current stroke dynamically as the current stroke is entered by the user, and extracting stroke recognition features from the stroke descriptor information of the current stroke when the current stroke is completed.

20. The method for recognizing handwritten characters of claim 19 wherein:

the dynamic extraction of stroke recognition features from the stroke descriptor information of the current stroke as the current stroke is entered by the user is in response to a pen down state.

21. The method for recognizing handwritten characters of claim 19 wherein:
the static extraction of stroke recognition features from the stroke descriptor information of the current stroke when the current stroke is completed is in response to a pen up state.

22. The method for recognizing handwritten characters of claim 18 wherein the stroke descriptor information comprises:
for each stroke, a sequence of coordinate points along the line of the stroke, including at least the first and last points of the line of the stroke, and a direction string indicating, for each point of the string, the direction of movement of the line of the stroke at the point.

23. The method for recognizing handwritten characters of claim 22, further comprising the steps of:
identifying segments of a stroke wherein a segment of a stroke includes at least a beginning point of the segment and an end point of the segment and wherein a segment does not contain a change in direction of movement of the line of the stroke, and identifying changes in the direction of movement of the line of a stroke wherein a change in direction of movement of the line of a stroke occurs when an angle between two lines connecting three consecutive points along the stroke exceeds a predetermined boundary defined by a cone defined by lines extending from any one of the three points, the cone lines extending from that point in the direction of movement of the pen at that point and the angle between the cone lines being defined by predetermined displacements along the coordinate axis orthogonal to the coordinate axis along the direction of movement of the pen at that point.

24. The method for recognizing handwritten characters of claim 23, further comprising the steps of:
inserting an additional point at a change in direction of the line of a stroke, wherein the additional point is located at the end point of the segment before the change in direction of the line of the stroke and operating as the beginning point of the segment following the change in direction of the line of the stroke.

25. The method for recognizing handwritten characters of claim 18, further comprising the steps of:
storing the stroke recognition features extracted from the current stroke, wherein the stroke recognition features describe the current stroke with variable degrees of hierarchical approximation, and include the direction string indicating, for points along the line of the stroke, the direction of movement of the line of the stroke at each point.

26. The method for recognizing handwritten characters of claim 25 wherein the stroke recognition features further include:
the coordinates of at least the beginning and end points of the line of the stroke.

27. The method for recognizing handwritten characters of claim 25 wherein the stroke recognition features further include:

an array of coordinates of all points along the line of the stroke as received as input coordinates from the tablet.

28. The method for recognizing handwritten characters of claim 18, further comprising the steps of:
reading the stroke recognition features from the stroke recognition feature data structure, generating a plurality of scaled topological representations of the current stroke, each scaled topological representation being a progressively smoothed representation of the current stroke generated from the stroke representation features, selecting a scaled topological representation of the current stroke, the scaled topological representation of the current stroke being selected to provide the maximum signal to noise ratio of the stroke representation, storing a list of ideal prototype representations corresponding to possible meanings of the current stroke from a plurality of ideal prototype representations of strokes, comparing the scaled topological representation of the current stroke and boundaries of the ideal prototype representations of the list of ideal prototype representations wherein the boundaries of the ideal prototype representations are determined by linear combinations of features of the ideal prototype representations, and assigning to the current stroke an identification of an ideal prototype representation having boundaries including the scaled topological representation of the current stroke the assigned identification of the matching ideal prototype representation representing a stroke meaning assigned to the current stroke.

29. The method for recognizing handwritten characters of claim 28, further comprising the steps of:
storing the stroke recognition features extracted from the current stroke, wherein the stroke recognition features describe the current stroke with variable degrees of hierarchical approximation, and include the direction string indicating, for points along the line of the stroke, the direction of movement of the line of the stroke at each point.

30. The method for recognizing handwritten characters of claim 29, further comprising the step of:
generating, for each ideal prototype representation, a corresponding reversed ideal prototype representation having a reversed direction string for use in the comparison of features of the topological representations of the current stroke and of the ideal prototype representations.

31. The method for recognizing handwritten characters of claim 18 wherein the stroke feature recognizer is responsive to the stroke recognition features for assigning a meaning to each current stroke and further comprising the steps of:
storing the strokes of a current cluster of strokes in the time order of their entry, storing the strokes of a preceding cluster of strokes, storing a contiguous group of strokes of the current cluster of strokes in spatial order according to the coordinates of the strokes of the group, constructing an influence list containing an identification of an area of influence of each stroke of the current cluster of strokes, receiving a current stroke, determining an area of influence of the current stroke, and when the area of influence of the current stroke indicates that the current stroke is a part of the current cluster of strokes, writing the current stroke into the current cluster of strokes, and when the area of influence of the current stroke indicates that the current stroke is not a part of the current cluster of strokes, transferring the strokes of the current cluster of strokes into the preceding cluster of stroke, and writing the current stroke into a new current cluster of strokes, scanning the influence list, and writing the strokes of the current stoke buffer into the spatially ordered contiguous group of strokes, storing plurality of cluster meanings, each cluster meaning representing a cluster of strokes and a corresponding meaning assigned to the cluster of strokes, reading combinations of strokes from the spatially ordered contiguous group of strokes, comparing the combinations of strokes from the spatially ordered contiguous group of strokes with the cluster meanings, determining when a combination a strokes from the spatially ordered contiguous group of strokes corresponds to a cluster meaning, providing as an output an identification of the cluster meaning corresponding to the combination of strokes from the spatially ordered contiguous group of strokes, removing the combination of strokes from the spatially ordered contiguous group of strokes, and transferring the combination of strokes from the current cluster of strokes to the preceding cluster of strokes.

32. The method for recognizing handwritten characters of claim 30, further comprising the step of:
responsive to a current stroke having spatial coordinates located between strokes which are previous in time, reordering the strokes in the current and preceding clusters of strokes to accommodate the current stroke, rewriting the strokes of the current cluster of strokes into the spatially ordered contiguous group of strokes in a corresponding new spatial order, and determining a new cluster meaning from the new combinations of strokes in the spatially ordered contiguous group of strokes.

33. The method for recognizing handwritten characters of claim 31 wherein the new stroke is an editing gesture, further comprising the step of:
responsive to the editing gesture, modifying the strokes stored in the current and preceding clusters of strokes as indicated by the editing gesture.

34. The method for recognizing handwritten characters of claim 30 wherein a combination of two consecutive strokes comprises an editing command, further comprising the steps of:
responsive to the combination of two consecutive strokes comprising an editing command, providing an output indicating the editing command, and modifying the strokes stored in the current and preceding clusters of strokes as indicated by the editing command.