KADMOS.h

/****************************************************************************
*
*  KADMOS.h
*
*  $Date: 19-Sep-2018 08:32 $
*
*  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 "8.0a"
#define KADMOS_MAJOR 0x70
#define KADMOS_MINOR 'a'

#define KADMOS_MKVER(major, minor) (((major)<<8) | (minor))
#define KADMOS_VERSION KADMOS_MKVER(KADMOS_MAJOR, KADMOS_MINOR)
/* Verwendungsbeispiel: #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);  // Nur DLL-Version; 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

/*  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 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    /* vom höchstwertigsten zum niedrigsten Bit */
  #define FILLORDER_LSB2MSB 2    /* vom niedrigsten zum höchstwertigsten 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 ().
****************************************************************************/
      
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  options;                 /* exclude, use basic labels, ... */
  long  labels_size;             /* Grösse der Allokation der Kennunge und Rückweisungen in Byte */
  short *wlabels;                /* aktive Kennungen, CODE_UTF_16 */
  short *wrejects;               /* aktive Rückweisungen, CODE_UTF_16 */
                                 /* nur für Parameter OPTIONS_RESTRICT_LABELS verwenden */
  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_* Makros */

  /*** hook - für den privaten Gebrauch */
  INT_PTR hookparm;              /* kopiert von REP nach REL, von REL nach REC */
} ReParm;        
      
/****************************************************************************
*
*  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 */
                                             /* sollte im Server-Mode nicht gesetzt werden, 
                                                wenn mehrere KADMOS Instanzen parallel 
                                                gestartet werden */
                                             /* 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_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 */
      
/****************************************************************************
*
*  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_WCHAR_SIZE 32  /* Größe von rec_wchar in Byte */
#define REC_WCHAR_COUNT 32 /* Anzahl der Zeichen in rec_wchar */
#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;

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 (%) */

  short rec_wchar[REC_ALT][REC_WCHAR_COUNT]; /* Erkennungsergebnis */
  unsigned char rec_value[REC_ALT];  /* uncertainty of recognition 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 
      
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
*
****************************************************************************/

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 (%) */

  short  rec_wchar[REC_ALT][REC_WCHAR_COUNT]; /* Erkennnungsergebnis */
  unsigned char rec_value[REC_ALT];  /* Unsicherheit der Erkennung 0...255 */

  long rec_top[REC_ALT];     /* Soll-Positionen */
  long rec_bottom[REC_ALT];  /* Soll-Positionen sein */
} RecData;

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;
  
   /*** 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 *, long labels_code,
       unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm(const ReParm *, long labels_code,
       unsigned char reject_level, const wchar_t *file_title, const char *section);

extern KADMOS_ERROR KADMOS_API re_writeparm2(const ReParm *, long labels_code, const ReSpellParm *,
       unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm2(const ReParm *, long labels_code, const ReSpellParm *,
       unsigned char reject_level, const wchar_t *file_title, const char *section);

extern KADMOS_ERROR KADMOS_API re_writeparm3(const ReParm *, long labels_code, const ReSpellParm *, 
       const ReSpellParm *, unsigned char reject_level, const char *file_title, const char *section);
extern KADMOS_ERROR KADMOS_API re_wwriteparm3(const ReParm *, long labels_code, 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_wexpand_lig(const UINT16 *src, UINT16 *dst);

#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, 
       long buffer_code, unsigned char reject_level, int reject_char, long text_format);
extern KADMOS_ERROR KADMOS_API repr_textline(const RepResult *, void *buffer, int buffsize, 
       long buffer_code, 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, 
       long buffer_code, 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 *, long output_code, 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, long output_code, 
       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 */