ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.15
Committed: Tue Feb 25 16:22:05 2003 UTC (21 years, 1 month ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.14: +116 -2 lines
Log Message:
Added -dw option for 16-bit i/o

File Contents

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