3dpcp/.svn/pristine/f3/f3997f49e5b64d30d27a6d47200d97372414e72d.svn-base

534 lines
18 KiB
Text
Raw Normal View History

2012-09-16 12:33:11 +00:00
/*
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;
}
// ------------------------------------------------------------------------