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

Comparing ray/src/px/ra_bn.c (file contents):
Revision 1.5 by greg, Wed Jun 20 09:17:32 1990 UTC vs.
Revision 2.7 by greg, Sat Feb 22 02:07:27 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  ra_bn.c - program to convert between RADIANCE and barneyscan picture format.
6   *
# Line 12 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9  
10   #include  <stdio.h>
11  
12 + #ifdef MSDOS
13 + #include  <fcntl.h>
14 + #endif
15 +
16 + #include  <time.h>
17 +
18 + #include  <math.h>
19 +
20   #include  "color.h"
21  
22 < extern double  atof(), pow();
22 > #include  "resolu.h"
23  
24 < double  gamma = 2.0;                    /* gamma correction */
24 > double  gamcor = 2.0;                   /* gamma correction */
25  
26 + int  bradj = 0;                         /* brightness adjustment */
27 +
28   char  *progname;
29  
30   char  errmsg[128];
# Line 33 | Line 40 | char  *argv[];
40   {
41          int  reverse = 0;
42          int  i;
43 <        
43 > #ifdef MSDOS
44 >        extern int  _fmode;
45 >        _fmode = O_BINARY;
46 >        setmode(fileno(stdin), O_BINARY);
47 >        setmode(fileno(stdout), O_BINARY);
48 > #endif
49          progname = argv[0];
50  
51          for (i = 1; i < argc; i++)
52                  if (argv[i][0] == '-')
53                          switch (argv[i][1]) {
54                          case 'g':
55 <                                gamma = atof(argv[++i]);
55 >                                gamcor = atof(argv[++i]);
56                                  break;
57                          case 'r':
58                                  reverse = !reverse;
59                                  break;
60 +                        case 'e':
61 +                                if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
62 +                                        goto userr;
63 +                                bradj = atoi(argv[++i]);
64 +                                break;
65                          default:
66                                  goto userr;
67                          }
68                  else
69                          break;
70 +                                                /* set gamma correction */
71 +        setcolrgam(gamcor);
72  
73          if (reverse) {
74                  if (i > argc-1 || i < argc-2)
# Line 66 | Line 85 | char  *argv[];
85                          quiterr(errmsg);
86                  }
87                                          /* put header */
88 +                newheader("RADIANCE", stdout);
89                  printargs(i, argv, rafp);
90 +                fputformat(COLRFMT, rafp);
91                  putc('\n', rafp);
92 <                fputresolu(YMAJOR|YDECR, xmax, ymax, rafp);
92 >                fprtresolu(xmax, ymax, rafp);
93                                          /* convert file */
94                  bn2ra();
95          } else {
# Line 82 | Line 103 | char  *argv[];
103                          quiterr(errmsg);
104                  }
105                                          /* get header */
106 <                getheader(rafp, NULL);
107 <                if (fgetresolu(&xmax, &ymax, rafp) != (YMAJOR|YDECR))
106 >                if (checkheader(rafp, COLRFMT, NULL) < 0 ||
107 >                                fgetresolu(&xmax, &ymax, rafp) < 0)
108                          quiterr("bad RADIANCE format");
109                  if (openbarney(argv[i+1], "w") < 0) {
110                          sprintf(errmsg, "cannot open output \"%s\"", argv[i+1]);
# Line 94 | Line 115 | char  *argv[];
115          }
116          quiterr(NULL);
117   userr:
118 <        fprintf(stderr, "Usage: %s [-g gamma] {input|-} output\n", progname);
98 <        fprintf(stderr, "   or: %s -r [-g gamma] input [output|-]\n",
118 >        fprintf(stderr, "Usage: %s [-g gamma][-e +/-stops] {input|-} output\n",
119                          progname);
120 +        fprintf(stderr, "   or: %s -r [-g gamma][-e +/-stops] input [output|-]\n",
121 +                        progname);
122          exit(1);
123   }
124  
# Line 165 | Line 187 | register FILE  *fp;
187  
188   ra2bn()                                 /* convert radiance to barneyscan */
189   {
190 <        unsigned char   gmap[1024];
191 <        register int    i,k,c;
170 <        register COLOR  *inl;
190 >        register int    i;
191 >        register COLR   *inl;
192          int     j;
193  
194 <        if ((inl = (COLOR *)malloc(xmax*sizeof(COLOR))) == NULL)
194 >        if ((inl = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
195                  quiterr("out of memory");
175 –        for (i = 0; i < 1024; i++)
176 –                gmap[i] = 256.*pow((i+.5)/1024., 1./gamma);
196          for (j = 0; j < ymax; j++) {
197 <                if (freadscan(inl, xmax, rafp) < 0)
197 >                if (freadcolrs(inl, xmax, rafp) < 0)
198                          quiterr("error reading RADIANCE file");
199 <                for (i = 0; i < xmax; i++)
200 <                        for (k = 0; k < 3; k++) {
201 <                                c = 1024.*colval(inl[i],k);
202 <                                if (c >= 1024)
203 <                                        c = 1023;
204 <                                putc(gmap[c], bnfp[k]);
205 <                        }
199 >                if (bradj)
200 >                        shiftcolrs(inl, xmax, bradj);
201 >                colrs_gambs(inl, xmax);
202 >                for (i = 0; i < xmax; i++) {
203 >                        putc(inl[i][RED], bnfp[0]);
204 >                        putc(inl[i][GRN], bnfp[1]);
205 >                        putc(inl[i][BLU], bnfp[2]);
206 >                }
207 >                if (ferror(bnfp[0]) || ferror(bnfp[1]) || ferror(bnfp[2]))
208 >                        quiterr("error writing Barney files");
209          }
210 <        free((char *)inl);
210 >        free((void *)inl);
211   }
212  
213  
214   bn2ra()                                 /* convert barneyscan to radiance */
215   {
216 <        float   gmap[256];
217 <        register int    i,k,c;
196 <        register COLOR  *outline;
216 >        register int    i;
217 >        register COLR   *outline;
218          int     j;
219  
220 <        if ((outline = (COLOR *)malloc(xmax*sizeof(COLOR))) == NULL)
220 >        if ((outline = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
221                  quiterr("out of memory");
201 –        for (i = 0; i < 256; i++)
202 –                gmap[i] = pow((i+.5)/256., gamma);
222          for (j = 0; j < ymax; j++) {
223 <                for (i = 0; i < xmax; i++)
224 <                        for (k = 0; k < 3; k++)
225 <                                if ((c = getc(bnfp[k])) == EOF)
226 <                                        quiterr("error reading barney file");
227 <                                else
228 <                                        colval(outline[i],k) = gmap[c];
229 <                if (fwritescan(outline, xmax, rafp) < 0)
223 >                for (i = 0; i < xmax; i++) {
224 >                        outline[i][RED] = getc(bnfp[0]);
225 >                        outline[i][GRN] = getc(bnfp[1]);
226 >                        outline[i][BLU] = getc(bnfp[2]);
227 >                }
228 >                if (feof(bnfp[0]) || feof(bnfp[1]) || feof(bnfp[2]))
229 >                        quiterr("error reading barney file");
230 >                gambs_colrs(outline, xmax);
231 >                if (bradj)
232 >                        shiftcolrs(outline, xmax, bradj);
233 >                if (fwritecolrs(outline, xmax, rafp) < 0)
234                          quiterr("error writing RADIANCE file");
235          }
236 <        free((char *)outline);
236 >        free((void *)outline);
237   }

Diff Legend

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