ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
(Generate patch)

Comparing ray/src/px/pvalue.c (file contents):
Revision 2.35 by greg, Mon Jul 15 22:39:50 2019 UTC vs.
Revision 2.46 by greg, Tue Jun 3 21:31:51 2025 UTC

# Line 26 | Line 26 | int  dataonly = 0;             /* data only format? */
26   int  putprim = ALL;             /* what to put out */
27   int  reverse = 0;               /* reverse conversion? */
28   int  format = 'a';              /* input/output format */
29 < char  *fmtid = "ascii";         /* format identifier for header */
29 > const char  *fmtid = "ascii";   /* format identifier for header */
30   int  header = 1;                /* do header? */
31   long  skipbytes = 0;            /* skip bytes in input? */
32   int  swapbytes = 0;             /* swap bytes? */
# Line 44 | Line 44 | int  rord[4];                  /* reverse ordering */
44  
45   COLOR  exposure = WHTCOLOR;
46  
47 – char  *progname;
48 –
47   FILE  *fin;
48   FILE  *fin2 = NULL, *fin3 = NULL;       /* for other color channels */
49  
# Line 66 | Line 64 | static putfunc_t putbascii, putbint, putbdouble, putbf
64   static putfunc_t putcascii, putcint, putcdouble, putcfloat, putcbyte, putcword;
65   static putfunc_t putpascii, putpint, putpdouble, putpfloat, putpbyte, putpword;
66  
67 + static int IDformat(const char *s);
68   static void set_io(void);
69   static void pixtoval(void);
70   static void valtopix(void);
# Line 93 | Line 92 | main(
92          char  **argv
93   )
94   {
95 <        double  d, expval = 1.0;
96 <        int  i;
95 >        const char      *inpmode = "r";
96 >        double          d, expval = 1.0;
97 >        int             i;
98  
99 <        progname = argv[0];
99 >        fixargv0(argv[0]);      /* sets global progname */
100          mybright = &rgb_bright; /* default */
101 +        picres.rt = PIXSTANDARD;
102  
103          for (i = 1; i < argc; i++)
104                  if (argv[i][0] == '-' || argv[i][0] == '+')
# Line 117 | Line 118 | main(
118                          case 'o':               /* original values */
119                                  original = argv[i][0] == '-';
120                                  break;
121 +                        case 'O':               /* original watts/sr/m^2 */
122 +                                original = -(argv[i][0] == '-');
123 +                                break;
124                          case 'g':               /* gamma correction */
125                                  gamcor = atof(argv[i+1]);
126                                  if (argv[i][0] == '+')
# Line 172 | Line 176 | main(
176                                  }
177                                  break;
178                          case 'd':               /* data only (no indices) */
179 <                                dataonly = argv[i][0] == '-';
179 >                                dataonly = (argv[i][0] == '-');
180                                  switch (argv[i][2]) {
181                                  case '\0':
182                                  case 'a':               /* ascii */
# Line 214 | Line 218 | main(
218                                  }
219                                  break;
220                          case 'x':               /* x resolution */
221 <                        case 'X':               /* x resolution */
221 >                        case 'X':
222                                  resolution = 0;
223                                  if (argv[i][0] == '-')
224                                          picres.rt |= XDECR;
225 +                                else
226 +                                        picres.rt &= ~XDECR;
227 +                                if (picres.yr == 0)
228 +                                        picres.rt &= ~YMAJOR;
229                                  picres.xr = atoi(argv[++i]);
230                                  break;
231                          case 'y':               /* y resolution */
232 <                        case 'Y':               /* y resolution */
232 >                        case 'Y':
233                                  resolution = 0;
234                                  if (argv[i][0] == '-')
235                                          picres.rt |= YDECR;
236 +                                else
237 +                                        picres.rt &= ~YDECR;
238                                  if (picres.xr == 0)
239                                          picres.rt |= YMAJOR;
240                                  picres.yr = atoi(argv[++i]);
# Line 239 | Line 249 | unkopt:
249                  else
250                          break;
251                                          /* recognize special formats */
252 <        if (dataonly && format == 'b') {
252 >        if (dataonly & (format == 'b')) {
253                  if (putprim == ALL)
254                          fmtid = "24-bit_rgb";
255                  else
256                          fmtid = "8-bit_grey";
257          }
258 <        if (dataonly && format == 'w') {
258 >        if (dataonly & (format == 'w')) {
259                  if (putprim == ALL)
260                          fmtid = "48-bit_rgb";
261                  else
262                          fmtid = "16-bit_grey";
263          }
264 +        if (!reverse | ((format != 'a') & (format != 'i')))
265 +                inpmode = "rb";
266                                          /* assign reverse ordering */
267          rord[ord[0]] = 0;
268          rord[ord[1]] = 1;
269          rord[ord[2]] = 2;
270                                          /* get input */
271          if (i == argc) {
272 +                long    n = skipbytes;
273 +                if (inpmode[1] == 'b')
274 +                        SET_FILE_BINARY(stdin);
275 +                while (n-- > 0)
276 +                        if (getchar() == EOF) {
277 +                                fprintf(stderr,
278 +                                "%s: cannot skip %ld bytes on standard input\n",
279 +                                                progname, skipbytes);
280 +                                quit(1);
281 +                        }
282                  fin = stdin;
283          } else if (i < argc) {
284 <                if ((fin = fopen(argv[i], "r")) == NULL) {
284 >                if ((fin = fopen(argv[i], inpmode)) == NULL) {
285                          fprintf(stderr, "%s: can't open file \"%s\"\n",
286                                                  progname, argv[i]);
287                          quit(1);
288                  }
289 <                if (reverse && putprim != BRIGHT && i == argc-3) {
290 <                        if ((fin2 = fopen(argv[i+1], "r")) == NULL) {
289 >                if (reverse & (putprim != BRIGHT ) & (i == argc-3)) {
290 >                        if ((fin2 = fopen(argv[i+1], inpmode)) == NULL) {
291                                  fprintf(stderr, "%s: can't open file \"%s\"\n",
292                                                  progname, argv[i+1]);
293                                  quit(1);
294                          }
295 <                        if ((fin3 = fopen(argv[i+2], "r")) == NULL) {
295 >                        if ((fin3 = fopen(argv[i+2], inpmode)) == NULL) {
296                                  fprintf(stderr, "%s: can't open file \"%s\"\n",
297                                                  progname, argv[i+2]);
298                                  quit(1);
# Line 278 | Line 300 | unkopt:
300                          interleave = -1;
301                  } else if (i != argc-1)
302                          fin = NULL;
303 <                if (reverse && putprim != BRIGHT && !interleave) {
304 <                        fin2 = fopen(argv[i], "r");
305 <                        fin3 = fopen(argv[i], "r");
303 >                if (reverse & (putprim != BRIGHT) & !interleave) {
304 >                        fin2 = fopen(argv[i], inpmode);
305 >                        fin3 = fopen(argv[i], inpmode);
306                  }
307 <                if (skipbytes && (fseek(fin, skipbytes, 0) || (fin2 != NULL &&
308 <                                (fseek(fin2, skipbytes, 0) ||
309 <                                fseek(fin3, skipbytes, 0))))) {
307 >                if (skipbytes && (fseek(fin, skipbytes, SEEK_SET) || (fin2 != NULL &&
308 >                                fseek(fin2, skipbytes, SEEK_SET) |
309 >                                fseek(fin3, skipbytes, SEEK_SET)))) {
310                          fprintf(stderr, "%s: cannot skip %ld bytes on input\n",
311                                          progname, skipbytes);
312                          quit(1);
# Line 294 | Line 316 | unkopt:
316                  fprintf(stderr, "%s: bad # file arguments\n", progname);
317                  quit(1);
318          }
297 –
319          if (reverse) {
299 – #if defined(_WIN32) || defined(_WIN64)
320                  SET_FILE_BINARY(stdout);
301 –                if (format != 'a' && format != 'i')
302 –                        SET_FILE_BINARY(fin);
303 – #endif
321                                          /* get header */
322                  if (header) {
323 <                        if (checkheader(fin, fmtid, stdout) < 0) {
324 <                                fprintf(stderr, "%s: wrong input format\n",
325 <                                                progname);
323 >                        getheader(fin, checkhead, stdout);
324 >                        if (wrongformat) {
325 >                                fprintf(stderr, "%s: wrong input format (expected %s)\n",
326 >                                                progname, fmtid);
327                                  quit(1);
328                          }
329                          if (fin2 != NULL) {
330                                  getheader(fin2, NULL, NULL);
331                                  getheader(fin3, NULL, NULL);
332                          }
333 <                } else
333 >                        resolution &= (picres.xr <= 0) | (picres.yr <= 0);
334 >                } else {
335                          newheader("RADIANCE", stdout);
336 +                }
337                                          /* get resolution */
338                  if ((resolution && !fgetsresolu(&picres, fin)) ||
339 <                                picres.xr <= 0 || picres.yr <= 0) {
339 >                                (picres.xr <= 0) | (picres.yr <= 0)) {
340                          fprintf(stderr, "%s: missing resolution\n", progname);
341                          quit(1);
342                  }
343                  if (resolution && fin2 != NULL) {
344                          RESOLU  pres2;
345                          if (!fgetsresolu(&pres2, fin2) ||
346 <                                        pres2.rt != picres.rt ||
347 <                                        pres2.xr != picres.xr ||
348 <                                        pres2.yr != picres.yr ||
346 >                                        (pres2.rt != picres.rt) |
347 >                                        (pres2.xr != picres.xr) |
348 >                                        (pres2.yr != picres.yr) ||
349                                          !fgetsresolu(&pres2, fin3) ||
350 <                                        pres2.rt != picres.rt ||
351 <                                        pres2.xr != picres.xr ||
352 <                                        pres2.yr != picres.yr) {
350 >                                        (pres2.rt != picres.rt) |
351 >                                        (pres2.xr != picres.xr) |
352 >                                        (pres2.yr != picres.yr)) {
353                                  fprintf(stderr, "%s: resolution mismatch\n",
354                                                  progname);
355                                  quit(1);
# Line 337 | Line 357 | unkopt:
357                  }
358                                                  /* add to header */
359                  printargs(i, argv, stdout);
360 <                if (expval < .99 || expval > 1.01)
360 >                if ((expval < .99) | (expval > 1.01))
361                          fputexpos(expval, stdout);
362 +                if (!header & (putprim != ALL)) {
363 +                        NCSAMP = 1;             /* no header, so trust user */
364 +                } else if (NCSAMP == 1) {
365 +                        if (putprim == ALL)
366 +                                putprim = BRIGHT;
367 +                } else {
368 +                        if (NCSAMP != 3) {
369 +                                fprintf(stderr, "%s: input NCOMP must be 1 or 3\n",
370 +                                                progname);
371 +                                quit(1);
372 +                        }
373 +                        if (putprim != ALL) {
374 +                                fprintf(stderr, "%s: NCOMP mismatch\n", progname);
375 +                                quit(1);
376 +                        }
377 +                }
378                  if (outprims != NULL) {
379                          if (outprims != stdprims)
380                                  fputprims(outprims, stdout);
381                          fputformat(COLRFMT, stdout);
382 <                } else                          /* XYZ data */
382 >                } else {                        /* XYZ data */
383 >                        if (original < 0) {
384 >                                scalecolor(exposure, WHTEFFICACY);
385 >                                doexposure++;
386 >                        }
387                          fputformat(CIEFMT, stdout);
388 +                }
389                  putchar('\n');
390                  fputsresolu(&picres, stdout);   /* always put resolution */
391                  valtopix();
392          } else {
393 < #if defined(_WIN32) || defined(_WIN64)
353 <                SET_FILE_BINARY(fin);
354 <                if (format != 'a' && format != 'i')
393 >                if ((format != 'a') & (format != 'i'))
394                          SET_FILE_BINARY(stdout);
356 – #endif
395                                                  /* get header */
396 <                getheader(fin, checkhead, NULL);
396 >                picres.rt = PIXSTANDARD;
397 >                picres.xr = picres.yr = 0;
398 >                getheader(fin, checkhead, header ? stdout : (FILE *)NULL);
399                  if (wrongformat) {
400                          fprintf(stderr,
401                                  "%s: input not a Radiance RGBE picture\n",
402                                          progname);
403                          quit(1);
404                  }
405 <                if (!fgetsresolu(&picres, fin)) {
405 >                if ((picres.xr <= 0) | (picres.yr <= 0) &&
406 >                                !fgetsresolu(&picres, fin)) {
407                          fprintf(stderr, "%s: missing resolution\n", progname);
408                          quit(1);
409                  }
410 +                if ((original < 0) & (mybright == &xyz_bright)) {
411 +                        scalecolor(exposure, 1./WHTEFFICACY);
412 +                        doexposure++;
413 +                }
414                  if (header) {
415                          printargs(i, argv, stdout);
416 <                        if (expval < .99 || expval > 1.01)
416 >                        if (dataonly)
417 >                                printf("%s%c\n", NCOMPSTR, "13"[putprim==ALL]);
418 >                        if (dataonly && !resolution & !uniq)
419 >                                printf("NCOLS=%d\nNROWS=%d\n", scanlen(&picres),
420 >                                                numscans(&picres));
421 >                        if ((expval < .99) | (expval > 1.01))
422                                  fputexpos(expval, stdout);
423 +                        if (swapbytes) {
424 +                                if (nativebigendian())
425 +                                        puts("BigEndian=0");
426 +                                else
427 +                                        puts("BigEndian=1");
428 +                        } else if ((format != 'a') & (format != 'i') &
429 +                                                (format != 'b'))
430 +                                fputendian(stdout);
431                          fputformat(fmtid, stdout);
432                          putchar('\n');
433                  }
# Line 384 | Line 442 | unkopt:
442  
443  
444   static int
445 + IDformat(const char *s)
446 + {
447 +        if (!s || !*s) return(0);
448 +        if (!strcmp(s, "ascii")) return('a');
449 +        if (!strcmp(s, "float")) return('f');
450 +        if (!strcmp(s, "double")) return('d');
451 +        if (!strcmp(s, "byte")) return('b');
452 +        if (!strcmp(s, "16-bit")) return('w');
453 +        return(0);
454 + }
455 +
456 +
457 + static int
458   checkhead(                              /* deal with line from header */
459          char    *line,
460          void    *p
461   )
462   {
463 <        char    fmt[MAXFMTLEN];
463 >        static char     fmt[MAXFMTLEN];
464 >        FILE    *fout = (FILE *)p;
465          double  d;
466          COLOR   ctmp;
467 +        int     rv;
468  
469          if (formatval(fmt, line)) {
470 <                if (!strcmp(fmt, CIEFMT))
470 >                if (reverse) {
471 >                        if (format == 'a') {
472 >                                format = IDformat(fmt);
473 >                                if (format)
474 >                                        fmtid = fmt;
475 >                                else
476 >                                        wrongformat = 1;
477 >                        } else
478 >                                wrongformat = strcmp(fmt, fmtid);
479 >                } else if (!strcmp(fmt, CIEFMT))
480                          mybright = &xyz_bright;
481 <                else if (!strcmp(fmt, COLRFMT))
481 >                else if (!strcmp(fmt, COLRFMT) || !strcmp(fmt, SPECFMT))
482                          mybright = &rgb_bright;
483                  else
484 <                        wrongformat++;
485 <        } else if (original && isexpos(line)) {
484 >                        wrongformat = 1;
485 >                return(1);
486 >        }
487 >        if (!strncmp(line,"NROWS=",6)) {
488 >                picres.yr = atoi(line+6);
489 >                return(1);
490 >        }
491 >        if (!strncmp(line,"NCOLS=",6)) {
492 >                picres.xr = atoi(line+6);
493 >                return(1);
494 >        }
495 >        if (isncomp(line)) {
496 >                NCSAMP = ncompval(line);
497 >                dataonly |= reverse;    /* pretty safe assumption */
498 >                return(1);
499 >        }
500 >        if (iswlsplit(line)) {
501 >                wlsplitval(WLPART, line);
502 >                return(1);
503 >        }
504 >        if (original && isexpos(line)) {
505                  d = 1.0/exposval(line);
506                  scalecolor(exposure, d);
507                  doexposure++;
508 <        } else if (original && iscolcor(line)) {
508 >                return(1);
509 >        }
510 >        if (original && iscolcor(line)) {
511                  colcorval(ctmp, line);
512                  setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
513                                  colval(exposure,GRN)/colval(ctmp,GRN),
514                                  colval(exposure,BLU)/colval(ctmp,BLU));
515                  doexposure++;
516 <        } else if (header)
517 <                fputs(line, stdout);
516 >                return(1);
517 >        }
518 >        if ((rv = isbigendian(line)) >= 0) {
519 >                if (reverse)
520 >                        swapbytes = (nativebigendian() != rv);
521 >                return(1);
522 >        }
523 >        if (fout != NULL)
524 >                fputs(line, fout);
525          return(0);
526   }
527  
# Line 433 | Line 543 | pixtoval(void)                         /* convert picture to values */
543                  quit(1);
544          }
545          dogamma = gamcor < .95 || gamcor > 1.05;
546 <        if (putprim == ALL && !interleave) {
546 >        if ((putprim == ALL) & !interleave) {
547                  startprim = RED; endprim = BLU;
548                  startpos = ftell(fin);
549          } else {
550                  startprim = putprim; endprim = putprim;
551          }
552          for (putprim = startprim; putprim <= endprim; putprim++) {
553 <                if (putprim != startprim && fseek(fin, startpos, 0)) {
553 >                if (putprim != startprim && fseek(fin, startpos, SEEK_SET)) {
554                          fprintf(stderr, "%s: seek error on input file\n",
555                                          progname);
556                          quit(1);
# Line 448 | Line 558 | pixtoval(void)                         /* convert picture to values */
558                  set_io();
559                  setcolor(lastc, 0.0, 0.0, 0.0);
560                  for (y = 0; y < numscans(&picres); y++) {
561 <                        if (freadscan(scanln, scanlen(&picres), fin) < 0) {
561 >                        if (fread2scan(scanln, scanlen(&picres), fin,
562 >                                                NCSAMP, WLPART) < 0) {
563                                  fprintf(stderr, "%s: read error\n", progname);
564                                  quit(1);
565                          }
# Line 1101 | Line 1212 | set_io(void)                   /* set put and get functions */
1212                                  if (fin2 == NULL)
1213                                          goto namerr;
1214                                  if (fseek(fin2,
1215 <                                (long)sizeof(float)*picres.xr*picres.yr, 1))
1215 >                                (long)sizeof(float)*picres.xr*picres.yr, SEEK_CUR))
1216                                          goto seekerr;
1217                                  if (fseek(fin3,
1218 <                                (long)sizeof(float)*2*picres.xr*picres.yr, 1))
1218 >                                (long)sizeof(float)*2*picres.xr*picres.yr, SEEK_CUR))
1219                                          goto seekerr;
1220                          }
1221                  }
# Line 1123 | Line 1234 | set_io(void)                   /* set put and get functions */
1234                                  if (fin2 == NULL)
1235                                          goto namerr;
1236                                  if (fseek(fin2,
1237 <                                (long)sizeof(double)*picres.xr*picres.yr, 1))
1237 >                                (long)sizeof(double)*picres.xr*picres.yr, SEEK_CUR))
1238                                          goto seekerr;
1239                                  if (fseek(fin3,
1240 <                                (long)sizeof(double)*2*picres.xr*picres.yr, 1))
1240 >                                (long)sizeof(double)*2*picres.xr*picres.yr, SEEK_CUR))
1241                                          goto seekerr;
1242                          }
1243                  }
# Line 1163 | Line 1274 | set_io(void)                   /* set put and get functions */
1274                                  if (fin2 == NULL)
1275                                          goto namerr;
1276                                  if (fseek(fin2,
1277 <                                (long)sizeof(uby8)*picres.xr*picres.yr, 1))
1277 >                                (long)sizeof(uby8)*picres.xr*picres.yr, SEEK_CUR))
1278                                          goto seekerr;
1279                                  if (fseek(fin3,
1280 <                                (long)sizeof(uby8)*2*picres.xr*picres.yr, 1))
1280 >                                (long)sizeof(uby8)*2*picres.xr*picres.yr, SEEK_CUR))
1281                                          goto seekerr;
1282                          }
1283                  }
# Line 1185 | Line 1296 | set_io(void)                   /* set put and get functions */
1296                                  if (fin2 == NULL)
1297                                          goto namerr;
1298                                  if (fseek(fin2,
1299 <                                (long)sizeof(uint16)*picres.xr*picres.yr, 1))
1299 >                                (long)sizeof(uint16)*picres.xr*picres.yr, SEEK_CUR))
1300                                          goto seekerr;
1301                                  if (fseek(fin3,
1302 <                                (long)sizeof(uint16)*2*picres.xr*picres.yr, 1))
1302 >                                (long)sizeof(uint16)*2*picres.xr*picres.yr, SEEK_CUR))
1303                                          goto seekerr;
1304                          }
1305                  }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines