ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.22
Committed: Mon Jul 21 22:30:19 2003 UTC (20 years, 9 months ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 2.21: +7 -4 lines
Log Message: 
Eliminated copystruct() macro, which is unnecessary in ANSI.
Reduced ambiguity warnings for nested if/if/else clauses.

File Contents

# User Rev Content
1 greg 1.1 #ifndef lint
2 schorsch 2.22 static const char RCSid[] = "$Id: pvalue.c,v 2.21 2003/06/26 00:58:10 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 greg 2.15
17 greg 2.5 #define min(a,b) ((a)<(b)?(a):(b))
18 greg 1.1
19 greg 2.10 /* what to put out (also RED, GRN, BLU) */
20     #define ALL 3
21     #define BRIGHT 4
22    
23 greg 2.5 RESOLU picres; /* resolution of picture */
24 greg 1.1
25 greg 1.6 int uniq = 0; /* print only unique values? */
26 greg 1.1
27 greg 2.7 int doexposure = 0; /* exposure change? (>100 to print) */
28 greg 1.1
29     int dataonly = 0; /* data only format? */
30    
31 greg 2.10 int putprim = ALL; /* what to put out */
32 greg 1.1
33     int reverse = 0; /* reverse conversion? */
34    
35     int format = 'a'; /* input/output format */
36 greg 1.6 char *fmtid = "ascii"; /* format identifier for header */
37 greg 1.1
38 greg 2.3 int header = 1; /* do header? */
39 greg 1.1
40 greg 2.10 long skipbytes = 0; /* skip bytes in input? */
41    
42 greg 2.16 int swapbytes = 0; /* swap bytes in 16-bit words? */
43    
44 greg 2.12 int interleave = 1; /* file is interleaved? */
45    
46 greg 2.3 int resolution = 1; /* put/get resolution string? */
47    
48 greg 2.7 int original = 0; /* convert to original values? */
49    
50 greg 1.6 int wrongformat = 0; /* wrong input format? */
51    
52 greg 2.5 double gamcor = 1.0; /* gamma correction */
53 greg 1.7
54 greg 2.4 int ord[3] = {RED, GRN, BLU}; /* RGB ordering */
55     int rord[4]; /* reverse ordering */
56    
57 greg 1.5 COLOR exposure = WHTCOLOR;
58 greg 1.1
59     char *progname;
60    
61     FILE *fin;
62 greg 2.10 FILE *fin2 = NULL, *fin3 = NULL; /* for other color channels */
63 greg 1.1
64     int (*getval)(), (*putval)();
65    
66 greg 2.14 double
67     rgb_bright(clr)
68     COLOR clr;
69     {
70     return(bright(clr));
71     }
72    
73     double
74     xyz_bright(clr)
75     COLOR clr;
76     {
77     return(clr[CIEY]);
78     }
79    
80     double (*mybright)() = &rgb_bright;
81    
82 greg 1.1
83     main(argc, argv)
84     int argc;
85     char **argv;
86     {
87     extern int checkhead();
88 greg 2.10 extern long atol();
89 greg 2.7 double d, expval = 1.0;
90 greg 1.1 int i;
91    
92     progname = argv[0];
93    
94     for (i = 1; i < argc; i++)
95 greg 1.8 if (argv[i][0] == '-' || argv[i][0] == '+')
96 greg 1.1 switch (argv[i][1]) {
97 greg 1.8 case 'h': /* header */
98     header = argv[i][0] == '+';
99 greg 1.1 break;
100 greg 2.3 case 'H': /* resolution string */
101     resolution = argv[i][0] == '+';
102     break;
103 greg 2.10 case 's': /* skip bytes in header */
104     skipbytes = atol(argv[++i]);
105     break;
106 greg 1.1 case 'u': /* unique values */
107 greg 1.8 uniq = argv[i][0] == '-';
108 greg 1.1 break;
109     case 'o': /* original values */
110 greg 1.8 original = argv[i][0] == '-';
111 greg 1.1 break;
112 greg 1.7 case 'g': /* gamma correction */
113 greg 2.7 gamcor = atof(argv[i+1]);
114 greg 1.8 if (argv[i][0] == '+')
115     gamcor = 1.0/gamcor;
116 greg 2.7 i++;
117 greg 1.7 break;
118 greg 2.7 case 'e': /* exposure correction */
119     d = atof(argv[i+1]);
120     if (argv[i+1][0] == '-' || argv[i+1][0] == '+')
121     d = pow(2.0, d);
122     if (argv[i][0] == '-')
123 greg 2.9 expval *= d;
124 greg 2.7 scalecolor(exposure, d);
125     doexposure++;
126     i++;
127     break;
128 greg 2.4 case 'R': /* reverse byte sequence */
129     if (argv[i][0] == '-') {
130     ord[0]=BLU; ord[1]=GRN; ord[2]=RED;
131     } else {
132     ord[0]=RED; ord[1]=GRN; ord[2]=BLU;
133     }
134     break;
135 greg 1.1 case 'r': /* reverse conversion */
136 greg 1.8 reverse = argv[i][0] == '-';
137 greg 1.1 break;
138 greg 2.12 case 'n': /* non-interleaved RGB */
139     interleave = argv[i][0] == '+';
140     break;
141 greg 1.1 case 'b': /* brightness values */
142 greg 2.10 putprim = argv[i][0] == '-' ? BRIGHT : ALL;
143 greg 1.1 break;
144 greg 2.10 case 'p': /* put primary */
145     switch (argv[i][2]) {
146     case 'r': case 'R': putprim = RED; break;
147     case 'g': case 'G': putprim = GRN; break;
148     case 'b': case 'B': putprim = BLU; break;
149     default: goto unkopt;
150     }
151     break;
152 greg 1.1 case 'd': /* data only (no indices) */
153 greg 1.8 dataonly = argv[i][0] == '-';
154 greg 1.1 switch (argv[i][2]) {
155     case '\0':
156     case 'a': /* ascii */
157     format = 'a';
158 greg 1.6 fmtid = "ascii";
159 greg 1.1 break;
160     case 'i': /* integer */
161 greg 1.6 format = 'i';
162     fmtid = "ascii";
163     break;
164 greg 1.1 case 'b': /* byte */
165 greg 1.8 dataonly = 1;
166 greg 1.6 format = 'b';
167     fmtid = "byte";
168     break;
169 greg 2.16 case 'W': /* 16-bit swapped */
170     swapbytes = 1;
171 greg 2.15 case 'w': /* 16-bit */
172     dataonly = 1;
173     format = 'w';
174     fmtid = "16-bit";
175     break;
176 greg 1.1 case 'f': /* float */
177 greg 1.8 dataonly = 1;
178 greg 1.6 format = 'f';
179     fmtid = "float";
180     break;
181 greg 1.1 case 'd': /* double */
182 greg 1.8 dataonly = 1;
183 greg 1.6 format = 'd';
184     fmtid = "double";
185 greg 1.1 break;
186     default:
187     goto unkopt;
188     }
189     break;
190     case 'x': /* x resolution */
191 greg 2.6 case 'X': /* x resolution */
192 greg 2.3 resolution = 0;
193 greg 1.8 if (argv[i][0] == '-')
194 greg 2.14 picres.rt |= XDECR;
195 greg 1.8 picres.xr = atoi(argv[++i]);
196 greg 1.1 break;
197     case 'y': /* y resolution */
198 greg 2.6 case 'Y': /* y resolution */
199 greg 2.3 resolution = 0;
200 greg 1.8 if (argv[i][0] == '-')
201 greg 2.14 picres.rt |= YDECR;
202 greg 1.8 if (picres.xr == 0)
203 greg 2.14 picres.rt |= YMAJOR;
204 greg 1.8 picres.yr = atoi(argv[++i]);
205 greg 1.1 break;
206     default:
207     unkopt:
208     fprintf(stderr, "%s: unknown option: %s\n",
209     progname, argv[i]);
210     quit(1);
211     break;
212     }
213     else
214     break;
215 greg 1.6 /* recognize special formats */
216 schorsch 2.22 if (dataonly && format == 'b') {
217 greg 2.17 if (putprim == ALL)
218     fmtid = "24-bit_rgb";
219     else
220 greg 1.6 fmtid = "8-bit_grey";
221 schorsch 2.22 }
222     if (dataonly && format == 'w') {
223 greg 2.17 if (putprim == ALL)
224     fmtid = "48-bit_rgb";
225 greg 1.6 else
226 greg 2.15 fmtid = "16-bit_grey";
227 schorsch 2.22 }
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 schorsch 2.21 RREAL 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 schorsch 2.22 if (uniq) {
427 greg 2.12 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 schorsch 2.22 }
437 greg 2.12 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 }