Build custom resources
This page describes how to build custom recognition resources to finetune the recognition.
How to build resources
This is a twostep process: You should first prepare a resource file. This file is a UTF8encoded file containing dedicated resources information.
For Text recognition, possible resources are lexicon and subset knowledge. Lexicon files should have a .txt
or a .lex
extension, whereas subset knowledge files should have a .txt
or a .sk
one.
For Math recognition, you can set up your math grammar defining the symbols and rules. They shall be saved in a .txt
or .def
file.
Once you have writen your resource file, you must compile it to generate the corresponding binary .res
file.
How to compile resources
Via the Developer Portal
MyScript Developer Portal comes with an online tool that lets you compile your own resources files.
Ondevice
MyScript iink SDK also comes with a builtin tool to generate text lexicons and math grammars (respectively
choose "Text Lexicon"
and "Math Grammar"
as the target asset type).
The workflow is as follows:
 Create a
RecognitionAssetsBuilder
object from your engine.  Call its
compile()
method, passing it the right information. 
Serialize the resource into a file using the
store()
method.  Reference the new resource in your configuration file
 Update your engine or editor configuration if needed (it may not be needed if you keep the same configuration bundle and name)
 Create a new part and associate it with an editor
For example, to compile a math grammar, steps 1 to 3 will look as follows:
// 1. Create a recognition assets builder
RecognitionAssetsBuilder assetsBuilder = engine.createRecognitionAssetsBuilder();
// 2. Define and compile the grammar
String grammar = "...";
assetsBuilder.compile("Math Grammar", grammar);
// 3. Save it to the disc
String internalStoragePath = getBaseContext().getFilesDir().getPath();
File file = new File(internalStoragePath, File.separator + "customisedgrammar.res");
assetsBuilder.store(file.getPath());
Step 4 consists in editing our math configuration (or create a new one) to load our custom grammar instead of the standard one:
AddResource math/customgrammar.res
You can get the list of recognition assets types that can be compiled via the getSupportedRecognitionAssetsTypes()
method of the
RecognitionAssetsBuilder
object.
Text
Lexicon
The lexicon is a list of words or expressions that is being used by the engine to recognize a specific set of terms. You can create your own lexicon to improve the recognition. It may contain terms that are unlikely to appear in a classical dictionary but that you will be led to write many times (proper nouns like the name of your company or your employees, your password, a hashtag, etc.).
For example, a lexicon can be the following set:
Johnson
Meyer
Lopez
Gibbons
Cooper
Martin
Bailey
If needed, you can also download another Lexicon example.
Subset knowledge
The Subset Knowledge resource (or SK) is a white list that works as a filter to constrain the recognition to a specific set of characters. You can create your own SK to improve the recognition and help the engine reduce the “margin of error”. The expected set can be limited to digits or to letters in a given alphabet or language.
For example: In a form field where you expect a phone number, constraining the recognition with a SK could avoid the engine to mistake a “0” for a “O” or a “1” for a “l”.
See below examples of SK resources:
0123456789
If needed, you can download another SK example.
Math
Grammar resource
The grammar resource indicates the way to parse handwritten mathematical expressions. It specifies:

a limited set of terminal symbols,
Terminal symbols are the elementary symbols. They are basic symbols such as a, b, c, …, 0, 1, …, +, , ±, etc. that cannot be broken down into “smaller” recognized units. See below the list of supported symbols. 
a limited set of nonterminal symbols,
Nonterminal symbols describe groups of terminal symbols organized according to rules. 
a limited set of rules,
Rules describe the way to parse digital ink. For instance, a fraction is a rule that contains a numerator, a fraction bar and a denominator. The recognizer expects to find these three elements to fit the fraction rule. See below the list of supported rules. 
a start symbol.
This defines the way your mathematical expression should be read depending on the above elements.
For example, a grammar resource can be:
symbol = 0 1 2 3 4 5 6 7 8 9 +  / ÷ = . , %  ( ) : * x
leftpar = (
rightpar = )
currency_symbol = $ R € ₹ £
character ::= identity(symbol)
 identity(currency_symbol)
fractionless ::= identity(character)
 fence (fractionless, leftpar, rightpar)
 hpair(fractionless, fractionless)
fractionable ::= identity(character)
 fence (fractionable, leftpar, rightpar)
 hpair(fractionable, fractionable)
 fraction(fractionless, fractionless)
expression ::= identity(character)
 fence (expression, leftpar, rightpar)
 hpair(expression, expression)
 fraction(fractionable, fractionable)
start(expression)
If needed, you can download another Grammar example.
Grammar syntax
You can build your own MyScriptMathcompliant grammar resource. To do so, you must define the grammar in conformity with the syntax set out below and then compile it.
You can add comments in a grammar resource as follows:
// This is the first way to start a whole comment line.
# This is the second way to start a whole comment line.
" This is the third way to start a whole comment line.
/* This is a block comment. */
Inline comments are not supported.
Your grammar resource will contain terminal symbol definitions such as the following:
my_terminal_name = 0 1 2 3 4 5 6 7 8 9

The terminal symbol name is defined as: [azAZ_][azAZ_09]
It is a character string which starts with a character from [azAZ_] and whose other characters are any of [azAZ_09]. In the above example, the terminal symbol name ismy_terminal_name
. 
The list of symbols referred to by the terminal name are defined as: ( ( !EOL . )+  EOL space+ )+
The definition of the symbols referred to by the terminal name does not start by a EOL (end of line). They can be any existing character separated by a space or EOL and a space. In other words, the definition of the symbols is allowed to span multiple lines, providing that the “continuation line” starts with a space. This means you can format long terminal symbol definitions in a more visually organized (“prettyformatted”) manner. In the above example, the list of symbols referred to bymy_terminal_name
is0 1 2 3 4 5 6 7 8 9
. 
Space is defined as ‘ ’ or ‘\t’

EOL is defined as ‘\r\n’ or ‘\n’ or ‘\r’
You will also need to list nonterminal symbol definitions. Here is an example:
my_non_terminal_name ::= fraction(my_terminal_name,my_terminal_name)
 The nonterminal symbol name is defined as : [azAZ_][azAZ_09]
It is a character string which starts with a character from [azAZ_] and whose other characters are any of [azAZ_09]. In the above example, the nonterminal symbol name ismy_non_terminal_name
.
The nonterminal symbol is defined as: non_terminal_name ::= rule ( rule)?
In the above example, the rule is fraction
. The example specifies that the numerator is a my_terminal_name
symbol and that
the denominator is also a my_terminal_name
symbol.
Rule continuations allow you to “pretty format” rule definitions by avoiding a repetition of target nonterminal symbol names.
Finally, your grammar must include the start symbol definition:
start(my_non_terminal_name)
Finally, you must define the start symbol.
In the above example, we specify that the general mathematical expression form that will be recognized is my_non_terminal_name
.
In other words, we expect the input digital ink to represent a fraction of digits.
Here is an example of a custom grammar:
Supported symbols and rules
A nonexhaustive list of supported math symbols and rules can be found here.
It is also possible to create a custom grammar resource, by constraining the recognition for particular use cases (integral calculus, vector calculus, finite element calculus, etc.).
The following table provides for each supported math rule its denomination in the grammar as well as the parameters it supports:
Rule  Visual structure  Syntax  Explanation 

Identity  N/A  identity(source) 
Reuse a previously defined symbol in a rule clause 
Horizontal pair  hpair(left, right) 
Ordered juxtaposition of the left and right expressions 

Fence  fence(exp, left, right) 
exp is placed between the left and right symbols 

Left fence  leftfence(exp, symbol) 
symbol is positioned at the left of exp . This allows for instance defining systems 

Square root  sqrt(exp) 
exp is placed under the square root 

Fraction  fraction(numerator, denominator) 
numerator is divided by denominator


Subscript  subscript(exp, index) 
index is placed as subscript at the right of exp


Superscript  superscript(exp, exponent) 
exponent is placed as superscript at the right of exp


Subsuperscript  subsuperscript(exp, index, exponent) 
index and exponents are respectively placed as subscript and superscript at the right of exp


Presuperscript  presuperscript(exp, exponent) 
exponent is placed as superscript at the left of exp


Presubscript  presubscript(exp, exponent) 
exponent is placed as subscript at the left of exp


Overscript  overscript(exp, top) 
top is placed above exp


Underscript  underscript(exp, bottom) 
bottom is placed as subscript at the left of exp


Underoverscript  underoverscript(exp, bottom, top) 
top and bottom are respectively placed as superscript and subscript at the left of exp


Vertical pair  vpair(top, bottom) 
top and bottom are respectively placed one on top of the other 

Vertical list  vlist(exp) 
exp represent the expressions that can be placed on several consecutive lines 

Table  table(exp) 
exp represent the expressions that can be placed inside the table cell. This allows for instance defining matrices 

Partial fraction (numerator)  partialfractionnumerator(numerator) 
Only the numerator of the fraction is defined  
Partial fraction (denominator)  partialfractiondenominator(denominator) 
Only the denominator of the fraction is defined  
Slanted fraction  slantedfraction(numerator, denominator) 
numerator is divided by denominator
