KADMOS.h
/****************************************************************************
*
* kadmos.h
*
* $Date: 30-Jan-2019 03:46 $
*
* Copyright 1993-2019 re Recognition GmbH
* Hafenstrasse 50b, 8280 Kreuzlingen, Switzerland
* +41 (0)71 6725100
* info@reRecognition.com * www.reRecognition.com
*
****************************************************************************/
#ifndef INC_KADMOS
#define INC_KADMOS "6.1a"
#define KADMOS_MAJOR 0x61
#define KADMOS_MINOR 'a'
#define KADMOS_MKVER(major, minor) (((major)<8) | (minor))
#define KADMOS_VERSION KADMOS_MKVER(KADMOS_MAJOR, KADMOS_MINOR)
/* sample usage: #if KADMOS_VERSION >= KADMOS_MKVER(0x60,'b') */
#ifdef __cplusplus
extern "C" {
#endif
#if !defined(_MSC_VER) || (_MSC_VER<1400)
#if !defined(INT_PTR)
#define INT_PTR long
#endif
#endif
/****************************************************************************
*
* Definition von KADMOS_API
*
****************************************************************************/
#ifndef KADMOS_API
#if defined(_WIN32) || defined(_WIN64)
#define KADMOS_API __stdcall
#else
#define KADMOS_API
#endif
#endif
extern int licfile_authorised(const char *file_title); // DLL version only; int==BOOL
/****************************************************************************
*
* Funktionen zur Abbruch- und Fehlerkontrolle
*
****************************************************************************/
#if !defined RE_ERRORHANDLING
#define RE_ERRORHANDLING
/* *** Beim Multithreading sind die folgenden Einstellungen und Funktionen Thread-spezifisch */
/* *** Sie haben nur Auswirkungen auf den verwandten Thread */
Konfiguration der KADMOS-Fehlerbehandlung festlegen / abrufen */
extern long KADMOS_API re_SetErrorConfig(long config);
extern long KADMOS_API re_GetErrorConfig(void);
/*** Makros zur Konfiguration der Fehlerbehandlung ('config' values) */
/* Standard-Programmbeendigung aktivieren / deaktivieren */
/* Strg + Pause, ESC, ALT + F4 (Konsolenanwendung und Windows) oder Strg + C (nur Konsolenanwendung): */
#define RE_QUITENABLED 0x80000000 /* Standard */
/* Konsolenausgabe von Fehlertexten und Warnungen aktivieren / deaktivieren: */
#define RE_ERRORDISPLAY 0x20000000 /* Standard */
/* Wenn RE_ERRORDISPLAY deaktiviert ist, sollte ein privater Fehlerbehandler installiert werden, */
/* um alle Fehlernachrichten abzurufen */
/* Programmabbruch nach Fehlern aktivieren / deaktivieren: */
#define RE_ERROREXIT 0x10000000
/* Aktivieren / Deaktivieren der Behandlung von Warnungen wie Fehlern (außer der Anzeige): */
#define RE_ENABLEWARNINGS 0x08000000
/* Um eine der vorherigen Einstellungen RE_XXXXXXXX zu deaktivieren, rufen Sie Folgendes auf: */
/* re_SetErrorConfig(re_GetErrorConfig()&~RE_XXXXXXXX); */
/* Deaktivieren Sie die Fehlerbehandlung, außer bei Fehler: */
#define RE_NOERRORHANDLING 0x00000000
#define KADMOS_ERROR long
/* set/get private_data des KADMOS-Fehlertextes */
extern KADMOS_ERROR KADMOS_API re_SetPrivateData(long private_data);
extern long KADMOS_API re_GetPrivateData(void);
#define RE_ERROR_PROGRAM_LEN 64
#define RE_ERROR_TEXT_LEN 512
typedef struct re_ErrorText_tag {
KADMOS_ERROR ident;
char program[RE_ERROR_PROGRAM_LEN];
char text[RE_ERROR_TEXT_LEN];
char systext[RE_ERROR_TEXT_LEN];
long private_data;
} re_ErrorText;
typedef struct re_wErrorText_tag {
KADMOS_ERROR ident;
wchar_t program[RE_ERROR_PROGRAM_LEN];
wchar_t text[RE_ERROR_TEXT_LEN];
wchar_t systext[RE_ERROR_TEXT_LEN];
long private_data;
} re_wErrorText;
/* Fehlertypen (Werte von ident) */
#define RE_SUCCESS 0x00000000
#define RE_ERROR 0x80000000
#define RE_QUIT 0x40000000
#define RE_WARNING 0x20000000
#define RE_INFO 0x10000000
#define RE_PARAMETERERROR 0x88000000
#define RE_MEMORYERROR 0x84000000
#define RE_FILEERROR 0x82000000
#define RE_PROTECTERROR 0x81000000
#define RE_SEGMENTATIONERROR 0x80080000
/* Fehlertext abrufen, Aufruf mit NULL nur für den Fehlerstatus (ident) */
extern KADMOS_ERROR KADMOS_API re_GetErrorText(re_ErrorText*);
extern KADMOS_ERROR KADMOS_API re_wGetErrorText(re_wErrorText*);
/* Fehlertext und den Fehlerstatus setzen (ident) */
extern void KADMOS_API re_SetErrorText(const re_ErrorText*);
extern void KADMOS_API re_wSetErrorText(const re_wErrorText*);
/* Aufruf mit NULL, um den KADMOS-Fehlertext anzuzeigen */
extern void KADMOS_API re_DisplayErrorText(const re_ErrorText*);
extern void KADMOS_API re_wDisplayErrorText(const re_wErrorText*);
/* Fehlerstatus löschen (ident) */
extern void KADMOS_API re_ClearError(void);
/* *** Bei Multithreading die folgenden Einstellungen für die Fehlerbehandlung */
/* *** hat Auswirkungen auf alle Threads */
/* Deklaration zur privaten Fehlerbehandlung */
typedef void (KADMOS_API *re_ErrorHandler)(const re_ErrorText*);
typedef void (KADMOS_API *re_wErrorHandler)(const re_wErrorText*);
/* Aufruf zum Installieren eines privaten Fehlerbehandlers, zum Deinstallieren mit NULL aufrufen */
extern re_ErrorHandler KADMOS_API re_SetErrorHandler(re_ErrorHandler);
extern re_wErrorHandler KADMOS_API re_wSetErrorHandler(re_wErrorHandler);
/* Aufruf zum Abrufen des installierten Fehlerhandlers (NULL == KADMOS-Fehlerhandler) */
extern re_ErrorHandler KADMOS_API re_GetErrorHandler(void);
extern re_wErrorHandler KADMOS_API re_wGetErrorHandler(void);
#endif /* RE_ERRORHANDLING */
/****************************************************************************
*
* Struktur für die Initialisierung
*
****************************************************************************/
typedef struct ReInit_tag {
char version[8]; /* korrekte KADMOS-Version überprüfen */
/*** vor dem Aufruf von rel_init () oder rep_init () setzen */
int rel_grid_maxlen; /* max. Anzahl der Elemente in rel_grid */
int rel_graph_maxlen; /* max. Anzahl der Elemente in rel_graph */
int rel_result_maxlen; /* max. Anzahl der Elemente in rel_result */
int options; /* OPTIONS_RESTRICT_LABELS - Wenn gesetzt, werden nur die unter */
/* ReParm.labels und ReParm..rejects angegebenen Labels geladen. */
/* ReParm.code muss entsprechend eingestellt werden. Chopper.exe verwenden, */
/* um die Labels und Rückweisungen eines Klassifizierers abzurufen */
/*** ausreichend Speicherplatz bereitstellen vor dem ersten Aufruf von rep_do() */
void *rep_memory; /* Speicher, um rep_result (s) zu erhalten */
long rep_memory_size; /* Größe des bereitgestellten Speichers */
/* kann auf gzopen, gzread und gzclose gesetzt werden, um g-gezippte Dateien (zlib) zu lesen */
/* Es kann aber auch jeder andere gleichwertige Satz von Dekompressionsfunktionen eingestellt werden */
void * (*zip_open) (const char *file_title, const char *mode);
void * (*zip_wopen) (const wchar_t *file_title, const char *mode);
int (*zip_compressed) (const char *file_title);
int (*zip_wcompressed) (const wchar_t *file_title);
/* Wenn zip_ (w) komprimiert nicht angegeben ist, signalisiert die Erweiterung ".gz" Kompression */
int (*zip_read) (void *file, void *buf, unsigned long len);
int (*zip_close)(void *file);
/*** intern verwendet von re? _init (), re? _info (), re? _do () und re? _end () */
INT_PTR interna1[4]; /* nicht ändern */
INT_PTR interna2[4]; /* nicht ändern */
} ReInit;
#define OPTIONS_RESTRICT_LABELS 1
/****************************************************************************
*
* Strukturen und Makros zur Bildbeschreibung
*
****************************************************************************/
typedef struct ReRect_tag {
long left, top;
long width, height;
} ReRect;
typedef struct ReStroke_tag {
long color;
long thickness;
long timestamp;
void *user_data;
long x0,y0;
long x1,y1;
} ReStroke;
typedef struct ReImage_tag {
void *data; /* pointer auf image/data vom Typ 'imgtype' */
unsigned long imgtype; /* see IMGTYPE_* (pixel, pointer, stroke, ...) */
unsigned long width; /* nur für IMGTYPE_PIXELARRAY, -_POINTERARRAY, -_FEATURE */
unsigned long height; /* nur für IMGTYPE_PIXELARRAY, -_POINTERARRAY, -_FEATURE */
unsigned long strokecount; /* nur für IMGTYPE_STROKE */
unsigned long max_strokecount; /* nur für IMGTYPE_STROKE */
ReRect subimage; /* für alle IMGTYPEs ausser IMGTYPE_FEATURE */
unsigned short bitsperpixel; /* Grösse der Datenelemente 'data' (0(=1), 1, 8, 24) */
unsigned short color; /* siehe COLOR_* (binary, gray, rgb) */
unsigned short photometric; /* siehe PHOTOMETRIC_* (min is white, ...) */
unsigned short alignment; /* Ausrichtung von Pixeldaten, 0, 1, 2, 4 */
unsigned short orientation; /* siehe ORIENTATION_* (topleft, ...) */
unsigned short fillorder; /* siehe FILLORDER_* (MSB2LSB, LSB2MSB) */
unsigned short filler; /* 8 byte Ausrichtung */
unsigned short resunit; /* siehe RESUNIT_* (inch, cm, ...) */
unsigned long xresolution;
unsigned long yresolution;
} ReImage;
/*** Für jede folgende Gruppe ist der erste Eintrag Standard */
#define IMGTYPE_PIXELARRAY 0
#define IMGTYPE_POINTERARRAY 1
#define IMGTYPE_STROKE 2
#define IMGTYPE_FEATURE 4
#define IMGTYPE_FEATURE_INT 5
#define IMGTYPE_FEATURE_UINT 6
#define IMGTYPE_FEATURE_FLOAT 7
/* *** Für IMGTYPE_FEATURE_ * gelten die folgenden Ausnahmen:
* - Der Merkmalsvektor wird unter 'data' angegeben.
* - height*width ist die Dimension des Merkmalsvektors.
* - bitsperpixel (Größe der Feature-Datenelemente) kann 8, 16, 32, 64 sein
* - Subimage und alle anderen Elemente von ReImage werden nicht verwendet
* Nach dem Laden eines Merkmals werden rec file (rec_init()), imgtype, width, height,
* und bitsperpixel auf die zugehörigen Standardwerte der Klassifizierer gesetzt */
#define COLOR_BINARY 0
#define COLOR_GRAY 1
#define COLOR_RGB 2
#ifndef TIFFMACROS_INCLUDED /* zuerst definieren, wenn bereits enthalten */
/*** macros gemäss tiff.h von Sam Leffler (Silicon Graphics Inc.) */
#define PHOTOMETRIC_MINISWHITE 0
#define PHOTOMETRIC_MINISBLACK 1
/* nicht für IMGTYPE_STROKE */
#define ORIENTATION_TOPLEFT 1
#define ORIENTATION_BOTLEFT 4
/*Nur für COLOR_BINARY, nicht für IMGTYPE_STROKE*/
#define FILLORDER_MSB2LSB 1 /* from most to least significant bit */
#define FILLORDER_LSB2MSB 2 /* from least to most significant bit */
#define RESUNIT_NONE 1
#define RESUNIT_INCH 2
#define RESUNIT_CENTIMETER 3
#endif /* TIFFMACROS_INCLUDED */
#define RESUNIT_METER 4
typedef void *ReImageHandle;
/****************************************************************************
*
* Parameter für REC, REL, and REP
*
****************************************************************************/
/*** Parameter zur Kontrolle der Erkennung von Linien und Boxen in REL, REP */
typedef struct RelGridParm_tag {
long grid; /* Typ der Box, siehe GRID_ * -Makros */
long min_width; /* minimale Breite einer Box, Linie oder eines Kamms */
long max_width; /* maximale Breite einer Box, Linie oder eines Kamms */
long min_height; /* minimale Höhe einer Box, Linie oder eines Kamms */
long max_height; /* maximale Höhe einer Box, Linie oder eines Kamms */
long subgrid_count; /* Anzahl der Subboxen oder Kammfelder */
ReRect search_area; /* Rechteck, um nach dem Gitterelement zu suchen */
} RelGridParm;
#define REPARM_LABELS_SIZE_MAX 8192 /* Maximalwert des Elements labels_size unten */
/****************************************************************************
* Im Rahmen von RecData, RelData oder RepData werden alle Elemente der
* Struktur ReParm durch einen Aufruf von rec_init (), rel_init () oder
* rep_init () gelöscht und auf Standardwerte gesetzt. Setzen Sie neue
* Werte nach rec_init (), rel_init () oder rep_init ().
****************************************************************************/
#ifdef _MSC_VER
#pragma warning(disable:4201)
#endif
typedef struct ReParm_tag {
long general; /* siehe GENERAL_ * -Makros */
/*** Vorverarbeitung */
long prep; /* siehe PREP_* Makros */
short deskew_min; /* minimaler Zeilenversatz, */
/* um de-skewing auszufüren*/
/* Null bedeutet kein de-skewing (Standard) */
short filler1; /* 8 byte alignment */
short noise_diameter_percent; /* Schmutzentfernung in REC, REL, und REP */
short noise_diameter_pixel; /* Schmutzentfernung in REC, REL, und REP */
short noise_width_percent; /* Schmutzentfernung in REC, REL, und REP */
short noise_length_percent; /* Schmutzentfernung in REC, REL, und REP */
short noise_width_pixel; /* Schmutzentfernung in REC, REL, und REP */
short noise_length_pixel; /* Schmutzentfernung in REC, REL, und REP */
short rem_back_gray_delta; /* entfernt Hintergrund aus einem Farbbild -
max Untrschied R-G-B um ein Graupixel zu sein */
short rem_back_gray_level; /* entfernt Hintergrund aus einem Farbbild -
das hellste Vordergrund-Graupixel 'lightest' */
RelGridParm *gridparm; /* Bereich der RelGridParm-Strukturen */
long gridparm_maxlen; /* Anzahl der vorgesehenen Strukturen */
/*** Segmentierung */
long typograph; /* siehe TYPO_ * -Makros */
long filler2; /* 8-Byte-Ausrichtung */
short line_space, base_line; /* Linienmetriken, falls bekannt */
short char_space_min; /* Zeichenmetrik (min, max) für die Breite */
short char_space_max; /* Zeichen + Zwischenraum (falls bekan */
/*** Klassifikation */
long code; /* CODE_PAGE_1252, CODE_ISO_8859_1, ... */
long options; /* exclude, use basic labels, ... */
long labels_size; /* Grösse der Allokation der Kennunge und Rückweisungen in Byte */
#if defined(__STDC__)
char *labels; /* aktive Labels; Speicher allokiert von re? _init() */
char *rejects; /* aktive RÜckweisungen; memory allokiert von re?_init() */
/* wird nur verwendet von OPTIONS_RESTRICT_LABELS */
#else
union {
char *labels; /* aktive Labels, CP 437 - ISO_8859_15, CODE_ASCII */
short *labels2; /* aktive Labels, CODE_UTF_16 */
};
union {
char *rejects; /* aktive RÜckweisungen, CP 437 - ISO_8859_15, CODE_ASCII */
short *rejects2; /* aktive RÜckweisungen, CODE_UTF_16 */
/* wird nur verwendet von OPTIONS_RESTRICT_LABELS */
};
#endif
long alc; /* (zusätzlich) aktive Kennungen, siehe ALC_* Makros */
long font; /* Einschränkung für Alc-Spezifikation, siehe FONT_* Makros */
short reject_limit; /* steuert die Anzahl der Alternativen; Standardeinstellung 128 */
short filler3[3]; /* 8-Byte-Ausrichtung */
/*** Kontext */
long pos; /* siehe POS_* macros */
/*** hook - für den privaten Gebrauch */
INT_PTR hookparm; /* kopiert von REP nach REL, von REL nach REC */
} ReParm;
#ifdef _MSC_VER
#pragma warning(default:4201)
#endif
/****************************************************************************
*
* Makros zur Prozesskontrolle
*
****************************************************************************/
/*** zeigt die Aufrufsequenz - intern gesetzt und verwendet - nicht ändern */
#define GENERAL_RECCALL 0x00010000 /* gesetzt von rec_init(), rec_do(),.. */
#define GENERAL_RECACCENTCALL 0x00020000 /* gesetzt von rec_accent() */
#define GENERAL_RELCALL 0x00040000 /* gesetzt von rel_init(), rel_do(),.. */
#define GENERAL_RELFINDCALL 0x00080000 /* gesetzt von rel_find() */
#define GENERAL_REPCALL 0x00100000 /* gesetzt von rep_init(), rep_do(),.. */
#define GENERAL_RESPELLCALL 0x00400000 /* gesetzt von respell_init(), respell_do(),.. */
#define GENERAL_RECALL 0x00ff0000
#define GENERAL_REPMULTITHREADING 0x00001000 /* Standardeinstellung für rep_do() */
/* Im Allgemeinen werden 2 Threads verwendet, */
/* wenn sie gesetzt sind */
/* in der Server-Version wird */
/* so viel wie möglich verwendet */
#define GENERAL_MULTITHREADING 0x0000ff00 /* Maske für Multithreading-Parameter */
#define GENERAL_PREP_ONLY 0x00000001 /* Rückkehr nach Vorverarbeitung */
#define GENERAL_LINESHADOW_ONLY 0x00000002 /* Rückkehr vor der Erkennung */
/*** nur für Aufrufe von rep_do () */
#define GENERAL_LINEPOSITION_ONLY 0x00000004 /* Rückkehr ohne Erkennung */
/*** nur für Aufrufe von rec_do () */
#define GENERAL_FEATURES_ONLY 0x00000008 /* Rückkehr nach der Merkmalsextraktion */
#define GENERAL_HOOKENGINE_LOADED 0x10000000 /* Status (Rückgabewert) */
#define GENERAL_HOOKENGINE_ON 0x20000000 /* benutze die Hook Engine */
/****************************************************************************
*
* Makros zum Auswählen von code pages
*
*
****************************************************************************/
#define CODE_PAGE_437 437
#define CODE_PAGE_720 720
#define CODE_PAGE_737 737
#define CODE_PAGE_850 850
#define CODE_PAGE_852 852
#define CODE_PAGE_855 855
#define CODE_PAGE_857 857
#define CODE_PAGE_858 858
#define CODE_PAGE_864 864
#define CODE_PAGE_866 866
#define CODE_PAGE_874 874
#define CODE_PAGE_1250 1250
#define CODE_PAGE_1251 1251
#define CODE_PAGE_1252 1252
#define CODE_PAGE_1253 1253
#define CODE_PAGE_1254 1254
#define CODE_PAGE_1255 1255
#define CODE_PAGE_1256 1256
#define CODE_PAGE_1257 1257
#define CODE_PAGE_1258 1258
#define CODE_ISO_8859_1 885901
#define CODE_ISO_8859_2 885902
#define CODE_ISO_8859_4 885904
#define CODE_ISO_8859_5 885905
#define CODE_ISO_8859_6 885906
#define CODE_ISO_8859_7 885907
#define CODE_ISO_8859_8 885908
#define CODE_ISO_8859_9 885909
#define CODE_ISO_8859_10 885910
#define CODE_ISO_8859_11 885911
#define CODE_ISO_8859_13 885913
#define CODE_ISO_8859_15 885915
#define CODE_ASCII 1000000 /* Ersatzdarstellung */
#define CODE_UTF_8 2000008
#define CODE_UTF_16 2000016
#define CODE_UTF_32 2000032
/*** sspezielle Klassifizierungscodes */
#define CODE_ASCII_7BIT 1000001
#define CODE_UTF_16_7BIT 2000017
/****************************************************************************
*
* Makros zur Vorverarbeitungssteuerung und zur grid-Erelementerkennung
*
****************************************************************************/
/*** beeinflusst REC */
#define PREP_NOSPACEREMOVAL 0x00000001 /* entfern keinen Raum um Zeichen */
/*** influences REL */
#define PREP_NOSPOTREMOVAL 0x00000002 /* entfern keinen Sprenkel */
/*** influences REC + REL + REP */
#define PREP_AUTO_NOISEREDUCTION 0x00000004 /* kontrolliert Schmutzentfernung */
/* (default) */
#define PREP_SCALING 0x00000008 /* Zeichengröße normalisieren */
#define PREP_RGBTOGRAY_COLORGRAY 0x00000000 /* rgb nach gray normal (Standard) */
#define PREP_RGBTOGRAY_COLORMIN 0x00000010 /* rgb nach gray Farbe entfernen */
#define PREP_RGBTOGRAY_COLORMAX 0x00000020 /* rgb nach gray Farbe verbessern */
#define PREP_GRAYTOBIN_VERY_THIN 0x00000100 /* gray nach bin Sehr schwache Schwärzung */
#define PREP_GRAYTOBIN_THIN 0x00000200 /* gray nach bin Schwache Schwärzung */
#define PREP_GRAYTOBIN_MEDIUM 0x00000300 /* gray nach bin Mittlere Schwärzung (Standard) */
#define PREP_GRAYTOBIN_THICK 0x00000400 /* gray nach bin Starke Schwärzung */
#define PREP_GRAYTOBIN_VERY_THICK 0x00000500 /* gray nach bin Sehr starke Schwärzung */
#define PREP_GRAYTOBIN_UNIFORM 0x00000800 /* gray to bin mit nur einer Schwelle */
#define PREP_BINFILTER_VERY_THIN 0x00001000 /* Zeichenglättung mit starker Ausdünnung */
#define PREP_BINFILTER_THIN 0x00002000 /* Zeichenglättung mit Ausdünnung */
#define PREP_BINFILTER_MEDIUM 0x00003000 /* Zeichenglättung ohne Ausdünnung */
#define PREP_BINFILTER_THICK 0x00004000 /* Zeichenglättung mit Verdickung */
#define PREP_BINFILTER_VERY_THICK 0x00005000 /* Zeichenglättung mit starker Verdickung */
#define PREP_BINFILTER 0x0000f000
#define PREP_REMOVE_BACKGROUND_AUTO 0x00010000 /* Bildhintergrund mit Histogramm entfernen (nur für Farbbilder) */
#define PREP_REMOVE_BACKGROUND 0x00020000 /* Bildhintergrund entfernen - (nur für Farbbilder) */
#define PREP_INPLACE 0x80000000 /* Bild in der Vorverarbeitung überschreiben */
#define GRID_LINE_H 0x00000001 /* horizontale Linie */
#define GRID_LINE_V 0x00000002 /* vertikale Linie */
#define GRID_BOX 0x00000004 /* Box um den Zeichen */
#define GRID_COMB 0x00000008 /* Kamm unter Zeichen */
#define GRID_ALL 0x000000FF /* alle Gitterelemente */
#define GRID_END 0x00000000 /* für das letzte Element von reparm.gridparm */
/****************************************************************************
*
* Makros zur Segmentierungssteuerung
*
****************************************************************************/
/*** beeinflusst REL */
#define TYPO_PROPORTIONAL 0x00000100 /* Proportionalabstand annehmen */
#define TYPO_EQUIDISTANT 0x00000200 /* äquidistanten Abstand annehmen */
#define TYPO_NOLIGATURES 0x00000400 /* keine Ligaturen annehmen */
#define TYPO_NOTOUCHINGCHARS 0x00000800 /* keine berührende Zeichen annehmen */
#define TYPO_NOSEGALTERNATIV 0x00010000 /* Keine Segmentierungsalternativen */
#define TYPO_4_SEGALTERNATIV 0x00040000 /* bis zu 4 Segmentierungsalternativen */
#define TYPO_8_SEGALTERNATIV 0x00080000 /* bis zu 8 Segmentierungsalternativen (Standard) */
#define TYPO_KEEPIMG 0x00100000 /* REC-Bilder nach rel_do () und / oder rec_accent () beibehalten */
#define TYPO_EXTENDED_SEGMENTATION 0x01000000 /* weniger Fehler, mehr CPU-Zeit */
#define TYPO_PROPORTIONAL 0x00000100 /* Proportionalabstand annehmen */
#define TYPO_EQUIDISTANT 0x00000200 /* äquidistanten Abstand annehmen */
#define TYPO_NOLIGATURES 0x00000400 /* keine Ligaturen annehmen */
#define TYPO_NOTOUCHINGCHARS 0x00000800 /* keine berührende Zeichen annehmen */
#define TYPO_NOSEGALTERNATIV 0x00010000 /* Keine Segmentierungsalternativen */
#define TYPO_4_SEGALTERNATIV 0x00040000 /* bis zu 4 Segmentierungsalternativen */
#define TYPO_8_SEGALTERNATIV 0x00080000 /* bis zu 8 Segmentierungsalternativen (Standard) */
#define TYPO_KEEPIMG 0x00100000 /* REC-Bilder nach rel_do () und / oder rec_accent () beibehalten */
#define TYPO_EXTENDED_SEGMENTATION 0x01000000 /* weniger Fehler, mehr CPU-Zeit */
/****************************************************************************
*
* Makros zur Kontrolle der Klassifizierung
*
****************************************************************************/
/*** Basis-Kennungen anstelle Gruppen-Kennungen verwenden */
#define OPTIONS_BASICLABELS_PARM 0x00000001 /* verwenden/erhalten diese in ReParm */
#define OPTIONS_BASICLABELS_RESULT 0x00000002 /* erhalten diese in Re?Result */
#define OPTIONS_BASICLABELS 0x00000003 /* verwenden/erhalten diese always */
/*** Alternativen der Einstufung ausschließen, wenn möglich */
#define OPTIONS_EXCLUDE 0x00000010
/*** Nur Klassifikatoren für die ausgewählten Etiketten verwenden (Standard) */
#define OPTIONS_STRICTSELECT 0x00000020
/*** schnelle Gittererkennung mit geringerer Genauigkeit */
#define OPTIONS_FAST_GRID 0x00000040
#define OPTIONS_FAST_REC 0x00000080
#define OPTIONS_FAST 0x000000c0
/*** Wiederholt rec_do () mit zeichenabhängiger Binärisierung */
#define OPTIONS_REL_REC_REPEAT 0x00000100
/*** erkennen (klassifizieren) und löschen von unsinnigen Objekten in rel_do() */
/* Wenn Boxen erkannt werden, wird alles außerhalb der Boxen gelöscht */
#define OPTIONS_REL_CLEAN 0x00001000
#ifndef _INC_PENWIN
#define _INC_PENWIN
#define ALC_DEFAULT 0x00000000
#define ALC_LCALPHA 0x00000001
#define ALC_UCALPHA 0x00000002
#define ALC_ALPHA (ALC_LCALPHA|ALC_UCALPHA)
#define ALC_NUMERIC 0x00000004
#define ALC_ALPHANUMERIC (ALC_ALPHA|ALC_NUMERIC)
/* #define ALC_PUNC 0x00000008 - ersetzt durch ALC_SPECIAL */
/* #define ALC_MATH 0x00000010 - ersetzt durch ALC_SPECIAL */
/* #define ALC_MONETARY 0x00000020 - ersetzt durch ALC_SPECIAL */
/* #define ALC_OTHER 0x00000040 - ersetzt durch ALC_SPECIAL */
#define ALC_GESTURE 0x00004000
#endif
/* #define ALC_SPECIAL (ALC_PUNC|ALC_MATH|ALC_MONETARY|ALC_OTHER) */
#define ALC_SPECIAL 0x00000078
#define ALC_ACCENT 0x00000080
#define ALC_ALL (ALC_ALPHANUMERIC|ALC_SPECIAL|ALC_ACCENT|ALC_GESTURE)
/*** Fontspezifikation */
#define FONT_HAND 0x00000001
#define FONT_MACHINE 0x00000002
#define FONT_HM (FONT_HAND|FONT_MACHINE)
#define FONT_LATIN 0x00000010
#define FONT_FRAKTUR 0x00000020
#define FONT_GREEK 0x00000040
#define FONT_CYRILLIC 0x00000080
#define FONT_ARABIC 0x00000100
#define FONT_FARSI 0x00000200
#define FONT_HEBREW 0x00000400
#define FONT_THAI 0x00000800
#define FONT_LANGUAGE (FONT_LATIN|FONT_FRAKTUR|FONT_GREEK|FONT_CYRILLIC|FONT_ARABIC|FONT_FARSI|FONT_HEBREW|FONT_THAI)
#define FONT_OCRA 0x00020000
#define FONT_OCRB 0x00040000
#define FONT_CMC7 0x00080000
#define FONT_E13B 0x00100000
#define FONT_F7B 0x00200000
#define FONT_SEMI 0x00400000
#define FONT_LCD 0x00800000
#define FONT_BRAILLE 0x01000000
#define FONT_NORM (FONT_OCRA|FONT_OCRB|FONT_CMC7|FONT_E13B|FONT_F7B|FONT_SEMI|FONT_LCD|FONT_BRAILLE)
#define FONT_LN (FONT_LANGUAGE|FONT_NORM)
#define FONT_ALL (FONT_HM|FONT_LN)
/****************************************************************************
*
* Makros für den Zeilenpositionskontext Auswertung
*
****************************************************************************/
#define POS_NOLINECONTEXT 0x00000001 /* kein Linienkontext für die Erkennung */
#define POS_SOFTLINECONTEXT 0x00000002 /* leichter Linienkontext für die Erkennung */
#define POS_HARDLINECONTEXT 0x00000004 /* starker Linienkontext für die Erkennung */
#define POS_NOWORDCONTEXT 0x00000100 /* kein Wortzusammenhang (Großbuchstaben,
Kleinbuchstaben, Zahlen) */
/****************************************************************************
*
* wParam für WM_USER messages von RE?_* ( nur Windows )
*
****************************************************************************/
#define REC_MESSAGE 0x0100 /* lParam = &recdata */
#define RECACCENT_MESSAGE 0x0200 /* lParam = &recdata, wParam = &accents */
#define REL_MESSAGE 0x0400 /* lParam = &reldata */
#define RELFIND_MESSAGE 0x0800 /* lParam = &reldata */
#define REP_MESSAGE 0x1000 /* lParam = &repdata */
#define REX_IMGREADY 0x0020 /* Vorverarbeitung des Bildes durchgeführt */
#define REX_ERROR 0x0040 /* Fehlerrückgabe */
#define REX_FINISHED 0x0080 /* Modul ist beendet */
#define REP_LINE_CNT 0x1001 /* lParam = rep_result_len */
#define REP_RESULT 0x1002 /* lParam = &rep_result[.] */
/****************************************************************************
*
* Ergebnisstrukturen für rec_accent(), rel_do() and rep_do()
*
****************************************************************************/
#define REC_CHAR_SIZE 16 /* Größe von rec_char in Byte */
#define REC_ALT 8 /* maximale Anzahl von Erkennungsalternativen */
#define SEG_ALT 8 /* maximale Anzahl von Segmentierungsalternativen */
typedef struct RecGraph_tag {
short result_number[SEG_ALT]; /* Index der Ergebnisalternative in rec_result */
short next[SEG_ALT]; /* Index des nächsten Elements in RecGraph; -1:end */
} RecGraph;
typedef struct RelGrid_tag {
long grid; /* erkanntes Gitterelement (siehe GRID_ * -Makros) */
long subgrid_count; /* Anzahl der Subboxen der angegebenen Box oder Kamm */
long left, top; /* Position des Gitterelements */
long width, height;
} RelGrid;
typedef struct RelGraph_tag {
short leading_blanks; /* Anzahl der Leerzeichen vor dem Zeichen */
short filler[3]; /* 8-Byte-Ausrichtung */
short result_number[SEG_ALT]; /* Index der Ergebnisalternative in rel_result */
short next[SEG_ALT]; /* Index des nächsten Elements in RelGraph; -1:end */
short seg_value[SEG_ALT][SEG_ALT]; /* Sicherheit alternativer Segmentierungen */
} RelGraph;
#ifdef _MSC_VER
#pragma warning(disable:4201)
#endif
typedef struct RelResult_tag {
long left, top; /* Position des Zeichens im Linienbild */
long width, height;
long result_flags; /* RESULT_FLAG_RESPELL_CONFIRMED, ... */
void *result_image; /* segmentiertes Zeichenbild (falls nicht NULL) */
long result_width; /* Breite von result_image (kann komprimiert sein) */
long result_height; /* Höhe von result_image (kann komprimiert werden) */
long projection[2]; /* schräge Projektion auf der Grundlinie */
short italic, bold; /* stylus (Neigung, Dicke) */
short strokelen, black; /* Strichlänge, schwarze Pixel (%) */
#if defined(__STDC__)
char rec_char[REC_ALT][REC_CHAR_SIZE]; /* Erkennungsergebnis */
#else
union {
char rec_char[REC_ALT][REC_CHAR_SIZE]; /* Erkennungsergebnis, CP437-ISO_8859_15, ASCII,... */
short rec_char2[REC_ALT][REC_CHAR_SIZE/2]; /* Erkennungsergebnis, CODE_UTF_16 only */
};
#endif
unsigned char rec_value[REC_ALT]; /* Ungewissheit der Erkennung 0...255 */
long rec_top[REC_ALT]; /* Soll-Positionen im Linienbild */
long rec_bottom[REC_ALT]; /* Soll-Positionen im Linienbild */
} RelResult;
#define RecResult RelResult /* Wir verwenden dieselbe Datenstruktur in rec_accent () */
#define RESULT_FLAG_RESPELL_CONFIRMED 0x10000000 /* einstellen, wenn von RESPELL bestätigt */
#define RESULT_FLAG_RESPELL_GENERATED 0x20000000 /* gesetzt, wenn von RESPELL generiert */
#define RESULT_FLAG_RESPELL 0x30000000
#define RESULT_FLAG_UNDERLINED 0x40000000 /* nicht verwechseln mit RESULT_FLAG_UNDERLINE von re_layout Definiert */
#define RESULT_FLAG_ACCENT_TOP 0x01000000 /* Wird gesetzt, wenn das verwandte Zeichen der höchsten Akzent ist */
#define RESULT_FLAG_ACCENT_BOTTOM 0x02000000 /* Wird gesetzt, wenn das verwandte Zeichen der unterste Akzent ist */
#define RESULT_FLAG_ACCENT 0x03000000 /* RESULT_FLAG_ACCENT_TOP | RESULT_FLAG_ACCENT_BOTTOM */
#define RESULT_FLAG_ACCENT_START 0x00100000 /* erste Komponente eines Akzentzeichens */
#define RESULT_FLAG_ACCENT_MEMBER 0x00200000 /* Komponente eines Akzentzeichens */
#define RESULT_FLAG_ACCENT_END 0x00400000 /* letzte Komponente eines Zeichens mit Akzent */
#define RESULT_FLAG_REC_REPEAT 0x00010000 /* gesetzt, wenn das Zeichen zweimal erkannt wurde, mit bestimmter Vorverarbeitung */
#define RESULT_FLAG_REC_COMBINED 0x00020000 /* gesetzt, wenn das Ergebnis aus Basis und Akzenten kombiniert wurde */
/* Ergebnisflags für die BIDI-gesteuerte Ausgabe. Siehe BIDI-Übereinkommen des UNICODE-Konsortiums */
#define RESULT_FLAG_BIDI_LTR_EMBEDDING 0x00001000
#define RESULT_FLAG_BIDI_RTL_EMBEDDING 0x00002000
#define RESULT_FLAG_BIDI_POP_DIR_FORMAT 0x00004000
#define RESULT_FLAG_BIDI_LTR_MARK 0x00000100
#define RESULT_FLAG_BIDI_RTL_MARK 0x00000200
#define RESULT_FLAG_BIDI_SPACES_LTR 0x00000400 // Leerzeichen vor dem Zeichen ausgeben
#define RESULT_FLAG_BIDI_SPACES_RTL 0x00000800 // Leerzeichen nach Zeichen ausgeben
#define RESULT_FLAG_BIDI 0x0000FF00
#ifdef _MSC_VER
#pragma warning(default:4201)
#endif
typedef struct RepResult_tag {
long left, top; /* Position des Linienbildes im bereitgestellten Bild */
long width, height;
short rel_deskew; /* korrigierte Neigung des Linienbildes */
short rel_char_space; /* mittlere Zeichenbreite + Zwischenraum */
short rel_blank_width; /* Breite von blank (signalisiert proportionale Schrift) */
short rel_blank_min; /* Mindestbreite von blank (proportionale Schrift) */
short rel_grid_len; /* Anzahl der Elemente in rel_grid */
short rel_graph_len; /* Anzahl der Elemente in rel_graph */
short rel_result_len; /* Anzahl der Elemente in in rel_result */
short filler1; /* 8-Byte-Ausrichtung */
RelGrid *rel_grid; /* erkannte grid Elemente */
RelGraph *rel_graph; /* Knoten in der Segmentierung */
RelResult *rel_result; /* Ergebnis der Einzelzeichenerkennung */
void *filler2; /* 8-Byte-Ausrichtung */
} RepResult;
/****************************************************************************
*
* Modul REC
*
****************************************************************************/
#ifdef _MSC_VER
#pragma warning(disable:4201)
#endif
typedef struct RecData_tag {
ReInit init; /* setzen for rec_init() */
/*** Parametes für rec_do() - setzen nach rec_init() */
ReParm parm; /* Standardeinstellungen werden festgelegt mit rec_init() */
/*** Darstellung von Bilddaten */
ReImage image; /* zu erkennende Bilder */
long image_top; /* Bildposition in Zeile (falls bekannt) */
long image_bottom;
/*** Erkennungskontrolle */
long busy; /* !=0: Erkennung läuft */
INT_PTR hWND_rec_finished; /* Fenster zum Senden der WM_USER-Nachricht mit */
/* wParam == REC_MESSAGE */
/* wParam |= REX_ERROR im Fehlerfall */
/* wParam |= REX_IMGREADY nach der Vorverarbeitung */
/* wParam |= REX_FINISHED nach der Erkennung */
/* lParam == &recdata */
/* nach der Ausführung (nur Windows) */
/*** Ergebnisse von rec_do() */
long left, top; /* Position des Zeichens nach Schmutzentferung */
long width, height;
long result_flags; /* RESULT_FLAG_RESPELL_CONFIRMED, ... */
void *result_image; /* segmentiertes Zeichenbild (falls nicht NULL) */
long result_width; /* Breite von result_image (kann komprimiert sein) */
long result_height; /* Höhe von result_image (kann komprimiert werden) */
long projection[2]; /* schräge Projektion auf der Grundlinie */
short italic, bold; /* stylus (Schräge, Dicke) */
short strokelen, black; /* Strichlänge, schwarze Pixel (%) */
#if defined(__STDC__)
char rec_char[REC_ALT][REC_CHAR_SIZE]; /* Erkennungsergebnis */
#else
union {
char rec_char[REC_ALT][REC_CHAR_SIZE]; /* Erkennungsergebnis, CP437-ISO_8859_15 */
short rec_char2[REC_ALT][REC_CHAR_SIZE/2]; /* Erkennungsergebnis, CODE_UTF_16 */
};
#endif
unsigned char rec_value[REC_ALT]; /* Ungewissheit der Erkennung 0...255 */
long rec_top[REC_ALT]; /* Soll-Positionen im Linienbild */
long rec_bottom[REC_ALT]; /* Soll-Positionen im Linienbild */
} RecData;
#ifdef _MSC_VER
#pragma warning(default:4201)
#endif
extern KADMOS_ERROR KADMOS_API rec_init (RecData *, const char *file_title);
extern KADMOS_ERROR KADMOS_API rec_winit (RecData *, const wchar_t *file_title);
extern KADMOS_ERROR KADMOS_API rec_info (RecData *);
extern KADMOS_ERROR KADMOS_API rec_filetitle (const RecData *, char *file_title); /* char, wchar_t */
extern KADMOS_ERROR KADMOS_API rec_do (RecData *);
extern KADMOS_ERROR KADMOS_API rec_accent (RecData *, KADMOS_ERROR (KADMOS_API *rec_hook)(RecData *),
RecGraph *recg, int rec_graph_maxlen, int *rec_graph_len,
RecResult *accents, int rec_result_maxlen, int *rec_result_len);
/* recg entsprechend vor dem rec_accent()-Aufruf zuordnen */
extern KADMOS_ERROR KADMOS_API rec_group_labels (RecData *);
extern KADMOS_ERROR KADMOS_API rec_end (RecData *);
extern KADMOS_ERROR KADMOS_API rec_freeimages (RecData *); /* siehe TYPO_KEEPIMG */
extern KADMOS_ERROR KADMOS_API rec_get_features (const RecData *,
void **features,
char *type, /* in8, un16, ... */
int *dimension);
/****************************************************************************
*
* Modul REL
*
****************************************************************************/
typedef struct RelData_tag {
ReInit init; /* setzen vor rel_init() */
/*** parameters for rel_do() - setzen nach rel_init() */
ReParm parm; /* defaults will be set by rel_init() */
/*** representation of image data */
ReImage image; /* das zu erkennende Bild */
long image_top; /* horizontale Bildposition in Linie (falls bekannt) */
long image_bottom;
/*** recognition control */
long busy; /* !=0: Die Erkennung arbeitet */
INT_PTR hWND_rel_finished; /* Fenster zum Senden der WM_USER-Nachricht mit */
/* wParam == REL_MESSAGE */
/* wParam |= REX_ERROR im Fehlerfall */
/* wParam |= REX_IMGREADY nach der Vorverarbeitung */
/* wParam |= REX_FINISHED nach der Erkennung */
/* lParam == &reldata */
/* nach der Ausführung (nur Windows) */
/*** Wird verwendet, um Ergebnisse von jedem internen Anruf von rec_do() zu erhalten*/
KADMOS_ERROR (KADMOS_API *rec_hook)(RecData *); /* ausgeführt nach rec_do() */
void *filler1; /* 8-Byte-Ausrichtung */
/*** Ergebnisse von rel_do() */
long left, top; /* Position des Zeilenbildes im Vollbild */
long width, height;
short rel_deskew; /* korrigierte Neigung des Zeilenbildes */
short rel_char_space; /* mittlere Zeichenbreite + Zwischenraum */
short rel_blank_width; /* Breite von blank (signalisiert proportionale Schrift) */
short rel_blank_min; Mindestbreite von blank (proportionale Schrift) */
/*** Anzahl der Ergebnisse von rel_do () */
short rel_grid_len; /* Anzahl der Elemente in rel_grid */
short rel_graph_len; /* Anzahl der Elemente in in rel_graph */
short rel_result_len; /* Anzahl der Elemente in in rel_result */
short filler2; /* 8-Byte-Ausrichtung */
/*** Ergebnis von rel_do(), allokieren vor dem ersten Aufruf von rel_do() */
RelGrid *rel_grid; /* Erkante grid-Elemente */
RelGraph *rel_graph; /* Knoten der Segmentierung */
RelResult *rel_result; /* Ergebnisse der Einzelzeichenerkennung */
void *filler3; /* 8-Byte-Ausrichtung */
} RelData;
extern KADMOS_ERROR KADMOS_API rel_init (RelData *, const char *file_title);
extern KADMOS_ERROR KADMOS_API rel_winit (RelData *, const wchar_t *file_title);
extern KADMOS_ERROR KADMOS_API rel_info (RelData *);
extern KADMOS_ERROR KADMOS_API rel_filetitle (const RelData *, char *file_title); /* char, wchar_t */
extern KADMOS_ERROR KADMOS_API rel_do (RelData *);
extern KADMOS_ERROR KADMOS_API rel_group_labels (RelData *);
extern KADMOS_ERROR KADMOS_API rel_find (RelData *, int char_count);
extern KADMOS_ERROR KADMOS_API rel_findg (RelData *, int char_count, int area_width, int char_height, int char_width);
/* negativer Wert von char_count: up to ... */
extern KADMOS_ERROR KADMOS_API rel_end (RelData *);
#define SHADOW_FONT_HAND 0x01
#define SHADOW_FONT_MACHINE 0x02
extern KADMOS_ERROR KADMOS_API rel_lineshadow(RelData *, unsigned char **vertical_shadow);
extern KADMOS_ERROR KADMOS_API rel_freeimages(RelData *); /* siehe TYPO_KEEPIMG */
/*** APIs zur Unterstützung von Pen-Computing und Formularverarbeitung */
extern KADMOS_ERROR KADMOS_API rel_clear(RelData *);
extern KADMOS_ERROR KADMOS_API rel_recset(RelData *, const RecData *, const ReRect *);
extern KADMOS_ERROR KADMOS_API rel_rec_accent_set(RelData *, RecGraph *recg, int rec_graph_len,
RecResult *accents, int rec_result_len, const ReRect *);
extern KADMOS_ERROR KADMOS_API rel_corr(RelData *);
/*** APIs zur Unterstützung von Wörterbüchern und Rechtschreibprüfungen */
typedef struct RelBranch_tag {
short seg_alt_number;
short rec_alt_number;
} RelBranch;
extern unsigned char KADMOS_API rel_word_value(const RelGraph *relg, const RelResult *relr,
int rel_graph_len, int rel_result_len, int rel_graph_start,
const RelBranch *rel_branch, int rel_branch_len);
/****************************************************************************
*
* Modul REP
*
****************************************************************************/
typedef struct RepData_tag {
ReInit init; /* setzen vor rep_init() */
/*** Parameter for rep_do() - setzen nach rep_init() */
ReParm parm; /* Standardeinstellungen werden festgelegt durch rep_init() */
/*** Darstellung von Bilddaten */
ReImage image; /* zu erkennendes Bild */
/*** Erkennungskontrolle */
long busy; /* !=0: Erkennung arbeitet */
INT_PTR hWND_rep_finished; /* Fenster zum Senden der WM_USER-Nachricht mit */
/* wParam == REP_MESSAGE */
/* wParam |= REX_ERROR im Fehlerfall */
/* wParam |= REX_IMGREADY nach der Vorverarbeitung */
/* wParam |= REX_FINISHED nach der Erkennung */
/* lParam == &repdata */
/* nach der Ausführung (nur Windows) */
INT_PTR hWND_line_message; /* Fenster zum Senden von WM_USER-Nachrichten mit Ergebnissen */
/* nach der Erkennung jeder Zeile*/
/* wParam == REP_LINE_CNT oder */
/* wParam == REP_RESULT */
/* (nur Windows) */
long filler1; /* 8-Byte-Ausrichtung */
/*** Wird verwendet, um Ergebnisse zu erhalten von jedem internen Aufruf von rec_do() oder rel_do()*/
KADMOS_ERROR (KADMOS_API *rec_hook)(RecData *); /* ausgeführt nach rec_do() */
KADMOS_ERROR (KADMOS_API *rel_hook)(RelData *); /* ausgeführt nach rel_do() */
/*** Ergebnis von rep_do() */
short rep_deskew; /* korrigierte Neigung des Bildes */
short rep_result_len; /* Anzahl der Elemente in rep_result */
RepResult *rep_result; /* Ergebnisse der Zeilenerkennung */
} RepData;
extern KADMOS_ERROR KADMOS_API rep_init (RepData *, const char *file_title);
extern KADMOS_ERROR KADMOS_API rep_winit (RepData *, const wchar_t *file_title);
extern KADMOS_ERROR KADMOS_API rep_info (RepData *);
extern KADMOS_ERROR KADMOS_API rep_filetitle (const RepData *, char *file_title); /* char, wchar_t */
extern KADMOS_ERROR KADMOS_API rep_do (RepData *);
extern KADMOS_ERROR KADMOS_API rep_idcard (RepData *);
extern KADMOS_ERROR KADMOS_API rep_group_labels (RepData *);
extern KADMOS_ERROR KADMOS_API repr_group_labels(RepData *, RepResult *);
extern KADMOS_ERROR KADMOS_API rep_end (RepData *);
/****************************************************************************
*
* module RESPELL
*
* Erstellt mit Unterstützung von Milind Joshi, CK Pradeep
* IDEA TECHNOSOFT INC. info@ideatechnosoft.com, http://www.ideatechnosoft.com
*
* Für Wörterbuchunterstützung, diese Software (KADMOS.DLL, RESPELL.LIB) basiert
* zum Teil auf der Open-Source-Software Ispell.
* http://www.gnu.org/software/ispell/ispell.html
*
* Für Hunspell Wörterbuchunterstützung, die Datei HUNSPELL.DLL von der
* Open-Source-Software Hunspell software. Sie erhalten eine Kopie der Lizenz unter
* http://www.mozilla.org/MPL/.
*
****************************************************************************/
typedef struct ReSpellInit_tag {
/*** setzen vor respell_init() */
/* Initialisierung der Suche nach Ispell-Wörterbüchern */
long ispell_config; /* ispell Konfiguration - noch nicht verwendet */
/* initialization of respell */
short respell_maxlen; /* Maximale Länge legaler Wörter */
short rel_graph_out_maxlen; /* maximale Anzahl der Elemente in rel_graph_out */
short rel_result_out_maxlen; /* maximale Anzahl der Elemente in rel_result_out */
short result_text_maxlen; /* Maximale Anzahl von Zeichen in result_text */
short filler[2]; /* 8-Byte-Ausrichtung */
/*** interner Gebrcuh durch respell_init(), respell_do(), respell_end(), und respell_filetitle() */
INT_PTR interna1[4]; /* nicht ändern */
INT_PTR interna2[4]; /* nicht ändern */
INT_PTR interna3[4]; /* nicht ändern */
} ReSpellInit;
#define RESPELL_ALLOW_COMPOUND_WORDS 0x00000001
#define RESPELL_DICTIONARY_COMPLETE 0x00000002 /* Klassifikator-Kennungen einschränken auf Wörterbuch-Kennungen */
#define RESPELL_DICTIONARY_CONFIRM 0x00000004 /* Alle Ergebnisse werden im Wörterbuch nachgeschlagen,
nicht nur die schlechten */
typedef struct ReSpellParm_tag {
long respell_config; /* RESPELL_ALLOW_COMPOUND_WORDS ispell nur, Standard */
long respell_font; /* Einschränkung für die Verwendung des Wörterbuchs, siehe FONT_* makros */
short rel_alternative_maximum; /* Maximum von Wortalternativen (1...SEG_ALT); Standard 1 */
short filler1; /* 8 byte alignment */
/* Parameter wie in re*_textline() um den Ergebnistext zur Verfügung zu stellen */
unsigned char reject_level;
unsigned char filler2; /* 8-Byte-Ausrichtung */
short reject_char;
long text_format;
} ReSpellParm;
typedef struct ReSpellData_tag {
ReSpellInit init; /* setzen vor respell_init() */
/*** parameters for respell_do() - setzen nach respell_init() */
ReSpellParm parm; /* Standardwerte werden gesetzt durch respell_init() */
/* input data */
short rel_graph_in_len; /* Anzahl der Elemente in rel_graph_in */
short rel_result_in_len; /* Anzahl der Elemente in rel_result_in */
const RelGraph *rel_graph_in;
const RelResult *rel_result_in;
long rel_codepage;
/*** Verwenden einer privaten/oem-Rechtschreibprüfung für respell_do() */
KADMOS_ERROR (KADMOS_API *oem_spell_lookup)(const char *word, char *results, int results_size);
long oem_codepage; /* Codepage der privaten/oem-Rechtschreibprüfung */
char oem_wordchars[512]; /* alle Zeichen aller Wörter der privaten/oem-Rechtschreibprüfung */
short oem_reject_char; /* Rückweisunges-Zeichen der der privaten/oem-Rechtschreibprüfung */
short filler1[3]; /* 8-Byte-Ausrichtung */
/*** erneuter Aufruf von rel_do() für jedes einzelne Wort das nicht im Wörterbuch gefunden wurde */
const RelData *rel_repeat; /* nur eines (rel_repeat oder rep_repeat) st zui setzen wenn erforderlich */
/* rel_repeat hat die Erkennungsergebnisse zu enthalten
für rel_graph_in, rel_result_in */
const RepData *rep_repeat; /* mit rel_repeat oder rep_repeat, PREP_INPLACE darf nicht gesetzt werden
für das zugehörige .parm.prep */
RepResult *repr; /* Erkennungsergebnisse für erkannte Textzeile im Fall von rep_repeat */
/*** Anzahl der Ergebnisse von respell_do () */
short rel_graph_out_len;
short rel_result_out_len;
short result_text_len;
short filler2; /* 8-Byte-Ausrichtung */
/*** results of respell_do(), allokieren vor dem ersten Aufruf von respell_do() */
RelGraph *rel_graph_out;
RelResult *rel_result_out;
void *result_text;
void *filler3; /* 8-Byte-Ausrichtung */
} ReSpellData;
extern KADMOS_ERROR KADMOS_API respell_init (ReSpellData *, const char *file_title);
extern KADMOS_ERROR KADMOS_API respell_winit (ReSpellData *, const wchar_t *file_title);
extern KADMOS_ERROR KADMOS_API respell_do (ReSpellData *);
/* wenn rel_graph_in, rel_result_in erzeugt ist mit OPTIONS_BASICLABELS_RESULT, */
/* der Aufruf re*_group_labels() vor respell_do() */
extern KADMOS_ERROR KADMOS_API respell_lookup (ReSpellData *, long code, const char *word,
char *results, int results_size,
long text_format);
/* text_format für word und results kann 0 oder TEXT_FORMAT_KADMOS_MULTIBYTE sein */
extern KADMOS_ERROR KADMOS_API respell_end (ReSpellData *);
extern KADMOS_ERROR KADMOS_API respell_filetitle (ReSpellData *, char *file_title); /* char, wchar_t */
extern long KADMOS_API respell_codepage (ReSpellData *);
extern KADMOS_ERROR KADMOS_API respell_wordchars (ReSpellData *, char *wordchars, int wordchars_size);
extern short KADMOS_API respell_reject_char(ReSpellData *);
extern KADMOS_ERROR KADMOS_API respell_freeimages (ReSpellData *); /* siehe TYPO_KEEPIMG */
/****************************************************************************
*
* Modul RE_CDO
*
* Color-drop-out
* Erzeugt graue Bilder und Binärbilder aus Farbbildern sowie eine
* Liste von Rechtecken der Bildzeilen
*
****************************************************************************/
typedef struct ReCdoLine_tag {
ReRect rect;
short aoi_number;
short order_number;
unsigned char mask;
unsigned char gray;
unsigned char filler[2]; /* 8-Byte-Ausrichtung */
} ReCdoLine;
typedef struct ReCdoInit_tag {
short result_maxlen; /* maximale Anzahl der Elemente in result_line */
short filler[3]; /* 8-Byte-Ausrichtung */
/*** used internally by re_cdo_init(), re_cdo_do(), and re_cdo_end() */
INT_PTR interna[4]; /* nicht ändern */
} ReCdoInit;
typedef struct ReCdoData_tag {
ReCdoInit init;
/*** Parameter für re_cdo_do() - setzen nach re_cdo_init() */
ReParm parm; /* Die Standardwerte werdengesetzt durch re_cdo_init() */
/*** Bereiche von Interesse - setzen vor re_cdo_do() */
ReRect *aoi_rect; /* NULL bedeutet ganzes Bild */
short aoi_len; /* Anzahl der Elemente in aoi_rect */
/* Eingabedaten */
ReImage color_image_in;
/* Ausgabedaten */
ReImage gray_image_out;
ReImageHandle h_gray_image_out; /* Allokations-Handle von gray_image_out */
ReImage result_image_out;
ReImageHandle h_result_image_out; /* Allokations-Handle von result_image_out */
short result_len; /*** Anzahl der Ergebnisse von re_cdo_do() */
ReCdoLine *result_line; /*** Ergebnisse von re_cdo_do(),
zu allokieren vor dem erstan Aufruf von re_cdo_do() */
} ReCdoData;
extern KADMOS_ERROR KADMOS_API re_cdo_init (ReCdoData *, const char *rec_file_title);
extern KADMOS_ERROR KADMOS_API re_cdo_winit (ReCdoData *, const wchar_t *rec_file_title);
extern KADMOS_ERROR KADMOS_API re_cdo_do (ReCdoData *);
extern KADMOS_ERROR KADMOS_API re_cdo_end (ReCdoData *);
/****************************************************************************
*
* Modul RE_LAYOUT
*
* Layoutanalyse Findet den Textbereich in einem bestimmten Bild,
* nachdem deskewing eine Liste von Teilbildern mit Textabsätzen,
* Bildern oder Rastern zurückgibt
*
****************************************************************************/
#define RESULT_FLAG_NOTEXT 0
#define RESULT_FLAG_GRID 1
#define RESULT_FLAG_UNDERLINE 2 /* nicht verwechseln mit RESULT_FLAG_UNDERLINED rel REL definiert */
#define RESULT_FLAG_TEXT 4
typedef struct ReLayoutResult_tag {
ReRect subimage; /* Position von Teilbildern in image_in oder
im deskewed Eingabe-Bild */
long result_flag; /* RESULT_FLAG_NOTEXT, RESULT_FLAG_GRID, RESULT_FLAG_TEXT, ... */
long filler; /* 8-Byte-Ausrichtung */
ReImageHandle h_result_image_bw; /* Bid-Handle voneinem schwarzweissem Teilbild */
/* Aufruf von re_imagehandle2image() um result_image zu erhalten*/
/* Speicherfreigaben durch re_free_layout() */
} ReLayoutResult;
#define LAYOUT_CONTENT_ONLY 0x00000001 /* kein layout_results wird zurückgegeben,
nur Schrägstellung und Inhalt */
#define LAYOUT_OPTIONS_FAST_GRID OPTIONS_FAST_GRID /* schnelle grid-Erkennung */
typedef struct ReLayoutData_tag {
ReImage image_in; /* zu analysierendes Bild */
ReRect *expected_areas;
short expected_areas_len; /* Anzahl von expected_areas */
short filler1; /* 8-Byte-Ausrichtung */
long parameter; /* LAYOUT_CONTENT_ONLY, LAYOUT_OPTIONS_FAST_GRID */
/*** Ergebnisse von re_layout () */
ReImage image_deskewed; /* schrägstehendes Bild */
ReImageHandle h_image_deskewed; /* Bild-Handle des schrägstehendes Bildes wenn re_layout_deskew!=0;
Aufruf von re_freeimage(*.h_image_deskewed) zur Speicherfreigabe */
ReRect content; /* gefundenes Bereich von Interesse */
short re_layout_deskew; /* korrigierte Schräglage von image_in */
short re_layout_result_len; /* Anzahl der Elemente in re_layout_result */
short filler2[2]; /* 8-Byte-Ausrichtung */
ReLayoutResult *re_layout_result; /* Ergebnisse der Layoutanalyse -
Speicher wird freigegeben durch re_free_layout() */
} ReLayoutData;
extern KADMOS_ERROR KADMOS_API re_layout(ReLayoutData *);
extern KADMOS_ERROR KADMOS_API re_free_layout(ReLayoutData *);
/****************************************************************************
*
* Modul RE_PAGE
*
* Vollständige Seitenerkennung
* Führt eine Layoutanalyse durch und erkennt den Textbereich
*
****************************************************************************/
typedef struct RePageParm_tag {
RepData rep; /* initialisierter Klassifikator und Parameter zur Erkennung */
/* rep.init.rep_memory oder rep.init.rep_memory_size nicht setzen,
re_page() macht das intern */
/* aber rep.init.rel_grid_maxlen, .rel_graph_maxlen,
und .rel_result_maxlen setzen*/
ReSpellData respell1; /* initialisierte Rechtschreibprüfung Nummer eins oder nullter Speicher */
ReSpellData respell2; /* initialisierte Rechtschreibprüfung Nummer zwei oder nullter Speicher */
ReRect application_area; /* Anwendungsbereich für diesen Klassifikator und die Rechtschreibprüfung,
bezogen auf das Deskewed-Inhaltsbild */
} RePageParm;
typedef struct RePageResult_tag {
ReRect subimage; /* Position des Teilbildes in image_in oder im Deskewed-Inhaltsbild */
long result_flag; /* RESULT_FLAG_NOTEXT, RESULT_FLAG_GRID, RESULT_FLAG_TEXT, ... */
long filler1; /* 8-Byte-Ausrichtung */
ReImageHandle h_result_image_bw; /* Bild-Handle eines segmentierten Shwarz-Weiss-Teilbildes */
/* Aufruf von re_imagehandle2image() um result_image zu bekommen*/
/* Aufruf von re_freeimage(*.h_result_image_bw) zur Speicherfreigabe */
short block_number; /* Die Absätze einer Seite werden in Blöcken zusammengefasst */
/* block_number==0 means the paragraph is a block of its own */
short rep_result_len; /* Anzahl der Elemente in rep_result wenn result_flag==RESULT_FLAG_TEXT */
short filler2[2]; /* 8-Byte-Ausrichtung */
RepResult *rep_result; /* Ergebnisse der zeilenerkennung wenn result_flag==RESULT_FLAG_TEXT */
} RePageResult;
typedef struct RePageData_tag {
ReImage image_in; /* Bild, das erkannt werden soll */
long parameter; /* LAYOUT_OPTIONS_FAST_GRID */
long filler1; /* 8-Byte-Ausrichtung */
/*** results of re_page() */
ReImage image_deskewed; /* schrägstehendes Bild */
ReImageHandle h_image_deskewed; /* Bild-Handle des schrägstehenden Bildes wenn re_page_deskew!=0;
call re_freeimage(*.h_image_deskewed) to free memory */
ReRect content; /* gefundener Bereich von Interesse */
short re_page_deskew; /* korrigierte Schräglage von image_in */
short re_page_parm_len; /*Anzahl der Elemente in re_page_parm, zu setzen vor re_page() */
short filler2[2]; /* 8-Byte-Ausrichtung */
RePageParm *re_page_parm; /* Parameter für die Seitenerkennung, zu setzen vor re_page() */
short block_count; /* Die Absätze einer Seite werden in Blöcken zusammengefasst;
Anzahl der gefundenen realen Blöcke +1 */
short re_page_result_len; /* Anzahl der Elemente in re_page_result */
short filler3[2]; /* 8-Byte-Ausrichtung */
RePageResult *re_page_result; /* Ergebnisse der Seitenerkennung -
Aufruf von re_free(*.re_page_result) zur Speicherfreigabe */
} RePageData;
extern KADMOS_ERROR KADMOS_API re_page(RePageData *);
extern KADMOS_ERROR KADMOS_API re_free_page(RePageData *);
/****************************************************************************
*
* API zum Freigeben von Speicher, der von einer KADMOS-Funktion zugewiesen
* wurde, mit Ausnahme von ReImageHandle:
* re_free()
* APIs zur Unterstützung von Multithreading:
* re_ClearThreadData()
* APIs zum Kopieren, Speichern oder Wiederherstellen von Erkennungsparametern:
* re_copyparm(), re_readparm(), re_readparm2(), re_readparm3(),
* re_writeparm(), re_writeparm2(), re_writeparm3()
* re_wreadparm(), re_wreadparm2(), re_wreadparm3(),
* re_wwriteparm(), re_wwriteparm2(), re_wwriteparm3()
* APIs für die Konfigurationserkennung
* (nur Windows, reconfig.dll ist erforderlich):
* rec_config(), rel_config(), rel_config2(), rel_config3()
* rep_config(), rep_config2(), rep_config3(), re_config_close()
* APIs zum Lesen und Schreiben von Bilddateien
* (KADMOS.dll oder reimageio.lib ist erforderlich):
* re_openimagefile(), re_wopenimagefile() - öffnen einer Bilddatei
* re_readimagefile() - Aus einer geöffneten Bilddatei in ReImage-Daten lesen
* re_writeimagefile() - schreibe ein ReImage in eine geöffnete Bilddatei
* re_endofimagefile() - Ende der Datei prüfen
* re_closeimagefile() - Schliessen der Bilddatei
* re_readimage(), re_wreadimage() - Lesen Einzelbildes in die ReImage-Daten
* re_writeimage(), re_wwriteimage() - Schreibt ein ReImage in eine Bilddatei
* APIs zum Konvertieren von Bildern aus und in Bitmap-Daten:
* re_image2bmp() - ReImage-Daten in Bitmaps konvertieren
* re_bmp2image() - ReImage-Daten in Bitmaps konvertieren
* APIs zum Lesen / Schreiben von Bildern aus / in die Zwischenablage:
* re_clipboard2image() - Holt den Inhalt der Zwischenablage in ReImage-Daten
* re_image2clipboard() - kopiert ein ReImage in die Zwischenablage
* APIs zum Konvertieren von Bildern von und zu HBITMAP-Daten:
* re_image2hbitmap() - um ReImage-Daten in HBITMAP-Daten umzuwandeln
* re_hbitmap2image() - HBITMAP-Daten in ReImage-Daten konvertieren
* API zum Abrufen des Bildes von einem Bild-Handle:
* re_imagehandle2image() - Extrahiert den Inhalt eines Bild-Handles
* API, um zugewiesenen Speicher von allen Bildfunktionen oben freizugeben:
* re_freeimage() - Freigabe eines allokierten Speichers von einem Bild
* APIs zur Bearbeitung eines ReImage:
* re_createimage()
* re_cloneimage()
* re_subimage()
* re_rotateimage()
* re_getpixel()
* re_setpixel()
* re_fillimage()
* API zur Handhabung / Erweiterung von Ligaturen:
* code_wexpand_lig()
* APIs, um erkannte Textzeichenfolgen zu erhalten:
* rel_(w)textline(), repr_(w)textline(), rep_(w)textline()
*
****************************************************************************/
/****************************************************************************
*
* Für die PNG-Unterstützung verwendet diese Software (KADMOS.dll, reimageio.lib)
* Teile von libpng. Copyright 2000-2002, Glenn-Randers
*
* Für die JPEG-Unterstützung basiert diese Software (KADMOS.dll, reimageio.lib)
* zum Teil auf der Arbeit der Independent JPEG Group.
*
* Für die TIFF-Unterstützung basiert diese Software (KADMOS.dll, reimageio.lib)
* teilweise auf Arbeiten von Sam Leffler, Silicon Graphics Inc. und der
* University of California.
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
* Copyright (c) 1985, 1986 The Regents of the University of California
*
****************************************************************************/
/* freier Speicher, der von einer KADMOS-Funktion wie page_text
zugewiesen wurde, mit Ausnahme von ReImageHandle */
extern void KADMOS_API re_free(void *);
/* Unterstützung für Multithreading - Aufruf direkt vor dem Beenden eines Threads */
extern KADMOS_ERROR KADMOS_API re_ClearThreadData(void);
/* Erkennungsparameter kopieren */
extern KADMOS_ERROR KADMOS_API re_copyparm(const ReParm *source, ReParm *destination);
/* speichern, Erkennungsparameter wiederherstellen */
extern KADMOS_ERROR KADMOS_API re_readparm(ReParm *,
unsigned char *reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wreadparm(ReParm *,
unsigned char *reject_level, const wchar_t *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_readparm2(ReParm *, ReSpellParm *,
unsigned char *reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wreadparm2(ReParm *, ReSpellParm *,
unsigned char *reject_level, const wchar_t *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_readparm3(ReParm *, ReSpellParm *, ReSpellParm *,
unsigned char *reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wreadparm3(ReParm *, ReSpellParm *, ReSpellParm *,
unsigned char *reject_level, const wchar_t *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_writeparm(const ReParm *,
unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm(const ReParm *,
unsigned char reject_level, const wchar_t *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_writeparm2(const ReParm *, const ReSpellParm *,
unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm2(const ReParm *, const ReSpellParm *,
unsigned char reject_level, const wchar_t *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_writeparm3(const ReParm *, const ReSpellParm *, const ReSpellParm *,
unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm3(const ReParm *, const ReSpellParm *, const ReSpellParm *,
unsigned char reject_level, const wchar_t *file_title, const char *section);
#if (defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE)
/* Dialog zum Einstellen der Erkennungsparameter (Klassifikator konfigurieren) */
extern KADMOS_ERROR KADMOS_API rec_config(RecData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rel_config(RelData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rep_config(RepData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rel_config2(RelData *, ReSpellData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rep_config2(RepData *, ReSpellData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rel_config3(RelData *, ReSpellData *, ReSpellData *, unsigned char *reject_level);
extern KADMOS_ERROR KADMOS_API rep_config3(RepData *, ReSpellData *, ReSpellData *, unsigned char *reject_level);
extern void KADMOS_API re_config_close(void);
extern KADMOS_ERROR KADMOS_API about_kadmos(void);
/* Die oben genannten Funktionen sind in einer separaten DLL implementiert, */
Es wird keine Fehlerbehandlung unterstützt (außer dem Rückgabewert) */
#endif
/* Bilder von / in Dateien lesen / schreiben */
typedef void *ReFileHandle;
#if ((defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE)) || defined(_CONSOLE)
extern KADMOS_ERROR KADMOS_API GetPrivateFileName(char *file_title,
const char *filter, unsigned int mode, const char *boxtext,
const char *inifile, const char *section, const char *entry);
/* filter, mode, boxtext=Title siehe Windows-Funktion GetOpenFileName () */
/* inifile, section, entry siehe Windows-Funktion GetPrivateProfileString () */
#if !defined(_WIN32) && !defined(_WIN64) && !defined(OF_READ)
/* Wert von mode */
#define OF_READ 0x00000000
#define OF_CREATE 0x00001000 /* muss gesetzt werden, wenn die Datei nicht existiert! */
#define OF_PROMPT 0x00002000
#define OF_EXIST 0x00004000
#endif
#endif
extern ReFileHandle KADMOS_API re_openimagefile(const char *file_title, const char *mode);
extern ReFileHandle KADMOS_API re_wopenimagefile(const wchar_t *file_title, const char *mode);
/* mode: "r" für lesen, "w" für schreiben, "a" zum Anhängen */
extern ReImageHandle KADMOS_API re_readimagefile(ReFileHandle, long image_number, ReImage *image);
/* image_number=0 für das erste Bild in der Datei */
extern KADMOS_ERROR KADMOS_API re_writeimagefile(ReFileHandle, const ReImage *image);
/* Bilder werden immer am Ende der Datei geschrieben */
extern int KADMOS_API re_endofimagefile(ReFileHandle);
/* gibt 1 im Fall von eof zurück, sonst 0 */
extern KADMOS_ERROR KADMOS_API re_closeimagefile(ReFileHandle);
/* ein oder erstes Bild aus einer Datei lesen */
extern ReImageHandle KADMOS_API re_readimage(const char *file_title, ReImage *image);
extern ReImageHandle KADMOS_API re_wreadimage(const wchar_t *file_title, ReImage *image);
/* Bilder aus ReImage-Daten in Bilddateien schreiben */
extern KADMOS_ERROR KADMOS_API re_writeimage(const ReImage *image, const char *file_title);
extern KADMOS_ERROR KADMOS_API re_wwriteimage(const ReImage *image, const wchar_t *file_title);
/* Bilder von ReImage-Daten in Bitmap-Daten konvertieren */
/* Bmp_buffer zeigt auf eine BITMAPINFOHEADER-Struktur */
/* Die Bitmap-Bits werden an Position zurückgegeben: */
/* (char *)bmp_buffer + (BITMAPINFOHEADER*)bmp_buffer->biSize + */
/* (BITMAPINFOHEADER*)bmp_buffer->biClrUsed * sizeof(RGBQUAD) */
extern ReImageHandle KADMOS_API re_image2bmp(const ReImage *image, void **bmp_buffer);
/* Bilder aus Bitmap-Daten in ReImage-Daten konvertieren */
/* Es wird erwartet, dass bmp_buffer auf eine BITMAPINFOHEADER-Struktur verweist */
/* Für bmp_bits == NULL werden die Bits an Position erwartet: */
/* (char *)bmp_buffer + ((BITMAPINFOHEADER*)bmp_buffer)->biSize + */
/* ((BITMAPINFOHEADER*)bmp_buffer)->biClrUsed * sizeof(RGBQUAD) */
extern ReImageHandle KADMOS_API re_bmp2image(const void *bmp_buffer, const void *bmp_bits, ReImage *image);
#if (defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE)
/* Inhalt der Zwischenablage abrufen */
extern ReImageHandle KADMOS_API re_clipboard2image(ReImage *image);
/* platziert ein Bild in der Zwischenablage */
extern KADMOS_ERROR KADMOS_API re_image2clipboard(const ReImage *image);
/* Bilder von HBITMAP-Handles in ReImage-Daten konvertieren */
extern ReImageHandle KADMOS_API re_hbitmap2image(HBITMAP hbmp, ReImage *image);
/* Konvertieren von Bildern aus ReImage-Daten in HBITMAP-Handles */
extern KADMOS_ERROR KADMOS_API re_image2hbitmap(const ReImage *image, HBITMAP *hbmp);
/* Zur Freigabe des HBITMAP-Handles hbmp nach der Verwendung, DeleteObject (hbmp) aufrufen. */
#endif
/* holt das Bild von einem Bild-Handle */
extern KADMOS_ERROR KADMOS_API re_imagehandle2image(ReImageHandle, ReImage *image);
/* Giebt den von den oben genannten Funktionen zugewiesenen Speicher frei */
extern KADMOS_ERROR KADMOS_API re_freeimage(ReImageHandle);
/* Erstellen / Zuordnen eines leeren Bildes basierend auf der Angabe im Parameter 'image' */
extern ReImageHandle KADMOS_API re_createimage(ReImage *image);
/* ein vorhandenes Bild duplizieren */
extern ReImageHandle KADMOS_API re_cloneimage(const ReImage *image, ReImage *cloneimage);
/* Erzeugen eines Teilbildes eines vorhandenen Bildes */
extern ReImageHandle KADMOS_API re_subimage(const ReImage *image, const ReRect *rect, ReImage *subimage);
/* ein Bild drehen */
extern ReImageHandle KADMOS_API re_rotateimage(const ReImage *image, ReImage *rotateimage, int angle);
/* Festlegen oder Abrufen der Pixelfarbe in Pixelbildern */
extern KADMOS_ERROR KADMOS_API re_setpixel(ReImage *image, long x, long y, long color);
extern KADMOS_ERROR KADMOS_API re_getpixel(const ReImage *image, long x, long y, long *color);
/* Füllen Sie ein Pixelbild (oder ein Bild-> Teilbild, falls angegeben) mit Farbe */
extern KADMOS_ERROR KADMOS_API re_fillimage(ReImage *image, long color);
/* erweitert die Ligaturen, falls vorhanden, andernfalls kopiert das Label von src nach dst */
/* Gibt die Anzahl der (w) Zeichen zurück, die in dst geschrieben wurden */
extern int KADMOS_API code_expand_lig(const char *src, char *dst, long code);
#define TEXT_FORMAT_ANSI 0x00000001 /* default, gilt auch für CODE_UTF_16 oder CODE_UTF_8 */
#define TEXT_FORMAT_POSTSCRIPT 0x00000002 /* noch nicht implementiert */
#define TEXT_FORMAT_XML 0x00000004 /* Codepage UTF8 */
#define TEXT_FORMAT_PDF 0x00000008 /* gilt für jede von KADMOS unterstützte Codepage */
#define TEXT_FORMAT_LEFT_TO_RIGHT 0x00100000 /* für Latin, Cyrillic,... gemischt mit Hebrew, Arabic,... */
#define TEXT_FORMAT_RIGHT_TO_LEFT 0x00200000 /* für Hebrew, Arabic,... gemischt mit Latin, Cyrillic,... */
#define TEXT_FORMAT_ACCENTS_BOTTOM_UP 0x01000000 /* Reihenfolge der oberen Akzente von unten nach oben - Standard */
#define TEXT_FORMAT_ACCENTS_TOP_DOWN 0x02000000 /* obere Akzente von oben nach unten */
#define TEXT_FORMAT_KADMOS_MULTIBYTE 0x10000000 /* Multi-Byte-Labels zurückgeben */
#define TEXT_FORMAT_OMIT_BIDI_CONTROL 0x20000000 /* für BIDI-Text ohne Ausgabe von 0x202D or 0x202E */
#define TEXT_FORMAT_RELGRAPH_INDICES 0x40000000 /* Rückgabewerte als kurzes Array, beendet durch -1 */
#define TEXT_FORMAT_RELRESULT_INDICES 0x80000000 /* Rückgabewerte als kurzes Array, beendet durch -1 */
extern KADMOS_ERROR KADMOS_API rel_textline(const RelData *, void *buffer,
int buffsize, unsigned char reject_level,
int reject_char, long text_format);
extern KADMOS_ERROR KADMOS_API repr_textline(const RepResult *, long code,
void *buffer, int buffsize,
unsigned char reject_level,
int reject_char, long text_format);
extern KADMOS_ERROR KADMOS_API rep_textline(const RepData *, int line_number,
void *buffer, int buffsize,
unsigned char reject_level,
int reject_char, long text_format);
/* den vollständigen Ergebnistext eines Absatzes erhalten; rep.init.rep_memory muss zugewiesen werden */
/* Aufruf von free(return_value), um Speicher freizugeben */
extern void * KADMOS_API rep_text(const RepData *, unsigned char reject_level, int reject_char,
char *indent, int indent_count, long text_format);
/* vollen Text einer Seite erhalten */
/* Aufruf von free(return_value), um Speicher freizugeben */
extern void * KADMOS_API page_text(const RePageData *, int page_number, unsigned char reject_level, int reject_char,
char *indent, int indent_count, long text_format);
/****************************************************************************
*
* APIs zum Sammeln von Bildern
*
****************************************************************************/
/* Aufruf vor dem ersten Aufruf von rec_do (), rel_do () oder rep_do () */
extern KADMOS_ERROR KADMOS_API re_collect_init(const char *image_file_title,
unsigned char save_value_min,
unsigned char save_value_max);
extern KADMOS_ERROR KADMOS_API re_collect_winit(const wchar_t *image_file_title,
unsigned char save_value_min,
unsigned char save_value_max);
/* Aufruf nach rec_do () oder als rec_hook vor dem Aufruf von rel_do (), rep_do () gesetzt */
extern KADMOS_ERROR KADMOS_API rec_collect_kernel(const RecData *rec);
/* Aufruf nach rel_do () oder als rel_hook vor dem Aufruf von rep_do () */
/* Geben Sie jedoch TYPO_KEEPIMG an, um korrekte Bilder zu erhalten */
extern KADMOS_ERROR KADMOS_API rel_collect_kernel(const RelData *rel);
/* Aufruf, um die Sammlung zu stoppen und die Bilddatei korrekt zu schliessen */
extern KADMOS_ERROR KADMOS_API re_collect_end(void);
#if (defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE)
/****************************************************************************
*
* hook engine interface
*
* Wenn KADMOSHookEngine leer ist, wird unter Windows bei jedem Aufruf
* von rec_init (), rel_init () oder rep_init () nach einem Hook-Modul
* gesucht, es wird geladen, falls es gefunden wird, und das Flag
* GENERAL_HOOKENGINE_LOADED wird gesetzt.
*
* Eine Hook Engine muss durch Setzen von GENERAL_HOOKENGINE_ON aktiviert
* werden, bevor rec_do (), rel_do () oder rep_do () aufgerufen wird.
*
****************************************************************************/
typedef struct HookEngineData_tag {
KADMOS_ERROR (KADMOS_API *HookRecDoStart)(RecData *);
KADMOS_ERROR (KADMOS_API *HookRecDoEnd)(RecData *);
KADMOS_ERROR (KADMOS_API *HookRelDoStart)(RelData *);
KADMOS_ERROR (KADMOS_API *HookRelDoEnd)(RelData *);
KADMOS_ERROR (KADMOS_API *HookRepDoStart)(RepData *);
KADMOS_ERROR (KADMOS_API *HookRepDoEnd)(RepData *);
} HookEngineData;
extern HookEngineData KadmosHookEngine;
#endif /* (defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE) */
/****************************************************************************
*
* APIs zur Unterstützung von Visual Basic. To use, include <wtypes.h>
* re_ArrayToString(): convert arrays into Visual Basic 'String'
* re_StringToArray(): convert Visual Basic 'String' into arrays
* re_ErrorText_bas: Visual Basic version of structure re_ErrorText
* re_GetErrorText_bas(): Visual Basic version of re_GetErrorText()
* re_SetErrorText_bas(): Visual Basic version of re_SetErrorText()
* re_DisplayErrorText_bas(): VB version of re_DisplayErrorText()
* Zeiger auf KADMOS-Funktionen übergeben:
* GetPointer(): Gib einen Pointer zurück als 'INT_PTR'
* FunctionAddress(): Rückgabe einer Funktionsadresse als 'INT_PTR'
* GetRe*(): Daten aus einem Array-Element in eine Struktur kopieren
* SetRe*(): Daten aus einer Struktur in ein Array-Element kopieren
*
****************************************************************************/
#if defined(_WIN32) && defined(__wtypes_h__)
/* Konvertiert Arrays in Visual Basic-Zeichenfolgen und umgekehrt */
KADMOS_ERROR KADMOS_API re_ArrayToString(void *array, BSTR *bstr, long maxlen, long array_type);
KADMOS_ERROR KADMOS_API re_StringToArray(BSTR *bstr, void *array, long maxlen, long array_type);
#define ARRAY_TYPE_BYTE 0
#define ARRAY_TYPE_WCHAR 1
#pragma pack(push)
#pragma pack(4)
typedef struct re_ErrorText_bas_tag {
int ident;
BSTR program;
BSTR text;
BSTR systext;
int private_data;
} re_ErrorText_bas;
#pragma pack(pop)
KADMOS_ERROR KADMOS_API re_GetErrorText_bas(re_ErrorText_bas *errtext);
void KADMOS_API re_SetErrorText_bas(re_ErrorText_bas *errtext);
void KADMOS_API re_DisplayErrorText_bas(re_ErrorText_bas *errtext);
#endif /* defined(_WIN32) && defined(__wtypes_h__) */
/* Zeiger auf KADMOS-Funktionen übergeben */
INT_PTR KADMOS_API GetPointer(void *p);
INT_PTR KADMOS_API FunctionAddress(INT_PTR p);
/* Get*(): copy data from an array element into a structure */
/* Set*(): Daten aus einer Struktur in ein Array-Element kopieren */
extern KADMOS_ERROR KADMOS_API GetRelGridParm(const RelGridParm*, int n, RelGridParm*);
extern KADMOS_ERROR KADMOS_API SetRelGridParm(const RelGridParm*, RelGridParm*, int n);
extern KADMOS_ERROR KADMOS_API GetRelGrid(const RelGrid*, int n, RelGrid*);
extern KADMOS_ERROR KADMOS_API SetRelGrid(const RelGrid*, RelGrid*, int n);
extern KADMOS_ERROR KADMOS_API GetRelGraph(const RelGraph*, int n, RelGraph*);
extern KADMOS_ERROR KADMOS_API SetRelGraph(const RelGraph*, RelGraph*, int n);
extern KADMOS_ERROR KADMOS_API GetRelResult(const RelResult*, int n, RelResult*);
extern KADMOS_ERROR KADMOS_API SetRelResult(const RelResult*, RelResult*, int n);
extern KADMOS_ERROR KADMOS_API GetRepResult(const RepResult*, int n, RepResult*);
extern KADMOS_ERROR KADMOS_API SetRepResult(const RepResult*, RepResult*, int n);
/****************************************************************************
*
* APIs to support Delphi
*
* re_CharArrayToPointer(): copy the Char Array content to memory
* re_PointerToCharArray(): copy the memory content to Char Array
*
****************************************************************************/
extern void KADMOS_API re_CharArrayToPointer(const char *array, void *pointer, long len);
extern void KADMOS_API re_PointerToCharArray(void *pointer, char *array, long len);
#ifdef __cplusplus
}
#endif
#endif /* INC_KADMOS */