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

Comparing ray/src/rt/ambient.c (file contents):
Revision 1.15 by greg, Thu Jun 13 09:41:15 1991 UTC vs.
Revision 2.14 by greg, Tue Nov 3 21:29:52 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1991 Regents of the University of California */
1 > /* Copyright (c) 1992 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 7 | Line 7 | static char SCCSid[] = "$SunId$ LBL";
7   /*
8   *  ambient.c - routines dealing with ambient (inter-reflected) component.
9   *
10 – *  The macro AMBFLUSH (if defined) is the number of ambient values
11 – *      to wait before flushing to the ambient file.
12 – *
10   *     5/9/86
11   */
12  
# Line 23 | Line 20 | static char SCCSid[] = "$SunId$ LBL";
20  
21   #include  "random.h"
22  
23 < #define  OCTSCALE       0.5     /* ceil((valid rad.)/(cube size)) */
23 > #define  OCTSCALE       0.5     /* ceil((valid rad.)/(cube size)) */
24  
25   typedef struct ambtree {
26 <        AMBVAL  *alist;         /* ambient value list */
27 <        struct ambtree  *kid;   /* 8 child nodes */
26 >        AMBVAL  *alist;         /* ambient value list */
27 >        struct ambtree  *kid;   /* 8 child nodes */
28   }  AMBTREE;                     /* ambient octree */
29  
30   extern CUBE  thescene;          /* contains space boundaries */
31  
32 < #define  MAXASET        511     /* maximum number of elements in ambient set */
33 < OBJECT  ambset[MAXASET+1]={0};  /* ambient include/exclude set */
32 > #define  MAXASET        511     /* maximum number of elements in ambient set */
33 > OBJECT  ambset[MAXASET+1]={0};  /* ambient include/exclude set */
34  
35 < double  maxarad;                /* maximum ambient radius */
36 < double  minarad;                /* minimum ambient radius */
35 > double  maxarad;                /* maximum ambient radius */
36 > double  minarad;                /* minimum ambient radius */
37  
38 < static AMBTREE  atrunk;         /* our ambient trunk node */
38 > static AMBTREE  atrunk;         /* our ambient trunk node */
39  
40   static FILE  *ambfp = NULL;     /* ambient file pointer */
41  
42 < #define  newambval()    (AMBVAL *)bmalloc(sizeof(AMBVAL))
42 > #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
43  
44 < #define  newambtree()   (AMBTREE *)calloc(8, sizeof(AMBTREE))
44 > #define  newambval()    (AMBVAL *)bmalloc(sizeof(AMBVAL))
45  
46 + #define  newambtree()   (AMBTREE *)calloc(8, sizeof(AMBTREE))
47  
48 < setambient(afile)                       /* initialize calculation */
49 < char  *afile;
48 > extern long  ftell(), lseek();
49 > static int  initambfile(), avsave(), avinsert(), ambsync();
50 >
51 >
52 > setambres(ar)                           /* set ambient resolution */
53 > int  ar;
54   {
55 <        long  ftell();
56 <        AMBVAL  amb;
55 >                                                /* set min & max radii */
56 >        if (ar <= 0) {
57 >                minarad = 0.0;
58 >                maxarad = thescene.cusize / 2.0;
59 >        } else {
60 >                minarad = thescene.cusize / ar;
61 >                maxarad = 16.0 * minarad;               /* heuristic */
62 >                if (maxarad > thescene.cusize / 2.0)
63 >                        maxarad = thescene.cusize / 2.0;
64 >        }
65 >        if (maxarad <= FTINY)
66 >                maxarad = .001;
67 > }
68  
56 –        maxarad = thescene.cusize / 2.0;                /* maximum radius */
57 –                                                        /* minimum radius */
58 –        minarad = ambres > 0 ? thescene.cusize/ambres : 0.0;
69  
70 <                                        /* open ambient file */
70 > setambient(afile)                       /* initialize calculation */
71 > char  *afile;
72 > {
73 >        long  headlen;
74 >        AMBVAL  amb;
75 >                                                /* init ambient limits */
76 >        setambres(ambres);
77 >                                                /* open ambient file */
78          if (afile != NULL)
79                  if ((ambfp = fopen(afile, "r+")) != NULL) {
80 <                        while (fread((char *)&amb,sizeof(AMBVAL),1,ambfp) == 1)
80 >                        initambfile(0);
81 >                        headlen = ftell(ambfp);
82 >                        while (readambval(&amb, ambfp))
83                                  avinsert(&amb, &atrunk, thescene.cuorg,
84                                                  thescene.cusize);
85                                                          /* align */
86 <                        fseek(ambfp, -(ftell(ambfp)%sizeof(AMBVAL)), 1);
87 <                } else if ((ambfp = fopen(afile, "w")) == NULL) {
86 >                        fseek(ambfp, -((ftell(ambfp)-headlen)%AMBVALSIZ), 1);
87 >                } else if ((ambfp = fopen(afile, "w+")) != NULL)
88 >                        initambfile(1);
89 >                else {
90                          sprintf(errmsg, "cannot open ambient file \"%s\"",
91                                          afile);
92                          error(SYSTEM, errmsg);
# Line 74 | Line 95 | char  *afile;
95  
96  
97   ambnotify(obj)                  /* record new modifier */
98 < OBJECT  obj;
98 > OBJECT  obj;
99   {
100          static int  hitlimit = 0;
101 <        register OBJREC  *o = objptr(obj);
101 >        register OBJREC  *o = objptr(obj);
102          register char  **amblp;
103  
104          if (hitlimit || !ismodifier(o->otype))
# Line 100 | Line 121 | COLOR  acol;
121   register RAY  *r;
122   {
123          static int  rdepth = 0;                 /* ambient recursion */
124 <        double  wsum;
124 >        double  d;
125  
105 –        rdepth++;                               /* increment level */
106 –
126          if (ambdiv <= 0)                        /* no ambient calculation */
127                  goto dumbamb;
128                                                  /* check number of bounces */
129 <        if (rdepth > ambounce)
129 >        if (rdepth >= ambounce)
130                  goto dumbamb;
131                                                  /* check ambient list */
132          if (ambincl != -1 && r->ro != NULL &&
# Line 115 | Line 134 | register RAY  *r;
134                  goto dumbamb;
135  
136          if (ambacc <= FTINY) {                  /* no ambient storage */
137 <                if (doambient(acol, r, NULL, NULL) == 0.0)
137 >                rdepth++;
138 >                d = doambient(acol, r, r->rweight, NULL, NULL);
139 >                rdepth--;
140 >                if (d == 0.0)
141                          goto dumbamb;
142 <                goto done;
142 >                return;
143          }
144                                                  /* get ambient value */
145          setcolor(acol, 0.0, 0.0, 0.0);
146 <        wsum = sumambient(acol, r, &atrunk, thescene.cuorg, thescene.cusize);
147 <        if (wsum > FTINY)
148 <                scalecolor(acol, 1.0/wsum);
149 <        else if (makeambient(acol, r) == 0.0)
150 <                goto dumbamb;
151 <        goto done;
152 <
146 >        d = sumambient(acol, r, rdepth,
147 >                        &atrunk, thescene.cuorg, thescene.cusize);
148 >        if (d > FTINY)
149 >                scalecolor(acol, 1.0/d);
150 >        else {
151 >                d = makeambient(acol, r, rdepth++);
152 >                rdepth--;
153 >        }
154 >        if (d > FTINY)
155 >                return;
156   dumbamb:                                        /* return global value */
157          copycolor(acol, ambval);
133 – done:                                           /* must finish here! */
134 –        rdepth--;
158   }
159  
160  
161   double
162 < sumambient(acol, r, at, c0, s)          /* get interpolated ambient value */
162 > sumambient(acol, r, al, at, c0, s)      /* get interpolated ambient value */
163   COLOR  acol;
164   register RAY  *r;
165 < AMBTREE  *at;
165 > int  al;
166 > AMBTREE  *at;
167   FVECT  c0;
168 < double  s;
168 > double  s;
169   {
170 <        extern double  sqrt();
147 <        double  d, e1, e2, wt, wsum;
170 >        double  d, e1, e2, wt, wsum;
171          COLOR  ct;
172          FVECT  ck0;
173          int  i;
174          register int  j;
175 <        register AMBVAL  *av;
175 >        register AMBVAL  *av;
176                                          /* do this node */
177          wsum = 0.0;
178          for (av = at->alist; av != NULL; av = av->next) {
179                  /*
180 <                 *  Ray strength test.
180 >                 *  Ambient level test.
181                   */
182 <                if (av->lvl > r->rlvl || av->weight < r->rweight-FTINY)
182 >                if (av->lvl > al || av->weight < r->rweight-FTINY)
183                          continue;
184                  /*
185                   *  Ambient radius test.
# Line 183 | Line 206 | double  s;
206                  for (j = 0; j < 3; j++)
207                          d += (r->rop[j] - av->pos[j]) *
208                                          (av->dir[j] + r->ron[j]);
209 <                if (d*0.5 < -minarad*ambacc)
209 >                if (d*0.5 < -minarad*ambacc-.001)
210                          continue;
211                  /*
212                   *  Jittering final test reduces image artifacts.
213                   */
214                  wt = sqrt(e1) + sqrt(e2);
215 <                wt *= .9 + .2*frandom();
215 >                wt *= .9 + .2*urand(9015+samplendx);
216                  if (wt > ambacc)
217                          continue;
218                  if (wt <= 1e-3)
# Line 216 | Line 239 | double  s;
239                                  break;
240                  }
241                  if (j == 3)
242 <                        wsum += sumambient(acol, r, at->kid+i, ck0, s);
242 >                        wsum += sumambient(acol, r, al, at->kid+i, ck0, s);
243          }
244          return(wsum);
245   }
246  
247  
248   double
249 < makeambient(acol, r)            /* make a new ambient value */
249 > makeambient(acol, r, al)        /* make a new ambient value */
250   COLOR  acol;
251   register RAY  *r;
252 + int  al;
253   {
254 <        AMBVAL  amb;
254 >        AMBVAL  amb;
255          FVECT   gp, gd;
256 <
257 <        amb.rad = doambient(acol, r, gp, gd);   /* compute ambient */
256 >                                                /* compute weight */
257 >        amb.weight = pow(AVGREFL, (double)al);
258 >        if (r->rweight < 0.2*amb.weight)        /* heuristic */
259 >                amb.weight = r->rweight;
260 >                                                /* compute ambient */
261 >        amb.rad = doambient(acol, r, amb.weight, gp, gd);
262          if (amb.rad == 0.0)
263                  return(0.0);
264                                                  /* store it */
265          VCOPY(amb.pos, r->rop);
266          VCOPY(amb.dir, r->ron);
267 <        amb.lvl = r->rlvl;
240 <        amb.weight = r->rweight;
267 >        amb.lvl = al;
268          copycolor(amb.val, acol);
269          VCOPY(amb.gpos, gp);
270          VCOPY(amb.gdir, gd);
271                                                  /* insert into tree */
272 <        avinsert(&amb, &atrunk, thescene.cuorg, thescene.cusize);
246 <        avsave(&amb);                           /* write to file */
272 >        avsave(&amb);                           /* and save to file */
273          return(amb.rad);
274   }
275  
276  
277   extambient(cr, ap, pv, nv)              /* extrapolate value at pv, nv */
278   COLOR  cr;
279 < register AMBVAL  *ap;
279 > register AMBVAL  *ap;
280   FVECT  pv, nv;
281   {
282          FVECT  v1, v2;
283          register int  i;
284 <        double  d;
284 >        double  d;
285  
286          d = 1.0;                        /* zeroeth order */
287                                          /* gradient due to translation */
# Line 275 | Line 301 | FVECT  pv, nv;
301  
302  
303   static
304 < avsave(av)                              /* save an ambient value */
305 < AMBVAL  *av;
304 > initambfile(creat)              /* initialize ambient file */
305 > int  creat;
306   {
307 < #ifdef  AMBFLUSH
308 <        static int  nunflshed = 0;
307 >        extern char  *progname, *octname, VersionID[];
308 >
309 > #ifdef MSDOS
310 >        setmode(fileno(ambfp), O_BINARY);
311   #endif
312 +        setbuf(ambfp, bmalloc(BUFSIZ));
313 +        if (creat) {                    /* new file */
314 +                fprintf(ambfp, "%s -av %g %g %g -ab %d -aa %g ",
315 +                                progname, colval(ambval,RED),
316 +                                colval(ambval,GRN), colval(ambval,BLU),
317 +                                ambounce, ambacc);
318 +                fprintf(ambfp, "-ad %d -as %d -ar %d %s\n",
319 +                                ambdiv, ambssamp, ambres,
320 +                                octname==NULL ? "" : octname);
321 +                fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
322 +                fputformat(AMBFMT, ambfp);
323 +                putc('\n', ambfp);
324 +                putambmagic(ambfp);
325 +                fflush(ambfp);
326 + #ifndef  NIX
327 +                sync();                 /* protect against NFS buffering */
328 + #endif
329 +        } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
330 +                error(USER, "bad ambient file");
331 + }
332 +
333 +
334 + static
335 + avsave(av)                              /* insert and save an ambient value */
336 + AMBVAL  *av;
337 + {
338 +        static int  nunflshed = 0;
339 +
340 +        avinsert(av, &atrunk, thescene.cuorg, thescene.cusize);
341          if (ambfp == NULL)
342                  return;
343 <        if (fwrite((char *)av, sizeof(AMBVAL), 1, ambfp) != 1)
343 >        if (writambval(av, ambfp) < 0)
344                  goto writerr;
288 – #ifdef  AMBFLUSH
345          if (++nunflshed >= AMBFLUSH) {
346 <                if (fflush(ambfp) == EOF)
346 >                if (ambsync() == EOF)
347                          goto writerr;
348                  nunflshed = 0;
349          }
294 – #endif
350          return;
351   writerr:
352          error(SYSTEM, "error writing ambient file");
# Line 300 | Line 355 | writerr:
355  
356   static
357   avinsert(aval, at, c0, s)               /* insert ambient value in a tree */
358 < AMBVAL  *aval;
358 > AMBVAL  *aval;
359   register AMBTREE  *at;
360   FVECT  c0;
361 < double  s;
361 > double  s;
362   {
363          FVECT  ck0;
364          int  branch;
365 <        register AMBVAL  *av;
365 >        register AMBVAL  *av;
366          register int  i;
367  
368          if ((av = newambval()) == NULL)
# Line 333 | Line 388 | double  s;
388   memerr:
389          error(SYSTEM, "out of memory in avinsert");
390   }
391 +
392 +
393 + #ifdef  NIX
394 +
395 + static
396 + ambsync()                       /* flush ambient file */
397 + {
398 +        return(fflush(ambfp));
399 + }
400 +
401 + #else
402 +
403 + #include  <sys/types.h>
404 + #include  <sys/stat.h>
405 +
406 + static
407 + ambsync()                       /* synchronize ambient file */
408 + {
409 +        static FILE  *ambinp = NULL;
410 +        struct flock  fls;
411 +        struct stat  sts;
412 + #define flen    sts.st_size
413 +        AMBVAL  avs;
414 +        long  lastpos;
415 +        register int  n;
416 +                                /* gain exclusive access */
417 +        fls.l_type = F_WRLCK;
418 +        fls.l_whence = 0;
419 +        fls.l_start = 0L;
420 +        fls.l_len = 0L;
421 +        if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
422 +                error(SYSTEM, "cannot lock ambient file");
423 +                                /* see if file has grown */
424 +        lastpos = lseek(fileno(ambfp), 0L, 1);  /* get previous position */
425 +        if (fstat(fileno(ambfp), &sts) < 0)     /* get current length */
426 +                error(SYSTEM, "cannot stat ambient file");
427 +        if (n = (flen - lastpos)/AMBVALSIZ) {   /* file has grown */
428 +                if (ambinp == NULL) {           /* use duplicate file */
429 +                        ambinp = fdopen(dup(fileno(ambfp)), "r");
430 +                        if (ambinp == NULL)
431 +                                error(SYSTEM, "fdopen failed in ambsync");
432 +                }
433 +                while (n--) {                   /* load contributed values */
434 +                        readambval(&avs, ambinp);
435 +                        avinsert(&avs,&atrunk,thescene.cuorg,thescene.cusize);
436 +                }                               /* moves shared file pointer */
437 +                if (n = (flen - lastpos)%AMBVALSIZ)     /* alignment */
438 +                        lseek(fileno(ambfp), flen-n, 0);
439 +        }
440 +        n = fflush(ambfp);                      /* calls write() at last */
441 +        fls.l_type = F_UNLCK;                   /* release file */
442 +        fcntl(fileno(ambfp), F_SETLKW, &fls);
443 +        return(n);
444 + }
445 +
446 + #endif

Diff Legend

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