From e5888a1ffdae813d7575f5fb02275c6bb07e5199 Mon Sep 17 00:00:00 2001 From: Taru Karttunen Date: Wed, 30 Mar 2011 15:46:40 +0300 Subject: Import sources from 2011-03-30 iso image --- sys/src/libscribble/scribbleimpl.h | 417 +++++++++++++++++++++++++++++++++++++ 1 file changed, 417 insertions(+) create mode 100755 sys/src/libscribble/scribbleimpl.h (limited to 'sys/src/libscribble/scribbleimpl.h') diff --git a/sys/src/libscribble/scribbleimpl.h b/sys/src/libscribble/scribbleimpl.h new file mode 100755 index 000000000..11d32218b --- /dev/null +++ b/sys/src/libscribble/scribbleimpl.h @@ -0,0 +1,417 @@ +/* + * 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 *); -- cgit v1.2.3