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

Comparing ray/src/px/pcomb.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:49:22 1989 UTC vs.
Revision 1.14 by greg, Thu May 23 13:46:05 1991 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1989 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 18 | Line 18 | static char SCCSid[] = "$SunId$ LBL";
18  
19   #include "calcomp.h"
20  
21 < #define MAXINP          16              /* maximum number of input files */
21 > #define MAXINP          32              /* maximum number of input files */
22 > #define WINSIZ          9               /* scanline window size */
23 > #define MIDSCN          4               /* current scan position */
24  
25 + #define BRT             (-1)            /* special index for brightness */
26 +
27   struct {
28          char    *name;          /* file name */
29          FILE    *fp;            /* stream pointer */
30 <        COLOR   *scan;          /* input scanline */
30 >        COLOR   *scan[WINSIZ];  /* input scanline window */
31 >        COLOR   coef;           /* coefficient */
32   }       input[MAXINP];                  /* input pictures */
33  
34   int     nfiles;                         /* number of input files */
35  
36   char    *vcolin[3] = {"ri", "gi", "bi"};
37   char    *vcolout[3] = {"ro", "go", "bo"};
38 + #define vbrtin          "li"
39 + #define vbrtout         "lo"
40  
41 + #define vnfiles         "nfiles"
42 + #define vxres           "xres"
43 + #define vyres           "yres"
44   #define vxpos           "x"
45   #define vypos           "y"
46  
47   int     nowarn = 0;                     /* no warning messages? */
48  
49 + int     original = 0;                   /* origninal values? */
50 +
51   int     xres=0, yres=0;                 /* picture resolution */
52  
53   int     xpos, ypos;                     /* picture position */
54  
55 + int     wrongformat = 0;
56  
57 +
58   tputs(s)                        /* put out string preceded by a tab */
59   char    *s;
60   {
61 <        putchar('\t');
62 <        fputs(s, stdout);
61 >        char    fmt[32];
62 >        double  d;
63 >        COLOR   ctmp;
64 >
65 >        if (isformat(s)) {                      /* check format */
66 >                formatval(fmt, s);
67 >                wrongformat = strcmp(fmt, COLRFMT);
68 >        } else if (original && isexpos(s)) {    /* exposure */
69 >                d = 1.0/exposval(s);
70 >                scalecolor(input[nfiles].coef, d);
71 >        } else if (original && iscolcor(s)) {   /* color correction */
72 >                colcorval(ctmp, s);
73 >                colval(input[nfiles].coef,RED) /= colval(ctmp,RED);
74 >                colval(input[nfiles].coef,GRN) /= colval(ctmp,GRN);
75 >                colval(input[nfiles].coef,BLU) /= colval(ctmp,BLU);
76 >        } else {                                /* echo unaffected line */
77 >                putchar('\t');
78 >                fputs(s, stdout);
79 >        }
80 >
81   }
82  
83  
# Line 53 | Line 85 | main(argc, argv)
85   int     argc;
86   char    *argv[];
87   {
88 <        extern double   l_redin(), l_grnin(), l_bluin();
89 <        int     a;
88 >        extern double   l_redin(), l_grnin(), l_bluin(), l_brtin(), atof();
89 >        double  f;
90 >        int     a, i;
91          
92 <        funset(vcolin[RED], 1, l_redin);
93 <        funset(vcolin[GRN], 1, l_grnin);
94 <        funset(vcolin[BLU], 1, l_bluin);
92 >        funset(vcolin[RED], 1, '=', l_redin);
93 >        funset(vcolin[GRN], 1, '=', l_grnin);
94 >        funset(vcolin[BLU], 1, '=', l_bluin);
95 >        funset(vbrtin, 1, '=', l_brtin);
96          
97          for (a = 1; a < argc; a++)
98                  if (argv[a][0] == '-')
99                          switch (argv[a][1]) {
100                          case '\0':
101 +                        case 's':
102 +                        case 'c':
103                                  goto getfiles;
104                          case 'x':
105                                  xres = atoi(argv[++a]);
# Line 74 | Line 110 | char   *argv[];
110                          case 'w':
111                                  nowarn = !nowarn;
112                                  break;
113 +                        case 'o':
114 +                                original = !original;
115 +                                break;
116                          case 'f':
117                                  fcompile(argv[++a]);
118                                  break;
119                          case 'e':
120 <                                scompile(NULL, argv[++a]);
120 >                                scompile(argv[++a], NULL, 0);
121                                  break;
122                          default:
123 <                                eputs("Usage: ");
85 <                                eputs(argv[0]);
86 <        eputs(" [-w][-x xres][-y yres][-e expr][-f file] [picture ..]\n");
87 <                                quit(1);
123 >                                goto usage;
124                          }
125                  else
126                          break;
127   getfiles:
128 +        for (nfiles = 0; nfiles < MAXINP; nfiles++)
129 +                setcolor(input[nfiles].coef, 1.0, 1.0, 1.0);
130          nfiles = 0;
131          for ( ; a < argc; a++) {
132                  if (nfiles >= MAXINP) {
# Line 96 | Line 134 | getfiles:
134                          eputs(": too many picture files\n");
135                          quit(1);
136                  }
137 <                if (argv[a][0] == '-') {
138 <                        input[nfiles].name = "<stdin>";
139 <                        input[nfiles].fp = stdin;
140 <                } else {
137 >                if (argv[a][0] == '-')
138 >                        switch (argv[a][1]) {
139 >                        case '\0':
140 >                                input[nfiles].name = "<stdin>";
141 >                                input[nfiles].fp = stdin;
142 >                                break;
143 >                        case 's':
144 >                                f = atof(argv[++a]);
145 >                                scalecolor(input[nfiles].coef, f);
146 >                                continue;
147 >                        case 'c':
148 >                                colval(input[nfiles].coef,RED)*=atof(argv[++a]);
149 >                                colval(input[nfiles].coef,GRN)*=atof(argv[++a]);
150 >                                colval(input[nfiles].coef,BLU)*=atof(argv[++a]);
151 >                                continue;
152 >                        default:
153 >                                goto usage;
154 >                        }
155 >                else {
156                          input[nfiles].name = argv[a];
157                          input[nfiles].fp = fopen(argv[a], "r");
158                          if (input[nfiles].fp == NULL) {
159 <                                eputs(argv[a]);
107 <                                eputs(": cannot open\n");
159 >                                perror(argv[a]);
160                                  quit(1);
161                          }
162                  }
163                  fputs(input[nfiles].name, stdout);
164                  fputs(":\n", stdout);
165 <                getheader(input[nfiles].fp, tputs);
166 <                if (fscanf(input[nfiles].fp, "-Y %d +X %d\n", &ypos, &xpos) != 2) {
165 >                getheader(input[nfiles].fp, tputs, NULL);
166 >                if (wrongformat) {
167                          eputs(input[nfiles].name);
168 +                        eputs(": not in Radiance picture format\n");
169 +                        quit(1);
170 +                }
171 +                if (fgetresolu(&xpos, &ypos, input[nfiles].fp) !=
172 +                                (YMAJOR|YDECR)) {
173 +                        eputs(input[nfiles].name);
174                          eputs(": bad picture size\n");
175                          quit(1);
176                  }
# Line 124 | Line 182 | getfiles:
182                          eputs(": resolution mismatch\n");
183                          quit(1);
184                  }
185 <                input[nfiles].scan = (COLOR *)emalloc(xres*sizeof(COLOR));
185 >                for (i = 0; i < WINSIZ; i++)
186 >                        input[nfiles].scan[i] =
187 >                                        (COLOR *)emalloc(xres*sizeof(COLOR));
188                  nfiles++;
189          }
190          printargs(argc, argv, stdout);
191 +        fputformat(COLRFMT, stdout);
192          putchar('\n');
193 <        printf("-Y %d +X %d\n", yres, xres);
193 >        fputresolu(YMAJOR|YDECR, xres, yres, stdout);
194          combine();
195          quit(0);
196 + usage:
197 +        eputs("Usage: ");
198 +        eputs(argv[0]);
199 +        eputs(
200 + " [-w][-h][-x xr][-y yr][-e expr][-f file] [ [-s f][-c r g b] pic ..]\n");
201 +        quit(1);
202   }
203  
204  
205   combine()                       /* combine pictures */
206   {
207 <        int     coldef[3];
207 >        EPNODE  *coldef[3], *brtdef;
208          COLOR   *scanout;
209 +        double  d;
210          register int    i, j;
211                                                  /* check defined variables */
212 <        for (j = 0; j < 3; j++)
213 <                coldef[j] = vardefined(vcolout[j]);
212 >        for (j = 0; j < 3; j++) {
213 >                if (vardefined(vcolout[j]))
214 >                        coldef[j] = eparse(vcolout[j]);
215 >                else
216 >                        coldef[j] = NULL;
217 >        }
218 >        if (vardefined(vbrtout))
219 >                brtdef = eparse(vbrtout);
220 >        else
221 >                brtdef = NULL;
222 >                                                /* define constants */
223 >        varset(vnfiles, ':', (double)nfiles);
224 >        varset(vxres, ':', (double)xres);
225 >        varset(vyres, ':', (double)yres);
226                                                  /* allocate scanline */
227          scanout = (COLOR *)emalloc(xres*sizeof(COLOR));
228 +                                                /* initialize input */
229 +        initinp();
230                                                  /* combine files */
231          for (ypos = yres-1; ypos >= 0; ypos--) {
232 <                for (i = 0; i < nfiles; i++)
233 <                        if (freadscan(input[i].scan, xres, input[i].fp) < 0) {
234 <                                eputs(input[i].name);
235 <                                eputs(": read error\n");
236 <                                quit(1);
232 >            advance();
233 >            varset(vypos, '=', (double)ypos);
234 >            for (xpos = 0; xpos < xres; xpos++) {
235 >                varset(vxpos, '=', (double)xpos);
236 >                eclock++;
237 >                if (brtdef != NULL) {
238 >                    d = evalue(brtdef);
239 >                    if (d < 0.0)
240 >                        d = 0.0;
241 >                    setcolor(scanout[xpos], d, d, d);
242 >                } else {
243 >                    for (j = 0; j < 3; j++) {
244 >                        if (coldef[j] != NULL) {
245 >                                d = evalue(coldef[j]);
246 >                        } else {
247 >                            d = 0.0;
248 >                            for (i = 0; i < nfiles; i++)
249 >                                d += colval(input[i].scan[MIDSCN][xpos],j);
250                          }
251 <                varset(vypos, (double)ypos);
252 <                for (xpos = 0; xpos < xres; xpos++) {
253 <                        varset(vxpos, (double)xpos);
254 <                        eclock++;
160 <                        for (j = 0; j < 3; j++)
161 <                                if (coldef[j]) {
162 <                                        colval(scanout[xpos],j) = varvalue(vcolout[j]);
163 <                                        if (colval(scanout[xpos],j) < 0.0)
164 <                                                colval(scanout[xpos],j) = 0.0;
165 <                                } else {
166 <                                        colval(scanout[xpos],j) = 0.0;
167 <                                        for (i = 0; i < nfiles; i++)
168 <                                                colval(scanout[xpos],j) += colval(input[i].scan[xpos],j);
169 <                                        colval(scanout[xpos],j) /= (double)nfiles;
170 <                                }
251 >                        if (d < 0.0)
252 >                            d = 0.0;
253 >                        colval(scanout[xpos],j) = d;
254 >                    }
255                  }
256 <                if (fwritescan(scanout, xres, stdout) < 0) {
257 <                        eputs("write error\n");
256 >            }
257 >            if (fwritescan(scanout, xres, stdout) < 0) {
258 >                    perror("write error");
259 >                    quit(1);
260 >            }
261 >        }
262 >        efree(scanout);
263 > }
264 >
265 >
266 > initinp()                       /* initilize scan windows */
267 > {
268 >        for (ypos = yres+(MIDSCN-1); ypos >= yres; ypos--)
269 >                advance();
270 > }
271 >
272 >
273 > advance()                       /* read in next scanline */
274 > {
275 >        register COLOR  *st;
276 >        register int    i, j;
277 >
278 >        for (i = 0; i < nfiles; i++) {
279 >                st = input[i].scan[WINSIZ-1];
280 >                for (j = WINSIZ-1; j > 0; j--)  /* rotate window */
281 >                        input[i].scan[j] = input[i].scan[j-1];
282 >                input[i].scan[0] = st;
283 >                if (ypos < MIDSCN)              /* hit bottom */
284 >                        continue;
285 >                if (freadscan(st, xres, input[i].fp) < 0) {
286 >                        eputs(input[i].name);
287 >                        eputs(": read error\n");
288                          quit(1);
289                  }
290 +                for (j = 0; j < xres; j++)      /* adjust color */
291 +                        multcolor(st[j], input[i].coef);
292          }
177 –        efree(scanout);
293   }
294  
295  
296   double
297 < colin(fn, ci)                   /* return color value for picture */
298 < register int    fn, ci;
297 > colin(ci)                       /* return color value for picture */
298 > register int    ci;
299   {
300 <        if (fn == 0)
301 <                return((double)nfiles);
302 <        if (fn < 1 || fn > nfiles) {
300 >        int     n, fn;
301 >        register int    xoff, yoff;
302 >        double  d;
303 >
304 >        fn = (d = argument(1)) - .5;
305 >        if (d <= -.5 || fn >= nfiles) {
306                  errno = EDOM;
307                  return(0.0);
308          }
309 <        return(colval(input[fn-1].scan[xpos],ci));
309 >        if (d < .5)
310 >                return((double)nfiles);
311 >        xoff = yoff = 0;
312 >        n = nargum();
313 >        if (n >= 2) {
314 >                d = argument(2);
315 >                if (d < 0.0) {
316 >                        xoff = d-.5;
317 >                        if (xpos+xoff < 0)
318 >                                xoff = -xpos;
319 >                } else {
320 >                        xoff = d+.5;
321 >                        if (xpos+xoff >= xres)
322 >                                xoff = xres-1-xpos;
323 >                }
324 >        }
325 >        if (n >= 3) {
326 >                d = argument(3);
327 >                if (d < 0.0) {
328 >                        yoff = d-.5;
329 >                        if (yoff+MIDSCN < 0)
330 >                                yoff = -MIDSCN;
331 >                        if (ypos+yoff < 0)
332 >                                yoff = -ypos;
333 >                } else {
334 >                        yoff = d+.5;
335 >                        if (yoff+MIDSCN >= WINSIZ)
336 >                                yoff = WINSIZ-1-MIDSCN;
337 >                        if (ypos+yoff >= yres)
338 >                                yoff = yres-1-ypos;
339 >                }
340 >        }
341 >        if (ci == BRT)
342 >                return(bright(input[fn].scan[MIDSCN+yoff][xpos+xoff]));
343 >        return(colval(input[fn].scan[MIDSCN+yoff][xpos+xoff],ci));
344   }
345  
346  
347   double
348   l_redin()                       /* get red color */
349   {
350 <        return(colin((int)(argument(1)+.5), RED));
350 >        return(colin(RED));
351   }
352  
353  
354   double
355   l_grnin()                       /* get green color */
356   {
357 <        return(colin((int)(argument(1)+.5), GRN));
357 >        return(colin(GRN));
358   }
359  
360  
361   double
362   l_bluin()                       /* get blue color */
363   {
364 <        return(colin((int)(argument(1)+.5), BLU));
364 >        return(colin(BLU));
365 > }
366 >
367 >
368 > double
369 > l_brtin()                       /* get brightness value */
370 > {
371 >        return(colin(BRT));
372   }
373  
374  

Diff Legend

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