Patent Description:
In the context of electronic document creation or editing via a touch-based user interface, there is a need to distinguish between gesture strokes, i.e., strokes which are associated with realizing a defined action on the content, and non-gesture strokes, such as actual content (e.g., text, math, shape, etc.) being added by the user.

Existing gesture recognition techniques are rules-based. More specifically, they rely on a manual definition of a set of heuristics for recognizing a defined set of gestures. While the performance of these techniques is generally acceptable, they typically perform poorly for more elaborate/atypical gesture strokes. In addition, the update of these techniques to add new gesture strokes is difficult because of the need to develop new heuristics each time for the new gesture strokes.

Prior-art patent document <CIT> discloses a compass-direction user interface which provides a method and system for entering musical notations in a computing system. A music recognizer associated with the compass-direction user interface receives gestures for translation into a corresponding musical notation. The gestures have a starting and an ending direction. A gesture recognizer recognizes gestures based on its starting and ending directions. The music recognizer receives recognized gestures from the gesture recognizer, references the context in which the gestures are drawn, and selects and appropriate musical notation corresponding to the gesture and context. The compass-direction user interface recognizes gestures based on combinations of compass directions.

Prior-art patent document <CIT> discloses a pen-based editing system for manipulating mathematical expressions. Through a largely gesture based, directly manipulative interface, the system allows a user to make conventional changes to expressions, such as copy and move, and also to work with the expressions in ways peculiar to the problem domain, including, for example, handling ambiguity, expression fragments and alternate recognitions.

Prior-art patent document <CIT> discloses a method and system for recognizing user input information including cursive handwriting and spoken words. A time-delayed neural network having an improved architecture is trained at the work level with an improved method, which, along with preprocessing improvements, results in a recognizer with greater recognition accuracy. Preprocessing is performed on the input data and, for example, may include resampling the data with sample points based on the second derivative to focus the recognizer on areas of the input data where the slope change per time is greatest. The input data is segmented, featurized and fed to the time-delayed neural network which outputs a matrix of character scores per segment. The neural network architecture outputs a separate score for the start and the continuation of a character. A dynamic time warp (DTW) is run against dictionary words to find the most probable path through the output matrix for that word, and each word is assigned a score based on the least costly path that can be traversed through the output matrix. The word (or words) with the overall lowest score (or scores) are returned. A DTW is similarly used in training, whereby the sample ink only need be labeled at the word level.

The present invention, as defined by the appended claims, addresses some of the recognized deficiencies of the prior art.

In the following, embodiments not falling under the terms of the claims are mere examples useful for understanding the invention.

Specifically, the present invention proposes a method for recognizing gesture strokes in user input applied onto an electronic document via a touch-based user interface, comprising:.

The stroke classifier may be implemented as a neural network. The use of a neural network means that a new gesture stroke can be added easily with simple retraining of the stroke classifier on data including the new gesture stroke.

According to embodiments, the electronic document may include handwritten content and/or typeset content.

The sub-stroke segmentation allows for a sequential representation that follows the path of the stroke to be obtained. Each segment corresponds as such to a local description of the stroke. Compared to representing the stroke as a mere sequence of points, sub-stroke segmentation permits to maintain path information (i.e., the relationships between points within each segment) which results in a reduction in computation time.

In an embodiment, the stroke classifier is implemented as a recurrent Bidirectional Long Short-Term Memory (BLSTM). The use of a recurrent BLSTM neural network means that the network includes memory blocks which enable it to learn long-term dependencies and to remember information over time. This type of network permits the stroke classifier to handle a sequence of vectors (an entire stroke) and to account for the temporal dependencies between successive sub-strokes (i.e., to remember the details of the path of the stroke).

In an embodiment, the method further comprises generating a plurality of corrected timestamps based on the plurality of timestamps.

The correction of the plurality of timestamps is advantageous to remove artifacts related to device capture and to improve gesture stroke recognition. Indeed, due to device capture issues, it is common that certain timestamps do not correspond to the exact instants at which their respective ink points are drawn. For example, in certain devices, the timestamps assigned to ink points correspond to the time at which an event log containing the ink points is sent to a processor unit, not the precise instants at which the ink points are captured. As such, different successive ink points can have the same timestamp value in the received data. Correction of the plurality of timestamps ensures that the timestamps better reflect the exact instants at which the respective ink points are drawn by the user. Improved gesture recognition is thereby achieved.

In an embodiment, generating the plurality of corrected timestamps based on the plurality of timestamps comprises:.

In an embodiment, the method further comprises resampling the plurality of ink points to generate a second plurality of ink points and an associated second plurality of timestamps,.

Resampling the plurality of ink points is advantageous to ensure uniform performance across different devices. Indeed, as devices typically use different sampling techniques, the data received may differ in terms of sampling characteristics between devices.

In an embodiment, the second plurality of timestamps are characterized by a fixed duration between consecutive timestamps.

In an embodiment, the resampling comprises interpolating the plurality of ink points and associated plurality of timestamps to generate the second plurality of ink points and the associated second plurality of timestamps.

In an embodiment, the segmenting of the plurality of ink points comprises segmenting the plurality of ink points such that the plurality of segments have equal duration. Alternatively or additionally, the plurality of segments may have an equal number of ink points. Improved recognition accuracy was shown to result from using one or more of these segmentation techniques.

In an embodiment, generating the plurality of feature vectors based respectively on the plurality of segments comprises, for each segment of the plurality of segments corresponding to a respective sub-stroke:.

The content that neighbors the sub-stroke may be defined as content that intersects a window centered with respect to the sub-stroke.

According to this embodiment, the feature vector associated with a sub-stroke describes both the shape of the sub-stroke and the content in which the sub-stroke is drawn. These two types of information are complementary and allow for a highly accurate recognition of the stroke as a gesture stroke or a non-gesture stroke.

In an embodiment, generating the geometric features comprises generating statistical sub-stroke geometric features and/or global sub-stroke geometric features for the sub-stroke. The statistical sub-stroke geometric features are features derived from statistical analysis performed on individual ink point geometric features. The global sub-stroke geometric features are features that represent the overall sub-stroke path (e.g., length, curvature, etc.).

In an embodiment, generating the statistical sub-stroke geometric features comprises, for each geometric feature of a set of geometric features:.

In an embodiment, generating the global sub-stroke geometric features for the sub-stroke comprises computing one or more of: a sub-stroke length, a count of singular ink points within the sub-stroke, and a ratio between the sub-stroke length and a distance between a first and a last ink point of the sub-stroke.

In an embodiment, generating the neighborhood features comprises generating one or more of:.

In another aspect, the present invention provides a computing device, comprising:.

In an embodiment, any of the above-described method embodiments may be implemented as instructions of a computer program. As such, the present disclosure provides a computer program including instructions that when executed by a processor cause the processor to execute a method according to any of the above-described method embodiments.

The computer program can use any programming language and may take the form of a source code, an object code, or a code intermediate between a source code and an object code, such as a partially compiled code, or any other desirable form.

The computer program may be recorded on a computer-readable medium. As such, the present disclosure is also directed to a computer-readable medium having recorded thereon a computer program as described above. The computer-readable medium can be any entity or device capable of storing the computer program.

Further features and advantages of the present invention will become apparent from the following description of certain embodiments thereof, given by way of illustration only, not limitation, with reference to the accompanying drawings in which:.

Systems and methods for recognizing gesture strokes in user input applied onto an electronic document via a touch-based user interface are disclosed herein.

<FIG> illustrates an example process <NUM> for recognizing gesture strokes in user input applied onto an electronic document via a touch-based user interface according to an embodiment of the present invention.

According to embodiments, a gesture stroke is a stroke having particular characteristics or attributes and which is intended to realize a corresponding action on content. In an embodiment, six gesture strokes are defined and used. These correspond to the following actions: Scratch-out (an erase gesture having a zigzag or a scribble shape), Strike-through (an erase gesture performed with a line stroke; the line stroke can be horizontal, vertical, or slanted), Split (a gesture to split a single word into two words, or a single line into two lines, or a single paragraph into two paragraphs), Join (a gesture to join two words into a single word, or two lines into a single line, or two paragraphs into a single paragraph), Surround (a gesture to surround content), and Underline. For the purpose of illustration, <FIG> illustrates a Split gesture stroke and a Join gesture stroke according to an example embodiment. As would be understood by a person of skill in the art based on the teachings herein, embodiments are not limited to having six gesture strokes and more or fewer gesture strokes may be defined and used.

In contrast, an add-stroke (non-gesture stroke) is any stroke that is not one of the defined gesture strokes. A non-gesture stroke may correspond to content being added by the user.

According to embodiments, gesture strokes are recognized in user input applied onto an electronic document via a touch-based user interface. Without limitation, the user input may be applied by a fingertip or a stylus pen, for example, onto the touch-based user interface. The electronic document may include handwritten content and/or typeset content. The touch-based user interface may be of any type (e.g., resistive, capacitive, etc.) and may be an interface to a computer, a mobile device, a tablet, a game console, etc..

As shown in <FIG>, example process <NUM> includes steps <NUM>, <NUM>, <NUM>, and <NUM>. However, as further described below, in other embodiments, process <NUM> may include additional intervening or subsequent steps to steps <NUM>, <NUM>, <NUM>, and <NUM>.

In an embodiment, process <NUM> begins in step <NUM>, which includes receiving data generated based on the user input applied onto the electronic document via the touch-based user interface.

The received data represents a stroke applied by the user and comprises a plurality of ink points and a plurality of timestamps associated respectively with the plurality of ink points. The plurality of ink points are localized in a rectangular coordinate space (defined based on a screen of the touch-based user interface) with each ink point being associated with (X,Y) coordinates in the rectangular coordinate space.

In an embodiment, the received data corresponds to data generated by the touch-based user interface and associated circuitry in response to capture of the stroke applied by the user. Different touch-based user interfaces may capture the stroke differently, including using different input sampling techniques, different data representation techniques, etc. In an embodiment, where the data received from the touch-based user interface is of a different format than the ink point format used by the present invention, the received data is converted such as to generate a plurality of ink points and a respective plurality of timestamps therefrom.

In an embodiment, process <NUM> may further include correcting the plurality of timestamps contained in the received data to generate a plurality of corrected timestamps. The plurality of corrected timestamps are then associated with the plurality of ink points and used instead of the original timestamps for the remainder of process <NUM>.

In an embodiment, correction of the plurality of timestamps is advantageous to remove artifacts related to device capture and to improve gesture stroke recognition. Indeed, due to device capture issues, it is common that certain timestamps do not correspond to the exact instants at which their respective ink points are drawn. For example, in certain devices, the timestamps assigned to ink points correspond to the time at which an event log containing the ink points is sent to a processor unit, not the precise instants at which the ink points are captured. As such, different successive ink points can have the same timestamp value in the received data. Correction of the plurality of timestamps ensures that the timestamps better reflect the exact instants at which the respective ink points are drawn by the user. Improved gesture recognition is thereby achieved.

In an embodiment, the correction of the plurality of timestamps is done by using a function that approximates an original timestamp curve of the plurality of ink points. The approximating function may be a linear function, though embodiments are not limited as such.

<FIG> illustrates a linear function <NUM> which approximates an original timestamp curve <NUM> according to an example. The original timestamp curve <NUM> provides for each of a plurality of ink points (numbered <NUM> to <NUM> as given by the X-axis) a corresponding timestamp (between <NUM> and <NUM> as given by the Y-axis). As shown, the original timestamp curve <NUM> is a step function, reflecting that multiple successive ink points have the same timestamp value. As discussed before, this may be due to device capture issues.

The linear function <NUM> is a linear approximation of the original timestamp curve <NUM>. In an embodiment, the linear function <NUM> is the best-fitting function to the original timestamp curve <NUM>. For example, the linear function <NUM> is obtained by Least Squares fitting to the original timestamp curve <NUM>.

The correction of a timestamp associated with an ink point includes modifying the timestamp associated with the ink point as provided by the original timestamp curve <NUM> to a corresponding value obtained by projecting the ink point onto the linear function <NUM>.

In an embodiment, process <NUM> may further include resampling the plurality of ink points to generate a second plurality of ink points and an associated second plurality of timestamps. The resampling may be performed based on the original or the corrected timestamps. The second plurality of ink points and the second plurality of timestamps are then used for the remainder of process <NUM>.

Resampling the plurality of ink points is advantageous to ensure uniform performance across different devices. Indeed, as devices typically use different sampling techniques, the data received in step <NUM> may differ in terms of sampling characteristics between devices.

Different resampling techniques may be used: temporal, spatial, or both. In an embodiment, resampling according to a temporal frequency is used, resulting in the second plurality of timestamps being characterized by a fixed duration between consecutive timestamps.

Returning to <FIG>, in step <NUM>, process <NUM> includes segmenting the plurality of ink points into a plurality of segments each corresponding to a respective sub-stroke of the stroke represented by the received data. Each sub-stroke comprises a respective subset of the plurality of ink points representing the stroke.

The insight behind sub-stroke segmentation is to obtain a sequential representation that follows the path of the stroke. Each segment corresponds as such to a local description of the stroke. Compared to representing the stroke as a mere sequence of points, sub-stroke segmentation permits to maintain path information (i.e., the relationships between points within each segment) which results in a reduction in computation time.

Different sub-stroke segmentation techniques may be used according to embodiments. In an embodiment, sub-stroke segmentation based on temporal information is used, resulting in the plurality of segments having equal duration. In an embodiment, the same segment duration is used for all strokes. Further, the segment duration may be device independent.

In an embodiment, where the plurality of ink points are resampled according to a temporal frequency, the subsequent segmentation of the plurality of ink points based on temporal information (i.e., into equal duration segments) corresponds to splitting the stroke into a plurality of segments having an equal number of ink points (with same durations but potentially with different lengths). <FIG> illustrates an example stroke <NUM> corresponding to an Underline gesture stroke. The data corresponding to stroke <NUM> is resampled according to a temporal frequency resulting in ink points <NUM> with a fixed duration between consecutive timestamps. The resampled ink points <NUM> are then split into sub-strokes of equal segment duration, defined by ink points <NUM>. As such, the stroke <NUM> is split into segments having an equal number of ink points as shown in <FIG>.

Returning to <FIG>, in step <NUM>, process <NUM> includes generating a plurality of feature vectors based respectively on the plurality of segments.

In an embodiment, step <NUM> includes, for each segment of the plurality of segments which corresponds to a respective sub-stroke of the stroke: generating geometric features that represent the shape of the respective sub-stroke; and generating neighborhood features that represent spatial relationships between the sub-stroke and content that neighbors the sub-stroke.

In an embodiment, the content that neighbors the sub-stroke is content that intersects a window centered with respect to the sub-stroke. The window size may be configured in various ways. In one embodiment, the window size is set proportionally to the mean height of characters and/or symbols in the electronic document. In another embodiment, if the electronic document contains no characters or symbols, the window size is set proportionally to the size of the touch-based user interface (which may correspond to the screen size of the device).

In an embodiment, generating the geometric features associated with a segment or sub-stroke includes generating statistical sub-stroke geometric features and/or global sub-stroke geometric features.

In an embodiment, the statistical sub-stroke geometric features are features derived from statistical analysis performed on individual ink point geometric features.

In an embodiment, a set of individual geometric features of interest to be computed per ink point of the segment is defined. The set of individual geometric features may describe for example geometric relationships between the (current) ink point and the previous ink point in the segment, the next ink point in the segment, the first ink point in the stroke, and/or a center of gravity of the stroke (obtained by averaging the X and Y coordinates of the ink points of the stroke).

In an embodiment, the set of individual geometric features may include: the absolute distance "ds" between the current ink point and the previous ink point in the segment (shown in <FIG>); the projections "dx" and "dy" on the X and Y axes respectively of the distance "ds" (shown in <FIG>); a measure of the curvature at the current ink point, represented in an embodiment illustrated in <FIG>, by the values cos <NUM>, sin θ, and θ, where θ is the angle formed between the line connecting the previous ink point to the current ink point and the line connecting the current ink point to the next ink point; the projections "dx_s" and "dy_s" on the X and Y axes respectively of the distance between the current ink point and the first ink point in the stroke (shown in <FIG>); and the projections "dx_g" and "dy_g" on the X and Y axes respectively of the distance between the current ink point and the center of gravity of the stroke (shown in <FIG>).

In an embodiment, for each feature of the set of individual geometric features, the feature is determined over all ink points of the segment (where appropriate) to determine respective values for the ink points of the segment. Then, one or more statistical measures are calculated, for each feature, based on the determined respective values corresponding to the feature. In an embodiment, for each feature, the minimum value, the maximum value, and the median value are obtained based on the determined respective values corresponding to the feature.

In an embodiment, the one or more statistical measures, computed over all features of the set of individual geometric features, correspond to the statistical sub-stroke geometric features for the sub-stroke.

The global sub-stroke geometric features are features that represent the overall sub-stroke path (e.g., length, curvature, etc.). In an embodiment, generating the global sub-stroke geometric features for a sub-stroke comprises computing one or more of: a sub-stroke length, a count of singular ink points (such as inflection points and/or crossing points (a crossing point being a point where the stroke intersects itself)) within the sub-stroke, and a ratio between the sub-stroke length and a distance between its first and last ink points.

In an embodiment, the geometric features associated with a segment or sub-stroke includes both statistical sub-stroke geometric features and global sub-stroke geometric features determined based on the sub-stroke.

As mentioned above, the neighborhood features associated with a segment or sub-stroke represent spatial relationships between the sub-stroke and content that neighbors the sub-stroke. This information is useful to eliminate ambiguity between different gesture strokes. For example, as shown in <FIG>, a Strike-through gesture stroke and an Underline gesture stroke can have similar shapes and as such similar geometric features. However, when the position of the stroke relative to its neighboring content is considered (i.e., whether or not the stroke is below the baseline of the characters or words), distinction between the two gesture strokes become much easier.

As mentioned above, in an embodiment, the content that neighbors the sub-stroke is content that intersects a window centered with respect to the sub-stroke. The window size may be configured in various ways. In one embodiment, the window size is set proportionally to the mean height of characters and/or symbols in the electronic document. In another embodiment, if the electronic document contains no characters or symbols, the window size is set proportionally to the size of the touch-based user interface (which may correspond to the screen size of the device).

In an embodiment, the three types of neighborhood features (textual, mathematical, and non-textual) are independent of one another. Each type may have its own fixed number of features.

<FIG> illustrates an example approach for generating textual neighborhood features for a sub-stroke according to an embodiment of the present invention. As shown in <FIG>, the approach includes selecting a neighborhood window centered at the sub-stroke and then dividing the neighborhood window into four regions around the sub-stroke center. The four regions may be determined by the intersecting diagonals of the neighborhood window.

Next, the four closest characters and/or the four closest words located at the left, right, top, and bottom of the sub-stroke (which are at least partly contained within the selected window) are identified. For example, a text recognizer, as described in <CIT>, may be used to identify the closest characters and/or words. In the example of <FIG>, the selected neighborhood window contains characters only and as such only characters are identified. Specifically, a left character, a top character, and a right character are identified.

Next, for each identified character or word, a group of features are determined. In an embodiment, the group of features include the distance between the center of the sub-stroke and a center of the identified character or word (the center of the identified character or word being the center of a bounding box of the identified character or word); the projections on the X and Y axes respectively of said distance; the distance between the center of the sub-stroke and a baseline of the identified characters or words; and the distance between the center of the sub-stroke and a midline of the identified characters or words. The baseline is the imaginary line upon which a line of text rests. The midline is the imaginary line at which all non-ascending letters stop. In an embodiment, the baseline and the midline are determined and provided by a text recognizer to the gesture recognizer.

In an embodiment, if no character or word is identified in a given region (e.g., no bottom character or word in the example of <FIG>), default values are used for the textual neighborhood features corresponding to the region.

As would be understood by a person of skill in the art based on the teachings herein, the neighborhood window is not limited to a square window as shown in <FIG> and may be rectangular. Further, the neighborhood window may be divided into more or fewer than four regions in other embodiments. As such, more or fewer than four closest characters and/or four closest words may be identified.

Mathematical neighborhood features and non-textual neighborhood features for a sub-stroke may also be generated according to the above-described approach, with mathematical or non-textual content identified instead of textual content.

In an embodiment, for mathematical neighborhood features, the closest mathematical symbols to the sub-stroke (e.g., four closest at the left, right, top, and bottom of the sub-stroke) are identified. For example, a math symbol recognizer, as described in <CIT>, may be used to identify the closest mathematical symbols. The features determined per identified symbol may include the projections on the X and Y axes of the distance between the center of the sub-stroke and the center of the symbol. As above, when a region does not include a mathematical symbol, the corresponding features are set to default values.

In an embodiment, for the non-textual neighborhood features, the closest shapes and primitives (parts of shapes) to the sub-stroke (e.g., four closest at the left, right, top, and bottom of the sub-stroke) are identified. For example, a shape recognizer, as described in <CIT> or <CIT>, may be used to identify the closest shapes and primitives. The features determined per identified shape or primitive may include the distance between the center of the sub-stroke and the center of the shape or primitive. As above, when a region does not include a shape or primitive, the corresponding features are set to default values.

In an embodiment, the feature vector associated with a segment or sub-stroke includes both geometric features and neighborhood features as described above. As such, the feature vector describes both the shape of the sub-stroke and the content in which the sub-stroke is drawn. These two types of information are complementary and allow for a highly accurate recognition of the stroke as a gesture stroke or a non-gesture stroke.

At the end of step <NUM>, the entire stroke is represented by a plurality of successive feature vectors (each vector corresponding to a respective sub-stroke of the stroke).

Returning to <FIG>, in step <NUM>, process <NUM> includes applying the plurality of feature vectors as an input sequence representing the stroke to a trained stroke classifier to generate a vector of probabilities, which include a probability that the stroke is a non-gesture stroke and a probability that the stroke is a given gest ure stroke of a set of gesture strokes. As mentioned above, the set of gesture strokes includes pre-defined gesture strokes such as Scratch-out, Strike-through, Split, Join, Surround, and Underline. In an embodiment, step <NUM> may include determining the respective probabilities that the stroke is a gesture stroke for all gesture strokes of the set of gesture strokes (e.g., the probability that the stroke is a Scratch-out gesture stroke, the probability that the stroke is a Strike-through gesture stroke, etc.).

<FIG> illustrates an example stroke classifier <NUM> according to an embodiment of the present invention. As mentioned above, the stroke classifier is trained before use for inference. An example approach which can be used to train the stroke classifier is described further below.

As shown in <FIG>, example stroke classifier <NUM> includes a recurrent Bidirectional Long Short-Term Memory (BLSTM) neural network <NUM>. Neural network <NUM> includes backward layers <NUM> and forward layers <NUM>. Detailed description of the functions that may be used for backward layers <NUM> and forward layers <NUM> can be found in "<NPL>"; "<NPL>," and "<NPL>. " Implementation of backward layers <NUM> and forward layers <NUM> are within the skill and knowledge of a person skilled in the art and will not be described herein.

The use of a recurrent BLSTM neural network means that network includes memory blocks which enable it to learn long-term dependencies and to remember information over time. In the context of gesture recognition, this network permits the stroke classifier to handle a sequence of vectors (an entire stroke) and to account for the temporal dependencies between successive sub-strokes (i.e., to remember the details of the path of the stroke).

In addition, example stroke classifier <NUM> includes an output layer <NUM> configured to generate a set of probabilities <NUM>-<NUM>, <NUM>-<NUM>,. , <NUM>-k based on the outputs of backward layers <NUM> and forward layers <NUM>. In an embodiment, output layer <NUM> may be implemented using a cross-entropy objective function and a softmax activation function, which is a standard implementation for <NUM> of K classification tasks. A detailed description of such an implementation can be found for example in <NPL>.

In operation, a sequence including a plurality of feature vectors t<NUM>,. , tn representing a stroke is applied as an input sequence to neural network <NUM>. As shown in <FIG>, and also described above, each feature vector ti (representing a sub-stroke) includes a geometric descriptor (corresponding to the geometric features described above) and a neighborhood descriptor (corresponding to the neighborhood features, including the textual, mathematical, and non-textual neighborhood features described above).

The input sequence is fed into neural network <NUM> both forwards and backwards by virtue of the bi-directionality of network <NUM>. In an embodiment, the input sequence is fed in its original order (i.e., t<NUM> then tt then t<NUM>, etc.) to forward layers <NUM>, and in the reverse order (i.e., tn then tn-<NUM> then tn-<NUM>, etc.) to backwards layer <NUM>. This permits the network <NUM> to process the stroke data both by considering previous information (information relating to past sub-strokes) and by considering following information (information relating to next sub-strokes).

Output layer <NUM> receives the outputs of backward layers <NUM> and forward layers <NUM> and generates the set of probabilities <NUM>-<NUM>, <NUM>-<NUM>,. In an embodiment, output layer <NUM> sums up the activation levels from both layers <NUM> and <NUM> to obtain the activation levels of nodes of output layer <NUM>. The activation levels of the nodes of output layer <NUM> are then normalized to add up to <NUM>. As such, they provide a vector with the set of probabilities <NUM>-<NUM>, <NUM>-<NUM>,. In an embodiment, as shown in <FIG>, probability <NUM>-<NUM> corresponds to the probability that the stroke is an add-stroke or a non-gesture stroke. Probabilities <NUM>-<NUM>,. , <NUM>-k each corresponds to a respective probability that the stroke is a respective gesture stroke of the set of gesture strokes.

In an embodiment, the gesture is recognized as being a particular gesture stroke (e.g., Underline) if the probability associated with the particular gesture stroke represents the maximum probability among the set of probabilities <NUM>-<NUM>, <NUM>-<NUM>,. Otherwise, if the probability associated with a non-gesture stroke is the maximum, the stroke will be considered a non-gesture stroke or an add-stroke.

In an embodiment, the stroke classifier is trained based on a set of training data specifically tailored for the stroke recognition task. As the stroke classifier is intended to distinguish between gesture strokes and non-gesture strokes, in an embodiment, the training data includes both gesture strokes (e.g., Underlines, Strike-throughs, etc.) and non-gesture strokes (e.g., text, math symbols, non-text strokes).

In an embodiment, the training data is built by imitating real use cases. Specifically, using a dedicated protocol for data collection, users are asked to copy notes (the original notes can be handwritten or typeset) to generate handwritten electronic notes. An example original note and a handwritten electronic copy thereof created by a user are shown in <FIG> respectively. Then, the user is shown another version of the original note with additional strokes applied (the additional strokes may be applied to different types of content in the note) and is asked to reproduce this version. For example, <FIG> illustrates another version of the original note of <FIG> with some content highlighted. In <FIG>, the user reproduces this version by double-underlining the highlighted content. The stroke data is captured as the user reproduces the modified content to be used in training.

Using the above approach, notes with various layouts (simple, multi-column, with/without separators, with or without title, etc.) and with various content types (text, tables, diagrams, equations, geometry, etc.) may be generated. Additionally, various languages and scripts may be used. For example, users of different countries may be invited to copy notes in their native languages and to perform strokes on these notes.

Additionally, different touch-based devices (e.g., iPad, Surface, etc.) may be used to generate the notes. This allows the classifier to be trained on data generated using different ink capture characteristics (e.g., different sampling rates, different timestamp generation methods, different pressure levels applied, etc.), which renders the classification more device independent.

The training data may also include notes generated in order to train the stroke classifier to perform on typeset documents. In an embodiment, these notes are generated by converting the produced handwritten notes into typeset versions by replacing each ink element (character, symbol, shape, or primitive) in the handwritten note with a respective model that corresponds to the path of the ink element. In an embodiment, for each ink element, its corresponding typeset model is rescaled to fit into a bounding box of the original ink element, and then positioned with respect to the baseline and the center of the corresponding ink element. <FIG> illustrates an example handwritten note and a corresponding typeset version generated according to this approach.

The stroke data captured for the handwritten notes is then applied onto the respective typeset versions.

<FIG> illustrates a computer device <NUM> which may be used to implement embodiments of the present invention. As shown in <FIG>, computer device <NUM> includes a processor <NUM>, a read-only memory (ROM) <NUM>, a random access memory (RAM) <NUM>, a non-volatile memory <NUM>, and communication means <NUM>. The ROM <NUM> of the computer device <NUM> may store a computer program including instructions that when executed by processor <NUM> cause processor <NUM> to perform a method of the present invention. The method may include one or more of the steps described above in <FIG>.

Claim 1:
A method of training a stroke classifier (<NUM>) for recognizing gesture strokes in user input applied onto an electronic document, comprising:
generating training data by
generating electronic notes by handwriting, via a touch-based user interface, electronic notes comprising ink elements;
converting the ink elements of the handwritten electronic notes into typeset versions;
capturing stroke data for the handwritten electronic notes and applying the captured stroke data onto the typeset versions as training data, wherein said training data includes gesture strokes and non-gesture strokes;
training the stroke classifier based on the training data.