Package com.livescribe.icr

Provides classes and interfaces for Intelligent Character Recognition (ICR).

See:
Description

Class Summary

DetailedResult	This class is not currently supported, but may be supported in a future release.
DetailedResult.CandidateEnumeration	An Enumeration of recognition candidates.
ICRContext	This class allows the application to use the Intelligent Character Recognition (ICR) engine.
Language	Represents a language localized to a specific region or country.
LKDynamicResource	A Linguistic Knowledge resource is used to enable the recognition of a set of words.
Resource	This class is an abstraction of a generic ICR resource file.
SKDynamicResource	This class is not currently supported, but may be supported in a future release.
WritingStyle	This class defines the writing styles support by the Intelligent Character Recognition (ICR) feature.

Package com.livescribe.icr Description

Provides classes and interfaces for Intelligent Character Recognition (ICR).

In the future:

• Support for several languages. Livescribe has only licensed English (United States) and Spanish (Spain) from Vision Objects. It is possible for Livescribe to buy additional languages to provide them to their developers. It could be also possible for external developers to license from Vision Objects additional languages for their own use.
• Support for three handwriting styles and a wide range of resources. By including all Alphabet, Subset, and Linguistic Knowledge resources (also lexicons), we allow future developers to utilize every possible combination without having to manually handle all these resources in their own application. Some default resources and scenarios are also provided.

  Regarding Isolated Handwriting Style support, it can be very useful if used in the correct context. For example, utilizing this handwriting style for a "title" or "subject" boxed field on the top of a page will lead to much better accuracy than if a cursive or handprinted style is used.

The main ICR features are as follows:

• User pause support.
• On-the-fly, or dynamic, resources (built by the application at runtime):
  • Subset resources SKDynamicResource to enable only a specific set of characters (not currently supported).
  • Linguistic resources LKDynamicResource to enable the recognition of a set of words or phrases.
• Toplist of detailed recognition results DetailedResult:
  • Recognition score of each candidate.
  • Three levels of recognition candidates:
    1. Text level: the whole entry,
    2. Word level: words that compose the entry, and
    3. Character level: characters of each word
  • Ink range for each candidate using strokes.
• Support for several languages including the default recognition language, English (United States), and 22 other languages.
  Please contact Livescribe Developer Support for information on how to obtain and use them.

  Here is a list of all currently supported languages:

  • Chinese–Simplified (China)
  • Chinese–Traditional (Taiwan)
  • Danish (Denmark)
  • Dutch (Netherlands)
  • English (Canada)
  • English (United Kingdom)
  • English (United States)—DEFAULT LANGUAGE (alphabet)
  • Finnish (Finland)
  • French (Canada)
  • French (France)
  • German (Germany)
  • Greek (Greece)
  • Italian (Italy)
  • Japanese (Japan)
  • Korean (Korea)
  • Norwegian (Norway)
  • Portuguese (Portugal)
  • Russian (Russia)
  • Spanish (Mexico)
  • Spanish (Spain)
  • Swedish (Sweden)
• Three handwriting styles supported by several Alphabet Knowledge resources:
  • Isolated style (best accuracy). The Application tells ICR where each character starts and ends. This is useful for forms.
    Use the WritingStyle.Isolated writing style and any of the ICRContext SYSRES_AK_* resources. Use ICRContext.startNewIsolatedCharacter(short) to tell the engine when a character starts.
  • Handprinted style: there is a pen lift between two characters.
    Use the WritingStyle.HandPrint writing style and any of the ICRContext SYSRES_AK_* resources.
  • Cursive style (this is the most complex style to recognize). Writing can be handprinted, cursive, or a mix of both.
    Use the WritingStyle.Cursive writing style and any of the ICRContext SYSRES_AK_* resources.
• Isolated Handwriting style support.
• Guideline support. Guidelines will increase the recognition accuracy only if they are correctly used by the user.

  

  When correctly utilized by the user, they will help ICR to distinguish:

  • Between upper and lower case characters,
  • Between letters with similar shapes such as lowercase E and L, and
  • Punctuation marks such as apostrophes, dashes, and underscores.

  Two different guidelines can be defined, one of them being optional. The other lines, the ascender and descender, are estimated by ICR. See ICRContext.setGuidelines(long, long).

  • Baseline (mandatory), and
  • Midline (optional).
• The crossing-out gesture is optionally supported. Note that crossing-out is only possible after at least 3 strokes have been drawn in order to avoid false detection of crossing-out, such as for the 't' or '+' characters. Two crossing-out modes are possible:
  • Crossing out the whole entry, and
  • Crossing out one or more words in the text.
• "Unlimited result" support for the recognition of long text.
• Recognition compromises with DetailedResult.

Here is an application sample that uses ICR to recognize one English word:

import com.livescribe.event.HWRListener;
import com.livescribe.event.PenTipListener;
import com.livescribe.event.StrokeListener;
import com.livescribe.icr.ICRContext;
import com.livescribe.penlet.PenletStateChangeException;

public class ICRApp extends Penlet
    implements HWRListener, StrokeListener, PenTipListener
{
    private ICRContext icrContext;

    public void initApp() throws PenletStateChangeException {
        // Acquire the ICR engine from the PenletContext

        try {
            icrContext = context.getICRContext(1000, this);
            icrContext.addResourceSet(icrContext.getSingleWordDefaultResourceSet());
        } catch (RuntimeException ex) {
            System.err.println("Error initializing HWR resources: " + ex);
            throw new PenletStateChangeException(ex.toString());
        }

        // Add the app as a listener for stroke and pen tip events

        context.addStrokeListener(this);
    }

    public void activateApp(int reason, Object[] params) {
        // Add listeners

        context.addStrokeListener(this);
        context.addPenTipListener(this);
    }

    public void deactivateApp(int reason) {
        // Remove listeners

        context.removePenTipListener(this);
        context.removeStrokeListener(this);

        // ICR

        icrContext.dispose();
        icrContext = null;
    }

    public void destroyApp() throws PenletStateChangeException {
    }

    // StrokeListener Methods

    public void strokeCreated(long time,
                              Region region,
                              PageInstance page) {
        icrEngine.addStroke(time);
    }

    // PenTipListener Methods

    public void penDown(long time,
                        Region region,
                        PageInstance pageInstance) {
        // Notify ICR to disable user-pause during stroke writing

        icrEngine.notifyPenDown(time);
    }

    public void doubleTap(long time, int x, int y) { }
    public void penUp(long time, Region region, PageInstance page) { }
    public void singleTap(long time, int x, int y) { }

    // HWRListener Methods

    public void hwrResult(long time, String result) {
        System.out.println("Intermediate recognition result = " + result);
    }

    public void hwrUserPause(long time, String result) {
        System.out.println("Final recognition result = " + result);
    }

    public void hwrError(long time, String error) {
        System.out.println("Error in HWR: " + error);
    }

    public void hwrCrossingOut(long time, String result) {
        System.out.println("Entry was crossed-out: result = " + result);
    }
}