entangledstate-isbn 1.4.0 → 1.4.1

data/src/gocr-0.48/src/gocr.c

@@ -0,0 +1,373 @@
+/*
+This is a Optical-Character-Recognition program
+Copyright (C) 2000-2009  Joerg Schulenburg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+ see README for EMAIL-address
+
+  sometimes I have written comments in german language, sorry for that
+
+ This file was retrieved from pgm2asc.cc of Joerg, in order to have
+ a library of the ocr-engine from Klaas Freitag
+ 
+ */
+#include "config.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#ifdef HAVE_GETTIMEOFDAY 
+#include <sys/time.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "pnm.h"
+#include "pgm2asc.h"
+#include "pcx.h"
+#include "ocr0.h"		/* only_numbers */
+#include "progress.h"
+#include "version.h"
+
+static void out_version(int v) {
+  fprintf(stderr, " Optical Character Recognition --- gocr "
+          version_string " " release_string "\n"
+          " Copyright (C) 2001-2009 Joerg Schulenburg  GPG=1024D/53BDFBE3\n"
+          " released under the GNU General Public License\n");
+  /* as recommended, (c) and license should be part of the binary */
+  /* no email because of SPAM, see README for contacting the author */
+  if (v)
+    fprintf(stderr, " use option -h for help\n");
+  if (v & 2)
+    exit(1);
+  return;
+}
+
+static void help(void) {
+  out_version(0);
+  /* output is shortened to essentials, see manual page for details */
+  fprintf(stderr,
+	  " using: gocr [options] pnm_file_name  # use - for stdin\n"
+	  " options (see gocr manual pages for more details):\n"
+	  " -h, --help\n"
+	  " -i name   - input image file (pnm,pgm,pbm,ppm,pcx,...)\n"
+	  " -o name   - output file  (redirection of stdout)\n"
+	  " -e name   - logging file (redirection of stderr)\n"
+	  " -x name   - progress output to fifo (see manual)\n"
+	  " -p name   - database path including final slash (default is ./db/)\n");
+  fprintf(stderr, /* string length less than 509 bytes for ISO C89 */
+	  " -f fmt    - output format (ISO8859_1 TeX HTML XML UTF8 ASCII)\n"
+	  " -l num    - threshold grey level 0<160<=255 (0 = autodetect)\n"
+	  " -d num    - dust_size (remove small clusters, -1 = autodetect)\n"
+	  " -s num    - spacewidth/dots (0 = autodetect)\n"
+	  " -v num    - verbose (see manual page)\n"
+	  " -c string - list of chars (debugging, see manual)\n"
+	  " -C string - char filter (ex. hexdigits: ""0-9A-Fx"", only ASCII)\n"
+	  " -m num    - operation modes (bitpattern, see manual)\n");
+  fprintf(stderr, /* string length less than 509 bytes for ISO C89 */
+	  " -a num    - value of certainty (in percent, 0..100, default=95)\n"
+	  " -u string - output this string for every unrecognized character\n");
+  fprintf(stderr, /* string length less than 509 bytes for ISO C89 */
+	  " examples:\n"
+	  "\tgocr -m 4 text1.pbm                   # do layout analyzis\n"
+	  "\tgocr -m 130 -p ./database/ text1.pbm  # extend database\n"
+	  "\tdjpeg -pnm -gray text.jpg | gocr -    # use jpeg-file via pipe\n"
+	  "\n");
+  fprintf(stderr, " webpage: http://jocr.sourceforge.net/\n");
+  exit(0);
+}
+
+#ifdef HAVE_GETTIMEOFDAY
+/* from the glibc documentation */
+static int timeval_subtract (struct timeval *result, struct timeval *x, 
+    struct timeval *y) {
+
+  /* Perform the carry for the later subtraction by updating Y. */
+  if (x->tv_usec < y->tv_usec) {
+    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
+    y->tv_usec -= 1000000 * nsec;
+    y->tv_sec += nsec;
+  }
+  if (x->tv_usec - y->tv_usec > 1000000) {
+    int nsec = (x->tv_usec - y->tv_usec) / 1000000;
+    y->tv_usec += 1000000 * nsec;
+    y->tv_sec -= nsec;
+  }
+
+  /* Compute the time remaining to wait.
+     `tv_usec' is certainly positive. */
+  result->tv_sec = x->tv_sec - y->tv_sec;
+  result->tv_usec = x->tv_usec - y->tv_usec;
+
+  /* Return 1 if result is negative. */
+  return x->tv_sec < y->tv_sec;
+}
+#endif
+
+static void process_arguments(job_t *job, int argn, char *argv[])
+{
+  int i;
+  char *s1;
+
+  assert(job);
+
+  if (argn <= 1) {
+    out_version(1);
+    exit(0);
+  }
+#ifdef HAVE_PGM_H
+  pnm_init(&argn, &argv);
+#endif
+  
+  /* process arguments */
+  for (i = 1; i < argn; i++) {
+    if (strcmp(argv[i], "--help") == 0)
+      help(); /* and quits */
+    if (argv[i][0] == '-' && argv[i][1] != 0) {
+      s1 = "";
+      if (i + 1 < argn)
+	s1 = argv[i + 1];
+      switch (argv[i][1]) {
+      case 'h': /* help */
+	help();
+	break;
+      case 'i': /* input image file */
+	job->src.fname = s1;
+	i++;
+	break;
+      case 'e': /* logging file */
+	if (s1[0] == '-' && s1[1] == '\0') {
+#ifdef HAVE_UNISTD_H
+          dup2(STDOUT_FILENO, STDERR_FILENO); /* -e /dev/stdout  works */
+#else
+	  fprintf(stderr, "stderr redirection not possible without unistd.h\n");
+#endif           
+	}
+	else if (!freopen(s1, "w", stderr)) {
+	  fprintf(stderr, "stderr redirection to %s failed\n", s1);
+	}
+	i++;
+	break;
+      case 'p': /* database path */
+	job->cfg.db_path=s1;
+	i++;
+	break;
+      case 'o': /* output file */
+	if (s1[0] == '-' && s1[1] == '\0') {	/* default */
+	}
+	else if (!freopen(s1, "w", stdout)) {
+	  fprintf(stderr, "stdout redirection to %s failed\n", s1);
+	};
+	i++;
+	break;
+      case 'f': /* output format */
+        if (strcmp(s1, "ISO8859_1") == 0) job->cfg.out_format=ISO8859_1; else
+        if (strcmp(s1, "TeX")       == 0) job->cfg.out_format=TeX; else
+        if (strcmp(s1, "HTML")      == 0) job->cfg.out_format=HTML; else
+        if (strcmp(s1, "XML")       == 0) job->cfg.out_format=XML; else
+        if (strcmp(s1, "SGML")      == 0) job->cfg.out_format=SGML; else
+        if (strcmp(s1, "UTF8")      == 0) job->cfg.out_format=UTF8; else
+        if (strcmp(s1, "ASCII")     == 0) job->cfg.out_format=ASCII; else
+        fprintf(stderr,"Warning: unknown format (-f %s)\n",s1);
+        i++;
+        break;
+      case 'c': /* list of chars (_ = not recognized chars) */
+	job->cfg.lc = s1;
+	i++;
+	break;
+      case 'C': /* char filter, default: NULL (all chars) */
+        /* ToDo: UTF8 input, wchar */
+	job->cfg.cfilter = s1;
+	i++;
+	break;
+      case 'd': /* dust size */
+	job->cfg.dust_size = atoi(s1);
+	i++;
+	break;
+      case 'l': /* grey level 0<160<=255, 0 for autodetect */
+	job->cfg.cs = atoi(s1);
+	i++;
+	break;
+      case 's': /* spacewidth/dots (0 = autodetect) */
+	job->cfg.spc = atoi(s1);
+	i++;
+	break;
+      case 'v': /* verbose mode */
+	job->cfg.verbose |= atoi(s1);
+	i++;
+	break;
+      case 'm': /* operation modes */
+	job->cfg.mode |= atoi(s1);
+	i++;
+	break;
+      case 'n': /* numbers only */
+	job->cfg.only_numbers = atoi(s1);
+	i++;
+	break;
+      case 'x': /* initialize progress output s1=fname */
+	ini_progress(s1);
+	i++;
+	break;
+      case 'a': /* set certainty */
+	job->cfg.certainty = atoi(s1);;
+	i++;
+	break;
+      case 'u': /* output marker for unrecognized chars */
+        job->cfg.unrec_marker = s1;
+        i++;
+        break;
+      default:
+	fprintf(stderr, "# unknown option use -h for help\n");
+      }
+      continue;
+    }
+    else /* argument can be filename v0.2.5 */ if (argv[i][0] != '-'
+						   || argv[i][1] == '\0' ) {
+      job->src.fname = argv[i];
+    }
+  }
+}
+
+static void mark_start(job_t *job) {
+  assert(job);
+
+  if (job->cfg.verbose) {
+    out_version(0);
+    /* insert some helpful info for support */
+    fprintf(stderr, "# compiled: " __DATE__ );
+#if defined(__GNUC__)
+    fprintf(stderr, " GNUC-%d", __GNUC__ );
+#endif
+#ifdef __GNUC_MINOR__
+    fprintf(stderr, ".%d", __GNUC_MINOR__ );
+#endif
+#if defined(__linux)
+    fprintf(stderr, " linux");
+#elif defined(__unix)
+    fprintf(stderr, " unix");
+#endif
+#if defined(__WIN32) || defined(__WIN32__)
+    fprintf(stderr, " WIN32");
+#endif
+#if defined(__WIN64) || defined(__WIN64__)
+    fprintf(stderr, " WIN64");
+#endif
+#if defined(__VERSION__)
+    fprintf(stderr, " version " __VERSION__ );
+#endif
+    fprintf(stderr, "\n");
+    fprintf(stderr,
+      "# options are: -l %d -s %d -v %d -c %s -m %d -d %d -n %d -a %d -C \"%s\"\n",
+      job->cfg.cs, job->cfg.spc, job->cfg.verbose, job->cfg.lc, job->cfg.mode, 
+      job->cfg.dust_size, job->cfg.only_numbers, job->cfg.certainty,
+      job->cfg.cfilter);
+    fprintf(stderr, "# file: %s\n", job->src.fname);
+#ifdef USE_UNICODE
+    fprintf(stderr,"# using unicode\n");
+#endif
+#ifdef HAVE_GETTIMEOFDAY
+    gettimeofday(&job->tmp.init_time, NULL);
+#endif
+  }
+}
+
+static void mark_end(job_t *job) {
+  assert(job);
+
+#ifdef HAVE_GETTIMEOFDAY
+  /* show elapsed time */
+  if (job->cfg.verbose) {
+    struct timeval end, result;
+    gettimeofday(&end, NULL);
+    timeval_subtract(&result, &end, &job->tmp.init_time);
+    fprintf(stderr,"Elapsed time: %d:%02d:%3.3f.\n", (int)result.tv_sec/60,
+	(int)result.tv_sec%60, (float)result.tv_usec/1000);
+  }
+#endif
+}
+
+static int read_picture(job_t *job) {
+  int rc=0;
+  assert(job);
+
+  if (strstr(job->src.fname, ".pcx"))
+    readpcx(job->src.fname, &job->src.p, job->cfg.verbose);
+  else
+    rc=readpgm(job->src.fname, &job->src.p, job->cfg.verbose);
+  return rc; /* 1 for multiple images, 0 else */
+}
+
+/* subject of change, we need more output for XML (ToDo) */
+void print_output(job_t *job) {
+  int linecounter = 0;
+  const char *line;
+
+  assert(job);
+        
+  linecounter = 0;
+  line = getTextLine(linecounter++);
+  while (line) {
+    /* notice: decode() is shiftet to getTextLine since 0.38 */
+    fputs(line, stdout);
+    if (job->cfg.out_format==HTML) fputs("<br />",stdout);
+    if (job->cfg.out_format!=XML)  fputc('\n', stdout);
+    line = getTextLine(linecounter++);
+  }
+  free_textlines();
+}
+
+/* FIXME jb: remove JOB; */
+job_t *JOB;
+
+
+/* -------------------------------------------------------------
+// ------   MAIN - replace this by your own aplication! 
+// ------------------------------------------------------------- */
+int main(int argn, char *argv[]) {
+  int multipnm=1;
+  job_t job;
+
+  JOB = &job;
+  setvbuf(stdout, (char *) NULL, _IONBF, 0);	/* not buffered */
+  
+  while (multipnm==1) {
+
+    job_init(&job);
+  
+    process_arguments(&job, argn, argv);
+
+    mark_start(&job);
+
+    multipnm = read_picture(&job);
+    /* separation of main and rest for using as lib
+       this will be changed later => introduction of set_option()
+       for better communication to the engine  */
+    if (multipnm<0) break; /* read error */
+  
+    /* call main loop */
+    pgm2asc(&job);
+
+    mark_end(&job);
+  
+    print_output(&job);
+
+    job_free(&job);
+  
+  }
+  
+  return 0;
+}

data/src/gocr-0.48/src/gocr.h

@@ -0,0 +1,288 @@
+/*
+This is a Optical-Character-Recognition program
+Copyright (C) 2000-2006 Joerg Schulenburg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+ see README for EMAIL-address
+
+  sometimes I have written comments in german language, sorry for that
+
+ - look for ??? for preliminary code
+*/
+ 
+/* General headerfile with gocr-definitions */
+
+#ifndef __GOCR_H__
+#define __GOCR_H__
+
+#include "pnm.h"
+#include "unicode.h"
+#include "list.h"
+#include <stddef.h>
+#ifdef HAVE_GETTIMEOFDAY
+#include <sys/time.h>
+#endif
+
+/*
+ *  wchar_t should always exist (ANSI), but WCHAR.H is sometimes missing
+ *  USE_UNICODE should be removed or replaced by HAVE_WCHAR_H in future
+ */
+#ifdef HAVE_WCHAR_H
+#define USE_UNICODE 1
+#endif
+
+/* extern "C"{ */
+/* ------------------------ feature extraction ----------------- */
+#define AT 7	/* mark */
+#define M1 1	/* mark */
+enum direction {
+  UP=1, DO, RI, LE
+};
+typedef enum direction DIRECTION;
+#define ST 7    /* stop */
+/* ------------------------------------------------------------- */
+/* detect maximas in of line overlapps (return in %) and line koord */
+#define HOR 1    /* horizontal */
+#define VER 2    /* vertikal   */
+#define RIS 3    /* rising=steigend */
+#define FAL 4    /* falling=fallend */
+
+#define MAXlines 1024
+
+/* ToDo: if we have a tree instead of a list, a line could be a node object */
+struct tlines {
+    int num;
+    int dx, dy;		/* direction of text lines (straight/skew) */
+    int m1[MAXlines],   /* start of line = upper bound of 'A' */
+        m2[MAXlines],   /* upper bound of 'e' */
+        m3[MAXlines],	/* lower bound of 'e' = baseline */
+        m4[MAXlines];	/* stop of line = lower bound of 'q' */
+    /* ToDo: add sureness per m1,m2 etc? */
+    int x0[MAXlines],
+        x1[MAXlines];	/* left and right border */
+    int wt[MAXlines];   /* weight, how sure thats correct in percent, v0.41 */
+    int pitch[MAXlines]; /* word pitch (later per box?), v0.41 */
+    int mono[MAXlines];  /* spacing type, 0=proportional, 1=monospaced */
+};
+
+#define NumAlt 10 /* maximal number of alternative chars (table length) */
+#define MaxNumFrames 8       /* maximum number of frames per char/box */
+#define MaxFrameVectors 128  /* maximum vectors per frame (*8=1KB/box) */
+/* ToDo: use only malloc_box(),free_box(),copybox() for creation, destroy etc.
+ *       adding reference_counter to avoid pointer pointing to freed box
+ */
+struct box { /* this structure should contain all pixel infos of a letter */
+    int x0,x1,y0,y1,x,y,dots; /* xmin,xmax,ymin,ymax,reference-pixel,i-dots */
+    int num_boxes, /* 1 "abc", 2 "!i?", 3 "&auml;" (composed objects) 0.41 */
+        num_subboxes;   /* 1 for "abdegopqADOPQR", 2 for "B"  (holes) 0.41 */
+    wchar_t c;		/* detected char (same as tac[0], obsolete?) */
+    wchar_t modifier;	/* default=0, see compose() in unicode.c */
+    int num;		/* same number = same char */
+    int line;		/* line number (points to struct tlines lines) */
+    int m1,m2,m3,m4;	/* m2 = upper boundary, m3 = baseline */
+    /* planed: sizeof hole_1, hole_2, certainty (run1=100%,run2=90%,etc.) */
+    pix *p;		/* pointer to pixmap (v0.2.5) */
+    /* tac, wac is used together with setac() to manage very similar chars */
+    int num_ac;         /* length of table (alternative chars), default=0 */
+    wchar_t tac[NumAlt]; /* alternative chars, only used by setac(),getac() */
+    int     wac[NumAlt]; /* weight of alternative chars */
+    char   *tas[NumAlt]; /* alternative UTF8-strings or XML codes if tac[]=0 */
+                         /*   replacing old obj */
+	                 /* ToDo: (*obj)[NumAlt] + olen[NumAlt] ??? */
+	                 /* ToDo: bitmap for possible Picture|Object|Char ??? */
+/*  char    *obj; */     /* pointer to text-object ... -> replaced by tas[] */
+                         /*  ... (melted chars, barcode, picture coords, ...) */
+                         /*  must be freed before box is freed! */
+                         /*  do _not_ copy only the pointer to object */
+    /* --------------------------------------------------------
+     *  extension since v0.41 js05, Store frame vectors,
+     *  which is a table of vectors sourrounding the char and its
+     *  inner white holes. The advantage is the independence from
+     *  resolution, handling of holes, overlap and rotation.
+     * --------------------------------------------------------- */
+    int num_frames;      /* number of frames: 1 for cfhklmnrstuvwxyz */
+                         /*                   2 for abdegijopq */
+    int frame_vol[MaxNumFrames]; /* volume inside frame +/- (black/white) */
+    int frame_per[MaxNumFrames]; /* periphery, summed length of vectors */
+    int num_frame_vectors[MaxNumFrames]; /* index to next frame */
+                /* biggest frame should be stored first (outer frame) */
+                /* biggest has the maximum pair distance */
+                /* num vector loops */
+    int frame_vector[MaxFrameVectors][2]; /* may be 16*int=fixpoint_number */
+    
+};
+typedef struct box Box;
+
+/* true if the coordination pair (a,b) is outside the image p */
+#define outbounds(p, a, b)  (a < 0 || b < 0 || a >= (p)->x || b >= (p)->y)
+
+/* ToDo: this structure seems to be obsolete, remove it */
+typedef struct path {
+  int start;	/* color at the beginning of the path, (0=white, 1=black) */
+  int *x;	/* x coordinates of transitions */
+  int *y;	/* y coordinates of transitions */
+  int num;	/* current number of entries in x or y */
+  int max;	/* maximum number of entries in x or y */
+  /* (if more values need to be stored, the arrays are enlarged) */
+} path_t;
+
+/* job_t contains all information needed for an OCR task */
+typedef struct job_s {
+  struct {       /* source data */
+    char *fname; /* input filename; default value: "-" */
+    pix p;       /* source pixel data, pixelmap 8bit gray */
+  } src;
+  struct { /* temporary stuff, e.g. buffers */
+#ifdef HAVE_GETTIMEOFDAY
+    struct timeval init_time; /* starting time of this job */
+#endif
+    pix ppo; /* pixmap for visual debugging output, obsolete */
+
+    /* sometimes recognition function is called again and again, if result was 0
+       n_run tells the pixel function to return alternative results */
+    int n_run;   /* num of run, if run_2 critical pattern get other results */
+                 /* used for 2nd try, pixel uses slower filter function etc. */
+    List dblist; /* list of boxes loaded from the character database */
+  } tmp;
+  struct {         /* results */
+    List boxlist;  /* store every object in a box, which contains */
+                   /* the characteristics of the object (see struct box) */
+    List linelist; /* recognized text lines after recognition */
+    
+    struct tlines lines; /* used to access to line-data (statistics) */
+                         /* here the positions (frames) of lines are */
+                         /* stored for further use */
+    int avX,avY;         /* average X,Y (avX=sumX/numC) */
+    int sumX,sumY,numC;  /* sum of all X,Y; num chars */
+  } res;
+  struct {    /* configuration */
+    int cs;   /* critical grey value (pixel<cs => black pixel) */
+              /* range: 0..255,  0 means autodetection */
+    int spc;  /* spacewidth/dots (0 = autodetect); default value: 0 */
+    int mode; /* operation modes; default value: 0 */
+              /* operation mode (see --help) */
+    int dust_size;    /* dust size; default value: 10 */
+    int only_numbers; /* numbers only; default value: 0 */
+    int verbose; /* verbose mode; default value: 0 */ 
+                 /* verbose option (see --help) */
+    FORMAT out_format; /* output format; default value: ISO8859_1*/
+    char *lc; /* debuglist of chars (_ = not recognized chars) */
+              /* default value: "_" */
+    char *db_path; /* pathname for database; default value: NULL */
+    char *cfilter; /* char filter; default value: NULL, ex: "A-Za-z" */
+        /* limit of certainty where chars are accepted as identified */
+    int  certainty; /* in units of 100 (percent); 0..100; default 95 */
+    char *unrec_marker; /* output this string for every unrecognized char */
+  } cfg;
+} job_t;
+
+/* initialze job structure */
+void job_init(job_t *job);
+
+/* free job structure */
+void job_free(job_t *job);
+
+/*FIXME jb: remove JOB; */
+extern job_t *JOB;
+
+/* calculate the overlapp of the line (0-1) with black points 
+ * by rekursiv bisection 
+ * (evl. Fehlertoleranz mit pixel in Umgebung dx,dy suchen) (umschaltbar) ???
+ * MidPoint Line Algorithm (Bresenham) Foley: ComputerGraphics better?
+ * will be replaced by vector functions
+ */
+
+/* gerade y=dy/dx*x+b, implizit d=F(x,y)=dy*x-dx*y+b*dx=0 
+ * incrementell y(i+1)=m*(x(i)+1)+b, F(x+1,y+1)=f(F(x,y))  */
+int get_line(int x0, int y0, int x1, int y1, pix *p, int cs, int ret);
+int get_line2(int x0, int y0, int x1, int y1, pix *p, int cs, int ret);
+
+/* look for white 0x02 or black 0x01 dots (0x03 = white+black) */
+char get_bw(int x0, int x1, int y0, int y1,
+             pix *p, int cs,int mask);
+
+/* look for black crossing a line x0,y0,x1,y1
+ * follow line and count crossings ([white]-black-transitions)
+ */
+int num_cross(int x0, int x1, int y0, int y1,
+               pix *p,  int cs);
+
+/* memory allocation with error checking */
+void *xrealloc(void *ptr, size_t size);
+
+/* follow a line x0,y0,x1,y1 recording locations of transitions,
+ * return count of transitions 
+ */
+int follow_path(int x0, int x1, int y0, int y1, pix *p,  int cs, path_t *path);
+
+/* -------------------------------------------------------------
+ * mark edge-points
+ *  - first move forward until b/w-edge
+ *  - more than 2 pixel?
+ *  - loop around
+ *    - if forward    pixel : go up, rotate right
+ *    - if forward no pixel : rotate left
+ *  - stop if found first 2 pixel in same order
+ * mit an rechter-Wand-entlang-gehen strategie
+ * --------------------------------------------------------------
+ * turmite game: inp: start-x,y, regel r_black=UP,r_white=RIght until border
+ *               out: last-position
+ * Zaehle dabei, Schritte,Sackgassen,xmax,ymax,ro-,ru-,lo-,lu-Ecken
+ * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ *
+ * is this the right place for declaration?
+ */
+void turmite(pix *p, int *x, int *y, 
+             int x0, int x1, int y0, int y1, int cs, int rw, int rb);
+
+/* test if points are connected via t-pixel (rekursiv!) */
+int joined(pix *p, int x0, int y0, int x1, int y1, int cs);
+
+/* move from x,y to direction r until pixel or l steps
+ * return number of steps
+ */
+int loop(pix *p, int x, int y, int l, int cs, int col, DIRECTION r);
+
+#define MAX_HOLES 3
+typedef struct list_holes { 
+  int num;    /* numbers of holes, initialize with 0 */ 
+  struct hole_s {
+    int size,x,y,x0,y0,x1,y1; /*  size, start point, outer rectangle */
+  } hole[MAX_HOLES];
+} holes_t;
+          
+/* look for white holes surrounded by black points
+ * at moment white point with black in all four directions
+ */
+int num_hole(int x0, int x1, int y0, int y1, pix *p, int cs, holes_t *holes);
+
+/* count for black nonconnected objects --- used for i,auml,ouml,etc. */
+int num_obj(int x0, int x1, int y0, int y1, pix  *p, int cs);
+
+int distance(   pix *p1, struct box *box1,	/* box-frame */
+		pix *p2, struct box *box2, int cs);
+
+/* call the OCR engine ;) */
+/* char whatletter(struct box *box1,int cs); */
+
+/* declared in pixel.c */
+/* getpixel() was pixel() but it may collide with netpnm pixel declaration */
+int getpixel(pix *p, int x, int y);
+int marked(pix *p, int  x, int  y);
+void put(pix * p, int x, int y, int ia, int io);
+
+/* } */ /* extern C */
+#endif /* __GOCR_H__ */