gocr-ruby 0.0.1

data/ext/gocr/jconv.c

@@ -0,0 +1,168 @@
+/* OCR Aug00 JS
+// PGM gray ASCII=P2 RAW=P5
+// PPM RGB  ASCII=P3 RAW=P6
+// PBM B/W  ASCII=P1 RAW=P4
+// ToDo: 
+//  - pbm-raw to pgm also for x!=0 (mod 8) 
+// v0.01 bug eliminated
+// v0.02 convert renamed into jconv because ImageMagick uses same name 
+// v0.03 code review bbg
+// program is not used anymore, use "convert -verbose -crop 0x0+1+1" instead
+*/ 
+
+// #include <iostream.h>
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "pnm.h"
+#ifdef HAVE_PAM_H
+# include <pam.h>
+#endif
+#include "pcx.h"
+#include "tga.h"
+
+void help( void ) {
+  printf("jconv version Aug2000 JS (pnm-raw,pcx8,tga24)\n"
+	 "use: jconv [options] ?infile.pnm? ?outfile.pgm? ?ox? ?oy? ?dx? ?dy?\n"
+	 "options: -shrink -pbm -? -help\n"
+	 "example: jconv -shrink -pbm font.pbm font.pbm 0 0 0 0\n");
+  exit(1);
+}
+
+int main(int argn, char *argv[])
+{
+  char *inam, *onam;
+  pix bild;
+  int ox, oy, dx, dy, x, y, i, vvv = 0;
+
+#ifdef HAVE_PAM_H
+  pnm_init(&argn, argv);
+#endif
+  // skip options
+  for (i = 1; i < argn; i++) {
+    if (argv[i][0] != '-')
+      break;
+    if (!strcmp(argv[i], "-?"))
+      help();
+    else if (!strcmp(argv[i], "-help"))
+      help();
+    else if (!strcmp(argv[i], "-shrink"))
+      vvv |= 2;
+    else if (!strcmp(argv[i], "-pbm"))
+      vvv |= 4;
+    else
+      printf("unknown option: %s\n", argv[i]);
+  }
+
+  if (argn - i != 6)
+    help();
+  inam = argv[i++];
+  onam = argv[i++];
+  ox = atoi(argv[i++]);
+  oy = atoi(argv[i++]);
+  dx = atoi(argv[i++]);
+  dy = atoi(argv[i++]);
+  printf("# in=%s out=%s offs=%d,%d len=%d,%d vvv=%d\n",
+	 inam, onam, ox, oy, dx, dy, vvv);
+
+  // ----- read picture
+  if (strstr(inam, ".pbm") ||
+      strstr(inam, ".pgm") ||
+      strstr(inam, ".ppm") ||
+      strstr(inam, ".pnm") ||
+      strstr(inam, ".pam"))
+    readpgm(inam, &bild, 1);
+  else if (strstr(inam, ".pcx"))
+    readpcx(inam, &bild, 1);
+  else if (strstr(inam, ".tga"))
+    readtga(inam, &bild, ((vvv > 1) ? 0 : 1));
+  else {
+    printf("Error: unknown suffix\n");
+    exit(1);
+  }
+  if (ox < 0 || ox >= bild.x)
+    ox = 0;
+  if (oy < 0 || ox >= bild.y)
+    oy = 0;
+  if (dx <= 0 || ox + dx > bild.x)
+    dx = bild.x - ox;
+  if (dy <= 0 || oy + dy > bild.y)
+    dy = bild.y - oy;
+  if ((vvv & 2) == 2 && bild.bpp == 1) {	// -shrink
+    int x, y;
+    printf("# shrinking PGM:   offs=%d,%d len=%d,%d\n", ox, oy, dx, dy);
+    for (y = 0; y < dy; y++) {	// shrink upper border
+      for (x = 0; x < dx; x++)
+	if (bild.p[x + ox + (y + oy) * bild.x] < 127)
+	  break;
+      if (x < dx) {
+	if (y > 0)
+	  y--;
+	oy += y;
+	dy -= y;
+	break;
+      }
+    }
+    for (y = 0; y < dy; y++) {	// shrink lower border
+      for (x = 0; x < dx; x++)
+	if (bild.p[ox + x + (oy + dy - y - 1) * bild.x] < 127)
+	  break;
+      if (x < dx) {
+	if (y > 0)
+	  y--;
+	dy -= y;
+	break;
+      }
+    }
+    for (x = 0; x < dx; x++) {	// shrink left border
+      for (y = 0; y < dy; y++)
+	if (bild.p[x + ox + (y + oy) * bild.x] < 127)
+	  break;
+      if (y < dy) {
+	if (x > 0)
+	  x--;
+	ox += x;
+	dx -= x;
+	break;
+      }
+    }
+    for (x = 0; x < dx; x++) {	// shrink right border
+      for (y = 0; y < dy; y++)
+	if (bild.p[ox + dx - x - 1 + (oy + y) * bild.x] < 127)
+	  break;
+      if (y < dy) {
+	if (x > 0)
+	  x--;
+	dx -= x;
+	break;
+      }
+    }
+  }
+  printf("# final dimension: offs=%d,%d len=%d,%d bpp=%d\n",
+	 ox, oy, dx, dy, bild.bpp);
+
+/* bbg: could be changed to memmoves */
+  // ---- new size
+  for (y = 0; y < dy; y++)
+    for (x = 0; x < dx; x++)
+      for (i = 0; i < 3; i++)
+	bild.p[i + bild.bpp * (x + dx * y)] =
+	  bild.p[i + bild.bpp * (x + ox + (y + oy) * bild.x)];
+  bild.x = dx;
+  bild.y = dy;
+  // ---- write internal picture of textsite 
+  printf("# write %s\n", onam);
+  if (strstr(onam, ".pbm"))
+    writepbm(onam, &bild);
+  else if (strstr(onam, ".pgm"))
+    writepgm(onam, &bild);
+  else if (strstr(onam, ".ppm"))
+    writeppm(onam, &bild);
+  else if (strstr(onam, ".pnm"))
+    writepgm(onam, &bild);
+  else
+    printf("Error: unknown suffix");
+  free( bild.p );
+}

data/ext/gocr/job.c

@@ -0,0 +1,92 @@
+/*
+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 "pgm2asc.h"
+#include "gocr.h"
+
+/* initialize job structure cfg and db (for all images of a multiimage) */
+void job_init(job_t *job) {
+  /* init source */
+  job->src.fname = "-";
+
+  /* init temporaries */
+  list_init( &job->tmp.dblist ); 
+
+  /* init cfg */
+  job->cfg.cs = 0;
+  job->cfg.spc = 0; 
+  job->cfg.mode = 0;
+  job->cfg.dust_size = -1; /* auto detect */
+  job->cfg.only_numbers = 0;
+  job->cfg.verbose = 0;
+  job->cfg.out_format = UTF8; /* old: ISO8859_1; */
+  job->cfg.lc = "_";
+  job->cfg.db_path = (char*)NULL;
+  job->cfg.cfilter = (char*)NULL;
+  job->cfg.certainty = 95;
+  job->cfg.unrec_marker = "_";
+}
+
+/* initialize job structure for every image (multi-images) */
+void job_init_image(job_t *job) {
+
+  /* FIXME jb: init pix */  
+  job->src.p.p = NULL;
+
+  /* init results */
+  list_init( &job->res.boxlist );
+  list_init( &job->res.linelist ); 
+  job->res.avX = 5;
+  job->res.avY = 8; 
+  job->res.sumX = 0;
+  job->res.sumY = 0;
+  job->res.numC = 0;
+  job->res.lines.dy=0; 
+  job->res.lines.num=0;
+  
+  /* init temporaries */
+  job->tmp.n_run = 0;
+  /* FIXME jb: init ppo */
+  job->tmp.ppo.p = NULL; 
+  job->tmp.ppo.x = 0;
+  job->tmp.ppo.y = 0;
+
+}
+
+/* free job structure */
+void job_free_image(job_t *job) {
+
+  /* if tmp is just a copy of the pointer to the original image */
+  if (job->tmp.ppo.p==job->src.p.p) job->tmp.ppo.p=NULL;
+
+  /* FIMXE jb: free lists
+   * list_free( &job->res.linelist );
+   * list_free( &job->tmp.dblist );
+   */
+ 
+  list_and_data_free(&(job->res.boxlist), (void (*)(void *))free_box);
+
+  /* FIXME jb: free pix */
+  if (job->src.p.p) { free(job->src.p.p); job->src.p.p=NULL; }
+
+  /* FIXME jb: free pix */
+  if (job->tmp.ppo.p) { free(job->tmp.ppo.p); job->tmp.ppo.p=NULL; }
+
+}

data/ext/gocr/lines.c

@@ -0,0 +1,364 @@
+/*
+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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <assert.h>
+#include "pgm2asc.h"
+#include "gocr.h"
+#include "unicode.h" /* decode() */
+#include "unicode_defs.h" /* UNKNOWN */
+
+const char *getTextLine (List *linelist, int line) {
+  int i;
+  Element *elem;
+  
+  if (line < 0 || line > list_total(linelist))
+    return NULL;
+
+  for ( i = 0, elem = linelist->start.next;
+        i < line && elem != NULL; i++ )
+    elem = elem->next;
+
+  if ( elem != NULL )
+    return (const char *)elem->data;
+
+  return NULL;
+}
+
+void free_textlines(List *linelist) {  // list.h
+  for_each_data(linelist) {
+    if (list_get_current(linelist))
+      free(list_get_current(linelist)); // free list element
+  } end_for_each(linelist);
+  list_free(linelist); // free list structure
+}
+
+/* append a string (s1) to the string buffer (buffer) of length (len)
+ * if buffer is to small or len==0 realloc buffer, len+=512
+ */
+char *append_to_line(char *buffer, const char *s1, int *len) {
+  char *temp;
+  int slen=0, alen;
+  if( s1==NULL || s1[0] == 0 ){
+    fprintf(stderr,"\n#BUG: appending 0 to a line makes no sense!");
+    return buffer;
+  }
+  if ( *len>0 ) slen= strlen(buffer);  // used buffer
+  alen = strlen(s1);
+  if ( slen+alen+1 >= *len ) {
+    *len += (((alen+1)>>9)+1)<<9;  // round up to next 512 bytes
+    temp = (char *)realloc(buffer, *len);
+    if( !temp ) { fprintf(stderr,"realloc failed!\n");
+      *len -= (((alen+1)>>9)+1)<<9; return buffer; } // go back
+    else buffer = temp;  // buffer successfull enlarged
+  }
+  temp = buffer + slen;   // end of buffered string
+  memcpy(temp,s1,alen+1); // copy including end sign '\0'
+  return buffer;
+}
+
+int calc_median_gap(struct tlines * lines) {
+  int gaps[MAXlines], l;
+  if (lines->num<2) return 0;
+  for (l = 0; l < lines->num - 1; l++)
+    gaps[l] = lines->m2[l + 1] - lines->m3[l];
+  qsort(gaps, lines->num - 1, sizeof(gaps[0]), intcompare);
+  return gaps[(lines->num - 1) / 2];
+}
+
+/*
+ *  Return the indent in pixels of the least-indented line.
+ *  Will be subtracted as base_indent to avoid negativ indent.
+ *
+ *  This is adjusted to account for an angle on the page as
+ *  a whole.  For instance, if the page is rotated clockwise,
+ *  lower lines may be physically closer to the left edge
+ *  than higher lines that are logically less indented.
+ *  We rotate around (0,0).  Note that this rotation could
+ *  rotate lines "off the left margin", leading to a negative
+ *  indent.
+ *
+ *  boxlist -- list of character boxes.
+ *  dx, dy -- rotation angle as vector
+ */
+int get_least_line_indent(List * boxlist, int dx, int dy, int verbose) {
+    int min_indent = INT_MAX;
+    int adjusted_indent;
+    struct box * box2;
+    if (verbose)
+      fprintf(stderr, "get_least_line_indent: rot.vector dxdy %d %d\n",
+              dx, dy);
+    for_each_data(boxlist) {
+        box2 = (struct box *)list_get_current(boxlist);
+        /* if num == -1, indicates this is a space or newline box,
+         * inserted in list_insert_spaces. */
+        if (box2->num != -1) {
+            adjusted_indent = box2->x0;
+            if (dx) adjusted_indent += box2->y0 * dy / dx;
+            if (adjusted_indent < min_indent) {
+                min_indent = adjusted_indent;
+                if (dy!=0 && verbose)
+                  fprintf(stderr, 
+                   "# Line %2d, unadjusted xy %3d %3d, adjusted x %2d\n", 
+                    box2->line, box2->x0, box2->y0, adjusted_indent);
+            }
+        }
+    } end_for_each(boxlist);
+    if (verbose)
+      fprintf(stderr, "# Minimum adjusted x: %d (min_indent)\n", min_indent);
+    return min_indent;
+}
+
+/* collect all the chars from the box tree and write them to a string buffer
+   mo is the mode: mode&8 means, use chars even if unsure recognized
+   ToDo: store full text(?), store decoded text+boxes+position chars (v0.4)
+         (HTML,UTF,ASCII,XML), not wchar incl. descriptions (at<95% in red)
+         remove decode(*c, job->cfg.out_format) from gocr.c!
+         XML add alternate-tags, format tags and position tags 
+   ToDo: better output XML to stdout instead of circumstantial store to lines
+       not all texts/images follow the line concept?
+   Better use a tree of objects where leafes are chars instead of simple list.
+   Chars or objects are taken into account. Objects can be text strings
+   or XML strings.
+   
+   ToDo: replacing by output_to_stream(FILE *ostream, int mo) ??
+     can be used via pipes (if library) ???
+ */
+void store_boxtree_lines(job_t *job, int mo) {
+  char *buffer;	/* temp buffer for text */
+  int i = 0, j = 0;
+  int len = 1024;   // initial buffer length for text line
+  struct box *box2;
+  int median_gap = 0;
+  int max_single_space_gap = 0;
+  struct tlines line_info;
+  int line, line_gap, oldline=-1;
+  int left_margin;
+  int i1=0, i2=0;
+
+  buffer = (char *)malloc(len);
+  if ( !buffer ) { 
+    fprintf(stderr,"malloc failed!\n"); // ToDo: index_to_error_list 
+    return;
+  }
+  *buffer = 0;
+
+  if ( job->cfg.verbose&1 ) 
+    fprintf(stderr,"# store boxtree to lines ...");
+
+  /* wew: calculate the median line gap, to determine line spacing
+   * for the text output.  The line gap used is between one line's
+   * m3 (baseline) and the next line's m2 (height of non-rising 
+   * lowercase).  We use these lines as they are the least likely
+   * to vary according to actual character content of lines.
+   */
+  median_gap = calc_median_gap(&job->res.lines);
+  if (median_gap <= 0) {
+    if ( job->cfg.verbose&1 )
+      fprintf(stderr, "# Warning: non-positive median line gap of %d\n",
+              median_gap);
+    median_gap = 8;
+    max_single_space_gap = 12;  /* arbitrary */
+  } else {
+    max_single_space_gap = median_gap * 7 / 4;
+  }
+
+  // Will be subtracted as base_indent to avoid negativ indent.
+  left_margin = get_least_line_indent(&job->res.boxlist,
+          job->res.lines.dx, 
+          job->res.lines.dy, job->cfg.verbose);
+
+  if (job->cfg.out_format==XML) { /* subject of change */
+    char s1[255]; /* ToDo: avoid potential buffer overflow !!! */
+    /* output lot of usefull information for XML filter */
+    sprintf(s1,"<page x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\">\n",
+       0,0,0,0);
+    buffer=append_to_line(buffer,s1,&len);
+    sprintf(s1,"<block x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\">\n",
+       0,0,0,0);
+    buffer=append_to_line(buffer,s1,&len);
+  } 
+
+  for_each_data(&(job->res.boxlist)) {
+    box2 = (struct box *)list_get_current(&(job->res.boxlist));
+    line = box2->line;
+    line_info = job->res.lines;
+    /* reset the output char if certainty is below the limit v0.44 */
+    if (box2->num_ac && box2->wac[0]<job->cfg.certainty) box2->c=UNKNOWN;
+    if (line!=oldline) {
+      if (job->cfg.out_format==XML && oldline>-1) { /* subject of change */
+        buffer=append_to_line(buffer,"</line>\n",&len);
+        list_app( &(job->res.linelist), (void *)strdup(buffer) ); // wcsdup
+        memset(buffer, 0, len);
+        j=0;  // reset counter for new line
+      } 
+      if (job->cfg.out_format==XML) { /* subject of change */
+        char s1[255]; /* ToDo: avoid potential buffer overflow !!! */
+        /* output lot of usefull information for XML filter */
+        sprintf(s1,"<line x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\" value=\"%d\">\n",
+           line_info.x0[line],line_info.m1[line],
+           line_info.x1[line]-line_info.x0[line]+1,
+           line_info.m4[line]-line_info.m1[line],line);
+        buffer=append_to_line(buffer,s1,&len);
+      }
+      oldline=line;
+    }
+    if (box2->c >  ' ' &&
+        box2->c <= 'z') i1++; /* count non-space chars */
+    if (box2->c == '\n') {
+      if (job->cfg.out_format!=XML) { /* subject of change */
+        line_info = job->res.lines;
+        line = box2->line;
+        if (line > 0) {
+          line_gap = line_info.m2[line] - line_info.m3[line - 1];
+          for (line_gap -= max_single_space_gap; line_gap > 0; 
+               line_gap -= median_gap) {
+            buffer=append_to_line(buffer,"\n",&len);
+            j++; /* count chars in line */
+          }
+        } 
+        list_app( &(job->res.linelist), (void *)strdup(buffer) ); // wcsdup
+        memset(buffer, 0, len);
+        j=0;  // reset counter for new line
+      } 
+    }
+    if (box2->c == ' ')	// fill large gaps with spaces
+    {
+      if (job->res.avX) { /* avoid SIGFPE */
+        if (job->cfg.out_format==XML) { /* subject of change */
+          char s1[255]; /* ToDo: avoid potential buffer overflow !!! */
+          /* output lot of usefull information for XML filter */
+          sprintf(s1," <space x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\" />\n",
+                  box2->x0,box2->y0,box2->x1-box2->x0+1,box2->y1-box2->y0+1);
+          buffer=append_to_line(buffer,s1,&len);
+        } else
+// multi spacing is done now in pgm2asc using insert spaces 2010-09-28
+//        for (i = (box2->x1 - box2->x0 + 1) / (2 * job->res.avX) + 1; i > 0; i--) 
+        {
+          buffer=append_to_line(buffer," ",&len);
+          j++; /* number of chars in line */
+        }
+      }
+    }
+    else if (box2->c != '\n') {
+      if (j==0 && job->res.avX) /* first char in new line? */ {
+        int indent = box2->x0 - job->res.lines.x0[box2->line];
+        /* correct for angle of page as a whole. */
+        if (job->res.lines.dx)
+          indent += box2->y0 * job->res.lines.dy / job->res.lines.dx;
+        /* subtract the base margin. */
+        indent -= left_margin;
+        if (job->cfg.out_format==XML) { /* subject of change */
+          char s1[255]; /* ToDo: avoid potential buffer overflow !!! */
+          /* output lot of usefull information for XML filter */
+          sprintf(s1," <space x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\" />\n",
+                  box2->x0,box2->y0,box2->x1-box2->x0+1,box2->y1-box2->y0+1);
+          buffer=append_to_line(buffer,s1,&len);
+        } else
+// ToDo: do the multi "\n" earlier in pgm2asc (like multi spacing)
+        for (i = indent / job->res.avX; i > 0; i--) {
+          buffer=append_to_line(buffer," ",&len); j++;
+        }
+      }
+      if (job->cfg.out_format==XML) { /* subject of change */
+        char s1[255]; /* ToDo: avoid potential buffer overflow !!! */
+        /* output lot of usefull information for XML filter */
+        sprintf(s1," <box x=\"%d\" y=\"%d\" dx=\"%d\" dy=\"%d\" value=\"",
+                box2->x0,box2->y0,box2->x1-box2->x0+1,box2->y1-box2->y0+1);
+        buffer=append_to_line(buffer,s1,&len);
+        if (box2->num_ac>1) { /* ToDo: output a list of alternatives */
+        }
+      }
+      if (box2->c != UNKNOWN  &&  box2->c != 0) {
+        buffer=
+          append_to_line(buffer,decode(box2->c,job->cfg.out_format),&len);
+        if (box2->c >  ' ' &&
+            box2->c <= 'z') i2++; /* count non-space chars */
+      } else { /* c == UNKNOWN or 0 */
+        wchar_t cc; cc=box2->c;
+        if (box2->num_ac>0 && box2->tas[0]
+          && (/* job->cfg.out_format!=XML || 2010-10 */ box2->tas[0][0]!='<')
+          ) {  // 2010-10 output XML code after XML frame, see below!
+          /* output glued chars or ... (?) Jan08 */
+          buffer=append_to_line(buffer,box2->tas[0],&len);
+          j+=strlen(box2->tas[0]);
+        } // else 2010-10-07
+        if (box2->num_ac == 0 || box2->c == UNKNOWN) {
+          /* ToDo: leave string empty? set placeholder per option */
+          /* output dummy string to mark UNKNOWN */
+          if (job->cfg.unrec_marker[0])
+            buffer = append_to_line(buffer, job->cfg.unrec_marker, &len);
+        }
+      }
+      if (job->cfg.out_format==XML) {
+        if (box2->num_ac>0) {
+          /* output alist ToDo: separate <altbox ...> */
+          int i1; char s1[256];
+          sprintf(s1,"\" numac=\"%d\" weights=\"",box2->num_ac);
+          buffer=append_to_line(buffer,s1,&len);
+          for (i1=0;i1<box2->num_ac;i1++) {
+            sprintf(s1,"%d",box2->wac[i1]);
+            buffer=append_to_line(buffer,s1,&len);
+            if (i1+1<box2->num_ac) buffer=append_to_line(buffer,",",&len);
+          }
+          if (box2->num_ac>1)
+            buffer=append_to_line(buffer,"\" achars=\"",&len);
+          for (i1=1;i1<box2->num_ac;i1++) {
+            if (box2->tas[i1] && box2->tas[i1][0]!='<')
+              buffer=append_to_line(buffer,box2->tas[i1],&len);
+            else
+              buffer=append_to_line(buffer,
+                 decode(box2->tac[i1],job->cfg.out_format),&len);
+            // ToDo: add tas[] (achars->avalues or alternate_strings?
+            if (i1+1<box2->num_ac) buffer=append_to_line(buffer,",",&len);
+          }
+        }
+        buffer=append_to_line(buffer,"\" />\n",&len);
+      }
+      if (box2->num_ac && box2->tas[0]) {
+        if (box2->tas[0][0]=='<') { /* output special XML object */ 
+          buffer=append_to_line(buffer,box2->tas[0],&len);
+          if (job->cfg.out_format==XML) // 2010-10-07
+            buffer=append_to_line(buffer,"\n",&len);
+          j+=strlen(box2->tas[0]);
+        }
+      }
+      j++; /* number of chars in line */
+    }
+    i++;
+  } end_for_each(&(job->res.boxlist));
+  if (job->cfg.out_format==XML && oldline>-1) { /* subject of change */
+    buffer=append_to_line(buffer,"</line>\n",&len);
+  } 
+  if (job->cfg.out_format==XML) { /* subject of change */
+    buffer=append_to_line(buffer,"</block>\n</page>\n",&len);
+  } 
+
+  /* do not forget last line */
+  // is there no \n in the last line? If there is, delete next line.
+  list_app( &(job->res.linelist), (void *)strdup(buffer) );
+  free(buffer);
+  if( job->cfg.verbose&1 )
+    fprintf(stderr,"... %d lines, boxes= %d, chars= %d\n",i,i1,i2);
+}