ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.16
Committed: Tue Feb 25 16:47:23 2003 UTC (21 years, 1 month ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.15: +25 -1 lines
Log Message: 
Added -dW option for 16-bit byte-swapped words

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