ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.30
Committed: Thu Dec 16 21:34:41 2010 UTC (13 years, 4 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.29: +25 -3 lines
Log Message: 
Added recording of other color spaces to pvalue -r conversion

File Contents

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