ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.4
Committed: Fri May 8 11:55:42 1992 UTC (31 years, 10 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.3: +37 -21 lines
Log Message:
added -R option for color order reversal

File Contents

# Content
1 /* Copyright (c) 1991 Regents of the University of California */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ LBL";
5 #endif
6
7 /*
8 * pvalue.c - program to print pixel values.
9 *
10 * 4/23/86
11 */
12
13 #include "standard.h"
14
15 #include "color.h"
16
17 #include "resolu.h"
18
19 #define min(a,b) ((a)<(b)?(a):(b))
20
21 RESOLU picres; /* resolution of picture */
22
23 int uniq = 0; /* print only unique values? */
24
25 int original = 0; /* convert back to original values? */
26
27 int dataonly = 0; /* data only format? */
28
29 int brightonly = 0; /* only brightness values? */
30
31 int reverse = 0; /* reverse conversion? */
32
33 int format = 'a'; /* input/output format */
34 char *fmtid = "ascii"; /* format identifier for header */
35
36 int header = 1; /* do header? */
37
38 int resolution = 1; /* put/get resolution string? */
39
40 int wrongformat = 0; /* wrong input format? */
41
42 double gamcor = 1.0; /* gamma correction */
43
44 int ord[3] = {RED, GRN, BLU}; /* RGB ordering */
45 int rord[4]; /* reverse ordering */
46
47 COLOR exposure = WHTCOLOR;
48
49 char *progname;
50
51 FILE *fin;
52
53 int (*getval)(), (*putval)();
54
55
56 main(argc, argv)
57 int argc;
58 char **argv;
59 {
60 extern int checkhead();
61 int i;
62
63 progname = argv[0];
64
65 for (i = 1; i < argc; i++)
66 if (argv[i][0] == '-' || argv[i][0] == '+')
67 switch (argv[i][1]) {
68 case 'h': /* header */
69 header = argv[i][0] == '+';
70 break;
71 case 'H': /* resolution string */
72 resolution = argv[i][0] == '+';
73 break;
74 case 'u': /* unique values */
75 uniq = argv[i][0] == '-';
76 break;
77 case 'o': /* original values */
78 original = argv[i][0] == '-';
79 break;
80 case 'g': /* gamma correction */
81 gamcor = atof(argv[++i]);
82 if (argv[i][0] == '+')
83 gamcor = 1.0/gamcor;
84 break;
85 case 'R': /* reverse byte sequence */
86 if (argv[i][0] == '-') {
87 ord[0]=BLU; ord[1]=GRN; ord[2]=RED;
88 } else {
89 ord[0]=RED; ord[1]=GRN; ord[2]=BLU;
90 }
91 break;
92 case 'r': /* reverse conversion */
93 reverse = argv[i][0] == '-';
94 break;
95 case 'b': /* brightness values */
96 brightonly = argv[i][0] == '-';
97 break;
98 case 'd': /* data only (no indices) */
99 dataonly = argv[i][0] == '-';
100 switch (argv[i][2]) {
101 case '\0':
102 case 'a': /* ascii */
103 format = 'a';
104 fmtid = "ascii";
105 break;
106 case 'i': /* integer */
107 format = 'i';
108 fmtid = "ascii";
109 break;
110 case 'b': /* byte */
111 dataonly = 1;
112 format = 'b';
113 fmtid = "byte";
114 break;
115 case 'f': /* float */
116 dataonly = 1;
117 format = 'f';
118 fmtid = "float";
119 break;
120 case 'd': /* double */
121 dataonly = 1;
122 format = 'd';
123 fmtid = "double";
124 break;
125 default:
126 goto unkopt;
127 }
128 break;
129 case 'x': /* x resolution */
130 resolution = 0;
131 if (argv[i][0] == '-')
132 picres.or |= XDECR;
133 picres.xr = atoi(argv[++i]);
134 break;
135 case 'y': /* y resolution */
136 resolution = 0;
137 if (argv[i][0] == '-')
138 picres.or |= YDECR;
139 if (picres.xr == 0)
140 picres.or |= YMAJOR;
141 picres.yr = atoi(argv[++i]);
142 break;
143 default:
144 unkopt:
145 fprintf(stderr, "%s: unknown option: %s\n",
146 progname, argv[i]);
147 quit(1);
148 break;
149 }
150 else
151 break;
152 /* recognize special formats */
153 if (dataonly && format == 'b')
154 if (brightonly)
155 fmtid = "8-bit_grey";
156 else
157 fmtid = "24-bit_rgb";
158 /* assign reverse ordering */
159 rord[ord[0]] = 0;
160 rord[ord[1]] = 1;
161 rord[ord[2]] = 2;
162 /* get input */
163 if (i == argc) {
164 fin = stdin;
165 } else if (i == argc-1) {
166 if ((fin = fopen(argv[i], "r")) == NULL) {
167 fprintf(stderr, "%s: can't open file \"%s\"\n",
168 progname, argv[i]);
169 quit(1);
170 }
171 } else {
172 fprintf(stderr, "%s: bad # file arguments\n", progname);
173 quit(1);
174 }
175
176 set_io();
177
178 if (reverse) {
179 /* get header */
180 if (header && checkheader(fin, fmtid, stdout) < 0) {
181 fprintf(stderr, "%s: wrong input format\n", progname);
182 quit(1);
183 }
184 /* get resolution */
185 if ((resolution && !fgetsresolu(&picres, fin)) ||
186 picres.xr <= 0 || picres.yr <= 0) {
187 fprintf(stderr, "%s: missing resolution\n", progname);
188 quit(1);
189 }
190 /* add to header */
191 printargs(i, argv, stdout);
192 fputformat(COLRFMT, stdout);
193 putchar('\n');
194 fputsresolu(&picres, stdout); /* always put resolution */
195 valtopix();
196 } else {
197 /* get header */
198 getheader(fin, checkhead, NULL);
199 if (wrongformat) {
200 fprintf(stderr, "%s: input not a Radiance picture\n",
201 progname);
202 quit(1);
203 }
204 if (!fgetsresolu(&picres, fin)) {
205 fprintf(stderr, "%s: missing resolution\n", progname);
206 quit(1);
207 }
208 if (header) {
209 printargs(i, argv, stdout);
210 fputformat(fmtid, stdout);
211 putchar('\n');
212 }
213 if (resolution) /* put resolution */
214 fputsresolu(&picres, stdout);
215 pixtoval();
216 }
217
218 quit(0);
219 }
220
221
222 checkhead(line) /* deal with line from header */
223 char *line;
224 {
225 char fmt[32];
226 double d;
227 COLOR ctmp;
228
229 if (isformat(line)) {
230 formatval(fmt, line);
231 wrongformat = strcmp(fmt, COLRFMT);
232 } else if (original && isexpos(line)) {
233 d = 1.0/exposval(line);
234 scalecolor(exposure, d);
235 } else if (original && iscolcor(line)) {
236 colcorval(ctmp, line);
237 setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
238 colval(exposure,GRN)/colval(ctmp,GRN),
239 colval(exposure,BLU)/colval(ctmp,BLU));
240 } else if (header)
241 fputs(line, stdout);
242 }
243
244
245 pixtoval() /* convert picture to values */
246 {
247 register COLOR *scanln;
248 int dogamma;
249 COLOR lastc;
250 FLOAT hv[2];
251 int y;
252 register int x;
253
254 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
255 if (scanln == NULL) {
256 fprintf(stderr, "%s: out of memory\n", progname);
257 quit(1);
258 }
259 dogamma = gamcor < .95 || gamcor > 1.05;
260 setcolor(lastc, 0.0, 0.0, 0.0);
261 for (y = 0; y < numscans(&picres); y++) {
262 if (freadscan(scanln, scanlen(&picres), fin) < 0) {
263 fprintf(stderr, "%s: read error\n", progname);
264 quit(1);
265 }
266 for (x = 0; x < scanlen(&picres); x++) {
267 if (uniq)
268 if ( colval(scanln[x],RED) ==
269 colval(lastc,RED) &&
270 colval(scanln[x],GRN) ==
271 colval(lastc,GRN) &&
272 colval(scanln[x],BLU) ==
273 colval(lastc,BLU) )
274 continue;
275 else
276 copycolor(lastc, scanln[x]);
277 if (original)
278 multcolor(scanln[x], exposure);
279 if (dogamma)
280 setcolor(scanln[x],
281 pow(colval(scanln[x],RED), 1.0/gamcor),
282 pow(colval(scanln[x],GRN), 1.0/gamcor),
283 pow(colval(scanln[x],BLU), 1.0/gamcor));
284 if (!dataonly) {
285 pix2loc(hv, &picres, x, y);
286 printf("%7d %7d ", (int)(hv[0]*picres.xr),
287 (int)(hv[1]*picres.yr));
288 }
289 if ((*putval)(scanln[x], stdout) < 0) {
290 fprintf(stderr, "%s: write error\n", progname);
291 quit(1);
292 }
293 }
294 }
295 free((char *)scanln);
296 }
297
298
299 valtopix() /* convert values to a pixel file */
300 {
301 int dogamma;
302 register COLOR *scanln;
303 int y;
304 register int x;
305
306 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
307 if (scanln == NULL) {
308 fprintf(stderr, "%s: out of memory\n", progname);
309 quit(1);
310 }
311 dogamma = gamcor < .95 || gamcor > 1.05;
312 for (y = 0; y < numscans(&picres); y++) {
313 for (x = 0; x < scanlen(&picres); x++) {
314 if (!dataonly)
315 fscanf(fin, "%*d %*d");
316 if ((*getval)(scanln[x], fin) < 0) {
317 fprintf(stderr, "%s: read error\n", progname);
318 quit(1);
319 }
320 if (dogamma)
321 setcolor(scanln[x],
322 pow(colval(scanln[x],RED), gamcor),
323 pow(colval(scanln[x],GRN), gamcor),
324 pow(colval(scanln[x],BLU), gamcor));
325 }
326 if (fwritescan(scanln, scanlen(&picres), stdout) < 0) {
327 fprintf(stderr, "%s: write error\n", progname);
328 quit(1);
329 }
330 }
331 free((char *)scanln);
332 }
333
334
335 quit(code)
336 int code;
337 {
338 exit(code);
339 }
340
341
342 getcascii(col, fp) /* get an ascii color value from fp */
343 COLOR col;
344 FILE *fp;
345 {
346 double vd[3];
347
348 if (fscanf(fp, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
349 return(-1);
350 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
351 return(0);
352 }
353
354
355 getcdouble(col, fp) /* get a double color value from fp */
356 COLOR col;
357 FILE *fp;
358 {
359 double vd[3];
360
361 if (fread((char *)vd, sizeof(double), 3, fp) != 3)
362 return(-1);
363 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
364 return(0);
365 }
366
367
368 getcfloat(col, fp) /* get a float color value from fp */
369 COLOR col;
370 FILE *fp;
371 {
372 float vf[3];
373
374 if (fread((char *)vf, sizeof(float), 3, fp) != 3)
375 return(-1);
376 setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]);
377 return(0);
378 }
379
380
381 getcint(col, fp) /* get an int color value from fp */
382 COLOR col;
383 FILE *fp;
384 {
385 int vi[3];
386
387 if (fscanf(fp, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
388 return(-1);
389 setcolor(col, (vi[rord[RED]]+.5)/256.,
390 (vi[rord[GRN]]+.5)/256., (vi[rord[BLU]]+.5)/256.);
391 return(0);
392 }
393
394
395 getcbyte(col, fp) /* get a byte color value from fp */
396 COLOR col;
397 FILE *fp;
398 {
399 BYTE vb[3];
400
401 if (fread((char *)vb, sizeof(BYTE), 3, fp) != 3)
402 return(-1);
403 setcolor(col, (vb[rord[RED]]+.5)/256.,
404 (vb[rord[GRN]]+.5)/256., (vb[rord[BLU]]+.5)/256.);
405 return(0);
406 }
407
408
409 getbascii(col, fp) /* get an ascii brightness value from fp */
410 COLOR col;
411 FILE *fp;
412 {
413 double vd;
414
415 if (fscanf(fp, "%lf", &vd) != 1)
416 return(-1);
417 setcolor(col, vd, vd, vd);
418 return(0);
419 }
420
421
422 getbdouble(col, fp) /* get a double brightness value from fp */
423 COLOR col;
424 FILE *fp;
425 {
426 double vd;
427
428 if (fread((char *)&vd, sizeof(double), 1, fp) != 1)
429 return(-1);
430 setcolor(col, vd, vd, vd);
431 return(0);
432 }
433
434
435 getbfloat(col, fp) /* get a float brightness value from fp */
436 COLOR col;
437 FILE *fp;
438 {
439 float vf;
440
441 if (fread((char *)&vf, sizeof(float), 1, fp) != 1)
442 return(-1);
443 setcolor(col, vf, vf, vf);
444 return(0);
445 }
446
447
448 getbint(col, fp) /* get an int brightness value from fp */
449 COLOR col;
450 FILE *fp;
451 {
452 int vi;
453 double d;
454
455 if (fscanf(fp, "%d", &vi) != 1)
456 return(-1);
457 d = (vi+.5)/256.;
458 setcolor(col, d, d, d);
459 return(0);
460 }
461
462
463 getbbyte(col, fp) /* get a byte brightness value from fp */
464 COLOR col;
465 FILE *fp;
466 {
467 BYTE vb;
468 double d;
469
470 if (fread((char *)&vb, sizeof(BYTE), 1, fp) != 1)
471 return(-1);
472 d = (vb+.5)/256.;
473 setcolor(col, d, d, d);
474 return(0);
475 }
476
477
478 putcascii(col, fp) /* put an ascii color to fp */
479 COLOR col;
480 FILE *fp;
481 {
482 fprintf(fp, "%15.3e %15.3e %15.3e\n",
483 colval(col,ord[0]),
484 colval(col,ord[1]),
485 colval(col,ord[2]));
486
487 return(ferror(fp) ? -1 : 0);
488 }
489
490
491 putcfloat(col, fp) /* put a float color to fp */
492 COLOR col;
493 FILE *fp;
494 {
495 float vf[3];
496
497 vf[0] = colval(col,ord[0]);
498 vf[1] = colval(col,ord[1]);
499 vf[2] = colval(col,ord[2]);
500 fwrite((char *)vf, sizeof(float), 3, fp);
501
502 return(ferror(fp) ? -1 : 0);
503 }
504
505
506 putcdouble(col, fp) /* put a double color to fp */
507 COLOR col;
508 FILE *fp;
509 {
510 double vd[3];
511
512 vd[0] = colval(col,ord[0]);
513 vd[1] = colval(col,ord[1]);
514 vd[2] = colval(col,ord[2]);
515 fwrite((char *)vd, sizeof(double), 3, fp);
516
517 return(ferror(fp) ? -1 : 0);
518 }
519
520
521 putcint(col, fp) /* put an int color to fp */
522 COLOR col;
523 FILE *fp;
524 {
525 fprintf(fp, "%d %d %d\n",
526 (int)(colval(col,ord[0])*256.),
527 (int)(colval(col,ord[1])*256.),
528 (int)(colval(col,ord[2])*256.));
529
530 return(ferror(fp) ? -1 : 0);
531 }
532
533
534 putcbyte(col, fp) /* put a byte color to fp */
535 COLOR col;
536 FILE *fp;
537 {
538 register int i;
539 BYTE vb[3];
540
541 i = colval(col,ord[0])*256.;
542 vb[0] = min(i,255);
543 i = colval(col,ord[1])*256.;
544 vb[1] = min(i,255);
545 i = colval(col,ord[2])*256.;
546 vb[2] = min(i,255);
547 fwrite((char *)vb, sizeof(BYTE), 3, fp);
548
549 return(ferror(fp) ? -1 : 0);
550 }
551
552
553 putbascii(col, fp) /* put an ascii brightness to fp */
554 COLOR col;
555 FILE *fp;
556 {
557 fprintf(fp, "%15.3e\n", bright(col));
558
559 return(ferror(fp) ? -1 : 0);
560 }
561
562
563 putbfloat(col, fp) /* put a float brightness to fp */
564 COLOR col;
565 FILE *fp;
566 {
567 float vf;
568
569 vf = bright(col);
570 fwrite((char *)&vf, sizeof(float), 1, fp);
571
572 return(ferror(fp) ? -1 : 0);
573 }
574
575
576 putbdouble(col, fp) /* put a double brightness to fp */
577 COLOR col;
578 FILE *fp;
579 {
580 double vd;
581
582 vd = bright(col);
583 fwrite((char *)&vd, sizeof(double), 1, fp);
584
585 return(ferror(fp) ? -1 : 0);
586 }
587
588
589 putbint(col, fp) /* put an int brightness to fp */
590 COLOR col;
591 FILE *fp;
592 {
593 fprintf(fp, "%d\n", (int)(bright(col)*256.));
594
595 return(ferror(fp) ? -1 : 0);
596 }
597
598
599 putbbyte(col, fp) /* put a byte brightness to fp */
600 COLOR col;
601 FILE *fp;
602 {
603 register int i;
604 BYTE vb;
605
606 i = bright(col)*256.;
607 vb = min(i,255);
608 fwrite((char *)&vb, sizeof(BYTE), 1, fp);
609
610 return(ferror(fp) ? -1 : 0);
611 }
612
613
614 set_io() /* set put and get functions */
615 {
616 switch (format) {
617 case 'a': /* ascii */
618 if (brightonly) {
619 getval = getbascii;
620 putval = putbascii;
621 } else {
622 getval = getcascii;
623 putval = putcascii;
624 }
625 return;
626 case 'f': /* binary float */
627 if (brightonly) {
628 getval = getbfloat;
629 putval = putbfloat;
630 } else {
631 getval = getcfloat;
632 putval = putcfloat;
633 }
634 return;
635 case 'd': /* binary double */
636 if (brightonly) {
637 getval = getbdouble;
638 putval = putbdouble;
639 } else {
640 getval = getcdouble;
641 putval = putcdouble;
642 }
643 return;
644 case 'i': /* integer */
645 if (brightonly) {
646 getval = getbint;
647 putval = putbint;
648 } else {
649 getval = getcint;
650 putval = putcint;
651 }
652 return;
653 case 'b': /* byte */
654 if (brightonly) {
655 getval = getbbyte;
656 putval = putbbyte;
657 } else {
658 getval = getcbyte;
659 putval = putcbyte;
660 }
661 return;
662 }
663 }