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 2.72 by greg, Fri Apr 11 22:54:34 2014 UTC vs.
Revision 2.83 by greg, Sat Apr 26 05:15:17 2014 UTC

# Line 51 | Line 51 | static int  nunflshed = 0;     /* number of unflushed ambi
51   #define MAX_SORT_INTVL  (SORT_INTVL<<6)
52   #endif
53  
54 +
55 + static double  qambacc = 0.;            /* ambient accuracy to the 1/4 power */
56   static double  avsum = 0.;              /* computed ambient value sum (log) */
57   static unsigned int  navsum = 0;        /* number of values in avsum */
58   static unsigned int  nambvals = 0;      /* total number of indirect values */
# Line 108 | Line 110 | setambres(                             /* set ambient resolution */
110                                                  /* set min & max radii */
111          if (ar <= 0) {
112                  minarad = 0;
113 <                maxarad = thescene.cusize / 2.0;
113 >                maxarad = thescene.cusize*0.5;
114          } else {
115                  minarad = thescene.cusize / ar;
116 <                maxarad = 64 * minarad;                 /* heuristic */
117 <                if (maxarad > thescene.cusize / 2.0)
118 <                        maxarad = thescene.cusize / 2.0;
116 >                maxarad = 64.0 * minarad;               /* heuristic */
117 >                if (maxarad > thescene.cusize*0.5)
118 >                        maxarad = thescene.cusize*0.5;
119          }
120          if (minarad <= FTINY)
121 <                minarad = 10*FTINY;
121 >                minarad = 10.0*FTINY;
122          if (maxarad <= minarad)
123 <                maxarad = 64 * minarad;
123 >                maxarad = 64.0 * minarad;
124   }
125  
126  
# Line 127 | Line 129 | setambacc(                             /* set ambient accuracy */
129          double  newa
130   )
131   {
132 <        double  ambdiff;
133 <
134 <        if (newa < 0.0)
135 <                newa = 0.0;
136 <        ambdiff = fabs(newa - ambacc);
137 <        if (ambdiff >= .01 && (ambacc = newa) > FTINY && nambvals > 0)
138 <                sortambvals(1);                 /* rebuild tree */
132 >        double  olda = qambacc*qambacc*qambacc*qambacc;
133 >        
134 >        newa *= (newa > 0);
135 >        if (fabs(newa - olda) >= .05*(newa + olda)) {
136 >                qambacc = sqrt(sqrt(ambacc = newa));
137 >                if (nambvals > 0)
138 >                        sortambvals(1);         /* rebuild tree */
139 >        }
140   }
141  
142  
# Line 320 | Line 323 | multambient(           /* compute ambient component & multiply
323          ok = makeambient(acol, r, nrm, rdepth-1);
324          rdepth--;
325          if (ok) {
326 <                multcolor(aval, acol);          /* got new value */
326 >                multcolor(aval, acol);          /* computed new value */
327                  return;
328          }
329   dumbamb:                                        /* return global value */
# Line 352 | Line 355 | sumambient(            /* get interpolated ambient value */
355          FVECT  c0,
356          double  s
357   )
358 < {                                       /* initial limit is ambacc radians */
359 <        const double    maxangle = (ambacc-PI/2.)*pow(r->rweight,0.13) + PI/2.;
358 > {                       /* initial limit is 10 degrees plus ambacc radians */
359 >        const double    minangle = 10.0 * PI/180.;
360 >        const double    maxangle = (minangle+ambacc-PI/2.)*pow(r->rweight,0.13)
361 >                                        + PI/2.;
362          double          wsum = 0.0;
363          FVECT           ck0;
364          int             i, j;
365          AMBVAL          *av;
366 +
367 +        if (at->kid != NULL) {          /* sum children first */                                
368 +                s *= 0.5;
369 +                for (i = 0; i < 8; i++) {
370 +                        for (j = 0; j < 3; j++) {
371 +                                ck0[j] = c0[j];
372 +                                if (1<<j & i)
373 +                                        ck0[j] += s;
374 +                                if (r->rop[j] < ck0[j] - OCTSCALE*s)
375 +                                        break;
376 +                                if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
377 +                                        break;
378 +                        }
379 +                        if (j == 3)
380 +                                wsum += sumambient(acol, r, rn, al,
381 +                                                        at->kid+i, ck0, s);
382 +                }
383 +                                        /* good enough? */
384 +                if (wsum > 0.04 && s > (minarad*0.8+maxarad*0.2))
385 +                        return(wsum);
386 +        }
387                                          /* sum this node */
388          for (av = at->alist; av != NULL; av = av->next) {
389                  double  d, delta_r2, delta_t2;
# Line 384 | Line 410 | sumambient(            /* get interpolated ambient value */
410                  if (delta_r2 >= maxangle*maxangle)
411                          continue;
412                  /*
413 +                 *  Modified ray behind test
414 +                 */
415 +                VSUB(ck0, av->pos, r->rop);
416 +                d = DOT(ck0, uvw[2]);
417 +                if (d < -minarad*qambacc-.001)
418 +                        continue;
419 +                d /= av->rad[0];
420 +                delta_t2 = d*d;
421 +                if (delta_t2 >= qambacc*qambacc)
422 +                        continue;
423 +                /*
424                   *  Elliptical radii test based on Hessian
425                   */
426                  decodedir(uvw[0], av->udir);
427                  VCROSS(uvw[1], uvw[2], uvw[0]);
391                VSUB(ck0, av->pos, r->rop);
428                  d = DOT(ck0, uvw[0]) / av->rad[0];
429 <                delta_t2 = d*d;
429 >                delta_t2 += d*d;
430                  d = DOT(ck0, uvw[1]) / av->rad[1];
431                  delta_t2 += d*d;
432 <                if (delta_t2 >= ambacc*ambacc)
432 >                if (delta_t2 >= qambacc*qambacc)
433                          continue;
434                  /*
399                 *  Intersection behind test
400                 */
401                d = 0.0;
402                for (j = 0; j < 3; j++)
403                        d += (r->rop[j] - av->pos[j])*(uvw[2][j] + r->ron[j]);
404                if (d*0.5 < -minarad*ambacc-.001)
405                        continue;
406                /*
435                   *  Extrapolate value and compute final weight (hat function)
436                   */
437                  extambient(ct, av, r->rop, rn, uvw);
438                  d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
439 <                        tfunc(ambacc, sqrt(delta_t2), 0.0);
439 >                        tfunc(qambacc, sqrt(delta_t2), 0.0);
440                  scalecolor(ct, d);
441                  addcolor(acol, ct);
442                  wsum += d;
443          }
416        if (at->kid == NULL)
417                return(wsum);
418                                        /* sum children */
419        s *= 0.5;
420        for (i = 0; i < 8; i++) {
421                for (j = 0; j < 3; j++) {
422                        ck0[j] = c0[j];
423                        if (1<<j & i)
424                                ck0[j] += s;
425                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
426                                break;
427                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
428                                break;
429                }
430                if (j == 3)
431                        wsum += sumambient(acol, r, rn, al,
432                                                at->kid+i, ck0, s);
433        }
444          return(wsum);
445   }
446  
# Line 454 | Line 464 | makeambient(           /* make a new ambient value for storage
464                  amb.weight = 1.25*r->rweight;
465          setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
466                                                  /* compute ambient */
467 <        if (!doambient(acol, r, amb.weight, uvw, amb.rad, amb.gpos, amb.gdir)) {
458 <                setcolor(acol, 0.0, 0.0, 0.0);
459 <                return(0);
460 <        }
467 >        i = doambient(acol, r, amb.weight, uvw, amb.rad, amb.gpos, amb.gdir);
468          scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
469 +        if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
470 +                return(i);
471                                                  /* store value */
472          VCOPY(amb.pos, r->rop);
473          amb.ndir = encodedir(r->ron);
# Line 530 | Line 539 | avinsert(                              /* insert ambient value in our tree */
539          at = &atrunk;
540          VCOPY(ck0, thescene.cuorg);
541          s = thescene.cusize;
542 <        while (s*(OCTSCALE/2) > av->rad[1]*ambacc) {
542 >        while (s*(OCTSCALE/2) > av->rad[1]*qambacc) {
543                  if (at->kid == NULL)
544                          if ((at->kid = newambtree()) == NULL)
545                                  error(SYSTEM, "out of memory in avinsert");

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines