ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.19
Committed: Sun Jun 8 12:03:10 2003 UTC (20 years, 10 months ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 2.18: +2 -1 lines
Log Message: 
Reduced compile warnings/errors on Windows.

File Contents

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