ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.17
Committed: Thu Feb 27 02:00:12 2003 UTC (21 years, 2 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R5
Changes since 2.16: +8 -10 lines
Log Message: 
Corrected format string for -pP option

File Contents

# User Rev Content
1 greg 1.1 #ifndef lint
2 greg 2.16 static const char RCSid[] = "$Id$";
3 greg 1.1 #endif
4     /*
5     * pvalue.c - program to print pixel values.
6     *
7     * 4/23/86
8     */
9    
10 greg 1.8 #include "standard.h"
11 greg 1.1
12     #include "color.h"
13    
14 greg 2.14 #include <time.h>
15    
16 greg 1.8 #include "resolu.h"
17    
18 greg 2.15 typedef unsigned short uint16; /* sizeof (uint16) must == 2 */
19    
20 greg 2.5 #define min(a,b) ((a)<(b)?(a):(b))
21 greg 1.1
22 greg 2.10 /* what to put out (also RED, GRN, BLU) */
23     #define ALL 3
24     #define BRIGHT 4
25    
26 greg 2.5 RESOLU picres; /* resolution of picture */
27 greg 1.1
28 greg 1.6 int uniq = 0; /* print only unique values? */
29 greg 1.1
30 greg 2.7 int doexposure = 0; /* exposure change? (>100 to print) */
31 greg 1.1
32     int dataonly = 0; /* data only format? */
33    
34 greg 2.10 int putprim = ALL; /* what to put out */
35 greg 1.1
36     int reverse = 0; /* reverse conversion? */
37    
38     int format = 'a'; /* input/output format */
39 greg 1.6 char *fmtid = "ascii"; /* format identifier for header */
40 greg 1.1
41 greg 2.3 int header = 1; /* do header? */
42 greg 1.1
43 greg 2.10 long skipbytes = 0; /* skip bytes in input? */
44    
45 greg 2.16 int swapbytes = 0; /* swap bytes in 16-bit words? */
46    
47 greg 2.12 int interleave = 1; /* file is interleaved? */
48    
49 greg 2.3 int resolution = 1; /* put/get resolution string? */
50    
51 greg 2.7 int original = 0; /* convert to original values? */
52    
53 greg 1.6 int wrongformat = 0; /* wrong input format? */
54    
55 greg 2.5 double gamcor = 1.0; /* gamma correction */
56 greg 1.7
57 greg 2.4 int ord[3] = {RED, GRN, BLU}; /* RGB ordering */
58     int rord[4]; /* reverse ordering */
59    
60 greg 1.5 COLOR exposure = WHTCOLOR;
61 greg 1.1
62     char *progname;
63    
64     FILE *fin;
65 greg 2.10 FILE *fin2 = NULL, *fin3 = NULL; /* for other color channels */
66 greg 1.1
67     int (*getval)(), (*putval)();
68    
69 greg 2.14 double
70     rgb_bright(clr)
71     COLOR clr;
72     {
73     return(bright(clr));
74     }
75    
76     double
77     xyz_bright(clr)
78     COLOR clr;
79     {
80     return(clr[CIEY]);
81     }
82    
83     double (*mybright)() = &rgb_bright;
84    
85 greg 1.1
86     main(argc, argv)
87     int argc;
88     char **argv;
89     {
90     extern int checkhead();
91 greg 2.10 extern long atol();
92 greg 2.7 double d, expval = 1.0;
93 greg 1.1 int i;
94    
95     progname = argv[0];
96    
97     for (i = 1; i < argc; i++)
98 greg 1.8 if (argv[i][0] == '-' || argv[i][0] == '+')
99 greg 1.1 switch (argv[i][1]) {
100 greg 1.8 case 'h': /* header */
101     header = argv[i][0] == '+';
102 greg 1.1 break;
103 greg 2.3 case 'H': /* resolution string */
104     resolution = argv[i][0] == '+';
105     break;
106 greg 2.10 case 's': /* skip bytes in header */
107     skipbytes = atol(argv[++i]);
108     break;
109 greg 1.1 case 'u': /* unique values */
110 greg 1.8 uniq = argv[i][0] == '-';
111 greg 1.1 break;
112     case 'o': /* original values */
113 greg 1.8 original = argv[i][0] == '-';
114 greg 1.1 break;
115 greg 1.7 case 'g': /* gamma correction */
116 greg 2.7 gamcor = atof(argv[i+1]);
117 greg 1.8 if (argv[i][0] == '+')
118     gamcor = 1.0/gamcor;
119 greg 2.7 i++;
120 greg 1.7 break;
121 greg 2.7 case 'e': /* exposure correction */
122     d = atof(argv[i+1]);
123     if (argv[i+1][0] == '-' || argv[i+1][0] == '+')
124     d = pow(2.0, d);
125     if (argv[i][0] == '-')
126 greg 2.9 expval *= d;
127 greg 2.7 scalecolor(exposure, d);
128     doexposure++;
129     i++;
130     break;
131 greg 2.4 case 'R': /* reverse byte sequence */
132     if (argv[i][0] == '-') {
133     ord[0]=BLU; ord[1]=GRN; ord[2]=RED;
134     } else {
135     ord[0]=RED; ord[1]=GRN; ord[2]=BLU;
136     }
137     break;
138 greg 1.1 case 'r': /* reverse conversion */
139 greg 1.8 reverse = argv[i][0] == '-';
140 greg 1.1 break;
141 greg 2.12 case 'n': /* non-interleaved RGB */
142     interleave = argv[i][0] == '+';
143     break;
144 greg 1.1 case 'b': /* brightness values */
145 greg 2.10 putprim = argv[i][0] == '-' ? BRIGHT : ALL;
146 greg 1.1 break;
147 greg 2.10 case 'p': /* put primary */
148     switch (argv[i][2]) {
149     case 'r': case 'R': putprim = RED; break;
150     case 'g': case 'G': putprim = GRN; break;
151     case 'b': case 'B': putprim = BLU; break;
152     default: goto unkopt;
153     }
154     break;
155 greg 1.1 case 'd': /* data only (no indices) */
156 greg 1.8 dataonly = argv[i][0] == '-';
157 greg 1.1 switch (argv[i][2]) {
158     case '\0':
159     case 'a': /* ascii */
160     format = 'a';
161 greg 1.6 fmtid = "ascii";
162 greg 1.1 break;
163     case 'i': /* integer */
164 greg 1.6 format = 'i';
165     fmtid = "ascii";
166     break;
167 greg 1.1 case 'b': /* byte */
168 greg 1.8 dataonly = 1;
169 greg 1.6 format = 'b';
170     fmtid = "byte";
171     break;
172 greg 2.16 case 'W': /* 16-bit swapped */
173     swapbytes = 1;
174 greg 2.15 case 'w': /* 16-bit */
175     dataonly = 1;
176     format = 'w';
177     fmtid = "16-bit";
178     break;
179 greg 1.1 case 'f': /* float */
180 greg 1.8 dataonly = 1;
181 greg 1.6 format = 'f';
182     fmtid = "float";
183     break;
184 greg 1.1 case 'd': /* double */
185 greg 1.8 dataonly = 1;
186 greg 1.6 format = 'd';
187     fmtid = "double";
188 greg 1.1 break;
189     default:
190     goto unkopt;
191     }
192     break;
193     case 'x': /* x resolution */
194 greg 2.6 case 'X': /* x resolution */
195 greg 2.3 resolution = 0;
196 greg 1.8 if (argv[i][0] == '-')
197 greg 2.14 picres.rt |= XDECR;
198 greg 1.8 picres.xr = atoi(argv[++i]);
199 greg 1.1 break;
200     case 'y': /* y resolution */
201 greg 2.6 case 'Y': /* y resolution */
202 greg 2.3 resolution = 0;
203 greg 1.8 if (argv[i][0] == '-')
204 greg 2.14 picres.rt |= YDECR;
205 greg 1.8 if (picres.xr == 0)
206 greg 2.14 picres.rt |= YMAJOR;
207 greg 1.8 picres.yr = atoi(argv[++i]);
208 greg 1.1 break;
209     default:
210     unkopt:
211     fprintf(stderr, "%s: unknown option: %s\n",
212     progname, argv[i]);
213     quit(1);
214     break;
215     }
216     else
217     break;
218 greg 1.6 /* recognize special formats */
219     if (dataonly && format == 'b')
220 greg 2.17 if (putprim == ALL)
221     fmtid = "24-bit_rgb";
222     else
223 greg 1.6 fmtid = "8-bit_grey";
224 greg 2.17 if (dataonly && format == 'w')
225     if (putprim == ALL)
226     fmtid = "48-bit_rgb";
227 greg 1.6 else
228 greg 2.15 fmtid = "16-bit_grey";
229 greg 2.4 /* assign reverse ordering */
230     rord[ord[0]] = 0;
231     rord[ord[1]] = 1;
232     rord[ord[2]] = 2;
233     /* get input */
234 greg 1.1 if (i == argc) {
235     fin = stdin;
236 greg 2.10 } else if (i < argc) {
237 greg 1.1 if ((fin = fopen(argv[i], "r")) == NULL) {
238     fprintf(stderr, "%s: can't open file \"%s\"\n",
239     progname, argv[i]);
240     quit(1);
241     }
242 greg 2.17 if (reverse && putprim != BRIGHT && i == argc-3) {
243 greg 2.10 if ((fin2 = fopen(argv[i+1], "r")) == NULL) {
244     fprintf(stderr, "%s: can't open file \"%s\"\n",
245     progname, argv[i+1]);
246     quit(1);
247     }
248     if ((fin3 = fopen(argv[i+2], "r")) == NULL) {
249     fprintf(stderr, "%s: can't open file \"%s\"\n",
250     progname, argv[i+2]);
251     quit(1);
252     }
253 greg 2.12 interleave = -1;
254 greg 2.10 } else if (i != argc-1)
255     fin = NULL;
256 greg 2.17 if (reverse && putprim != BRIGHT && !interleave) {
257 greg 2.12 fin2 = fopen(argv[i], "r");
258     fin3 = fopen(argv[i], "r");
259     }
260     if (skipbytes && (fseek(fin, skipbytes, 0) || (fin2 != NULL &&
261     (fseek(fin2, skipbytes, 0) ||
262     fseek(fin3, skipbytes, 0))))) {
263     fprintf(stderr, "%s: cannot skip %ld bytes on input\n",
264     progname, skipbytes);
265     quit(1);
266     }
267 greg 2.10 }
268     if (fin == NULL) {
269 greg 1.1 fprintf(stderr, "%s: bad # file arguments\n", progname);
270     quit(1);
271     }
272    
273     if (reverse) {
274 greg 2.5 #ifdef MSDOS
275     setmode(fileno(stdout), O_BINARY);
276     if (format != 'a' && format != 'i')
277     setmode(fileno(fin), O_BINARY);
278     #endif
279 greg 1.6 /* get header */
280 greg 2.8 if (header) {
281     if (checkheader(fin, fmtid, stdout) < 0) {
282     fprintf(stderr, "%s: wrong input format\n",
283     progname);
284     quit(1);
285     }
286 greg 2.10 if (fin2 != NULL) {
287     getheader(fin2, NULL, NULL);
288     getheader(fin3, NULL, NULL);
289     }
290 greg 2.8 } else
291     newheader("RADIANCE", stdout);
292 greg 2.3 /* get resolution */
293     if ((resolution && !fgetsresolu(&picres, fin)) ||
294     picres.xr <= 0 || picres.yr <= 0) {
295     fprintf(stderr, "%s: missing resolution\n", progname);
296     quit(1);
297     }
298 greg 2.10 if (resolution && fin2 != NULL) {
299     RESOLU pres2;
300     if (!fgetsresolu(&pres2, fin2) ||
301 greg 2.14 pres2.rt != picres.rt ||
302 greg 2.10 pres2.xr != picres.xr ||
303     pres2.yr != picres.yr ||
304     !fgetsresolu(&pres2, fin3) ||
305 greg 2.14 pres2.rt != picres.rt ||
306 greg 2.10 pres2.xr != picres.xr ||
307     pres2.yr != picres.yr) {
308     fprintf(stderr, "%s: resolution mismatch\n",
309     progname);
310     quit(1);
311     }
312     }
313 greg 1.6 /* add to header */
314     printargs(i, argv, stdout);
315 greg 2.9 if (expval < .99 || expval > 1.01)
316 greg 2.7 fputexpos(expval, stdout);
317 greg 1.6 fputformat(COLRFMT, stdout);
318 greg 1.8 putchar('\n');
319 greg 2.3 fputsresolu(&picres, stdout); /* always put resolution */
320 greg 1.1 valtopix();
321     } else {
322 greg 2.5 #ifdef MSDOS
323     setmode(fileno(fin), O_BINARY);
324     if (format != 'a' && format != 'i')
325     setmode(fileno(stdout), O_BINARY);
326     #endif
327 greg 1.1 /* get header */
328 greg 1.6 getheader(fin, checkhead, NULL);
329     if (wrongformat) {
330 greg 2.14 fprintf(stderr,
331     "%s: input not a Radiance RGBE picture\n",
332 greg 1.6 progname);
333     quit(1);
334     }
335 greg 2.3 if (!fgetsresolu(&picres, fin)) {
336     fprintf(stderr, "%s: missing resolution\n", progname);
337     quit(1);
338     }
339 greg 1.1 if (header) {
340     printargs(i, argv, stdout);
341 greg 2.9 if (expval < .99 || expval > 1.01)
342 greg 2.7 fputexpos(expval, stdout);
343 greg 1.6 fputformat(fmtid, stdout);
344 greg 1.8 putchar('\n');
345 greg 1.1 }
346 greg 2.3 if (resolution) /* put resolution */
347     fputsresolu(&picres, stdout);
348 greg 1.1 pixtoval();
349     }
350    
351     quit(0);
352     }
353    
354    
355 gwlarson 2.13 int
356 greg 1.1 checkhead(line) /* deal with line from header */
357     char *line;
358     {
359 greg 1.6 char fmt[32];
360 greg 1.5 double d;
361     COLOR ctmp;
362    
363 greg 2.14 if (formatval(fmt, line)) {
364     if (!strcmp(fmt, CIEFMT)) {
365     mybright = &xyz_bright;
366     if (original) {
367     scalecolor(exposure, 1./WHTEFFICACY);
368     doexposure++;
369     }
370     } else if (!strcmp(fmt, COLRFMT))
371     mybright = &rgb_bright;
372     else
373     wrongformat++;
374     } else if (original && isexpos(line)) {
375 greg 1.5 d = 1.0/exposval(line);
376     scalecolor(exposure, d);
377 greg 2.7 doexposure++;
378 greg 1.6 } else if (original && iscolcor(line)) {
379 greg 1.5 colcorval(ctmp, line);
380 greg 1.7 setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
381     colval(exposure,GRN)/colval(ctmp,GRN),
382     colval(exposure,BLU)/colval(ctmp,BLU));
383 greg 2.7 doexposure++;
384 greg 1.6 } else if (header)
385     fputs(line, stdout);
386 gwlarson 2.13 return(0);
387 greg 1.1 }
388    
389    
390     pixtoval() /* convert picture to values */
391     {
392 greg 2.5 register COLOR *scanln;
393 greg 1.7 int dogamma;
394 greg 1.1 COLOR lastc;
395 greg 1.8 FLOAT hv[2];
396 greg 2.12 int startprim, endprim;
397     long startpos;
398 greg 1.1 int y;
399     register int x;
400    
401 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
402 greg 1.1 if (scanln == NULL) {
403     fprintf(stderr, "%s: out of memory\n", progname);
404     quit(1);
405     }
406 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
407 greg 2.12 if (putprim == ALL && !interleave) {
408     startprim = RED; endprim = BLU;
409     startpos = ftell(fin);
410     } else {
411     startprim = putprim; endprim = putprim;
412     }
413     for (putprim = startprim; putprim <= endprim; putprim++) {
414     if (putprim != startprim && fseek(fin, startpos, 0)) {
415     fprintf(stderr, "%s: seek error on input file\n",
416     progname);
417 greg 1.1 quit(1);
418     }
419 greg 2.12 set_io();
420     setcolor(lastc, 0.0, 0.0, 0.0);
421     for (y = 0; y < numscans(&picres); y++) {
422     if (freadscan(scanln, scanlen(&picres), fin) < 0) {
423     fprintf(stderr, "%s: read error\n", progname);
424 greg 1.1 quit(1);
425     }
426 greg 2.12 for (x = 0; x < scanlen(&picres); x++) {
427     if (uniq)
428     if ( colval(scanln[x],RED) ==
429     colval(lastc,RED) &&
430     colval(scanln[x],GRN) ==
431     colval(lastc,GRN) &&
432     colval(scanln[x],BLU) ==
433     colval(lastc,BLU) )
434     continue;
435     else
436     copycolor(lastc, scanln[x]);
437     if (doexposure)
438     multcolor(scanln[x], exposure);
439     if (dogamma)
440     setcolor(scanln[x],
441     pow(colval(scanln[x],RED), 1.0/gamcor),
442     pow(colval(scanln[x],GRN), 1.0/gamcor),
443     pow(colval(scanln[x],BLU), 1.0/gamcor));
444     if (!dataonly) {
445     pix2loc(hv, &picres, x, y);
446     printf("%7d %7d ",
447     (int)(hv[0]*picres.xr),
448     (int)(hv[1]*picres.yr));
449     }
450     if ((*putval)(scanln[x]) < 0) {
451     fprintf(stderr, "%s: write error\n",
452     progname);
453     quit(1);
454     }
455     }
456 greg 1.1 }
457     }
458 greg 2.14 free((void *)scanln);
459 greg 1.1 }
460    
461    
462     valtopix() /* convert values to a pixel file */
463     {
464 greg 1.7 int dogamma;
465 greg 2.5 register COLOR *scanln;
466 greg 1.1 int y;
467     register int x;
468    
469 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
470 greg 1.1 if (scanln == NULL) {
471     fprintf(stderr, "%s: out of memory\n", progname);
472     quit(1);
473     }
474 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
475 greg 2.12 set_io();
476 greg 1.8 for (y = 0; y < numscans(&picres); y++) {
477     for (x = 0; x < scanlen(&picres); x++) {
478 greg 2.10 if (!dataonly) {
479 greg 1.1 fscanf(fin, "%*d %*d");
480 greg 2.10 if (fin2 != NULL) {
481     fscanf(fin2, "%*d %*d");
482     fscanf(fin3, "%*d %*d");
483     }
484     }
485 greg 2.11 if ((*getval)(scanln[x]) < 0) {
486 greg 1.1 fprintf(stderr, "%s: read error\n", progname);
487     quit(1);
488     }
489 greg 1.7 if (dogamma)
490     setcolor(scanln[x],
491 greg 1.8 pow(colval(scanln[x],RED), gamcor),
492     pow(colval(scanln[x],GRN), gamcor),
493     pow(colval(scanln[x],BLU), gamcor));
494 greg 2.7 if (doexposure)
495     multcolor(scanln[x], exposure);
496 greg 1.1 }
497 greg 1.8 if (fwritescan(scanln, scanlen(&picres), stdout) < 0) {
498 greg 1.1 fprintf(stderr, "%s: write error\n", progname);
499     quit(1);
500     }
501     }
502 greg 2.14 free((void *)scanln);
503 greg 1.1 }
504    
505    
506 greg 2.14 void
507 greg 1.1 quit(code)
508     int code;
509     {
510     exit(code);
511     }
512    
513    
514 greg 2.16 swap16(wp, n) /* swap n 16-bit words */
515     register uint16 *wp;
516     int n;
517     {
518     while (n-- > 0) {
519     *wp = *wp << 8 | ((*wp >> 8) & 0xff);
520     wp++;
521     }
522     }
523    
524 greg 2.11 getcascii(col) /* get an ascii color value from stream(s) */
525 greg 1.1 COLOR col;
526     {
527 greg 2.5 double vd[3];
528 greg 1.1
529 greg 2.11 if (fin2 == NULL) {
530     if (fscanf(fin, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
531 greg 2.10 return(-1);
532     } else {
533 greg 2.11 if (fscanf(fin, "%lf", &vd[0]) != 1 ||
534     fscanf(fin2, "%lf", &vd[1]) != 1 ||
535     fscanf(fin3, "%lf", &vd[2]) != 1)
536 greg 2.10 return(-1);
537     }
538 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
539 greg 1.1 return(0);
540     }
541    
542    
543 greg 2.11 getcdouble(col) /* get a double color value from stream(s) */
544 greg 1.1 COLOR col;
545     {
546 greg 2.5 double vd[3];
547 greg 1.1
548 greg 2.11 if (fin2 == NULL) {
549     if (fread((char *)vd, sizeof(double), 3, fin) != 3)
550 greg 2.10 return(-1);
551     } else {
552 greg 2.11 if (fread((char *)vd, sizeof(double), 1, fin) != 1 ||
553     fread((char *)(vd+1), sizeof(double), 1, fin2) != 1 ||
554     fread((char *)(vd+2), sizeof(double), 1, fin3) != 1)
555 greg 2.10 return(-1);
556     }
557 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
558 greg 1.1 return(0);
559     }
560    
561    
562 greg 2.11 getcfloat(col) /* get a float color value from stream(s) */
563 greg 1.1 COLOR col;
564     {
565     float vf[3];
566    
567 greg 2.11 if (fin2 == NULL) {
568     if (fread((char *)vf, sizeof(float), 3, fin) != 3)
569 greg 2.10 return(-1);
570     } else {
571 greg 2.11 if (fread((char *)vf, sizeof(float), 1, fin) != 1 ||
572     fread((char *)(vf+1), sizeof(float), 1, fin2) != 1 ||
573     fread((char *)(vf+2), sizeof(float), 1, fin3) != 1)
574 greg 2.10 return(-1);
575     }
576 greg 2.4 setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]);
577 greg 1.1 return(0);
578     }
579    
580    
581 greg 2.11 getcint(col) /* get an int color value from stream(s) */
582 greg 1.1 COLOR col;
583     {
584     int vi[3];
585    
586 greg 2.11 if (fin2 == NULL) {
587     if (fscanf(fin, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
588 greg 2.10 return(-1);
589     } else {
590 greg 2.11 if (fscanf(fin, "%d", &vi[0]) != 1 ||
591     fscanf(fin2, "%d", &vi[1]) != 1 ||
592     fscanf(fin3, "%d", &vi[2]) != 1)
593 greg 2.10 return(-1);
594     }
595 greg 2.4 setcolor(col, (vi[rord[RED]]+.5)/256.,
596     (vi[rord[GRN]]+.5)/256., (vi[rord[BLU]]+.5)/256.);
597 greg 1.1 return(0);
598     }
599    
600    
601 greg 2.11 getcbyte(col) /* get a byte color value from stream(s) */
602 greg 1.1 COLOR col;
603     {
604     BYTE vb[3];
605    
606 greg 2.11 if (fin2 == NULL) {
607     if (fread((char *)vb, sizeof(BYTE), 3, fin) != 3)
608 greg 2.10 return(-1);
609     } else {
610 greg 2.11 if (fread((char *)vb, sizeof(BYTE), 1, fin) != 1 ||
611     fread((char *)(vb+1), sizeof(BYTE), 1, fin2) != 1 ||
612     fread((char *)(vb+2), sizeof(BYTE), 1, fin3) != 1)
613 greg 2.10 return(-1);
614     }
615 greg 2.4 setcolor(col, (vb[rord[RED]]+.5)/256.,
616     (vb[rord[GRN]]+.5)/256., (vb[rord[BLU]]+.5)/256.);
617 greg 1.1 return(0);
618     }
619    
620    
621 greg 2.15 getcword(col) /* get a 16-bit color value from stream(s) */
622     COLOR col;
623     {
624     uint16 vw[3];
625    
626     if (fin2 == NULL) {
627     if (fread((char *)vw, sizeof(uint16), 3, fin) != 3)
628     return(-1);
629     } else {
630     if (fread((char *)vw, sizeof(uint16), 1, fin) != 1 ||
631     fread((char *)(vw+1), sizeof(uint16), 1, fin2) != 1 ||
632     fread((char *)(vw+2), sizeof(uint16), 1, fin3) != 1)
633     return(-1);
634     }
635 greg 2.16 if (swapbytes)
636     swap16(vw, 3);
637 greg 2.15 setcolor(col, (vw[rord[RED]]+.5)/65536.,
638     (vw[rord[GRN]]+.5)/65536., (vw[rord[BLU]]+.5)/65536.);
639     return(0);
640     }
641    
642    
643 greg 2.11 getbascii(col) /* get an ascii brightness value from fin */
644 greg 1.1 COLOR col;
645     {
646 greg 2.5 double vd;
647 greg 1.1
648 greg 2.11 if (fscanf(fin, "%lf", &vd) != 1)
649 greg 1.1 return(-1);
650     setcolor(col, vd, vd, vd);
651     return(0);
652     }
653    
654    
655 greg 2.11 getbdouble(col) /* get a double brightness value from fin */
656 greg 1.1 COLOR col;
657     {
658 greg 2.5 double vd;
659 greg 1.1
660 greg 2.11 if (fread((char *)&vd, sizeof(double), 1, fin) != 1)
661 greg 1.1 return(-1);
662     setcolor(col, vd, vd, vd);
663     return(0);
664     }
665    
666    
667 greg 2.11 getbfloat(col) /* get a float brightness value from fin */
668 greg 1.1 COLOR col;
669     {
670     float vf;
671    
672 greg 2.11 if (fread((char *)&vf, sizeof(float), 1, fin) != 1)
673 greg 1.1 return(-1);
674     setcolor(col, vf, vf, vf);
675     return(0);
676     }
677    
678    
679 greg 2.11 getbint(col) /* get an int brightness value from fin */
680 greg 1.1 COLOR col;
681     {
682     int vi;
683 greg 2.5 double d;
684 greg 1.1
685 greg 2.11 if (fscanf(fin, "%d", &vi) != 1)
686 greg 1.1 return(-1);
687     d = (vi+.5)/256.;
688     setcolor(col, d, d, d);
689     return(0);
690     }
691    
692    
693 greg 2.11 getbbyte(col) /* get a byte brightness value from fin */
694 greg 1.1 COLOR col;
695     {
696     BYTE vb;
697 greg 2.5 double d;
698 greg 1.1
699 greg 2.11 if (fread((char *)&vb, sizeof(BYTE), 1, fin) != 1)
700 greg 1.1 return(-1);
701     d = (vb+.5)/256.;
702     setcolor(col, d, d, d);
703     return(0);
704     }
705    
706    
707 greg 2.15 getbword(col) /* get a 16-bit brightness value from fin */
708     COLOR col;
709     {
710     uint16 vw;
711     double d;
712    
713     if (fread((char *)&vw, sizeof(uint16), 1, fin) != 1)
714     return(-1);
715 greg 2.16 if (swapbytes)
716     swap16(&vw, 1);
717 greg 2.15 d = (vw+.5)/65536.;
718     setcolor(col, d, d, d);
719     return(0);
720     }
721    
722    
723 greg 2.11 putcascii(col) /* put an ascii color to stdout */
724 greg 1.1 COLOR col;
725     {
726 greg 2.11 fprintf(stdout, "%15.3e %15.3e %15.3e\n",
727 greg 2.4 colval(col,ord[0]),
728     colval(col,ord[1]),
729     colval(col,ord[2]));
730 greg 1.1
731 greg 2.11 return(ferror(stdout) ? -1 : 0);
732 greg 1.1 }
733    
734    
735 greg 2.11 putcfloat(col) /* put a float color to stdout */
736 greg 1.1 COLOR col;
737     {
738     float vf[3];
739    
740 greg 2.4 vf[0] = colval(col,ord[0]);
741     vf[1] = colval(col,ord[1]);
742     vf[2] = colval(col,ord[2]);
743 greg 2.11 fwrite((char *)vf, sizeof(float), 3, stdout);
744 greg 1.1
745 greg 2.11 return(ferror(stdout) ? -1 : 0);
746 greg 1.1 }
747    
748    
749 greg 2.11 putcdouble(col) /* put a double color to stdout */
750 greg 1.1 COLOR col;
751     {
752 greg 2.5 double vd[3];
753 greg 1.1
754 greg 2.4 vd[0] = colval(col,ord[0]);
755     vd[1] = colval(col,ord[1]);
756     vd[2] = colval(col,ord[2]);
757 greg 2.11 fwrite((char *)vd, sizeof(double), 3, stdout);
758 greg 1.1
759 greg 2.11 return(ferror(stdout) ? -1 : 0);
760 greg 1.1 }
761    
762    
763 greg 2.11 putcint(col) /* put an int color to stdout */
764 greg 1.1 COLOR col;
765     {
766 greg 2.11 fprintf(stdout, "%d %d %d\n",
767 greg 2.4 (int)(colval(col,ord[0])*256.),
768     (int)(colval(col,ord[1])*256.),
769     (int)(colval(col,ord[2])*256.));
770 greg 1.1
771 greg 2.11 return(ferror(stdout) ? -1 : 0);
772 greg 1.1 }
773    
774    
775 greg 2.11 putcbyte(col) /* put a byte color to stdout */
776 greg 1.1 COLOR col;
777     {
778 greg 2.15 long i;
779 greg 1.1 BYTE vb[3];
780    
781 greg 2.4 i = colval(col,ord[0])*256.;
782 greg 1.1 vb[0] = min(i,255);
783 greg 2.4 i = colval(col,ord[1])*256.;
784 greg 1.1 vb[1] = min(i,255);
785 greg 2.4 i = colval(col,ord[2])*256.;
786 greg 1.1 vb[2] = min(i,255);
787 greg 2.11 fwrite((char *)vb, sizeof(BYTE), 3, stdout);
788 greg 1.1
789 greg 2.11 return(ferror(stdout) ? -1 : 0);
790 greg 1.1 }
791    
792    
793 greg 2.15 putcword(col) /* put a 16-bit color to stdout */
794     COLOR col;
795     {
796     long i;
797     uint16 vw[3];
798    
799     i = colval(col,ord[0])*65536.;
800     vw[0] = min(i,65535);
801     i = colval(col,ord[1])*65536.;
802     vw[1] = min(i,65535);
803     i = colval(col,ord[2])*65536.;
804     vw[2] = min(i,65535);
805 greg 2.16 if (swapbytes)
806     swap16(vw, 3);
807 greg 2.15 fwrite((char *)vw, sizeof(uint16), 3, stdout);
808    
809     return(ferror(stdout) ? -1 : 0);
810     }
811    
812    
813 greg 2.11 putbascii(col) /* put an ascii brightness to stdout */
814 greg 1.1 COLOR col;
815     {
816 greg 2.14 fprintf(stdout, "%15.3e\n", (*mybright)(col));
817 greg 1.1
818 greg 2.11 return(ferror(stdout) ? -1 : 0);
819 greg 1.1 }
820    
821    
822 greg 2.11 putbfloat(col) /* put a float brightness to stdout */
823 greg 1.1 COLOR col;
824     {
825     float vf;
826    
827 greg 2.14 vf = (*mybright)(col);
828 greg 2.11 fwrite((char *)&vf, sizeof(float), 1, stdout);
829 greg 1.1
830 greg 2.11 return(ferror(stdout) ? -1 : 0);
831 greg 1.1 }
832    
833    
834 greg 2.11 putbdouble(col) /* put a double brightness to stdout */
835 greg 1.1 COLOR col;
836     {
837 greg 2.5 double vd;
838 greg 1.1
839 greg 2.14 vd = (*mybright)(col);
840 greg 2.11 fwrite((char *)&vd, sizeof(double), 1, stdout);
841 greg 1.1
842 greg 2.11 return(ferror(stdout) ? -1 : 0);
843 greg 1.1 }
844    
845    
846 greg 2.11 putbint(col) /* put an int brightness to stdout */
847 greg 1.1 COLOR col;
848     {
849 greg 2.14 fprintf(stdout, "%d\n", (int)((*mybright)(col)*256.));
850 greg 1.1
851 greg 2.11 return(ferror(stdout) ? -1 : 0);
852 greg 1.1 }
853    
854    
855 greg 2.11 putbbyte(col) /* put a byte brightness to stdout */
856 greg 1.1 COLOR col;
857     {
858     register int i;
859     BYTE vb;
860    
861 greg 2.14 i = (*mybright)(col)*256.;
862 greg 1.1 vb = min(i,255);
863 greg 2.11 fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
864 greg 1.1
865 greg 2.11 return(ferror(stdout) ? -1 : 0);
866 greg 1.1 }
867    
868    
869 greg 2.15 putbword(col) /* put a 16-bit brightness to stdout */
870     COLOR col;
871     {
872     long i;
873     uint16 vw;
874    
875     i = (*mybright)(col)*65536.;
876     vw = min(i,65535);
877 greg 2.16 if (swapbytes)
878     swap16(&vw, 1);
879 greg 2.15 fwrite((char *)&vw, sizeof(uint16), 1, stdout);
880    
881     return(ferror(stdout) ? -1 : 0);
882     }
883    
884    
885 greg 2.11 putpascii(col) /* put an ascii primary to stdout */
886 greg 2.10 COLOR col;
887     {
888 greg 2.11 fprintf(stdout, "%15.3e\n", colval(col,putprim));
889 greg 2.10
890 greg 2.11 return(ferror(stdout) ? -1 : 0);
891 greg 2.10 }
892    
893    
894 greg 2.11 putpfloat(col) /* put a float primary to stdout */
895 greg 2.10 COLOR col;
896     {
897     float vf;
898    
899     vf = colval(col,putprim);
900 greg 2.11 fwrite((char *)&vf, sizeof(float), 1, stdout);
901 greg 2.10
902 greg 2.11 return(ferror(stdout) ? -1 : 0);
903 greg 2.10 }
904    
905    
906 greg 2.11 putpdouble(col) /* put a double primary to stdout */
907 greg 2.10 COLOR col;
908     {
909     double vd;
910    
911     vd = colval(col,putprim);
912 greg 2.11 fwrite((char *)&vd, sizeof(double), 1, stdout);
913 greg 2.10
914 greg 2.11 return(ferror(stdout) ? -1 : 0);
915 greg 2.10 }
916    
917    
918 greg 2.11 putpint(col) /* put an int primary to stdout */
919 greg 2.10 COLOR col;
920     {
921 greg 2.11 fprintf(stdout, "%d\n", (int)(colval(col,putprim)*256.));
922 greg 2.10
923 greg 2.11 return(ferror(stdout) ? -1 : 0);
924 greg 2.10 }
925    
926    
927 greg 2.11 putpbyte(col) /* put a byte primary to stdout */
928 greg 2.10 COLOR col;
929     {
930 greg 2.15 long i;
931 greg 2.10 BYTE vb;
932    
933     i = colval(col,putprim)*256.;
934     vb = min(i,255);
935 greg 2.11 fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
936 greg 2.10
937 greg 2.11 return(ferror(stdout) ? -1 : 0);
938 greg 2.10 }
939    
940    
941 greg 2.15 putpword(col) /* put a 16-bit primary to stdout */
942     COLOR col;
943     {
944     long i;
945     uint16 vw;
946    
947     i = colval(col,putprim)*65536.;
948     vw = min(i,65535);
949 greg 2.16 if (swapbytes)
950     swap16(&vw, 1);
951 greg 2.15 fwrite((char *)&vw, sizeof(uint16), 1, stdout);
952    
953     return(ferror(stdout) ? -1 : 0);
954     }
955    
956    
957 greg 1.1 set_io() /* set put and get functions */
958     {
959     switch (format) {
960     case 'a': /* ascii */
961 greg 2.10 if (putprim == BRIGHT) {
962 greg 1.1 getval = getbascii;
963     putval = putbascii;
964 greg 2.10 } else if (putprim != ALL) {
965     getval = getbascii;
966     putval = putpascii;
967 greg 1.1 } else {
968     getval = getcascii;
969     putval = putcascii;
970 greg 2.12 if (reverse && !interleave) {
971     fprintf(stderr,
972     "%s: ASCII input files must be interleaved\n",
973     progname);
974     quit(1);
975     }
976 greg 1.1 }
977     return;
978     case 'f': /* binary float */
979 greg 2.10 if (putprim == BRIGHT) {
980 greg 1.1 getval = getbfloat;
981     putval = putbfloat;
982 greg 2.10 } else if (putprim != ALL) {
983     getval = getbfloat;
984     putval = putpfloat;
985 greg 1.1 } else {
986     getval = getcfloat;
987     putval = putcfloat;
988 greg 2.12 if (reverse && !interleave) {
989     if (fin2 == NULL)
990     goto namerr;
991     if (fseek(fin2,
992     (long)sizeof(float)*picres.xr*picres.yr, 1))
993     goto seekerr;
994     if (fseek(fin3,
995     (long)sizeof(float)*2*picres.xr*picres.yr, 1))
996     goto seekerr;
997     }
998 greg 1.1 }
999     return;
1000     case 'd': /* binary double */
1001 greg 2.10 if (putprim == BRIGHT) {
1002 greg 1.1 getval = getbdouble;
1003     putval = putbdouble;
1004 greg 2.10 } else if (putprim != ALL) {
1005     getval = getbdouble;
1006     putval = putpdouble;
1007 greg 1.1 } else {
1008     getval = getcdouble;
1009     putval = putcdouble;
1010 greg 2.12 if (reverse && !interleave) {
1011     if (fin2 == NULL)
1012     goto namerr;
1013     if (fseek(fin2,
1014     (long)sizeof(double)*picres.xr*picres.yr, 1))
1015     goto seekerr;
1016     if (fseek(fin3,
1017     (long)sizeof(double)*2*picres.xr*picres.yr, 1))
1018     goto seekerr;
1019     }
1020 greg 1.1 }
1021     return;
1022     case 'i': /* integer */
1023 greg 2.10 if (putprim == BRIGHT) {
1024 greg 1.1 getval = getbint;
1025     putval = putbint;
1026 greg 2.10 } else if (putprim != ALL) {
1027     getval = getbint;
1028     putval = putpint;
1029 greg 1.1 } else {
1030     getval = getcint;
1031     putval = putcint;
1032 greg 2.12 if (reverse && !interleave) {
1033     fprintf(stderr,
1034     "%s: integer input files must be interleaved\n",
1035     progname);
1036     quit(1);
1037     }
1038 greg 1.1 }
1039     return;
1040     case 'b': /* byte */
1041 greg 2.10 if (putprim == BRIGHT) {
1042 greg 1.1 getval = getbbyte;
1043     putval = putbbyte;
1044 greg 2.10 } else if (putprim != ALL) {
1045     getval = getbbyte;
1046     putval = putpbyte;
1047 greg 1.1 } else {
1048     getval = getcbyte;
1049     putval = putcbyte;
1050 greg 2.12 if (reverse && !interleave) {
1051     if (fin2 == NULL)
1052     goto namerr;
1053     if (fseek(fin2,
1054     (long)sizeof(BYTE)*picres.xr*picres.yr, 1))
1055     goto seekerr;
1056     if (fseek(fin3,
1057     (long)sizeof(BYTE)*2*picres.xr*picres.yr, 1))
1058 greg 2.15 goto seekerr;
1059     }
1060     }
1061     return;
1062     case 'w': /* 16-bit */
1063     if (putprim == BRIGHT) {
1064     getval = getbword;
1065     putval = putbword;
1066     } else if (putprim != ALL) {
1067     getval = getbword;
1068     putval = putpword;
1069     } else {
1070     getval = getcword;
1071     putval = putcword;
1072     if (reverse && !interleave) {
1073     if (fin2 == NULL)
1074     goto namerr;
1075     if (fseek(fin2,
1076     (long)sizeof(uint16)*picres.xr*picres.yr, 1))
1077     goto seekerr;
1078     if (fseek(fin3,
1079     (long)sizeof(uint16)*2*picres.xr*picres.yr, 1))
1080 greg 2.12 goto seekerr;
1081     }
1082 greg 1.1 }
1083     return;
1084     }
1085 greg 2.12 badopt:
1086     fprintf(stderr, "%s: botched file type\n", progname);
1087     quit(1);
1088     namerr:
1089     fprintf(stderr, "%s: non-interleaved file(s) must be named\n",
1090     progname);
1091     quit(1);
1092     seekerr:
1093     fprintf(stderr, "%s: cannot seek on interleaved input file\n",
1094     progname);
1095     quit(1);
1096 greg 1.1 }