/*
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

    v0.1.0 initial version (stdin added)
    v0.2.0 popen added
    v0.2.7 review by Bruno Barberi Gnecco
    v0.39  autoconf
    v0.41  fix integer and heap overflow, change color output
    v0.46  fix blank spaces problem in filenames
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#ifdef HAVE_UNISTD_H
/* #include <unistd.h> */
#endif

/* Windows needs extra code to work fine, ^Z in BMP's will stop input else.
 * I do not have any idea when this text mode will be an advantage
 * but the MS community seems to like to do simple things in a complex way. */
#if defined(O_BINARY) && (defined(__WIN32) || defined(__WIN32__)\
 || defined(__WIN64) || defined(__WIN64__) || defined(__MSDOS__))
# include <fcntl.h>
# define SET_BINARY(_f) do {if (!isatty(_f)) setmode (_f, O_BINARY);} while (0)
#else
# define SET_BINARY(f) (void)0
#endif

#include "pnm.h"
#ifdef HAVE_PAM_H
# include <pam.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <fcntl.h>
#else
# include <ctype.h>
#endif

#define EE()         fprintf(stderr,"\nERROR "__FILE__" L%d: ",__LINE__)
#define E0(x0)       {EE();fprintf(stderr,x0 "\n");      }
#define F0(x0)       {EE();fprintf(stderr,x0 "\n");      exit(1);}
#define F1(x0,x1)    {EE();fprintf(stderr,x0 "\n",x1);   exit(1);}

/*
 * Weights to use for the different colours when converting a ppm
 * to greyscale.  These weights should sum to 1.0
 * 
 * The below values have been chosen to reflect the fact that paper
 * goes a reddish-yellow as it ages.
 *
 * v0.41: for better performance, we use integer instead of double
 *        this integer value divided by 1024 (2^10) gives the factor 
 */
#define PPM_RED_WEIGHT   511  /* .499 */
#define PPM_GREEN_WEIGHT 396  /* .387 */
#define PPM_BLUE_WEIGHT  117  /* .114 */

/*
    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".
    calling external programs is a security risk
    ToDo: for better security replace gzip by /usr/bin/gzip !
 */
char *xlist[]={
  ".pnm.gz",	"gzip -cd",  /* compressed pnm-files, gzip package */
  ".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",  /* JPG/JPEG, jpeg package */
  ".jpeg",	"djpeg -gray -pnm",
  ".gif",	"giftopnm -image=all",  /* GIF, netpbm package */
  ".bmp",	"bmptoppm",
  ".tiff",	"tifftopnm",
  ".png",	"pngtopnm", /* Portable Network Graphics (PNG) format */
  ".ps",	"pstopnm -stdout -portrait -pgm", /* postscript */
  ".eps",	"pstopnm -stdout -portrait -pgm", /* encapsulated postscript */
   /* gs -sDEVICE=pgmraw -sOutputFile=- -g609x235 -r141x141 -q -dNOPAUSE */
  ".fig",	"fig2dev -L ppm -m 3", /* xfig files, transfig package */
  NULL
};

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

  for(i = 0; xlist[i] != NULL; i += 2 ) {
    if((rr=strstr(name, xlist[i])) != NULL)
      if(strlen(rr)==strlen(xlist[i])) /* handle *.eps.pbm correct */
        return xlist[i+1];
  }
  return NULL;
}


char read_char(FILE *f1){	// filter #-comments
  char c;
  int  m;
  for(m=0;;){
    c=fgetc(f1);
    if( feof(f1)   )		E0("read feof");
    if( ferror(f1) )		F0("read ferror");
    if( c == '#'  )		{ m = 1; continue; }
    if( m ==  0   )		return c;
    if( c == '\n' )		m = 0;
  }
}


/*
   for simplicity only PAM of netpbm is used, the older formats
   PBM, PGM and PPM can be handled implicitly by PAM routines (js05)
   v0.43: return 1 if multiple file (hold it open), 0 otherwise
 */
#ifdef HAVE_PAM_H
int readpgm(char *name, pix * p, int vvv) {
  static FILE *fp=NULL;
  static char *pip; 
  char magic1, magic2;
  int i, j, sample, minv = 0, maxv = 0, eofP=0;
  struct pam inpam;
  tuple *tuplerow;

  assert(p);

  if (!fp) { // fp!=0 for multi-pnm and idx>0
    /* open file; test if conversion is needed. */
    if (name[0] == '-' && name[1] == '\0') {
      fp = stdin;
      SET_BINARY (fileno(fp)); // Windows needs it for correct work
    }
    else {
      pip = testsuffix(name);
      if (!pip) {
        fp = fopen(name, "rb");
        if (!fp)
          F1("opening file %s", name);
      }
      else {
        char *buf = (char *)malloc((strlen(pip)+strlen(name)+4));
        sprintf(buf, "%s \"%s\"", pip, name); /* allow spaces in filename */
        if (vvv) {
          fprintf(stderr, "# popen( %s )\n", buf);
        }
#ifdef HAVE_POPEN
        /* potential security vulnerability, if name contains tricks */
        /* example: gunzip -c dummy | rm -rf * */
        /* windows needs "rb" for correct work, linux not, cygwin? */
        /* ToDo: do you have better code to go arround this? */
#if defined(__WIN32) || defined(__WIN32__) || defined(__WIN64) || defined(__WIN64__)
	fp = popen(buf, "rb");  /* ToDo: may fail, please report */
	if (!fp) fp = popen(buf, "r"); /* 2nd try, the gnu way */
#else
        fp = popen(buf, "r");
#endif
#else
        F0("sorry, compile with HAVE_POPEN to use pipes");
#endif
        if (!fp)
          F1("opening pipe %s", buf);
        free(buf);
      }
    }
  }

  /* netpbm 0.10.36 tries to write a comment to nonzero char** comment_p */
  /* patch by C.P.Schmidt 21Nov06 */
  memset (&inpam, 0, sizeof(inpam));

  /* read pgm-header */
  /* struct pam may change between netpbm-versions, causing problems? */
#ifdef PAM_STRUCT_SIZE  /* ok for netpbm-10.35 */
  /* new-and-better? but PAM_STRUCT_SIZE is not defined in netpbm-10.18 */
  pnm_readpaminit(fp, &inpam, PAM_STRUCT_SIZE(tuple_type));
#else /* ok for netpbm-10.18 old-and-bad for new netpbms */
  pnm_readpaminit(fp, &inpam, sizeof(inpam));
#endif

  p->x = inpam.width;
  p->y = inpam.height;
  magic1=(inpam.format >> 8) & 255; /* 'P' for PNM,PAM */
  magic2=(inpam.format     ) & 255; /* '7' for PAM */
  minv=inpam.maxval;
  if (vvv) {
      fprintf(stderr, "# readpam: format=0x%04x=%c%c h*w(d*b)=%d*%d(%d*%d)\n",
        inpam.format, /* magic1*256+magic2 */
        ((magic1>31 && magic1<127)?magic1:'.'),
        ((magic2>31 && magic2<127)?magic2:'.'),
        inpam.height,
        inpam.width,
        inpam.depth,
        inpam.bytes_per_sample);
  }
  if ( (1.*(p->x*p->y))!=((1.*p->x)*p->y) )
    F0("Error integer overflow");
  if ( !(p->p = (unsigned char *)malloc(p->x*p->y)) )
    F1("Error at malloc: p->p: %d bytes", p->x*p->y);
  tuplerow = pnm_allocpamrow(&inpam);
  for ( i=0; i < inpam.height; i++ ) {
    pnm_readpamrow(&inpam, tuplerow);   /* exit on error */
    for ( j = 0; j < inpam.width; j++ ) {
      if (inpam.depth>=3)
        /* tuplerow is unsigned long (see pam.h sample) */
        /* we expect 8bit or 16bit integers,
           no overflow up to 32-10-2=20 bits */
        sample
          = ((PPM_RED_WEIGHT   * tuplerow[j][0] + 511)>>10)
          + ((PPM_GREEN_WEIGHT * tuplerow[j][1] + 511)>>10)
          + ((PPM_BLUE_WEIGHT  * tuplerow[j][2] + 511)>>10);
      else
        sample = tuplerow[j][0];
      sample = 255 * sample / inpam.maxval; /* normalize to 8 bit */
      p->p[i*inpam.width+j] = sample;
      if (maxv<sample) maxv=sample;
      if (minv>sample) minv=sample;
    }
  }
  pnm_freepamrow(tuplerow);
  pnm_nextimage(fp,&eofP);
  if (vvv)
    fprintf(stderr,"# readpam: min=%d max=%d eof=%d\n", minv, maxv, eofP);
  p->bpp = 1;
  if (eofP) {
    if (!pip) fclose(fp);
#ifdef HAVE_POPEN
    else      pclose(fp);	/* close pipe (v0.43) */
#endif
    fp=NULL; return 0; 
  }
  return 1; /* multiple image = concatenated pnm */
}

#else
/*
   if PAM not installed, here is the fallback routine,
   which is not so powerful but needs no dependencies from other libs
 */
static int fread_num(char *buf, int bps, FILE *f1) {
  int mode, j2, j3; char c1;
  for (j2=0;j2<bps;j2++) buf[j2]=0; // initialize value to zero
  for(mode=0;!feof(f1);){ // mod=0 means skip leading spaces, 1 scan digits
    c1=read_char(f1);
    if (isspace(c1)) { if (mode==0) continue; else break; }
    mode=1; // digits scan mode
    if( !isdigit(c1) ) F0("unexpected char");
    for (j3=j2=0;j2<bps;j2++) {      // multiply bps*bytes by 10
      j3 = buf[j2]*10 + j3;  // j3 is used as result and carry
      buf[j2]=j3 & 255; j3>>=8; 
    }
    buf[0] += c1-'0';
  }
  return 0;
}

/*
 * read image file, used to read the OCR-image and database images,
 * image file can be PBM/PGM/PPM in RAW or TEXT
 *   name: filename of image (input)
 *   p:    pointer where to store the loaded image (input)
 *   vvv:  verbose mode (input)
 *   return: 0=ok, 1=further image follows (multiple image), -1 on error
 * this is the fall back routine if libpnm cant be used
 */
int readpgm( char *name, pix *p, int vvv){
  static char c1, c2;           /* magic bytes, file type */
  static char *pip;             // static to survive multiple calls
  int  nx,ny,nc,mod,i,j;	// buffer
  static FILE *f1=NULL;         // trigger read new file or multi image file
  unsigned char *pic;
  char buf[512];
  int lx, ly, dx;
  int bps=1; /* bytes per sample (0..255..65535...) */

  if (!f1) {  /* first of multiple image, on MultipleImageFiles c1 was read */
    pip=NULL;
    if (name[0]=='-' && name[1]==0) {
      f1=stdin;  /* is this correct ??? */
      SET_BINARY (fileno(f1)); // Windows needs it for correct work
    } else {
      pip=testsuffix(name);
      if (!pip) {
        f1=fopen(name,"rb"); if (!f1) F1("opening file %s",name);
      } else {
        sprintf(buf,"%s \"%s\"",pip,name); /* ToDo: how to prevent OVL ? */
        if (vvv) { fprintf(stderr,"# popen( %s )\n",buf); }
#ifdef HAVE_POPEN
#if defined(__WIN32) || defined(__WIN32__) || defined(__WIN64) || defined(__WIN64__)
	f1 = popen(buf, "rb");  /* ToDo: may fail, please report */
	if (!f1) f1 = popen(buf, "r"); /* 2nd try, the gnu way */
#else
        f1=popen(buf,"r");
#endif
#else
        F0("only PNM files supported (compiled without HAVE_POPEN)");
#endif
        if (!f1) F1("opening pipe %s",buf);
      }
    }
    c1=fgetc(f1); if (feof(f1)) { E0("unexpected EOF"); return -1; }
  }
  c2=fgetc(f1);   if (feof(f1)) { E0("unexpected EOF"); return -1; }
  // check the first two bytes of the PNM file 
  //         PBM   PGM   PPM
  //    TXT   P1    P2    P3
  //    RAW   P4    P5    P6
  if (c1!='P' || c2 <'1' || c2 >'6') { 
    fprintf(stderr,"\nread-PNM-error: file number is %2d,"
                   " position %ld", fileno(f1), ftell(f1));
    fprintf(stderr,"\nread-PNM-error: bad magic bytes, expect 0x50 0x3[1-6]"
                   " but got 0x%02x 0x%02x", 255&c1, 255&c2);
    if (f1) fclose(f1); f1=NULL; return(-1);
  }
  nx=ny=nc=0; if (c2=='4' || c2=='1') nc=1;
  for(mod=0;((c2=='5' || c2=='2') && (mod&7)<6)
        ||  ((c2=='6' || c2=='3') && (mod&7)<6)		
        ||  ((c2=='4' || c2=='1') && (mod&7)<4);)		
  {						// mode: 0,2,4=[ |\t|\r|\n] 
  						//   1=nx 3=ny 5=nc 8-13=#rem
    c1=read_char(f1);				// former: # mod|=8
    if( (mod & 1)==0 )				// whitespaces
    if( !isspace(c1) ) mod++;
    if( (mod & 1)==1 ) {
      if( !isdigit(c1) ) {
        if( !isspace(c1) )F0("unexpected character");
        mod++; }
      else if(mod==1) nx=nx*10+c1-'0';
      else if(mod==3) ny=ny*10+c1-'0';
      else if(mod==5) nc=nc*10+c1-'0';
    }
  }
  if(vvv)
   fprintf(stderr,"# PNM P%c h*w=%d*%d c=%d head=%ld",c2,ny,nx,nc,ftell(f1));
  if( c2=='4' && (nx&7)!=0 ){
    /* nx=(nx+7)&~7;*/ if(vvv)fprintf(stderr," PBM2PGM nx %d",(nx+7)&~7);
  }
  if (nc>> 8) bps=2; // bytes per color and pixel
  if (nc>>16) bps=3;
  if (nc>>24) bps=4;
  fflush(stdout);
  if ( (1.*(nx*ny))!=((1.*nx)*ny) )
    F0("Error integer overflow");
  pic=(unsigned char *)malloc( nx*ny );
  if(pic==NULL)F0("memory failed");			// no memory
  for (i=0;i<nx*ny;i++) pic[i]=255; // init to white if reading fails 
  /* this is a slow but short routine for P1 to P6 formats */
  if( c2=='5' || c2=='2' ) /* slow PGM-RAW/ASC read pixelwise */
    for (i=0;i<nx*ny;i++) {
     if (c2=='5') { if(bps!=(int)fread(buf,1,bps,f1)) {
        fprintf(stderr," ERROR reading at head+%d*%d\n", bps, i); break; } }
     else for (j=0;j<3;j++) fread_num(buf+j*bps, bps, f1);
     pic[i]=buf[bps-1]; /* store the most significant byte */
    }
  // we want to normalize brightness to 0..255
  if (c2=='6' || c2=='3') {  // PPM-RAW/ASC
    for (i=0;i<nx*ny;i++) {
      if (c2=='6') { if (3*bps!=(int)fread(buf,1,3*bps,f1)){
         fprintf(stderr," ERROR reading at head+3*%d*%d\n", bps, i); break; } }
      else for (j=0;j<3;j++) fread_num(buf+j*bps, bps, f1);
      pic[i]
          = ((PPM_RED_WEIGHT   * (unsigned char)buf[  bps-1] + 511)>>10)
          + ((PPM_GREEN_WEIGHT * (unsigned char)buf[2*bps-1] + 511)>>10)
          + ((PPM_BLUE_WEIGHT  * (unsigned char)buf[3*bps-1] + 511)>>10);
      /* normalized to 0..255 */
    }
  }
  if( c2=='1' )
    for(mod=j=i=0,nc=255;i<nx*ny && !feof(f1);){ // PBM-ASCII 0001100
    c1=read_char(f1);
    if( isdigit(c1) ) { pic[i]=((c1=='0')?255:0); i++; }
    else if( !isspace(c1) )F0("unexpected char");
  }
  if( c2=='4' ){				// PBM-RAW
    dx=(nx+7)&~7;				// dx (mod 8)
    if(ny!=(int)fread(pic,dx>>3,ny,f1))F0("read");	// read all bytes
    for(ly=ny-1;ly>=0;ly--)
    for(lx=nx-1;lx>=0;lx--)
    pic[lx+ly*nx]=( (128 & (pic[(lx+ly*dx)>>3]<<(lx & 7))) ? 0 : 255 );
    nc=255;
  }
  {
    int minc=255, maxc=0;
    for (i=0;i<nx*ny;i++) {
      if (pic[i]>maxc) maxc=pic[i];
      if (pic[i]<minc) minc=pic[i];
    }
    if (vvv) fprintf(stderr," min=%d max=%d", minc, maxc);
  }
  p->p=pic;  p->x=nx;  p->y=ny; p->bpp=1;
  if (vvv) fprintf(stderr,"\n");  
  c1=0; c1=fgetc(f1); /* needed to trigger feof() */
  if (feof(f1) || c1!='P') {  /* EOF ^Z or not 'P' -> single image */
    if (vvv) fprintf(stderr,"# PNM EOF\n");
    if(name[0]!='-' || name[1]!=0){ /* do not close stdin */
      if(!pip) fclose(f1);
#ifdef HAVE_POPEN
      else     pclose(f1);	/* close pipe (Jul00) */
#endif
    }
    f1=NULL;  /* set file is closed flag */
    return 0;
  }
  return 1; /* multiple image = concatenated pnm's */
}
#endif /* HAVE_PAM_H */

int writepgm(char *nam,pix *p){// P5 raw-pgm
  FILE *f1;int a,x,y;
  f1=fopen(nam,"wb");if(!f1)F0("open");		// open-error
  fprintf(f1,"P5\n%d %d\n255\n",p->x,p->y);
  if(p->bpp==3)
  for(y=0;y<p->y;y++)
  for(x=0;x<p->x;x++){	// set bit
    a=x+y*p->x;
    p->p[a]=(p->p[3*a+0]+p->p[3*a+1]+p->p[3*a+2])/3;
  }
  if(p->y!=(int)fwrite(p->p,p->x,p->y,f1))F0("write");	// write all lines
  fclose(f1);
  return 0;
}

/* adding colours, care about range */
void addrgb(unsigned char rgb[3], int sr, int sg, int sb) {
 int add[3], i;
 /* add colour on dark pixels, subtract on white pixels */ 
 add[0]=2*sr; add[1]=2*sg; add[2]=2*sb;
 if (((int)rgb[0])+((int)rgb[1])+((int)rgb[2])>=3*160)
    { add[0]=(-sg-sb); add[1]=(-sr-sb); add[2]=(-sr-sg); } // rgb/2?
 /* care about colour range */
 for (i=0;i<3;i++)
   if (add[i]<0) rgb[i]-=((    rgb[i]<-add[i])?    rgb[i]:-add[i]);
   else          rgb[i]+=((255-rgb[i]< add[i])?255-rgb[i]: add[i]);
}
/*
 * pgmtoppm or pnmtopng, use last 3 bits for farbcoding 
 * replaces old writebmp variant
 */
int writeppm(char *nam, pix *p){ /* P6 raw-ppm */
  FILE *f1=NULL; int x,y,f1t=0; unsigned char rgb[3], gray, bits;
  char buf[128];
  if (strchr(nam,'|')) return -1;  /* no nasty code */
  if (strstr(nam,".ppm")) { f1=fopen(nam,"wb"); }
#ifdef HAVE_POPEN
  /* be sure that nam contains hacker code like "dummy | rm -rf *" */
  if (!f1) {
    strncpy(buf,"pnmtopng > ",12);  /* no spaces within filenames allowed! */
    strncpy(buf+11,nam,111); buf[123]=0;
    strncpy(buf+strlen(buf),".png",5);
    /* we dont care about win "wb" here, never debug on win systems */
    f1 = popen(buf, "w"); if(f1) f1t=1; else E0("popen pnmtopng");
  }
  if (!f1) {
    strncpy(buf,"gzip -c > ",11);
    strncpy(buf+10,nam,109); buf[120]=0;
    strncpy(buf+strlen(buf),".ppm.gz",8); 
    /* we dont care about win "wb" here, never debug on win systems */
    f1 = popen(buf, "w"); if(f1) f1t=1; else E0("popen gzip -c");
  }
#endif
  if (!f1) {
    strncpy(buf,nam,113); buf[114]=0;
    strncpy(buf+strlen(buf),".ppm",5);
    f1=fopen(buf,"wb");
  }
  if (!f1) F0("open"); /* open-error */
  fprintf(f1,"P6\n%d %d\n255\n",p->x,p->y);
  if ( p->bpp==1 )
  for (y=0;y<p->y;y++)
  for (x=0;x<p->x;x++){
    gray=p->p[x+y*p->x];
    bits=(gray&0x0F);  /* save marker bits */
    /* replace used bits to get max. contrast, 160=0xA0 */
    gray = ((gray<160) ? (gray&~0x0F)>>1 : 0xC3|(gray>>1) );
    rgb[0] = rgb[1] = rgb[2] = gray;
    if ((bits &  1)==1) { addrgb(rgb,0,0,8+8*((x+y)&1)); } /* dark blue */
    if ((bits &  8)==8) { addrgb(rgb,0,0, 16); } /* blue (low priority) */
    if ((bits &  6)==6) { addrgb(rgb,0,0, 32); } /* blue */
    if ((bits &  6)==4) { addrgb(rgb,0,48,0); } /* green */
    if ((bits &  6)==2) { addrgb(rgb,32,0,0); } /* red */
    if ( 1!=(int)fwrite(rgb,3,1,f1) ) { E0("write"); y=p->y; break; }
  }
  if ( p->bpp==3 )
  if ( p->y!=(int)fwrite(p->p,3*p->x,p->y,f1) ) E0("write");
#ifdef HAVE_POPEN
  if (f1t) { pclose (f1); f1=NULL; }
#endif
  if (f1) fclose(f1);
  return 0;
}

// high bit = first, 
int writepbm(char *nam,pix *p){// P4 raw-pbm
  FILE *f1;int x,y,a,b,dx,i;
  dx=(p->x+7)&~7;	// enlarge to a factor of 8
  for(y=0;y<p->y;y++)
  for(x=0;x<p->x;x++){	// set bit
    a=(x+y*dx)>>3;b=7-(x&7);	// adress an bitisnumber
    i=x+y*p->x;
    if(p->bpp==3) i=(p->p[3*i+0]+p->p[3*i+1]+p->p[3*i+2])/3;
    else          i= p->p[  i  ];
    i=((i>127)?0:1);
    p->p[a]=(p->p[a] & (~1<<b)) | (i<<b);
  }
  f1=fopen(nam,"wb");if(!f1)F0("open");		// open-error
  fprintf(f1,"P4\n%d %d\n",p->x,p->y);
  if(p->y!=(int)fwrite(p->p,dx>>3,p->y,f1))F0("write");	// write all lines
  fclose(f1);
  return 0;
}
// ------------------------------------------------------------------------