418 lines
13 KiB
C
418 lines
13 KiB
C
/*
|
|
* scribble.h: User-Level API for Handwriting Recognition
|
|
* Author: James Kempf
|
|
* Created On: Mon Nov 2 14:01:25 1992
|
|
* Last Modified By: Sape Mullender
|
|
* Last Modified On: Fri Aug 25 10:24:50 EDT 2000
|
|
* Copyright (c) 1994 by Sun Microsystems Computer Company
|
|
* All rights reserved.
|
|
*
|
|
* Use and copying of this software and preparation of
|
|
* derivative works based upon this software are permitted.
|
|
* Any distribution of this software or derivative works
|
|
* must comply with all applicable United States export control
|
|
* laws.
|
|
*
|
|
* This software is made available as is, and Sun Microsystems
|
|
* Computer Company makes no warranty about the software, its
|
|
* performance, or its conformity to any specification
|
|
*/
|
|
|
|
/*
|
|
* Opaque type for the recognizer. The toolkit must access through
|
|
* appropriate access functions.
|
|
*/
|
|
#pragma incomplete struct _Recognizer
|
|
typedef struct _Recognizer* recognizer;
|
|
|
|
/*
|
|
* Opaque type for recognizers to implement dictionaries.
|
|
*/
|
|
|
|
typedef struct _wordset *wordset;
|
|
typedef struct rc rc;
|
|
typedef struct rec_correlation rec_correlation;
|
|
typedef struct rec_alternative rec_alternative;
|
|
typedef struct rec_element rec_element;
|
|
typedef struct gesture gesture;
|
|
typedef uint wchar_t;
|
|
|
|
/* Scalar Type Definitions */
|
|
|
|
/* For better readibility.*/
|
|
|
|
typedef int bool;
|
|
|
|
#define true 1
|
|
#define false 0
|
|
|
|
/*For pointers to extra functions on recognizer.*/
|
|
|
|
typedef void (*rec_fn)();
|
|
|
|
/*
|
|
* rec_confidence is an integer between 0-100 giving the confidence of the
|
|
* recognizer in a particular result.
|
|
*/
|
|
|
|
typedef uchar rec_confidence;
|
|
|
|
/**************** RECOGNIZER CONFIGURATION INFORMATION *******************/
|
|
|
|
/*
|
|
* Recognizer information. Gives the locale, category of the character
|
|
* set returned by the recognizer, and any subsets to which the
|
|
* recognition can be limited. The locale and category should be
|
|
* suitable for the setlocale(3). Those recognizers which don't do text
|
|
* can simply report a blank locale and category, and report the
|
|
* graphics types they recognize in the subset.
|
|
*/
|
|
|
|
typedef struct {
|
|
char* ri_locale; /*The locale of the character set.*/
|
|
char* ri_name; /*Complete pathname to the recognizer.*/
|
|
char** ri_subset; /*Null terminated list of subsets supported*/
|
|
} rec_info;
|
|
|
|
/*These define a set of common character subset names.*/
|
|
|
|
#define GESTURE "GESTURE" /* gestures only */
|
|
#define MATHSET "MATHSET" /* %^*()_+={}<>,/. */
|
|
#define MONEYSET "MONEYSET" /* $, maybe cent, pound, and yen */
|
|
#define WHITESPACE "WHITESPACE" /* gaps are recognized as space */
|
|
#define KANJI_JIS1 "KANJI_JIS1" /* the JIS1 kanji only */
|
|
#define KANJI_JIS1_PLUS "KANJI_JIS1_PLUS" /* JIS1 plus some JIS2 */
|
|
#define KANJI_JIS2 "KANJI_JIS2" /* the JIS1 + JIS2 kanji */
|
|
#define HIRIGANA "HIRIGANA" /* the hirigana */
|
|
#define KATAKANA "KATAKANA" /* the katakana */
|
|
#define UPPERCASE "UPPERCASE" /* upper case alphabetics, no digits */
|
|
#define LOWERCASE "LOWERCASE" /* lower case alphabetics, no digits */
|
|
#define DIGITS "DIGITS" /* digits 0-9 only */
|
|
#define PUNCTUATION "PUNCTUATION" /* \!-;'"?()&., */
|
|
#define NONALPHABETIC "NONALPHABETIC" /* all nonalphabetics, no digits */
|
|
#define ASCII "ASCII" /* the ASCII character set */
|
|
#define ISO_LATIN12 "ISO_LATIN12" /* The ISO Latin 12 characters */
|
|
|
|
|
|
/******************** RECOGNITION INPUT STRUCTURES ***********************/
|
|
|
|
/*
|
|
* WINDOW SYSTEM INTERFACE
|
|
*/
|
|
|
|
/*Bounding box. Structurally identical to Rectangle.*/
|
|
|
|
typedef Rectangle pen_rect;
|
|
|
|
|
|
/*
|
|
* RECOGNITION CONTEXT
|
|
*/
|
|
|
|
/* Structure for reporting writing area geometric constraints. */
|
|
|
|
typedef struct {
|
|
pen_rect pr_area;
|
|
short pr_row, pr_col;
|
|
} pen_frame;
|
|
|
|
/*
|
|
* Structure for describing a set of letters to constrain recognition.
|
|
* ls_type is the same as the re_type field for rec_element below.
|
|
*/
|
|
|
|
typedef struct _letterset {
|
|
char ls_type;
|
|
union _ls_set {
|
|
char* aval;
|
|
wchar_t* wval;
|
|
} ls_set;
|
|
} letterset;
|
|
|
|
/********************* RECOGNITION RETURN VALUES *************************/
|
|
|
|
|
|
/*Different types in union. "Other" indicates a cast is needed.*/
|
|
|
|
#define REC_NONE 0x0 /*No return value*/
|
|
#define REC_GESTURE 0x1 /*Gesture.*/
|
|
#define REC_ASCII 0x2 /*Array of 8 bit ASCII*/
|
|
#define REC_VAR 0x4 /*Array of variable width characters. */
|
|
#define REC_WCHAR 0x8 /*Array of Unicode (wide) characters. */
|
|
#define REC_OTHER 0x10 /*Undefined type.*/
|
|
#define REC_CORR 0x20 /*rec_correlation struct*/
|
|
|
|
/*
|
|
* Recognition elements. A recognition element is a structure having a
|
|
* confidence level member, and a union, along with a flag indicating
|
|
* the union type. The union contains a pointer to the result. This
|
|
* is the basic recognition return value, corresponding to one
|
|
* recognized word, letter, or group of letters.
|
|
*/
|
|
|
|
struct rec_element {
|
|
char re_type; /*Union type flag.*/
|
|
union {
|
|
gesture * gval; /*Gesture.*/
|
|
char* aval; /*ASCII and variable width.*/
|
|
wchar_t* wval; /*Unicode.*/
|
|
rec_correlation* rcval; /*rec_correlation*/
|
|
} re_result;
|
|
rec_confidence re_conf; /*Confidence (0-100).*/
|
|
};
|
|
|
|
/*
|
|
* Recognition alternative. The recognition alternative gives
|
|
* a translated element for a particular segmentation, and
|
|
* a pointer to an array of alternatives for the next position
|
|
* in the segmentation thread.
|
|
*/
|
|
|
|
struct rec_alternative {
|
|
rec_element ra_elem; /*the translated element*/
|
|
uint ra_nalter; /*number of next alternatives*/
|
|
rec_alternative* ra_next; /*the array of next alternatives*/
|
|
};
|
|
|
|
/************************** GESTURES **************************/
|
|
|
|
/*
|
|
* Gestures. The toolkit initializes the recognizer with a
|
|
* set of gestures having appropriate callbacks.
|
|
* When a gesture is recognized, it is returned as part of a
|
|
* recognition element. The recognizer fills in the bounding
|
|
* box and hotspots. The toolkit fills in any additional values,
|
|
* such as the current window, and calls the callback.
|
|
*/
|
|
|
|
struct gesture {
|
|
char* g_name; /*The gesture's name.*/
|
|
uint g_nhs; /*Number of hotspots.*/
|
|
pen_point* g_hspots; /*The hotspots.*/
|
|
pen_rect g_bbox; /*The bounding box.*/
|
|
void (*g_action)(gesture*); /*Pointer to execution function.*/
|
|
void* g_wsinfo; /*For toolkit to fill in.*/
|
|
};
|
|
|
|
typedef void (*xgesture)(gesture*);
|
|
|
|
/*
|
|
* Recognition correlation. A recognition correlation is a recognition
|
|
* of the stroke input along with a correlation between the stroke
|
|
* input and the recognized text. The rec_correlation struct contains
|
|
* a pointer to an arrray of pointers to strokes, and
|
|
* two arrays of integers, giving the starting point and
|
|
* stopping point of each corresponding recogition element returned
|
|
* in the strokes.
|
|
*/
|
|
|
|
struct rec_correlation {
|
|
rec_element ro_elem; /*The recognized alternative.*/
|
|
uint ro_nstrokes; /*Number of strokes.*/
|
|
Stroke* ro_strokes; /*Array of strokes.*/
|
|
uint* ro_start; /*Starting index of points.*/
|
|
uint* ro_stop; /*Stopping index of points.*/
|
|
};
|
|
|
|
/*
|
|
* ADMINISTRATION
|
|
*/
|
|
|
|
/*
|
|
* recognizer_load - If directory is not NULL, then use it as a pathname
|
|
* to find the recognizer. Otherwise, use the default naming conventions
|
|
* to find the recognizer having file name name. The subset argument
|
|
* contains a null-terminated array of names for character subsets which
|
|
* the recognizer should translate.
|
|
*/
|
|
|
|
recognizer recognizer_load(char*, char*, char**);
|
|
|
|
/*
|
|
* recognizer_unload - Unload the recognizer.
|
|
*/
|
|
|
|
int recognizer_unload(recognizer);
|
|
|
|
/*
|
|
* recognizer_get_info-Get a pointer to a rec_info
|
|
* giving the locale and subsets supported by the recognizer, and shared
|
|
* library pathname.
|
|
*/
|
|
|
|
const rec_info* recognizer_get_info(recognizer);
|
|
|
|
/*
|
|
* recognizer_manager_version-Return the version number string of the
|
|
* recognition manager.
|
|
*/
|
|
|
|
const char* recognizer_manager_version(recognizer);
|
|
|
|
/*
|
|
* recognizer_load_state-Get any recognizer state associated with name
|
|
* in dir. Note that name may not be simple file name, since
|
|
* there may be more than one file involved. Return 0 if successful,
|
|
* -1 if not.
|
|
*/
|
|
|
|
int recognizer_load_state(recognizer, char*, char*);
|
|
|
|
/*
|
|
* recognizer_save_state-Save any recognizer state to name
|
|
* in dir. Note that name may not be a simple file name, since
|
|
* there may be more than one file involved. Return 0 if successful,
|
|
* -1 if not.
|
|
*/
|
|
|
|
int recognizer_save_state(recognizer, char*, char*);
|
|
|
|
/*
|
|
* recognizer_error-Return the last error message, or NULL if none.
|
|
*/
|
|
|
|
char* recognizer_error(recognizer);
|
|
|
|
/*
|
|
* DICTIONARIES
|
|
*/
|
|
|
|
/* recognizer_load_dictionary-Load a dictionary from the directory
|
|
* dir and file name. Return the dictionary pointer if successful,
|
|
* otherwise NULL.
|
|
*/
|
|
|
|
wordset recognizer_load_dictionary(recognizer, char*, char*);
|
|
|
|
/* recoginzer_save_dictionary-Save the dictionary to the file. Return 0
|
|
* successful, -1 if error occurs.
|
|
*/
|
|
|
|
int recognizer_save_dictionary(recognizer, char*, char*, wordset);
|
|
|
|
/*
|
|
* recognizer_free_dictionary-Free the dictionary. Return 0 if successful,
|
|
* -1 if error occurs.
|
|
*/
|
|
|
|
int recognizer_free_dictionary(recognizer, wordset);
|
|
|
|
/*
|
|
* recognizer_add_to_dictionary-Add the word to the dictionary. Return 0
|
|
* if successful, -1 if error occurs.
|
|
*/
|
|
|
|
int recognizer_add_to_dictionary(recognizer, letterset*, wordset);
|
|
|
|
/*
|
|
* recognizer_delete_from_dictionary-Delete the word from the dictionary.
|
|
* Return 0 if successful, -1 if error occurs.
|
|
*/
|
|
|
|
int recognizer_delete_from_dictionary(recognizer, letterset*, wordset);
|
|
|
|
/*
|
|
* TRANSLATION
|
|
*/
|
|
|
|
/* recognizer_set/get_context - Set/get the recognition context for
|
|
* subsequent buffering and translation. recognizer_set_context()
|
|
* returns -1 if an error occurs, otherwise 0. recognizer_get_context()
|
|
* returns NULL if no context has been set. The context is copied to avoid
|
|
* potential memory deallocation problems.
|
|
*/
|
|
|
|
int recognizer_set_context(recognizer, rc*);
|
|
rc* recognizer_get_context(recognizer);
|
|
|
|
/* recognizer_clear - Set stroke buffer to NULL and clear the context.
|
|
* Returns -1 if an error occurred, otherwise 0. Both the context and the
|
|
* stroke buffer are deallocated. If delete_points_p is true, delete the
|
|
* points also.
|
|
*/
|
|
|
|
int recognizer_clear(recognizer, bool);
|
|
|
|
/* recognizer_get/set_buffer - Get/set the stroke buffer. The stroke buffer
|
|
* is copied to avoid potential memory allocation problems. Returns -1 if
|
|
* an error occurs, otherwise 0.
|
|
*/
|
|
|
|
int recognizer_get_buffer(recognizer, uint*, Stroke**);
|
|
int recognizer_set_buffer(recognizer, uint, Stroke*);
|
|
|
|
/* recognizer_translate - Copy the strokes argument into the stroke buffer and
|
|
* translate the buffer. If correlate_p is true, then provide stroke
|
|
* correlations as well. If either nstrokes is 0 or strokes is NULL, then
|
|
* just translate the stroke buffer and return the translation. Return an
|
|
* array of alternative translation segmentations in the ret pointer and the
|
|
* number of alternatives in nret, or NULL and 0 if there is no translation.
|
|
* The direction of segmentation is as specified by the rc_direction field in
|
|
* the buffered recognition context. Returns -1 if an error occurred,
|
|
* otherwise 0.
|
|
*/
|
|
|
|
int recognizer_translate(recognizer, uint, Stroke*, bool,
|
|
int*, rec_alternative**);
|
|
|
|
/*
|
|
* recognizer_get_extension_functions-Return a null terminated array
|
|
* of functions providing extended functionality. Their interfaces
|
|
* will change depending on the recognizer.
|
|
*/
|
|
|
|
rec_fn* recognizer_get_extension_functions(recognizer);
|
|
|
|
/*
|
|
* GESTURE SUPPORT
|
|
*/
|
|
|
|
/*
|
|
* recognizer_get_gesture_names - Return a null terminated array of
|
|
* character strings containing the gesture names.
|
|
*/
|
|
|
|
char** recognizer_get_gesture_names(recognizer);
|
|
|
|
/*
|
|
* recognizer_set_gesture_action-Set the action function associated with the
|
|
* name.
|
|
*/
|
|
|
|
xgesture recognizer_set_gesture_action(recognizer, char*, xgesture, void*);
|
|
|
|
/*
|
|
* The following functions are for deleting data structures returned
|
|
* by the API functions.
|
|
*/
|
|
|
|
void delete_rec_alternative_array(uint, rec_alternative*, bool);
|
|
void delete_rec_correlation(rec_correlation*, bool);
|
|
|
|
/*
|
|
* These are used by clients to create arrays for passing to API
|
|
* functions.
|
|
*/
|
|
|
|
Stroke* make_Stroke_array(uint);
|
|
void delete_Stroke_array(uint, Stroke*, bool);
|
|
|
|
pen_point* make_pen_point_array(uint);
|
|
void delete_pen_point_array(pen_point*);
|
|
|
|
Stroke* copy_Stroke_array(uint, Stroke*);
|
|
|
|
/*Extension function interfaces and indices.*/
|
|
|
|
#define LI_ISA_LI 0 /*Is this a li recognizer?.*/
|
|
#define LI_TRAIN 1 /*Train recognizer*/
|
|
#define LI_CLEAR 2 /* ari's clear-state extension fn. */
|
|
#define LI_GET_CLASSES 3 /* ari's get-classes extension fn. */
|
|
#define LI_NUM_EX_FNS 4 /*Number of extension functions*/
|
|
|
|
typedef bool (*li_isa_li)(recognizer r);
|
|
typedef int (*li_recognizer_train)(recognizer, rc*, uint,
|
|
Stroke*, rec_element*, bool);
|
|
typedef int (*li_recognizer_clearState)(recognizer);
|
|
typedef int (*li_recognizer_getClasses)(recognizer, char ***, int *);
|