src/px/pvalue.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  pvalue.c - program to print pixel values.
 *
 *     4/23/86
 */

#include  "standard.h"

#include  "color.h"

#include  "resolu.h"

#define  min(a,b)               ((a)<(b)?(a):(b))

RESOLU  picres;                 /* resolution of picture */

int  uniq = 0;                  /* print only unique values? */

int  original = 0;              /* convert back to original values? */

int  dataonly = 0;              /* data only format? */

int  brightonly = 0;            /* only brightness values? */

int  reverse = 0;               /* reverse conversion? */

int  format = 'a';              /* input/output format */
char  *fmtid = "ascii";         /* format identifier for header */

int  header = 1;                /* do header */

int  wrongformat = 0;           /* wrong input format? */

double  gamcor = 1.0;           /* gamma correction */

COLOR  exposure = WHTCOLOR;

char  *progname;

FILE  *fin;

extern double  atof(), pow();

int  (*getval)(), (*putval)();


main(argc, argv)
int  argc;
char  **argv;
{
        extern int  checkhead();
        int  i;

        progname = argv[0];

        for (i = 1; i < argc; i++)
                if (argv[i][0] == '-' || argv[i][0] == '+')
                        switch (argv[i][1]) {
                        case 'h':               /* header */
                                header = argv[i][0] == '+';
                                break;
                        case 'u':               /* unique values */
                                uniq = argv[i][0] == '-';
                                break;
                        case 'o':               /* original values */
                                original = argv[i][0] == '-';
                                break;
                        case 'g':               /* gamma correction */
                                gamcor = atof(argv[++i]);
                                if (argv[i][0] == '+')
                                        gamcor = 1.0/gamcor;
                                break;
                        case 'r':               /* reverse conversion */
                                reverse = argv[i][0] == '-';
                                break;
                        case 'b':               /* brightness values */
                                brightonly = argv[i][0] == '-';
                                break;
                        case 'd':               /* data only (no indices) */
                                dataonly = argv[i][0] == '-';
                                switch (argv[i][2]) {
                                case '\0':
                                case 'a':               /* ascii */
                                        format = 'a';
                                        fmtid = "ascii";
                                        break;
                                case 'i':               /* integer */
                                        format = 'i';
                                        fmtid = "ascii";
                                        break;
                                case 'b':               /* byte */
                                        dataonly = 1;
                                        format = 'b';
                                        fmtid = "byte";
                                        break;
                                case 'f':               /* float */
                                        dataonly = 1;
                                        format = 'f';
                                        fmtid = "float";
                                        break;
                                case 'd':               /* double */
                                        dataonly = 1;
                                        format = 'd';
                                        fmtid = "double";
                                        break;
                                default:
                                        goto unkopt;
                                }
                                break;
                        case 'x':               /* x resolution */
                                if (argv[i][0] == '-')
                                        picres.or |= XDECR;
                                picres.xr = atoi(argv[++i]);
                                break;
                        case 'y':               /* y resolution */
                                if (argv[i][0] == '-')
                                        picres.or |= YDECR;
                                if (picres.xr == 0)
                                        picres.or |= YMAJOR;
                                picres.yr = atoi(argv[++i]);
                                break;
                        default:
unkopt:
                                fprintf(stderr, "%s: unknown option: %s\n",
                                                progname, argv[i]);
                                quit(1);
                                break;
                        }
                else
                        break;
                                        /* recognize special formats */
        if (dataonly && format == 'b')
                if (brightonly)
                        fmtid = "8-bit_grey";
                else
                        fmtid = "24-bit_rgb";

        if (i == argc) {
                fin = stdin;
        } else if (i == argc-1) {
                if ((fin = fopen(argv[i], "r")) == NULL) {
                        fprintf(stderr, "%s: can't open file \"%s\"\n",
                                                progname, argv[i]);
                        quit(1);
                }
        } else {
                fprintf(stderr, "%s: bad # file arguments\n", progname);
                quit(1);
        }

        set_io();

        if (reverse) {
                                        /* get header */
                if (header && checkheader(fin, fmtid, stdout) < 0) {
                        fprintf(stderr, "%s: wrong input format\n", progname);
                        quit(1);
                }
                if (picres.xr <= 0 || picres.yr <= 0)   /* get resolution */
                        if (!fgetsresolu(&picres, fin)) {
                                fprintf(stderr, "%s: missing resolution\n",
                                                progname);
                                quit(1);
                        }
                                                /* add to header */
                printargs(i, argv, stdout);
                fputformat(COLRFMT, stdout);
                putchar('\n');
                fputsresolu(&picres, stdout);
                valtopix();
        } else {
                                                /* get header */
                getheader(fin, checkhead, NULL);
                if (wrongformat) {
                        fprintf(stderr, "%s: input not a Radiance picture\n",
                                        progname);
                        quit(1);
                }

                if (picres.xr <= 0 || picres.yr <= 0)   /* get picture size */
                        if (!fgetsresolu(&picres, fin)) {
                                fprintf(stderr, "%s: missing resolution\n",
                                                progname);
                                quit(1);
                        }
                if (header) {
                        printargs(i, argv, stdout);
                        fputformat(fmtid, stdout);
                        putchar('\n');
                }
                pixtoval();
        }

        quit(0);
}


checkhead(line)                         /* deal with line from header */
char  *line;
{
        char    fmt[32];
        double  d;
        COLOR   ctmp;

        if (isformat(line)) {
                formatval(fmt, line);
                wrongformat = strcmp(fmt, COLRFMT);
        } else if (original && isexpos(line)) {
                d = 1.0/exposval(line);
                scalecolor(exposure, d);
        } else if (original && iscolcor(line)) {
                colcorval(ctmp, line);
                setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
                                colval(exposure,GRN)/colval(ctmp,GRN),
                                colval(exposure,BLU)/colval(ctmp,BLU));
        } else if (header)
                fputs(line, stdout);
}


pixtoval()                              /* convert picture to values */
{
        register COLOR  *scanln;
        int  dogamma;
        COLOR  lastc;
        FLOAT  hv[2];
        int  y;
        register int  x;

        scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
        if (scanln == NULL) {
                fprintf(stderr, "%s: out of memory\n", progname);
                quit(1);
        }
        dogamma = gamcor < .95 || gamcor > 1.05;
        setcolor(lastc, 0.0, 0.0, 0.0);
        for (y = 0; y < numscans(&picres); y++) {
                if (freadscan(scanln, scanlen(&picres), fin) < 0) {
                        fprintf(stderr, "%s: read error\n", progname);
                        quit(1);
                }
                for (x = 0; x < scanlen(&picres); x++) {
                        if (uniq)
                                if (    colval(scanln[x],RED) ==
                                                colval(lastc,RED) &&
                                        colval(scanln[x],GRN) ==
                                                colval(lastc,GRN) &&
                                        colval(scanln[x],BLU) ==
                                                colval(lastc,BLU)       )
                                        continue;
                                else
                                        copycolor(lastc, scanln[x]);
                        if (original)
                                multcolor(scanln[x], exposure);
                        if (dogamma)
                                setcolor(scanln[x],
                                pow(colval(scanln[x],RED), 1.0/gamcor),
                                pow(colval(scanln[x],GRN), 1.0/gamcor),
                                pow(colval(scanln[x],BLU), 1.0/gamcor));
                        if (!dataonly) {
                                pix2loc(hv, &picres, x, y);
                                printf("%7d %7d ", (int)(hv[0]*picres.xr),
                                                (int)(hv[1]*picres.yr));
                        }
                        if ((*putval)(scanln[x], stdout) < 0) {
                                fprintf(stderr, "%s: write error\n", progname);
                                quit(1);
                        }
                }
        }
        free((char *)scanln);
}


valtopix()                      /* convert values to a pixel file */
{
        int  dogamma;
        register COLOR  *scanln;
        int  y;
        register int  x;

        scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
        if (scanln == NULL) {
                fprintf(stderr, "%s: out of memory\n", progname);
                quit(1);
        }
        dogamma = gamcor < .95 || gamcor > 1.05;
        for (y = 0; y < numscans(&picres); y++) {
                for (x = 0; x < scanlen(&picres); x++) {
                        if (!dataonly)
                                fscanf(fin, "%*d %*d");
                        if ((*getval)(scanln[x], fin) < 0) {
                                fprintf(stderr, "%s: read error\n", progname);
                                quit(1);
                        }
                        if (dogamma)
                                setcolor(scanln[x],
                                        pow(colval(scanln[x],RED), gamcor),
                                        pow(colval(scanln[x],GRN), gamcor),
                                        pow(colval(scanln[x],BLU), gamcor));
                }
                if (fwritescan(scanln, scanlen(&picres), stdout) < 0) {
                        fprintf(stderr, "%s: write error\n", progname);
                        quit(1);
                }
        }
        free((char *)scanln);
}


quit(code)
int  code;
{
        exit(code);
}


getcascii(col, fp)              /* get an ascii color value from fp */
COLOR  col;
FILE  *fp;
{
        double  vd[3];

        if (fscanf(fp, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
                return(-1);
        setcolor(col, vd[0], vd[1], vd[2]);
        return(0);
}


getcdouble(col, fp)             /* get a double color value from fp */
COLOR  col;
FILE  *fp;
{
        double  vd[3];

        if (fread((char *)vd, sizeof(double), 3, fp) != 3)
                return(-1);
        setcolor(col, vd[0], vd[1], vd[2]);
        return(0);
}


getcfloat(col, fp)              /* get a float color value from fp */
COLOR  col;
FILE  *fp;
{
        float  vf[3];

        if (fread((char *)vf, sizeof(float), 3, fp) != 3)
                return(-1);
        setcolor(col, vf[0], vf[1], vf[2]);
        return(0);
}


getcint(col, fp)                /* get an int color value from fp */
COLOR  col;
FILE  *fp;
{
        int  vi[3];

        if (fscanf(fp, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
                return(-1);
        setcolor(col,(vi[0]+.5)/256.,(vi[1]+.5)/256.,(vi[2]+.5)/256.);
        return(0);
}


getcbyte(col, fp)               /* get a byte color value from fp */
COLOR  col;
FILE  *fp;
{
        BYTE  vb[3];

        if (fread((char *)vb, sizeof(BYTE), 3, fp) != 3)
                return(-1);
        setcolor(col,(vb[0]+.5)/256.,(vb[1]+.5)/256.,(vb[2]+.5)/256.);
        return(0);
}


getbascii(col, fp)              /* get an ascii brightness value from fp */
COLOR  col;
FILE  *fp;
{
        double  vd;

        if (fscanf(fp, "%lf", &vd) != 1)
                return(-1);
        setcolor(col, vd, vd, vd);
        return(0);
}


getbdouble(col, fp)             /* get a double brightness value from fp */
COLOR  col;
FILE  *fp;
{
        double  vd;

        if (fread((char *)&vd, sizeof(double), 1, fp) != 1)
                return(-1);
        setcolor(col, vd, vd, vd);
        return(0);
}


getbfloat(col, fp)              /* get a float brightness value from fp */
COLOR  col;
FILE  *fp;
{
        float  vf;

        if (fread((char *)&vf, sizeof(float), 1, fp) != 1)
                return(-1);
        setcolor(col, vf, vf, vf);
        return(0);
}


getbint(col, fp)                /* get an int brightness value from fp */
COLOR  col;
FILE  *fp;
{
        int  vi;
        double  d;

        if (fscanf(fp, "%d", &vi) != 1)
                return(-1);
        d = (vi+.5)/256.;
        setcolor(col, d, d, d);
        return(0);
}


getbbyte(col, fp)               /* get a byte brightness value from fp */
COLOR  col;
FILE  *fp;
{
        BYTE  vb;
        double  d;

        if (fread((char *)&vb, sizeof(BYTE), 1, fp) != 1)
                return(-1);
        d = (vb+.5)/256.;
        setcolor(col, d, d, d);
        return(0);
}


putcascii(col, fp)                      /* put an ascii color to fp */
COLOR  col;
FILE  *fp;
{
        fprintf(fp, "%15.3e %15.3e %15.3e\n",
                        colval(col,RED),
                        colval(col,GRN),
                        colval(col,BLU));

        return(ferror(fp) ? -1 : 0);
}


putcfloat(col, fp)                      /* put a float color to fp */
COLOR  col;
FILE  *fp;
{
        float  vf[3];

        vf[0] = colval(col,RED);
        vf[1] = colval(col,GRN);
        vf[2] = colval(col,BLU);
        fwrite((char *)vf, sizeof(float), 3, fp);

        return(ferror(fp) ? -1 : 0);
}


putcdouble(col, fp)                     /* put a double color to fp */
COLOR  col;
FILE  *fp;
{
        double  vd[3];

        vd[0] = colval(col,RED);
        vd[1] = colval(col,GRN);
        vd[2] = colval(col,BLU);
        fwrite((char *)vd, sizeof(double), 3, fp);

        return(ferror(fp) ? -1 : 0);
}


putcint(col, fp)                        /* put an int color to fp */
COLOR  col;
FILE  *fp;
{
        fprintf(fp, "%d %d %d\n",
                        (int)(colval(col,RED)*256.),
                        (int)(colval(col,GRN)*256.),
                        (int)(colval(col,BLU)*256.));

        return(ferror(fp) ? -1 : 0);
}


putcbyte(col, fp)                       /* put a byte color to fp */
COLOR  col;
FILE  *fp;
{
        register int  i;
        BYTE  vb[3];

        i = colval(col,RED)*256.;
        vb[0] = min(i,255);
        i = colval(col,GRN)*256.;
        vb[1] = min(i,255);
        i = colval(col,BLU)*256.;
        vb[2] = min(i,255);
        fwrite((char *)vb, sizeof(BYTE), 3, fp);

        return(ferror(fp) ? -1 : 0);
}


putbascii(col, fp)                      /* put an ascii brightness to fp */
COLOR  col;
FILE  *fp;
{
        fprintf(fp, "%15.3e\n", bright(col));

        return(ferror(fp) ? -1 : 0);
}


putbfloat(col, fp)                      /* put a float brightness to fp */
COLOR  col;
FILE  *fp;
{
        float  vf;

        vf = bright(col);
        fwrite((char *)&vf, sizeof(float), 1, fp);

        return(ferror(fp) ? -1 : 0);
}


putbdouble(col, fp)                     /* put a double brightness to fp */
COLOR  col;
FILE  *fp;
{
        double  vd;

        vd = bright(col);
        fwrite((char *)&vd, sizeof(double), 1, fp);

        return(ferror(fp) ? -1 : 0);
}


putbint(col, fp)                        /* put an int brightness to fp */
COLOR  col;
FILE  *fp;
{
        fprintf(fp, "%d\n", (int)(bright(col)*256.));

        return(ferror(fp) ? -1 : 0);
}


putbbyte(col, fp)                       /* put a byte brightness to fp */
COLOR  col;
FILE  *fp;
{
        register int  i;
        BYTE  vb;

        i = bright(col)*256.;
        vb = min(i,255);
        fwrite((char *)&vb, sizeof(BYTE), 1, fp);

        return(ferror(fp) ? -1 : 0);
}


set_io()                        /* set put and get functions */
{
        switch (format) {
        case 'a':                                       /* ascii */
                if (brightonly) {
                        getval = getbascii;
                        putval = putbascii;
                } else {
                        getval = getcascii;
                        putval = putcascii;
                }
                return;
        case 'f':                                       /* binary float */
                if (brightonly) {
                        getval = getbfloat;
                        putval = putbfloat;
                } else {
                        getval = getcfloat;
                        putval = putcfloat;
                }
                return;
        case 'd':                                       /* binary double */
                if (brightonly) {
                        getval = getbdouble;
                        putval = putbdouble;
                } else {
                        getval = getcdouble;
                        putval = putcdouble;
                }
                return;
        case 'i':                                       /* integer */
                if (brightonly) {
                        getval = getbint;
                        putval = putbint;
                } else {
                        getval = getcint;
                        putval = putcint;
                }
                return;
        case 'b':                                       /* byte */
                if (brightonly) {
                        getval = getbbyte;
                        putval = putbbyte;
                } else {
                        getval = getcbyte;
                        putval = putcbyte;
                }
                return;
        }
}
Revision:	1.8
Committed:	Mon Nov 11 14:01:37 1991 UTC (32 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+61 -45 lines
Log Message:	Improved handling of scanline ordering
#	User	Rev	Content
1	greg	1.7	/* Copyright (c) 1991 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* pvalue.c - program to print pixel values.
9			*
10			* 4/23/86
11			*/
12
13	greg	1.8	#include "standard.h"
14	greg	1.1
15			#include "color.h"
16
17	greg	1.8	#include "resolu.h"
18
19	greg	1.1	#define min(a,b) ((a)<(b)?(a):(b))
20
21	greg	1.8	RESOLU picres; /* resolution of picture */
22	greg	1.1
23	greg	1.6	int uniq = 0; /* print only unique values? */
24	greg	1.1
25	greg	1.6	int original = 0; /* convert back to original values? */
26	greg	1.1
27			int dataonly = 0; /* data only format? */
28
29			int brightonly = 0; /* only brightness values? */
30
31			int reverse = 0; /* reverse conversion? */
32
33			int format = 'a'; /* input/output format */
34	greg	1.6	char fmtid = "ascii"; / format identifier for header */
35	greg	1.1
36			int header = 1; /* do header */
37
38	greg	1.6	int wrongformat = 0; /* wrong input format? */
39
40	greg	1.8	double gamcor = 1.0; /* gamma correction */
41	greg	1.7
42	greg	1.5	COLOR exposure = WHTCOLOR;
43	greg	1.1
44			char *progname;
45
46			FILE *fin;
47
48	greg	1.7	extern double atof(), pow();
49
50	greg	1.1	int (getval)(), (putval)();
51
52
53			main(argc, argv)
54			int argc;
55			char **argv;
56			{
57			extern int checkhead();
58			int i;
59
60			progname = argv[0];
61
62			for (i = 1; i < argc; i++)
63	greg	1.8	if (argv[i][0] == '-' \|\| argv[i][0] == '+')
64	greg	1.1	switch (argv[i][1]) {
65	greg	1.8	case 'h': /* header */
66			header = argv[i][0] == '+';
67	greg	1.1	break;
68			case 'u': /* unique values */
69	greg	1.8	uniq = argv[i][0] == '-';
70	greg	1.1	break;
71			case 'o': /* original values */
72	greg	1.8	original = argv[i][0] == '-';
73	greg	1.1	break;
74	greg	1.7	case 'g': /* gamma correction */
75	greg	1.8	gamcor = atof(argv[++i]);
76			if (argv[i][0] == '+')
77			gamcor = 1.0/gamcor;
78	greg	1.7	break;
79	greg	1.1	case 'r': /* reverse conversion */
80	greg	1.8	reverse = argv[i][0] == '-';
81	greg	1.1	break;
82			case 'b': /* brightness values */
83	greg	1.8	brightonly = argv[i][0] == '-';
84	greg	1.1	break;
85			case 'd': /* data only (no indices) */
86	greg	1.8	dataonly = argv[i][0] == '-';
87	greg	1.1	switch (argv[i][2]) {
88			case '\0':
89			case 'a': /* ascii */
90			format = 'a';
91	greg	1.6	fmtid = "ascii";
92	greg	1.1	break;
93			case 'i': /* integer */
94	greg	1.6	format = 'i';
95			fmtid = "ascii";
96			break;
97	greg	1.1	case 'b': /* byte */
98	greg	1.8	dataonly = 1;
99	greg	1.6	format = 'b';
100			fmtid = "byte";
101			break;
102	greg	1.1	case 'f': /* float */
103	greg	1.8	dataonly = 1;
104	greg	1.6	format = 'f';
105			fmtid = "float";
106			break;
107	greg	1.1	case 'd': /* double */
108	greg	1.8	dataonly = 1;
109	greg	1.6	format = 'd';
110			fmtid = "double";
111	greg	1.1	break;
112			default:
113			goto unkopt;
114			}
115			break;
116			case 'x': /* x resolution */
117	greg	1.8	if (argv[i][0] == '-')
118			picres.or \|= XDECR;
119			picres.xr = atoi(argv[++i]);
120	greg	1.1	break;
121			case 'y': /* y resolution */
122	greg	1.8	if (argv[i][0] == '-')
123			picres.or \|= YDECR;
124			if (picres.xr == 0)
125			picres.or \|= YMAJOR;
126			picres.yr = atoi(argv[++i]);
127	greg	1.1	break;
128			default:
129			unkopt:
130			fprintf(stderr, "%s: unknown option: %s\n",
131			progname, argv[i]);
132			quit(1);
133			break;
134			}
135			else
136			break;
137	greg	1.6	/* recognize special formats */
138			if (dataonly && format == 'b')
139			if (brightonly)
140			fmtid = "8-bit_grey";
141			else
142			fmtid = "24-bit_rgb";
143
144	greg	1.1	if (i == argc) {
145			fin = stdin;
146			} else if (i == argc-1) {
147			if ((fin = fopen(argv[i], "r")) == NULL) {
148			fprintf(stderr, "%s: can't open file \"%s\"\n",
149			progname, argv[i]);
150			quit(1);
151			}
152			} else {
153			fprintf(stderr, "%s: bad # file arguments\n", progname);
154			quit(1);
155			}
156
157			set_io();
158
159			if (reverse) {
160	greg	1.6	/* get header */
161			if (header && checkheader(fin, fmtid, stdout) < 0) {
162			fprintf(stderr, "%s: wrong input format\n", progname);
163			quit(1);
164			}
165	greg	1.8	if (picres.xr <= 0 \|\| picres.yr <= 0) /* get resolution */
166			if (!fgetsresolu(&picres, fin)) {
167			fprintf(stderr, "%s: missing resolution\n",
168			progname);
169			quit(1);
170			}
171	greg	1.6	/* add to header */
172			printargs(i, argv, stdout);
173			fputformat(COLRFMT, stdout);
174	greg	1.8	putchar('\n');
175			fputsresolu(&picres, stdout);
176	greg	1.1	valtopix();
177			} else {
178			/* get header */
179	greg	1.6	getheader(fin, checkhead, NULL);
180			if (wrongformat) {
181			fprintf(stderr, "%s: input not a Radiance picture\n",
182			progname);
183			quit(1);
184			}
185	greg	1.1
186	greg	1.8	if (picres.xr <= 0 \|\| picres.yr <= 0) /* get picture size */
187			if (!fgetsresolu(&picres, fin)) {
188			fprintf(stderr, "%s: missing resolution\n",
189	greg	1.1	progname);
190			quit(1);
191			}
192			if (header) {
193			printargs(i, argv, stdout);
194	greg	1.6	fputformat(fmtid, stdout);
195	greg	1.8	putchar('\n');
196	greg	1.1	}
197			pixtoval();
198			}
199
200			quit(0);
201			}
202
203
204			checkhead(line) /* deal with line from header */
205			char *line;
206			{
207	greg	1.6	char fmt[32];
208	greg	1.5	double d;
209			COLOR ctmp;
210
211	greg	1.6	if (isformat(line)) {
212			formatval(fmt, line);
213			wrongformat = strcmp(fmt, COLRFMT);
214			} else if (original && isexpos(line)) {
215	greg	1.5	d = 1.0/exposval(line);
216			scalecolor(exposure, d);
217	greg	1.6	} else if (original && iscolcor(line)) {
218	greg	1.5	colcorval(ctmp, line);
219	greg	1.7	setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
220			colval(exposure,GRN)/colval(ctmp,GRN),
221			colval(exposure,BLU)/colval(ctmp,BLU));
222	greg	1.6	} else if (header)
223			fputs(line, stdout);
224	greg	1.1	}
225
226
227			pixtoval() /* convert picture to values */
228			{
229	greg	1.7	register COLOR *scanln;
230			int dogamma;
231	greg	1.1	COLOR lastc;
232	greg	1.8	FLOAT hv[2];
233	greg	1.1	int y;
234			register int x;
235
236	greg	1.8	scanln = (COLOR )malloc(scanlen(&picres)sizeof(COLOR));
237	greg	1.1	if (scanln == NULL) {
238			fprintf(stderr, "%s: out of memory\n", progname);
239			quit(1);
240			}
241	greg	1.8	dogamma = gamcor < .95 \|\| gamcor > 1.05;
242	greg	1.1	setcolor(lastc, 0.0, 0.0, 0.0);
243	greg	1.8	for (y = 0; y < numscans(&picres); y++) {
244			if (freadscan(scanln, scanlen(&picres), fin) < 0) {
245	greg	1.1	fprintf(stderr, "%s: read error\n", progname);
246			quit(1);
247			}
248	greg	1.8	for (x = 0; x < scanlen(&picres); x++) {
249	greg	1.1	if (uniq)
250	greg	1.7	if ( colval(scanln[x],RED) ==
251			colval(lastc,RED) &&
252			colval(scanln[x],GRN) ==
253			colval(lastc,GRN) &&
254			colval(scanln[x],BLU) ==
255			colval(lastc,BLU) )
256	greg	1.1	continue;
257			else
258			copycolor(lastc, scanln[x]);
259			if (original)
260	greg	1.5	multcolor(scanln[x], exposure);
261	greg	1.7	if (dogamma)
262			setcolor(scanln[x],
263	greg	1.8	pow(colval(scanln[x],RED), 1.0/gamcor),
264			pow(colval(scanln[x],GRN), 1.0/gamcor),
265			pow(colval(scanln[x],BLU), 1.0/gamcor));
266			if (!dataonly) {
267			pix2loc(hv, &picres, x, y);
268			printf("%7d %7d ", (int)(hv[0]*picres.xr),
269			(int)(hv[1]*picres.yr));
270			}
271	greg	1.1	if ((*putval)(scanln[x], stdout) < 0) {
272			fprintf(stderr, "%s: write error\n", progname);
273			quit(1);
274			}
275			}
276			}
277			free((char *)scanln);
278			}
279
280
281			valtopix() /* convert values to a pixel file */
282			{
283	greg	1.7	int dogamma;
284			register COLOR *scanln;
285	greg	1.1	int y;
286			register int x;
287
288	greg	1.8	scanln = (COLOR )malloc(scanlen(&picres)sizeof(COLOR));
289	greg	1.1	if (scanln == NULL) {
290			fprintf(stderr, "%s: out of memory\n", progname);
291			quit(1);
292			}
293	greg	1.8	dogamma = gamcor < .95 \|\| gamcor > 1.05;
294			for (y = 0; y < numscans(&picres); y++) {
295			for (x = 0; x < scanlen(&picres); x++) {
296	greg	1.1	if (!dataonly)
297			fscanf(fin, "%d %d");
298			if ((*getval)(scanln[x], fin) < 0) {
299			fprintf(stderr, "%s: read error\n", progname);
300			quit(1);
301			}
302	greg	1.7	if (dogamma)
303			setcolor(scanln[x],
304	greg	1.8	pow(colval(scanln[x],RED), gamcor),
305			pow(colval(scanln[x],GRN), gamcor),
306			pow(colval(scanln[x],BLU), gamcor));
307	greg	1.1	}
308	greg	1.8	if (fwritescan(scanln, scanlen(&picres), stdout) < 0) {
309	greg	1.1	fprintf(stderr, "%s: write error\n", progname);
310			quit(1);
311			}
312			}
313			free((char *)scanln);
314			}
315
316
317			quit(code)
318			int code;
319			{
320			exit(code);
321			}
322
323
324			getcascii(col, fp) /* get an ascii color value from fp */
325			COLOR col;
326			FILE *fp;
327			{
328			double vd[3];
329
330			if (fscanf(fp, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
331			return(-1);
332			setcolor(col, vd[0], vd[1], vd[2]);
333			return(0);
334			}
335
336
337			getcdouble(col, fp) /* get a double color value from fp */
338			COLOR col;
339			FILE *fp;
340			{
341			double vd[3];
342
343	greg	1.4	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
344	greg	1.1	return(-1);
345			setcolor(col, vd[0], vd[1], vd[2]);
346			return(0);
347			}
348
349
350			getcfloat(col, fp) /* get a float color value from fp */
351			COLOR col;
352			FILE *fp;
353			{
354			float vf[3];
355
356	greg	1.4	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
357	greg	1.1	return(-1);
358			setcolor(col, vf[0], vf[1], vf[2]);
359			return(0);
360			}
361
362
363			getcint(col, fp) /* get an int color value from fp */
364			COLOR col;
365			FILE *fp;
366			{
367			int vi[3];
368
369			if (fscanf(fp, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
370			return(-1);
371			setcolor(col,(vi[0]+.5)/256.,(vi[1]+.5)/256.,(vi[2]+.5)/256.);
372			return(0);
373			}
374
375
376			getcbyte(col, fp) /* get a byte color value from fp */
377			COLOR col;
378			FILE *fp;
379			{
380			BYTE vb[3];
381
382	greg	1.4	if (fread((char *)vb, sizeof(BYTE), 3, fp) != 3)
383	greg	1.1	return(-1);
384			setcolor(col,(vb[0]+.5)/256.,(vb[1]+.5)/256.,(vb[2]+.5)/256.);
385			return(0);
386			}
387
388
389			getbascii(col, fp) /* get an ascii brightness value from fp */
390			COLOR col;
391			FILE *fp;
392			{
393			double vd;
394
395			if (fscanf(fp, "%lf", &vd) != 1)
396			return(-1);
397			setcolor(col, vd, vd, vd);
398			return(0);
399			}
400
401
402			getbdouble(col, fp) /* get a double brightness value from fp */
403			COLOR col;
404			FILE *fp;
405			{
406			double vd;
407
408	greg	1.4	if (fread((char *)&vd, sizeof(double), 1, fp) != 1)
409	greg	1.1	return(-1);
410			setcolor(col, vd, vd, vd);
411			return(0);
412			}
413
414
415			getbfloat(col, fp) /* get a float brightness value from fp */
416			COLOR col;
417			FILE *fp;
418			{
419			float vf;
420
421	greg	1.4	if (fread((char *)&vf, sizeof(float), 1, fp) != 1)
422	greg	1.1	return(-1);
423			setcolor(col, vf, vf, vf);
424			return(0);
425			}
426
427
428			getbint(col, fp) /* get an int brightness value from fp */
429			COLOR col;
430			FILE *fp;
431			{
432			int vi;
433			double d;
434
435			if (fscanf(fp, "%d", &vi) != 1)
436			return(-1);
437			d = (vi+.5)/256.;
438			setcolor(col, d, d, d);
439			return(0);
440			}
441
442
443			getbbyte(col, fp) /* get a byte brightness value from fp */
444			COLOR col;
445			FILE *fp;
446			{
447			BYTE vb;
448			double d;
449
450	greg	1.4	if (fread((char *)&vb, sizeof(BYTE), 1, fp) != 1)
451	greg	1.1	return(-1);
452			d = (vb+.5)/256.;
453			setcolor(col, d, d, d);
454			return(0);
455			}
456
457
458			putcascii(col, fp) /* put an ascii color to fp */
459			COLOR col;
460			FILE *fp;
461			{
462			fprintf(fp, "%15.3e %15.3e %15.3e\n",
463			colval(col,RED),
464			colval(col,GRN),
465			colval(col,BLU));
466
467			return(ferror(fp) ? -1 : 0);
468			}
469
470
471			putcfloat(col, fp) /* put a float color to fp */
472			COLOR col;
473			FILE *fp;
474			{
475			float vf[3];
476
477			vf[0] = colval(col,RED);
478			vf[1] = colval(col,GRN);
479			vf[2] = colval(col,BLU);
480	greg	1.4	fwrite((char *)vf, sizeof(float), 3, fp);
481	greg	1.1
482			return(ferror(fp) ? -1 : 0);
483			}
484
485
486			putcdouble(col, fp) /* put a double color to fp */
487			COLOR col;
488			FILE *fp;
489			{
490			double vd[3];
491
492			vd[0] = colval(col,RED);
493			vd[1] = colval(col,GRN);
494			vd[2] = colval(col,BLU);
495	greg	1.4	fwrite((char *)vd, sizeof(double), 3, fp);
496	greg	1.1
497			return(ferror(fp) ? -1 : 0);
498			}
499
500
501			putcint(col, fp) /* put an int color to fp */
502			COLOR col;
503			FILE *fp;
504			{
505			fprintf(fp, "%d %d %d\n",
506			(int)(colval(col,RED)*256.),
507			(int)(colval(col,GRN)*256.),
508			(int)(colval(col,BLU)*256.));
509
510			return(ferror(fp) ? -1 : 0);
511			}
512
513
514			putcbyte(col, fp) /* put a byte color to fp */
515			COLOR col;
516			FILE *fp;
517			{
518			register int i;
519			BYTE vb[3];
520
521			i = colval(col,RED)*256.;
522			vb[0] = min(i,255);
523			i = colval(col,GRN)*256.;
524			vb[1] = min(i,255);
525			i = colval(col,BLU)*256.;
526			vb[2] = min(i,255);
527	greg	1.4	fwrite((char *)vb, sizeof(BYTE), 3, fp);
528	greg	1.1
529			return(ferror(fp) ? -1 : 0);
530			}
531
532
533			putbascii(col, fp) /* put an ascii brightness to fp */
534			COLOR col;
535			FILE *fp;
536			{
537			fprintf(fp, "%15.3e\n", bright(col));
538
539			return(ferror(fp) ? -1 : 0);
540			}
541
542
543			putbfloat(col, fp) /* put a float brightness to fp */
544			COLOR col;
545			FILE *fp;
546			{
547			float vf;
548
549			vf = bright(col);
550	greg	1.4	fwrite((char *)&vf, sizeof(float), 1, fp);
551	greg	1.1
552			return(ferror(fp) ? -1 : 0);
553			}
554
555
556			putbdouble(col, fp) /* put a double brightness to fp */
557			COLOR col;
558			FILE *fp;
559			{
560			double vd;
561
562			vd = bright(col);
563	greg	1.4	fwrite((char *)&vd, sizeof(double), 1, fp);
564	greg	1.1
565			return(ferror(fp) ? -1 : 0);
566			}
567
568
569			putbint(col, fp) /* put an int brightness to fp */
570			COLOR col;
571			FILE *fp;
572			{
573			fprintf(fp, "%d\n", (int)(bright(col)*256.));
574
575			return(ferror(fp) ? -1 : 0);
576			}
577
578
579			putbbyte(col, fp) /* put a byte brightness to fp */
580			COLOR col;
581			FILE *fp;
582			{
583			register int i;
584			BYTE vb;
585
586			i = bright(col)*256.;
587			vb = min(i,255);
588	greg	1.4	fwrite((char *)&vb, sizeof(BYTE), 1, fp);
589	greg	1.1
590			return(ferror(fp) ? -1 : 0);
591			}
592
593
594			set_io() /* set put and get functions */
595			{
596			switch (format) {
597			case 'a': /* ascii */
598			if (brightonly) {
599			getval = getbascii;
600			putval = putbascii;
601			} else {
602			getval = getcascii;
603			putval = putcascii;
604			}
605			return;
606			case 'f': /* binary float */
607			if (brightonly) {
608			getval = getbfloat;
609			putval = putbfloat;
610			} else {
611			getval = getcfloat;
612			putval = putcfloat;
613			}
614			return;
615			case 'd': /* binary double */
616			if (brightonly) {
617			getval = getbdouble;
618			putval = putbdouble;
619			} else {
620			getval = getcdouble;
621			putval = putcdouble;
622			}
623			return;
624			case 'i': /* integer */
625			if (brightonly) {
626			getval = getbint;
627			putval = putbint;
628			} else {
629			getval = getcint;
630			putval = putcint;
631			}
632			return;
633			case 'b': /* byte */
634			if (brightonly) {
635			getval = getbbyte;
636			putval = putbbyte;
637			} else {
638			getval = getcbyte;
639			putval = putcbyte;
640			}
641			return;
642			}
643			}