gocr-ruby 0.0.1

data/ext/gocr/ocr1.c

@@ -0,0 +1,85 @@
+// test routines - faster to compile
+#include <stdlib.h>
+#include <stdio.h>
+#include "pgm2asc.h"
+#include "unicode.h"
+#include "amiga.h"
+#include "gocr.h"
+
+// for learn_mode/analyze_mode high, with, yoffset, num of pattern_i,
+//  - holes (center,radius in relative coordinates) etc. => cluster analyze
+// num_hole => min-volume, tolerance border
+// pattern:  @@ @. @@
+//           .@ @. ..
+// regular filter for large resolutions to make edges more smooth (on boxes)
+// extra-filter (only if not recognized?)
+//   map + same color to (#==change)
+//       - anti color
+//       . not used
+// strongest neighbour pixels (3x3) => directions
+// second/third run with more and more tolerance!?
+
+/* FIXME jb: following is unused */
+#if 0
+struct lobj {	// line-object (for fitting to near lines)
+	int x0,y0;	// starting point (left up)
+        int x1,y1;      // end point      (right down)
+        int mt;		// minimum thickness
+	int q;		// quality, overlapp
+};
+
+/* FIXME jb global */
+struct lobj obj1;
+#endif
+
+// that is the first draft of feature extraction 
+// detect main lines and bows
+// seems bad implemented, looking for better algorithms (ToDo: use autotrace)
+#define MAXL 10
+void ocr2(pix *b,int cs){
+  int x1,y1,x2,y2,l,i,j,xa[MAXL],ya[MAXL],xb[MAXL],yb[MAXL],ll[MAXL];
+  for(i=0;i<MAXL;i++)xa[i]=ya[i]=xb[i]=yb[i]=ll[i]=0;
+  for(x1=0;x1<b->x;x1++)		// very slowly, but simple to program
+  for(y1=0;y1<b->y;y1++)         // brute force
+  for(x2=0;x2<b->x;x2++)
+  for(y2=y1+1;y2<b->y;y2++)
+  {
+    if( get_line2(x1,y1,x2,y2,b,cs,100)>99 )
+    {  // line ???
+      l=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);  // len
+      for(i=0;i<MAXL;i++)
+      {  // remove similar lines (same middle point) IMPROVE IT !!!!!! ???
+        if(
+            abs(x1+x2-xa[i]-xb[i])<1+b->x/2
+         && abs(y1+y2-ya[i]-yb[i])<1+b->y/2
+         && abs(y1-ya[i])<1+b->y/4
+         && abs(x1-xa[i])<1+b->x/4
+          )
+        {
+          if( l>ll[i] )
+          {
+            for(j=i;j<MAXL-1;j++)
+            {  // shift table
+              xa[j]=xa[j+1];ya[j]=ya[j+1];
+              xb[j]=xb[j+1];yb[j]=yb[j+1];ll[j]=ll[j+1];
+            }
+            ll[MAXL-1]=0;
+          }
+          else break; // forget it if shorter
+        }
+        if( l>ll[i] ){ // insert if larger
+          for(j=MAXL-1;j>i;j--){  // shift table
+            xa[j]=xa[j-1];ya[j]=ya[j-1];
+            xb[j]=xb[j-1];yb[j]=yb[j-1];ll[j]=ll[j-1];
+          }
+          xa[i]=x1;ya[i]=y1;xb[i]=x2;yb[i]=y2;ll[i]=l;
+          break;
+        }
+      }
+    }
+  }
+  for(i=0;i<MAXL;i++){
+    printf(" %2d %2d %2d %2d %3d\n",xa[i],ya[i],xb[i],yb[i],ll[i]);
+  }  
+}
+

data/ext/gocr/ocr1.h

@@ -0,0 +1,3 @@
+/* #include "pgm2asc.h" */
+#include "pnm.h"
+/* wchar_t ocr1(struct box *box1, pix  *b, int cs); */

data/ext/gocr/otsu.c

@@ -0,0 +1,310 @@
+/*
+This is a Optical-Character-Recognition program
+Copyright (C) 2000-2010  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
+
+ the following code was send by Ryan Dibble <dibbler@umich.edu>
+ 
+  The algorithm is very simple but works good hopefully.
+ 
+  Compare the grayscale histogram with a mass density diagram:
+  I think the algorithm is a kind of
+  divide a body into two parts in a way that the mass 
+  centers have the largest distance from each other,
+  the function is weighted in a way that same masses have a advantage
+  
+  - otsu algorithm is failing on diskrete multi color images
+  
+  TODO:
+    RGB: do the same with all colors (CMYG?) seperately 
+
+    test: hardest case = two colors
+       bbg: test done, using a two color gray file. Output:
+       # threshold: Value = 43 gmin=43 gmax=188
+
+ my changes:
+   - float -> double
+   - debug option added (vvv & 1..2)
+   - **image => *image,  &image[i][1] => &image[i*cols+1]
+   - do only count pixels near contrast regions
+     this makes otsu much better for shadowed fonts or multi colored text 
+     on white background
+
+ (m) Joerg Schulenburg (see README for email address)
+
+ ToDo:
+   - measure contrast
+   - detect low-contrast regions
+
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#define Abs(x) ((x<0)?-(x):x)
+
+/*======================================================================*
+ * global thresholding routine                                          *
+ *   takes a 2D unsigned char array pointer, number of rows, and        *
+ *   number of cols in the array. returns the value of the threshold    *
+ * x0,y0,x0+dx,y0+dy are the edgepoints of the interesting region       *
+ * vvv is the verbosity for debugging purpose                           * 
+ *======================================================================*/
+int
+otsu (unsigned char *image, int rows, int cols,
+      int x0, int y0, int dx, int dy, int vvv) {
+
+  unsigned char *np;    // pointer to position in the image we are working with
+  unsigned char op1, op2, op3, op4;   // predecessor of pixel *np (start value)
+  int maxc=0;           // maximum contrast (start value) 
+  int thresholdValue=1; // value we will threshold at
+  int ihist[256];       // image histogram
+  int chist[256];       // contrast histogram
+
+  int i, j, k;          // various counters
+  int is, i1, i2, ns, n1, n2, gmin, gmax;
+  double m1, m2, sum, csum, fmax, sb;
+
+  // zero out histogram ...
+  memset(ihist, 0, sizeof(ihist));
+  memset(chist, 0, sizeof(chist));
+  op4=op3=op1=op2=image[y0*cols+x0];
+
+  gmin=255; gmax=0; k=dy/512+1;
+  // v0.43 first get max contrast, dont do it together with next step
+  //  because it failes if we have pattern as background (on top)
+  for (i =  0; i <  dy ; i+=k) {
+    np = &image[(y0+i)*cols+x0];
+    for (j = 0; j < dx ; j++) {
+      ihist[*np]++;
+      if (*np > gmax) gmax=*np;
+      if (*np < gmin) gmin=*np;
+      if (Abs(*np-op1)>maxc) maxc=Abs(*np-op1); /* new maximum contrast */
+      if (Abs(*np-op2)>maxc) maxc=Abs(*np-op2); /* new maximum contrast */
+      // 2010-10-07 add op3+op4 for invalid_ogv.jpg
+      if (Abs(*np-op3)>maxc) maxc=Abs(*np-op3); /* new maximum contrast */
+      if (Abs(*np-op4)>maxc) maxc=Abs(*np-op4); /* new maximum contrast */
+      /* we hope that maxc will be find its maximum very fast */
+      op4=op3;op3=op2;op2=op1;    /* shift old pixel to next older */
+      op1=*np;     /* store old pixel for contrast check */
+      np++;       /* next pixel */
+    }
+  }
+  if ((vvv&1)) // Debug
+    fprintf(stderr,"# threshold: max_contrast= %d\n", maxc);
+
+  // generate the histogram
+  // Aug06 images with large white or black homogeneous
+  //   areas give bad results, so we only add pixels on contrast edges
+  op4=op3=op1=op2=image[y0*cols+x0];
+  for (i =  0; i <  dy ; i+=k) {
+    np = &image[(y0+i)*cols+x0];
+    for (j = 0; j < dx ; j++) {
+      if (Abs(*np-op1)>=1*maxc/4 // min_d_max_contrast=1
+       || Abs(*np-op2)>=1*maxc/4 // min_d_max_contrast=2
+       || Abs(*np-op3)>=1*maxc/4
+       || Abs(*np-op4)>=1*maxc/4
+//       || Abs(*np-gmax)<=1*maxc/4
+//       || Abs(*np-gmin)<=1*maxc/4
+       )
+         chist[*np]++; // count only relevant pixels
+      op4=op3;op3=op2;op2=op1;    /* shift old pixel to next older */
+      op1=*np;     /* store old pixel for contrast check */
+      np++;       /* next pixel */
+    }
+  }
+
+  // set up everything
+  sum = csum = 0.0;
+  ns = 0;
+  is = 0;
+  
+  for (k = 0; k <= 255; k++) {
+    sum += (double) k * (double) chist[k];  /* x*f(x) cmass moment */
+    ns  += chist[k];                        /*  f(x)    cmass      */
+    is  += ihist[k];                        /*  f(x)    imass      */
+    // Debug: output to out_hist.dat?
+    // fprintf(stderr,"\chistogram %3d %6d (brightness weight)", k, ihist[k]);
+  }
+
+  if (!ns) {
+    // if n has no value we have problems...
+    fprintf (stderr, "NOT NORMAL, thresholdValue = 160\n");
+    return (160);
+  }
+
+  // ToDo: search max contrast in 2 near(r=8) pixels, take as mass centers + dist
+  //   expand b/w-mass ranges by further contrast dipols
+  //   min_max_b_b_distance + max_b_b distance
+  //  use a range white=... black=... for between values due local thresholding 
+  //  24x24 field (cashed) where 8x8 center is thresholded
+  // ToDo: only care about extremas in a 3 pixel environment
+  //       check if there are more than 2 mass centers (more colors)
+  //       return object colors and color radius instead of threshold value
+  //        also the reagion, where colored objects are found
+  //       what if more than one background color? no otsu at all?
+  //       whats background? box with lot of other boxes in it
+  //       threshold each box (examples/invers.png,colors.png) 
+  //  get maximum white and minimum black pixel color (possible range)
+  //    check range between them for low..high contrast ???
+  // typical scenes (which must be covered): 
+  //    - white page with text of different colors (gray values)
+  //    - binear page: background (gray=1) + black text (gray=0)
+  //    - text mixed with big (dark) images
+  //  ToDo: recursive clustering for maximum multipol moments?
+  //  idea: normalize ihist to max=1024 before otsu?
+  
+  // do the otsu global thresholding method
+
+  if ((vvv&1)) // Debug
+    fprintf(stderr,"# threshold: value ihist chist mass_dipol_moment trigg\n");
+  fmax = -1.0;
+  n1 = 0;
+  for (k = 0; k < 255; k++) {
+    n1 += chist[k];          // left  mass (integration)
+    if (!n1) continue;       // we need at least one foreground pixel
+    n2 = ns - n1;            // right mass (num pixels - left mass)
+    if (n2 == 0) break;      // we need at least one background pixel
+    csum += (double) k *chist[k];  // left mass moment
+    m1 =        csum  / n1;        // left  mass center (black chars)
+    m2 = (sum - csum) / n2;        // right mass center (white background)
+    // max. dipol moment?
+    // orig: sb = (double) n1 *(double) n2 * (m1 - m2) * (m1 - m2);
+    sb = (double) n1 *(double) n2 * (m2 - m1); // seems to be better Aug06
+    /* bbg: note: can be optimized. */
+    if (sb > fmax) {
+      fmax = sb;
+      thresholdValue = k + 1;
+      // thresholdValue = (m1 + 3 * m2) / 4;
+    }
+    if ((vvv&1) && ihist[k]) // Debug
+     fprintf(stderr,"# threshold: %3d %6d %6d %8.3f %4d\n",
+       k, ihist[k], chist[k],
+       sb*256/(dx*dy)/(dx*dy),  /* normalized dipol moment */
+       thresholdValue);
+  }
+  // ToDo: error = left/right point where sb is 90% of maximum?
+  // now we count all pixels for background detection
+  i1 = 0;
+  for (k = 0; k < thresholdValue; k++) {
+    i1 += ihist[k];          // left  mass (integration)
+  }
+  i2 = is - i1;            // right mass (num pixels - left mass)
+
+  // at this point we have our thresholding value
+  // black_char: value<cs,  white_background: value>=cs
+  
+  // can it happen? check for sureness
+  if (thresholdValue >  gmax) {
+    fprintf(stderr,"# threshold: Value >gmax\n");
+    thresholdValue = gmax;
+  }
+  if (thresholdValue <= gmin) {
+    fprintf(stderr,"# threshold: Value<=gmin\n");
+    thresholdValue = gmin+1;
+  }
+
+  // debug code to display thresholding values
+  if ( vvv & 1 )
+  fprintf(stderr,"# threshold: Value = %d gmin=%d gmax=%d cmax=%d"
+                 " b/w= %d %d\n",
+     thresholdValue, gmin, gmax, maxc, i1, i2);
+
+  // this is a primitive criteria for inversion and should be improved
+  // old: i1 >= 4*i2, but 0811qemu1.png has a bit above 1/4 
+  if (2*i1 > 7*i2) { // more black than white, obviously black is background
+    if ( vvv & 1 )
+      fprintf(stderr,"# threshold: invert the image\n");
+    // we do inversion here (no data lost)
+    for (i =  0; i <  dy ; i++) {
+      np = &image[(y0+i)*cols+x0];
+      for (j = 0; j < dx ; j++) {
+        *np=255-*np;
+        np++;       /* next pixel */
+      }
+    }
+    thresholdValue=255-thresholdValue+1;
+  }
+
+  return(thresholdValue); 
+  /* range: 0 < thresholdValue <= 255, example: 1 on b/w images */
+  /* 0..threshold-1 is foreground */
+  /* threshold..255 is background */
+  /* ToDo:  min=blackmasscenter/2,thresh,max=(whitemasscenter+255)/2 */
+}
+
+/*======================================================================*/
+/* thresholding the image  (set threshold to 128+32=160=0xA0)           */
+/*   now we have a fixed thresholdValue good to recognize on gray image */
+/*   - so lower bits can used for other things (bad design?)            */
+/* ToDo: different foreground colors, gray on black/white background    */
+/*======================================================================*/
+int
+thresholding (unsigned char *image, int rows, int cols,
+  int x0, int y0, int dx, int dy, int thresholdValue) {
+
+  unsigned char *np; // pointer to position in the image we are working with
+
+  int i, j;          // various counters
+  int gmin=255,gmax=0;
+  int nmin=255,nmax=0;
+
+  // Aug10: i=y0+1, why 1 pixel frame? bug if v[y0] > gmax, fixed
+  // calculate min/max (twice?)
+  for (i = y0 /*+ 1*/; i < y0 + dy /*- 1*/; i++) {
+    np = &image[i*cols+x0+1];
+    for (j = x0 /*+ 1*/; j < x0 + dx /*- 1*/; j++) {
+      if(*np > gmax) gmax=*np;
+      if(*np < gmin) gmin=*np;
+      np++; /* next pixel */
+    }
+  }
+  
+  /* allowed_threshold=gmin+1..gmax v0.43 */
+  if (thresholdValue<=gmin || thresholdValue>gmax){
+    thresholdValue=(gmin+gmax+1)/2; /* range=0..1 -> threshold=1 */
+    fprintf(stderr,"# thresholdValue out of range %d..%d, reset to %d\n",
+     gmin, gmax, thresholdValue);
+  }
+
+  /* b/w: min=0,tresh=1,max=1 v0.43 */
+  // actually performs the thresholding of the image...
+  //  later: grayvalues should also be used, only rescaling threshold=160=0xA0
+  // sometimes images have no contrast (thresholdValue == gmin)
+  for (i = y0; i < y0+dy; i++) {
+    np = &image[i*cols+x0];
+    for (j = x0; j < x0+dx; j++) {
+      if ( *np > gmax || *np <gmin) // should never happen
+        fprintf(stderr,"ERROR th yx= %2d %2d t= %d v= %3d min/max= %d %d\n",
+          i,j,thresholdValue,*np,gmin,gmax);
+      *np = (unsigned char) (*np >= thresholdValue || thresholdValue == gmin ?
+         (255-(gmax - *np)* 80/(gmax - thresholdValue + 1)) :
+         (  0+(*np - gmin)*150/(thresholdValue - gmin    )) );
+      if(*np > nmax) nmax=*np;
+      if(*np < nmin) nmin=*np;
+      np++;
+    }
+  }
+
+  // fprintf(stderr,"# thresholding:  nmin=%d nmax=%d\n", nmin, nmax);
+
+  return(128+32); // return the new normalized threshold value
+  /*   0..159 is foreground */
+  /* 160..255 is background */
+}
+

data/ext/gocr/otsu.h

@@ -0,0 +1,23 @@
+/*
+
+    see README for EMAIL-address
+
+ */
+
+
+/*======================================================================*/
+/* OTSU global thresholding routine                                     */
+/*   takes a 2D unsigned char array pointer, number of rows, and        */
+/*   number of cols in the array. returns the value of the threshold    */
+/*======================================================================*/
+int
+otsu (unsigned char *image, int rows, int cols, int x0, int y0, int dx, int dy, int vvv);
+
+
+/*======================================================================*/
+/* thresholding the image  (set threshold to 128+32=160=0xA0)           */
+/*   now we have a fixed thresholdValue good to recognize on gray image */
+/*   - so lower bits can used for other things (bad design?)            */
+/*======================================================================*/
+int
+thresholding (unsigned char *image, int rows, int cols, int x0, int y0, int dx, int dy, int thresholdValue);

data/ext/gocr/output.c

@@ -0,0 +1,291 @@
+/*
+This is a Optical-Character-Recognition program
+Copyright (C) 2000-2010  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
+*/
+
+#include <string.h>
+#include "unicode.h"
+#include "output.h"
+#include "pcx.h"
+#include "gocr.h"  /* extern job_t OCR_JOB; */
+#include "unicode_defs.h" /* UNKNOWN + PICTURE */
+
+/* function is only for debugging and for developing
+   it prints out a part of pixmap b at point x0,y0 to stderr
+   using dots .,; if no pixel, and @xoO for pixels
+   modify n_run and print out what would happen on 2nd, 3th loop!
+   new: output original and copied pixmap in the same figure
+ */
+void out_b(struct box *px, pix *b, int x0, int y0, int dx, int dy, int cs ){
+  int x,y,x2,y2,yy0,tx,ty,n1,i;
+  char c1, c2;
+  yy0=y0;
+  if (px) { /* overwrite rest of arguments */
+    if (!b) {
+      b=px->p;
+      x0=px->x0; dx=px->x1-px->x0+1;
+      y0=px->y0; dy=px->y1-px->y0+1; yy0=y0;
+    }
+    if(cs==0) cs=OCR_JOB->cfg.cs;
+    fprintf(stderr,"\n# list box      x= %4d %4d d= %3d %3d r= %3d %3d"
+                    " nrun=%d p=%p", /* ToDo: r,nrun is obsolete */
+	  px->x0, px->y0, px->x1 - px->x0 + 1, px->y1 - px->y0 + 1,
+	  px->x - px->x0, px->y - px->y0, OCR_JOB->tmp.n_run, (void*)px);
+    fprintf(stderr,"\n#  dots=%d boxes=%d subboxes=%d c=%s mod=%s"
+            " line=%d m= %d %d %d %d",
+	  px->dots, px->num_boxes, px->num_subboxes, 
+	  decode(px->c,ASCII), decode(px->modifier,ASCII), px->line,
+	  px->m1 - px->y0, px->m2 - px->y0, px->m3 - px->y0, px->m4 - px->y0);
+    if (px->num_frames) {
+      int i,j,jo;
+      fprintf(stderr,"\n#  frames= %d (sumvects=%d)",px->num_frames,
+         ((px->num_frames)?px->num_frame_vectors[px->num_frames-1]:-1));
+      // output objects: volume periphery(de:Umfang) num_frame_vectors
+      for (jo=j=i=0; i<px->num_frames; i++, jo=j) {
+        fprintf(stderr,"\n#  frame %d (%+4d,%3d,%2d) ",
+                i, px->frame_vol[i], px->frame_per[i],
+                   px->num_frame_vectors[i]-jo);
+        /* print only the first vectors of each frame */
+        for (;j<px->num_frame_vectors[i] && j<MaxFrameVectors; j++)
+          fprintf(stderr," #%02d %2d %2d", j,
+                            px->frame_vector[j][0] - px->x0,
+                            px->frame_vector[j][1] - px->y0);
+      }
+    }
+    if (px->num_ac){ /* output table of chars and its probabilities */
+      fprintf(stderr,"\n# list box char: ");
+      for(i=0;i<px->num_ac && i<NumAlt;i++)
+      /* output the (xml-)string (picture position, barcodes, glyphs, ...) */
+        if (px->tas[i])
+         fprintf(stderr," %s(%d)",       px->tas[i]       ,px->wac[i]);
+        else
+         fprintf(stderr," %s(%d)",decode(px->tac[i],ASCII),px->wac[i]);
+    }
+    fprintf(stderr,"\n");
+    if (px->m2 && px->m1<y0 && (px->dots || y0>px->m2)) {
+      yy0=px->m1; dy=px->y1-yy0+1;
+    }
+  }
+  tx=dx/80+1;
+  ty=dy/40+1; /* step, usually 1, but greater on large maps */
+  fprintf(stderr,"# list pattern  x= %4d %4d d= %3d %3d t= %d %d yy0= %d\n",
+                 x0,y0,dx,dy,tx,ty,yy0);
+  if (dx>0)
+  for(y=yy0;y<yy0+dy;y+=ty) { /* reduce the output to max 78x40 */
+    /* first image is the copied and modified bitmap of the box */
+    if (px)
+    for(x=x0;x<x0+dx;x+=tx){  /* by merging sub-pixels */
+      n1=0; c1='.';
+      for(y2=y;y2<y+ty && y2<y0+dy;y2++) /* sub-pixels */
+      for(x2=x;x2<x+tx && x2<x0+dx;x2++)
+      {
+        if((getpixel(px->p,x2-x0+px->x0,
+                        y2-y0+px->y0)<cs)) c1='@';
+      }
+      if (px->num_frames) { /* mark vectors */
+        int i;
+        if (c1!='$' && c1!='S') /* dont mark twice */
+        for (i=0;i<px->num_frame_vectors[px->num_frames-1];i++)
+          if ((px->frame_vector[i][0]-px->x0)/tx==(x-x0)/tx
+           && (px->frame_vector[i][1]-px->y0)/ty==(y-y0)/ty)
+              { c1=((c1=='@')?'$':'S'); break; }
+      }
+      fprintf(stderr,"%c", c1 );
+    }
+
+    /* 2nd image is the boxframe in the original bitmap */
+    if (dx<40) fprintf(stderr,"  ");
+    if (dx<40) /* do it only, if we have enough place */
+    for(x=x0;x<x0+dx;x+=tx){  /* by merging sub-pixels */
+      c1='.';
+      for(y2=y;y2<y+ty && y2<y0+dy;y2++) /* sub-pixels */
+      for(x2=x;x2<x+tx && x2<x0+dx;x2++)
+        { if((getpixel(b,x2,y2)<cs)) c1='@'; }
+      fprintf(stderr,"%c", c1 );
+    }
+
+    c1=c2=' ';
+    /* mark lines with < */
+    if (px) if (y-y0+px->y0==px->m1 || y-y0+px->y0==px->m2
+             || y-y0+px->y0==px->m3 || y-y0+px->y0==px->m4)  c1='<';
+    if (y==y0 || y==yy0+dy-1)  c2='-';  /* boxmarks */
+        
+    fprintf(stderr,"%c%c\n",c1,c2);
+  }
+}
+
+/* same as out_b, but for faster use, only a box as argument
+ */
+void out_x(struct box *px) {
+  out_b(px,NULL,0, 0, 0, 0, OCR_JOB->cfg.cs);
+}
+
+
+/* print out two boxes side by side, for debugging comparision algos */
+void out_x2(struct box *box1, struct box *box2){
+  int x,y,i,tx,ty,dy;
+  /*FIXME jb static*/static char *c1="OXXXXxx@.,,,,,,,";
+  pix *b=&OCR_JOB->src.p;
+  dy=(box1->y1-box1->y0+1);
+  if(dy<box2->y1-box2->y0+1)dy=box2->y1-box2->y0+1;
+  tx=(box1->x1-box1->x0)/40+1;
+  ty=(box1->y1-box1->y0)/40+1; /* step, usually 1, but greater on large maps */
+  if(box2)fprintf(stderr,"\n# list 2 patterns");
+  for(i=0;i<dy;i+=ty) { /* reduce the output to max 78x40??? */
+    fprintf(stderr,"\n"); y=box1->y0+i;
+    for(x=box1->x0;x<=box1->x1;x+=tx) 
+    fprintf(stderr,"%c", c1[ ((getpixel(b,x,y)<OCR_JOB->cfg.cs)?0:8)+marked(b,x,y) ] );
+    if(!box2) continue;
+    fprintf(stderr,"  "); y=box2->y0+i;
+    for(x=box2->x0;x<=box2->x1;x+=tx)
+    fprintf(stderr,"%c", c1[ ((getpixel(b,x,y)<OCR_JOB->cfg.cs)?0:8)+marked(b,x,y) ] );
+  }
+}
+
+
+/* ---- list output ---- for debugging ---
+ * list all boxes where the results can be found within the c-option  
+ */
+int output_list(job_t *job) {
+  int i = 0, j;
+  struct box *box2;
+  pix  *pp = &job->src.p;
+  char *lc = job->cfg.lc;
+
+  fprintf(stderr,"\n# list shape for charlist %s",lc);
+  for_each_data(&(job->res.boxlist)) {
+    box2 = (struct box *) list_get_current(&(job->res.boxlist));
+    for (j=0; j<box2->num_ac; j++) 
+      if (!lc || (box2->tac[j] && strchr(lc, box2->tac[j]))
+              || (box2->tas[j] && strstr(lc, box2->tas[j]))) break;
+    if (j<box2->num_ac)
+      fprintf(stderr,"\n#            box found in charlist");
+    if (!lc || (strchr(lc, box2->c) && box2->c < 256 && box2->c)
+            || (strchr(lc, '_') && box2->c==UNKNOWN) /* for compability */
+            || j<box2->num_ac ){  /* also list alternative chars */
+      if (!pp) pp=box2->p;
+      fprintf(stderr,
+	      "\n# list shape %3d x=%4d %4d d= %3d %3d vf=%d ac=%d %04x %s",
+	      i, box2->x0, box2->y0,
+	      box2->x1 - box2->x0 + 1,
+	      box2->y1 - box2->y0 + 1,
+	      box2->num_frames, box2->num_ac, 
+	      (int)box2->c,   /* wchar_t -> char ???? */
+	      decode(box2->c,ASCII) );
+      if (job->cfg.verbose & 4) out_x(box2);
+    }
+    i++;
+  } end_for_each(&(job->res.boxlist));
+  fprintf(stderr,"\n");
+  return 0;
+}
+
+/* --- output of image incl. corored lines usefull for developers ---
+ *  debugging
+ *  bit 0+1 is used for color coding (optical marker)
+ * color/gray:  0x01=red, 0x02=blue, 0x04=green???
+ * opt: 1 - mark unknown boxes red       (first pass)
+ *      2 - mark unknown boxes more red  (final pass)
+ *      4 - mark lines blue
+ *      8 - reset coloring (remove old marker)
+ */
+int debug_img(char *fname, struct job_s *job, int opt) {
+  struct box *box2;
+  int x, y, ic, dx, i, j, col;
+  unsigned char *np;
+  pix *pp = &job->tmp.ppo;
+
+  if ( opt & 8 ) {		/* clear debug bits in image */
+    for(y=0;y<pp->y;y++) {
+      np=&pp->p[(pp->x)*y];
+      for(x=0;x<pp->x;x++) {
+        *np = *np & 0xF1;
+        np++;
+      }
+    }
+  }
+
+  /* mark longest line which was used to estimate the rotation angle */
+  if ((job->cfg.verbose&32) && job->res.lines.dx)
+    for(i=0;i<pp->x;i++) {
+      y=pp->y/2;
+      if (job->res.lines.dx) y+=job->res.lines.dy*i/job->res.lines.dx;
+      x=i;
+      if (x<0 || x>=pp->x || y<0 || y>=pp->y) continue;
+      np=&pp->p[x + (pp->x)*y];
+      if (*np<160) continue;
+      if((x&7)<5 && !(x&1))  /* dotted line */
+        put(pp,x,y,255,8);
+    }
+
+  ic = ((opt & 2) ? 1 : 2); /* obsolete */
+  for_each_data(&(job->res.boxlist)) {
+    box2 = (struct box *) list_get_current(&(job->res.boxlist));
+    /* mark boxes in 32=0x40=blue */
+    if (box2->c == ' ' || box2->c == '\n') continue;
+    /* mark chars with green left and under line */
+    col = 4; /* green */
+    if (box2->c == UNKNOWN  && (opt & 3)) col=2; /* red */
+    if (box2->x0>1)
+    for (y = box2->y0; y <= box2->y1; y++) {
+      np=&pp->p[box2->x0-1 +   y * pp->x]; if (*np<160) continue; *np|=col; }
+    if (box2->y1+1<pp->y)
+    for (x = box2->x0; x <= box2->x1; x++) {
+      np=&pp->p[x + (box2->y1+1) * pp->x]; if (*np<160) continue; *np|=col; }
+    /* mark pictures by green cross */
+    if (box2->c == PICTURE)
+      for (x = 0; x < box2->x1-box2->x0+1; x++){
+         y=(box2->y1-box2->y0+1)*x/(box2->x1-box2->x0+1);
+         pp->p[(box2->x0+x) + (box2->y0+y) * pp->x] |= 4;
+         pp->p[(box2->x1-x) + (box2->y0+y) * pp->x] |= 4;
+      }
+  } end_for_each(&(job->res.boxlist));
+
+  if( opt & 4 )
+  {
+      struct tlines *lines = &job->res.lines;
+      int yr;
+      if (job->cfg.verbose)                                          
+        fprintf(stderr, "# mark lines for %s.ppm\n", fname); 
+      /* or read from outside??? */
+      for (i = 0; i < lines->num; i++) { /* mark lines by 0x08 = blue */
+        dx = lines->x1[i] - lines->x0[i] + 1;
+	for (j = -1; j < dx+1; j++) {
+	  x  = lines->x0[i] + j;
+          if (x<0 || x>=pp->x) continue;
+	  for (y=lines->m1[i];y<=lines->m4[i];y++) {
+	    /* box arround m2-m3 */
+	    if (y>=lines->m2[i] && y<=lines->m3[i] && j>-1 && j<dx) continue;
+            yr  = y; /* y.rotated */
+            if (lines->dx) yr += lines->dy * x / (lines->dx);
+            if (yr<0 || yr>=pp->y) continue;
+            np = &(pp->p[x + (pp->x)*yr]);
+            if (*np<160) continue; /* do not touch dark pixels */
+            if ((*np&6)!=0) continue; /* only change white pixels */
+            put(pp, x, yr, 255, 6); /* UPN: 255 and 6 or */
+	  }
+	}
+      }
+  }
+
+  if (job->cfg.verbose&1)
+    fprintf(stderr,"# writing %s[.png] xy= %d %d\n", fname, pp->x, pp->y);
+  writeppm(fname, pp);
+  return 0;
+}