---

image.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 "config.h"
#include "_gocr.h"
#include "gocr.h"
#include <string.h>
#ifdef HAVE_PAM_H
#include <pam.h>
#endif
#if defined HAVE_PNM_H && !defined HAVE_PAM_H
#include <pnm.h>
#endif

gocrImage *currentimage = NULL;

/* Fills the NEW image, sharing it with orig->data.
 */

int _gocr_imageSharedCopy ( gocrImage *orig, int x0, int y0, int x1, int y1,
                            gocrImage *new ) {
  int i;

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

  if ( orig == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL pointer at _gocr_imageSharedCopy\n");)
    return -1;
  }

  _gocr_fixParameters ( &x0, &y0, &x1, &y1 );
  if ( x0 < 0 || x1 >= orig->x || y0 < 0 || y1 >= orig->y ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageSharedCopy: data OOB\n");)
    return -1;
  }

  if ( new == NULL ) {
    new = (gocrImage *)malloc(sizeof(gocrImage));
    if ( new == NULL ) {
      _gocr_debug(1, fprintf(_data.error, "gocr_imageSharedCopy NULL malloc\n");)
      return -1;
    }
  }
  else
    _gocr_debug(2, fprintf(_data.error, 
        "gocr_imageSharedCopy got a non NULL structure; memory waste may occur\n");)
    
  new->filename = NULL;
  new->x = x1 - x0 + 1;
  new->y = y1 - y0 + 1;
  new->type = orig->type;
  new->data = (gocrPixel **)malloc(new->x * sizeof(gocrPixel *));
  if ( new->data == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageSharedCopy: NULL malloc\n");)
    return -1;
  }
    
  for ( i = 0; i < new->x; i++ )
    new->data[i] = &orig->data[i + x0][y0];

  list_init(&new->blocklist);
  return 0;
}

/*  */
int _gocr_imageCopy ( gocrImage *orig, int x0, int y0, int x1, int y1,
                            gocrImage *new ) {
  int i;

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

  if ( orig == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "NULL pointer at _gocr_imageCopy\n");)
    return -1;
  }

  _gocr_fixParameters ( &x0, &y0, &x1, &y1 );
  if ( x0 < 0 || x1 >= orig->x || y0 < 0 || y1 >= orig->y ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageCopy: data OOB\n");)
    return -1;
  }

  if ( new == NULL ) {
    new = (gocrImage *)malloc(sizeof(gocrImage));
    if ( new == NULL ) {
      _gocr_debug(1, fprintf(_data.error, "gocr_imageCopy NULL malloc\n");)
      return -1;
    }
  }
  new->filename = NULL;
  new->x = x1 - x0 + 1;
  new->y = y1 - y0 + 1;
  new->type = orig->type;
  new->data = (gocrPixel **)malloc(new->x * sizeof(gocrPixel *));
  if ( new->data == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageCopy: NULL malloc\n");)
    return -1;
  }
    
  for ( i = 0; i < new->x; i++ ) {
    new->data[i] = (gocrPixel *)malloc(new->y * sizeof(gocrPixel));
    if ( new->data[i] == NULL ) {
      _gocr_debug(1, fprintf(_data.error, "_gocr_imageCopy: NULL malloc[]\n");)
      for ( i--; i >= 0; i-- ) {
        free(new->data[i]);
        free(new);
      }
      return -1;
    }
    memcpy(new->data[i], &orig->data[i + x0][y0], new->y);
  }

  list_init(&new->blocklist);
  return 0;
}

void _gocr_fixParameters ( int *x0, int *x1, int *y0, int *y1 ) {
  if ( *x0 <= *x1 && *y0 <= *y1 ) /* OK */
    return;

  if ( *x0 > *x1 && *y0 > *y1 ) { /* then swap the pairs */
    int i;
    i = *x0; *x0 = *x1; *x1 = i;
    i = *y0; *y0 = *y1; *y1 = i;
    return;
  }

  if ( *x0 > *x1 && *y0 <= *y1 ) { /* correct is (x1,y0), (x0,y1) */
    int i;
    i = *x0; *x0 = *x1; *x1 = i;
    return;
  }
  
  if ( *x0 <= *x1 && *y0 > *y1 ) { /* correct is (x0,y1), (x1,y0) */
    int i;
    i = *y0; *y0 = *y1; *y1 = i;
    return;
  }
}

/*
    feel free to expand this list of usable converting programs
    Note 1: the last field must be NULL.
    Note 2: "smaller" extensions must come later: ".pnm.gz" must come
       before ".pnm".
 */
static const char *xlist[]={
  ".pnm.gz",    "gzip -cd",
  ".pbm.gz",    "gzip -cd",
  ".pgm.gz",    "gzip -cd",
  ".ppm.gz",    "gzip -cd",
  ".pnm.bz2",   "bzip2 -cd",
  ".pbm.bz2",   "bzip2 -cd",
  ".pgm.bz2",   "bzip2 -cd",
  ".ppm.bz2",   "bzip2 -cd",
  ".jpg",       "djpeg -gray -pnm",
  ".jpeg",      "djpeg -gray -pnm",
  ".gif",       "giftopnm",
  ".bmp",       "bmptoppm",
  ".tiff",      "tifftopnm",
  ".png",       "pngtopnm",
  NULL
};

/* return a pointer to command converting file to pnm or NULL */
static const char *testsuffix ( const char *name ) {
  int i;

  for ( i = 0; xlist[i] != NULL; i += 2 ) {
    if ( strstr( name, xlist[i] ) != NULL )
      return xlist[i+1];
  }
  return NULL;
}

int gocr_imageLoad ( const char *filename ) {
  const char *command;
  unsigned char **data;
  FILE *fp;
  int row, col, i;
#ifdef HAVE_PAM_H
  struct pam inpam;
  tuple *tuplerow;
#endif

  _gocr_debug(3, fprintf(_data.error, "gocr_imageLoad(%s)\n", filename);)

  /* open file; test if conversion is needed. */
  command = testsuffix( filename );
  if ( !command ) {
    fp = fopen(filename, "rb");
    if (!fp) {
      _gocr_debug(1, fprintf(_data.error, "File %s couldn't be opened\n", filename);)
      return -1;
    }
  }
  else {
    char *buf = (char *)malloc((strlen(command)+strlen(filename)+2)*sizeof(char));

    sprintf(buf, "%s %s", buf, filename);
    _gocr_debug(3, fprintf(_data.error, "# popen( %s )\n", buf);)
#if defined(__USE_POSIX2)
    fp = popen(buf, "r");
#else
    _gocr_debug(0, fprintf(_data.error, "Sorry, you must compile with __USE_POSIX2 to use pipes\n"
        "Cannot open this file format without pipes\n");)
#endif
    if (!fp)
      _gocr_debug(1, fprintf(_data.error, "opening pipe %s\n", buf);)

    free(buf);
  }

  /* do we have an image? If so, close it first */
  if ( currentimage )
    gocr_imageClose();

  /* read file */
  /* Ok, I'll explain my dirty trick to save lots of memory: I cast img.data
    to (unsigned char **), read the image into it and filter. The monochrome
    conversor then is called with a threshold and takes care of filling the
    image.data.value fields correctly and zeroing all other fields. Confusing?
    Yes, a bit. But the nice method would take two times the memory we use now.
    Of course, a change in the size of gocrPixel is a disaster. Read the
    developers.txt file. */

  /* allocate memory */
  currentimage = (gocrImage *)malloc(sizeof(gocrImage));
  if ( currentimage == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "gocr_loadImage NULL malloc\n");)
    return -1;
  }

#ifdef HAVE_PAM_H
  pnm_readpaminit(fp, &inpam, sizeof(inpam));

  /* allocate memory for the image data */
  currentimage->x = inpam.height;
  currentimage->y = inpam.width;
  currentimage->data = (gocrPixel **)malloc(currentimage->x * sizeof(gocrPixel *));
  if ( currentimage->data == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageSharedCopy: NULL malloc\n");)
    fclose(fp);
    return -1;
  }
  for ( i = 0; i < currentimage->x; i++ )
    currentimage->data[i] = (gocrPixel *)malloc(currentimage->y * sizeof(gocrPixel));

  /* and fill it */
  if ( inpam.depth == 1 && strcmp(inpam.tuple_type, PAM_PBM_TUPLETYPE) == 0 ) {
    /* we have a PBM (Black and white) */
    _gocr_debug(3, fprintf(_data.error, "PBM format detected.\n");)

    currentimage->type = BLACK_AND_WHITE;

    tuplerow = pnm_allocpamrow(&inpam);
    for ( row = 0; row < inpam.height; row++ ) {
      pnm_readpamrow(&inpam, tuplerow);
      for ( col = 0; col < inpam.width; col++ ) {
        currentimage->data[row][col].value = 
            (tuplerow[col][0] == PAM_PBM_BLACK ? GOCR_BLACK : GOCR_WHITE );
      }
    }
    pnm_freepamrow(tuplerow);
  }
  else if ( inpam.depth == 1 && strcmp(inpam.tuple_type, PAM_PGM_TUPLETYPE) == 0 ) {
    /* we have a PGM (gray) */
    unsigned char **data = (unsigned char **)currentimage->data;

    _gocr_debug(3, fprintf(_data.error, "PGM format detected.\n");)

    currentimage->type = GRAY;

    tuplerow = pnm_allocpamrow(&inpam);
    for ( row = 0; row < inpam.height; row++ ) {
      pnm_readpamrow(&inpam, tuplerow);
      for ( col = 0; col < inpam.width; col++ ) {
        data[row][col] = tuplerow[col][0];
      }
    }
    pnm_freepamrow(tuplerow);
  } 
  else if ( inpam.depth == 3 && strcmp(inpam.tuple_type, PAM_PPM_TUPLETYPE) == 0 ) {
    /* we have a PPM (color) */
    _gocr_debug(3, fprintf(_data.error, "PPM format detected.\n");)
    _gocr_debug(0, fprintf(_data.error, "PPM format not handled yet.\n");)
    goto error;
  } 
  else {
    _gocr_debug(1, fprintf(_data.error, "Format not recognized.\n");)
    goto error;
  }
#endif
#if defined HAVE_PNM_H && !defined HAVE_PAM_H
 _gocr_debug(0, fprintf(_data.error, "PNM not coded yet. Get a newer NetPBM with pam functions.\n");)
#endif

  currentimage->filename = strdup(filename);

  list_init(&currentimage->blocklist);
  fclose(fp);

  return 0;

error: /* free, close, and return */
  fclose(fp);
  free(currentimage->data);
  free(currentimage);
  return -1;
}

void gocr_imageClose ( void ) {
  gocr_imageFree(currentimage);
}

void gocr_imageFree ( gocrImage *image ) {
   _gocr_debug(3, fprintf(_data.error, "gocr_imageFree(%p)\n", image);)

  if ( image == NULL )
    return;

  if ( image->filename )
    free(image->filename);
  if ( image->data ) {
    int i;
    
    for ( i = 0; i < image->x; i++ )
      if (image->data[i])
        free(image->data[i]);

    free(image->data);
  }
  image->x = image->y = 0;
  free(image);
/*TODO  list_free(block)*/
}

/* if data == 1, print blocks and boxes frames */
int _gocr_imageWrite ( gocrImage *image, char *filename, char data ) {
  FILE *fp;
#ifdef HAVE_PAM_H
  struct pam outpam;
#endif

  _gocr_debug(3, fprintf(_data.error, "_gocr_imageWrite(%p, %s)\n", image, filename);)

  if ( image == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageWrite: NULL image\n");)
    return -1;
  }
  
  /* open the file */
  if ( filename == NULL ) {
    filename = image->filename;
    if ( filename == NULL ) {
      _gocr_debug(1, fprintf(_data.error, "_gocr_imageWrite: NULL filename\n");)
      return -1;
    }
  }

  fp = fopen(filename, "w");
  if ( fp == NULL ) {
    _gocr_debug(1, fprintf(_data.error, "_gocr_imageWrite: file open error\n");)
    return -1;
  }
  
#ifdef HAVE_PAM_H
  /* fill the pam structure */
  outpam.file = fp;
#ifdef NOTDONEYET
  outpam.size = ;
  outpam.len = ;
  outpam.height = image->y;
  outpam.width = image->x;

  if ( data == 1 ) { /* output .pbm */
    outpam.format = PBM_FORMAT;
    outpam.depth = 1;
    outpam.maxval = 1;
    outpam.tuple_type = BLACKANDWHITE; 
  }
  else { /* output ppm */
    outpam.format = PPM_FORMAT;
    outpam.depth = 3;
    outpam.maxval = 255;
    outpam.tuple_type = RGB;
  }
#endif
    
  pnm_writepaminit(&outpam);
  {
    tuple *tuplerow;
    int row;
 
    tuplerow = pnm_allocpamrow(&outpam);
    for (row = 0; row < outpam.height; row++) {
      /* fill row */
      pnm_writepamrow(&outpam, tuplerow);
    }
    pnm_freepamrow(tuplerow);
  }
#endif
#if defined HAVE_PNM_H && !defined HAVE_PAM_H
  if ( data == 0 ) { /* output .pbm */
    bit *bitrow;

    pbm_writepbminit(fp, image->x, image->y, 0);
    bitrow = pbm_allocrow(image->x);
    for ( i = 0; i < image->y; i++ ) {
      for ( j = 0; j < image->x; j++ )
        bitrow[j] = ( image->data[i][j].value == GOCR_BLACK ? PBM_BLACK : PBM_WHITE );
      pbm_writepbmrow(fp, bitrow, image->x, 0 );
    }
    pbm_freerow(bitrow);
  }
  else { /* output .ppm */
    pixel *pixelrow;

    ppm_writeppminit(fp, image->x, image->y, 255, 0);
    pixelrow = ppm_allocrow(image->x);
    for ( i = 0; i < image->y; i++ ) {
      for ( j = 0; j < image->x; j++ ) {
        /*TODO*/
      }
      ppm_writeppmrow(fp, pixelrow, image->x, 255, 0 );
    }
    ppm_freerow(pixelrow);
    
  }
#endif

  fclose(fp);
}

int gocr_imageWrite ( gocrImage *image, char *filename ) {
  return _gocr_imageWrite( image, filename, 0 );
}

int gocr_imageWriteWithData ( gocrImage *image, char *filename ) {
  return _gocr_imageWrite( image, filename, 1 );
}

---