---

print.c

/*
GOCR Copyright (C) 2000  Joerg Schulenburg Joerg.Schulenburg@physik.uni-magdeburg.de 
GOCR API Copyright (C) 2001 Bruno Barberi Gnecco <brunobg@sourceforge.net>

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.

*/

#include "_gocr.h"
#include "gocr_module.h"

static int returnflag = 0;


int gocr_printArea ( gocrImage *image, int x0, int y0, int x1, int y1 ) {
  int i, j;

  _gocr_debug(3, fprintf(_data.error, "gocr_printArea(%p, %d, %d, %d, %d)\n", 
      image, x0, y0, x1, y1);)

  if ( image == NULL || image->data == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL image or image data\n");)
    return -1;
  }

  _gocr_fixParameters ( &x0, &y0, &x1, &y1 );

  for ( i = x0; i <= x1; i++ ) {
    if ( _data.print == 6 ) { /* just dump it */
      fwrite(image->data[i], sizeof(gocrPixel), y0-y1+1, _data.error);
    }
    else for ( j = y0; j <= y1; j++ )
      switch ( _data.print ) {
        case 0: /* only data bit */
          fputc((image->data[i][j].value == GOCR_BLACK ? '*' : '.'), _data.error);
          break;
        case 1: /* marked bits */
          fputc('0' + image->data[i][j].mark1 + 2*image->data[i][j].mark2
              + 4*image->data[i][j].mark3, _data.error);
          break;
        case 2: /* data+marked */
          fputc((image->data[i][j].value  == GOCR_BLACK? 'A' : 'a') + 
              image->data[i][j].mark1 + 2*image->data[i][j].mark2 + 
              4*image->data[i][j].mark3, _data.error);
          break;
        case 3: /* block bit */
          fputc((image->data[i][j].isblock == GOCR_BLACK ? '*' : '.'), _data.error);
          break;
        case 4: /* recognized bit */
          fputc((image->data[i][j].ischar == GOCR_BLACK ? '*' : '.'), _data.error);
          break;
        case 5: /* all, hexa */
          fprintf(_data.error, "%x", (int)*((unsigned char *)&image->data[i][j]));
          break;
    }
    if ( !returnflag ) /* this is used by gocr_printBox2 */
      fputc('\n', _data.error);
  }
  return 0;
}

int gocr_printBlock ( gocrBlock *b ) {
  _gocr_debug(3, fprintf(_data.error, "gocr_printBlock(%p)\n", b);)

  if ( b == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL gocrBlock at gocr_printBlock\n");)
    return -1;
  }

/* future: let the user provide his own print block function too */
  fprintf(_data.error, "Block: x0:%d, y0:%d, x1:%d, y1:%; type %s\n",
      b->x0, b->y0, b->x1, b->y1, gocr_getNamebyType(b->t));

  if ( _data.print_image )
    return gocr_printArea(&b->image, 0, 0, b->image.x-1, b->image.y-1);

  return 0;
}
      
int gocr_printBox ( gocrBox *b ) {
  _gocr_debug(3, fprintf(_data.error, "gocr_printBox(%p)\n", b);)

  if ( b == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL gocrBox at gocr_printBox\n");)
    return -1;
  }

  fprintf(_data.error, "Box: x0:%d, y0:%d, x1:%d, y1:%; c:%x ac:%x mod:%x\n",
      b->x0, b->y0, b->x1, b->y1, b->c, b->ac, b->modifier);

  if ( _data.print_image )
    return gocr_printArea(&currentblock->image, b->x0, b->y0, b->x1, b->y1);

  return 0;
}

int gocr_printBox2 ( gocrBox *b1, gocrBox *b2 ) {
  int xmax, xend, i, j;
  
  _gocr_debug(3, fprintf(_data.error, "gocr_printBox2(%p, %p)\n", b1, b2);)

  if ( b1 == NULL || b2 == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL gocrBox at gocr_printBox2\n");)
    return -1;
  }
#if 0
  if ( b1->image == NULL || b2->image == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL gocrBox image at gocr_printBox2\n");)
    return -1;
  }
#endif

  /* these are used below, to know which box ends first */
  if ( b1->x1 - b1->x0 < b2->x1 - b2->x0 ) {
    xmax = b1->x1 - b1->x0 + 1;
    xend = b2->x1 - b2->x0 + 1;
  }
  else {
    xmax = b2->x1 - b2->x0 + 1;
    xend = b1->x1 - b1->x0 + 1;
  }
 
  fprintf(_data.error, "Box1: x0:%d, y0:%d, x1:%d, y1:%; c:%x ac:%x mod:%x\n",
      b1->x0, b1->y0, b1->x1, b1->y1, b1->c, b1->ac, b1->modifier);
  fprintf(_data.error, "Box2: x0:%d, y0:%d, x1:%d, y1:%; c:%x ac:%x mod:%x\n",
      b2->x0, b2->y0, b2->x1, b2->y1, b2->c, b2->ac, b2->modifier);

  returnflag++; /* so printArea doesn't print \n */
  /* print */
  if ( _data.print_image ) {
    for ( i = 0; i < xmax; i++ ) {
      gocr_printArea(&currentblock->image, b1->x0+i, b1->y0, b1->x0+i, b1->y1);
      fputs("  ", _data.error);
      gocr_printArea(&currentblock->image, b2->x0+i, b2->y0, b2->x0+i, b2->y1);
      fputs("\n", _data.error);
    }
  }
  /* one of the characters ended first; print the rest of the other */
  for ( ; i < xend; i++ ) {
    if ( b1->x1 - b1->x0 < b2->x1 - b2->x0 ) { /* pad with spaces */
      for ( j = b1->y0; j <= b1->y1; j++ )
        fputc(' ', _data.error);
      fputs("  ", _data.error);
      gocr_printArea(&currentblock->image, b2->x0+i, b2->y0, b2->x0+i, b2->y1);
    }
    else {
      gocr_printArea(&currentblock->image, b1->x0+i, b1->y0, b1->x0+i, b1->y1);
    }
    fputs("\n", _data.error);
  }
  returnflag = 0;
      
  return 0;
} 

---