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

Comparing ray/src/px/pfilt.c (file contents):
Revision 1.3 by greg, Tue Apr 11 21:39:00 1989 UTC vs.
Revision 2.3 by greg, Tue Sep 8 15:33:08 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1991 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 16 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16  
17   #include  "color.h"
18  
19 + #include  "resolu.h"
20  
21 + #include  "paths.h"
22 +
23   extern char  *malloc();
24 + extern float  *matchlamp();
25  
26 + #define  FEQ(a,b)       ((a) >= .98*(b) && (a) <= 1.02*(b))
27 +
28   #define  CHECKRAD       1.5     /* radius to check for filtering */
29  
30   COLOR  exposure = WHTCOLOR;     /* exposure for the frame */
# Line 28 | Line 34 | double  rad = 0.0;             /* output pixel radius for filteri
34   int  nrows = 0;                 /* number of rows for output */
35   int  ncols = 0;                 /* number of columns for output */
36  
37 < double  xrat = 1.0;             /* ratio of input x size to output */
38 < double  yrat = 1.0;             /* ratio of input y size to output */
37 > double  x_c = 1.0;              /* ratio of output x size to input */
38 > double  y_r = 1.0;              /* ratio of output y size to input */
39  
40   int  singlepass = 0;            /* true means skip first pass */
41  
# Line 41 | Line 47 | int  npts = 0;                 /* (half) number of points for stars
47  
48   double  spread = 1e-4;          /* spread for star points */
49  
44 – #define  TEMPLATE       "/usr/tmp/pfXXXXXX"
45 –
50   char  *tfname = NULL;
51  
52 + char  *lampdat = "lamp.tab";    /* lamp data file */
53 +
54 + int  order;                     /* scanline ordering of input */
55   int  xres, yres;                /* resolution of input */
56 + double  inpaspect = 1.0;        /* pixel aspect ratio of input */
57 + int  correctaspect = 0;         /* aspect ratio correction? */
58  
59 < double  x_c, y_r;               /* conversion factors */
59 > int  wrongformat = 0;
60  
61   int  xrad;                      /* x window size */
62   int  yrad;                      /* y window size */
# Line 63 | Line 72 | main(argc, argv)
72   int  argc;
73   char  **argv;
74   {
75 <        extern char  *mktemp();
67 <        extern double  atof(), pow();
75 >        extern double  pow();
76          extern long  ftell();
77 <        extern int  quit();
77 >        extern int  quit(), headline();
78          FILE  *fin;
79 +        float  *lampcolor;
80 +        char  *lamptype = NULL;
81          long  fpos;
82 +        double  outaspect = 0.0;
83          double  d;
84 <        int  i;
84 >        int  i, j;
85  
86          if (signal(SIGINT, quit) == SIG_IGN)
87                  signal(SIGINT, SIG_IGN);
# Line 90 | Line 101 | char  **argv;
101                          switch (argv[i][1]) {
102                          case 'x':
103                                  i++;
104 <                                if (argv[i][0] == '/')
105 <                                        xrat = atof(argv[i]+1);
106 <                                else
104 >                                if (argv[i][0] == '/') {
105 >                                        x_c = 1.0/atof(argv[i]+1);
106 >                                        ncols = 0;
107 >                                } else
108                                          ncols = atoi(argv[i]);
109                                  break;
110                          case 'y':
111                                  i++;
112 <                                if (argv[i][0] == '/')
113 <                                        yrat = atof(argv[i]+1);
114 <                                else
112 >                                if (argv[i][0] == '/') {
113 >                                        y_r = 1.0/atof(argv[i]+1);
114 >                                        nrows = 0;
115 >                                } else
116                                          nrows = atoi(argv[i]);
117                                  break;
118 +                        case 'c':
119 +                                correctaspect = !correctaspect;
120 +                                break;
121 +                        case 'p':
122 +                                i++;
123 +                                outaspect = atof(argv[i]);
124 +                                break;
125                          case 'e':
126                                  if (argv[i+1][0] == '+' || argv[i+1][0] == '-')
127                                          d = pow(2.0, atof(argv[i+1]));
128                                  else
129                                          d = atof(argv[i+1]);
130 +                                if (d < 1e-20 || d > 1e20) {
131 +                                        fprintf(stderr,
132 +                                                "%s: exposure out of range\n",
133 +                                                        argv[0]);
134 +                                        exit(1);
135 +                                }
136                                  switch (argv[i][2]) {
137                                  case '\0':
138                                          scalecolor(exposure, d);
# Line 125 | Line 151 | char  **argv;
151                                  }
152                                  i++;
153                                  break;
154 +                        case 'f':
155 +                                lampdat = argv[++i];
156 +                                break;
157 +                        case 't':
158 +                                lamptype = argv[++i];
159 +                                break;
160                          case '1':
161                                  singlepass = 1;
162                                  break;
163 <                        case 'p':
163 >                        case '2':
164 >                                singlepass = 0;
165 >                                break;
166 >                        case 'n':
167                                  npts = atoi(argv[++i]) / 2;
168                                  break;
169                          case 's':
# Line 155 | Line 190 | char  **argv;
190                          }
191                  else
192                          break;
193 <                        
193 >                                        /* get lamp data (if necessary) */
194 >        if (lamptype != NULL) {
195 >                if (loadlamps(lampdat) < 0)
196 >                        quit(1);
197 >                if ((lampcolor = matchlamp(lamptype)) == NULL) {
198 >                        fprintf(stderr, "%s: unknown lamp type\n", lamptype);
199 >                        quit(1);
200 >                }
201 >                for (i = 0; i < 3; i++)
202 >                        if (lampcolor[i] > 1e-4)
203 >                                colval(exposure,i) /= lampcolor[i];
204 >                freelamps();
205 >        }
206 >                                        /* open input file */
207          if (i == argc) {
208                  if (singlepass)
209                          fin = stdin;
# Line 182 | Line 230 | char  **argv;
230                  fprintf(stderr, "%s: bad # file arguments\n", progname);
231                  quit(1);
232          }
233 <                                        /* copy header */
234 <        copyheader(fin, stdout);
233 >                                        /* get header */
234 >        getheader(fin, headline, NULL);
235 >        if (wrongformat) {
236 >                fprintf(stderr, "%s: input must be a Radiance picture\n",
237 >                                progname);
238 >                quit(1);
239 >        }
240                                          /* add new header info. */
241          printargs(i, argv, stdout);
242                                          /* get picture size */
243 <        if (fscanf(fin, "-Y %d +X %d\n", &yres, &xres) != 2) {
243 >        if ((order = fgetresolu(&xres, &yres, fin)) < 0) {
244                  fprintf(stderr, "%s: bad picture size\n", progname);
245                  quit(1);
246          }
247 <        if (ncols > 0)
248 <                xrat = (double)xres/ncols;
249 <        else
250 <                ncols = xres/xrat + .5;
251 <        if (nrows > 0)
252 <                yrat = (double)yres/nrows;
253 <        else
254 <                nrows = yres/yrat + .5;
247 >        if (!(order & YMAJOR))
248 >                inpaspect = 1.0/inpaspect;
249 >                                        /* compute output resolution */
250 >        if (ncols <= 0)
251 >                ncols = x_c*xres + .5;
252 >        if (nrows <= 0)
253 >                nrows = y_r*yres + .5;
254 >        if (outaspect > .01) {
255 >                d = inpaspect * yres/xres / outaspect;
256 >                if (d * ncols > nrows)
257 >                        ncols = nrows / d;
258 >                else
259 >                        nrows = ncols * d;
260 >        }
261 >        x_c = (double)ncols/xres;
262 >        y_r = (double)nrows/yres;
263  
264 <        if (singlepass) {
204 <                                        /* skip exposure, etc. */
264 >        if (singlepass) {               /* skip exposure, etc. */
265                  pass1default();
266                  pass2(fin);
267                  quit(0);
# Line 221 | Line 281 | char  **argv;
281   }
282  
283  
284 + headline(s)                             /* process line from header */
285 + char  *s;
286 + {
287 +        char  fmt[32];
288 +
289 +        fputs(s, stdout);               /* copy to output */
290 +        if (isaspect(s))                /* get aspect ratio */
291 +                inpaspect *= aspectval(s);
292 +        else if (isformat(s)) {
293 +                formatval(fmt, s);
294 +                wrongformat = strcmp(fmt, COLRFMT);
295 +        }
296 + }
297 +
298 +
299   copyfile(in, out)                       /* copy a file */
300   register FILE  *in, *out;
301   {
# Line 259 | Line 334 | FILE  *in;
334                          fprintf(stderr, "%s: warning - partial frame (%d%%)\n",
335                                          progname, 100*i/yres);
336                          yres = i;
337 +                        y_r = (double)nrows/yres;
338                          break;
339                  }
340                  pass1scan(scan, i);
# Line 304 | Line 380 | FILE  *in;
380                          quit(1);
381                  }
382          }
383 +                                        /* skip leftovers */
384 +        while (yread < yres) {
385 +                if (freadscan(scanin[0], xres, in) < 0)
386 +                        break;
387 +                yread++;
388 +        }
389   }
390  
391  
392   scan2init()                     /* prepare scanline arrays */
393   {
394 <        double  e;
394 >        COLOR   ctmp;
395 >        double  d;
396          register int  i;
397  
315 –        x_c = (double)ncols/xres;
316 –        y_r = (double)nrows/yres;
317 –
398          if (rad <= 0.0) {
399                  xrad = xres/ncols/2 + 1;
400                  yrad = yres/nrows/2 + 1;
# Line 327 | Line 407 | scan2init()                    /* prepare scanline arrays */
407  
408                  initmask();             /* initialize filter table */
409          }
410 <        barsize = 2 * yrad;
410 >        barsize = 2*yrad + 1;
411          scanin = (COLOR **)malloc(barsize*sizeof(COLOR *));
412          for (i = 0; i < barsize; i++) {
413                  scanin[i] = (COLOR *)malloc(xres*sizeof(COLOR));
# Line 341 | Line 421 | scan2init()                    /* prepare scanline arrays */
421                  fprintf(stderr, "%s: out of memory\n", progname);
422                  quit(1);
423          }
424 <        e = bright(exposure);
425 <        if (e < 1-1e-7 || e > 1+1e-7)           /* record exposure */
426 <                printf("EXPOSURE=%e\n", e);
424 >                                        /* record pixel aspect ratio */
425 >        if (!correctaspect) {
426 >                d = order & YMAJOR ? x_c/y_r : y_r/x_c ;
427 >                if (!FEQ(d,1.0))
428 >                        fputaspect(d, stdout);
429 >        }
430 >                                        /* record exposure */
431 >        d = bright(exposure);
432 >        if (!FEQ(d,1.0))
433 >                fputexpos(d, stdout);
434 >                                        /* record color correction */
435 >        copycolor(ctmp, exposure);
436 >        scalecolor(ctmp, 1.0/d);
437 >        if (!FEQ(colval(ctmp,RED),colval(ctmp,GRN)) ||
438 >                        !FEQ(colval(ctmp,GRN),colval(ctmp,BLU)))
439 >                fputcolcor(ctmp, stdout);
440          printf("\n");
441 <        printf("-Y %d +X %d\n", nrows, ncols);  /* write picture size */
441 >                                        /* write out resolution */
442 >        fputresolu(order, ncols, nrows, stdout);
443   }
444  
445  

Diff Legend

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