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.1 by greg, Thu Feb 2 10:41:17 1989 UTC vs.
Revision 1.7 by greg, Tue Sep 5 09:46:17 1989 UTC

# Line 203 | Line 203 | double  s;
203                   *  Jittering final test reduces image artifacts.
204                   */
205                  wt = sqrt(e1) + sqrt(e2);
206 <                if (wt > ambacc*(0.9 + 0.2*frandom()))
206 >                wt *= .9 + .2*frandom();
207 >                if (wt > ambacc)
208                          continue;
209                  if (wt <= 1e-3)
210                          wt = 1e3;
# Line 221 | Line 222 | double  s;
222          for (i = 0; i < 8; i++) {
223                  for (j = 0; j < 3; j++) {
224                          ck0[j] = c0[j];
225 <                        if (1<<j & i) {
225 >                        if (1<<j & i)
226                                  ck0[j] += s;
227 <                                if (r->rop[j] < ck0[j] - OCTSCALE*s)
228 <                                        break;
229 <                        } else
230 <                                if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
230 <                                        break;
227 >                        if (r->rop[j] < ck0[j] - OCTSCALE*s)
228 >                                break;
229 >                        if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
230 >                                break;
231                  }
232                  if (j == 3)
233                          wsum += sumambient(acol, r, at->kid+i, ck0, s);
# Line 267 | Line 267 | register RAY  *r;
267          extern int  ambcmp();
268          extern double  sin(), cos(), sqrt();
269          double  phi, xd, yd, zd;
270 +        double  b, b2;
271          register AMBSAMP  *div;
272          AMBSAMP  dnew;
273          RAY  ar;
# Line 321 | Line 322 | register RAY  *r;
322                                  div[ne].n = 0;
323                                  div[ne].t = i; div[ne].p = j;
324                                                          /* sum errors */
325 <                                xd = bright(ar.rcol);
325 >                                b = bright(ar.rcol);
326                                  if (i > 0) {            /* from above */
327 <                                        yd = bright(div[ne-np].v) - xd;
328 <                                        yd *= yd * 0.25;
329 <                                        div[ne].k += yd;
327 >                                        b2 = bright(div[ne-np].v) - b;
328 >                                        b2 *= b2 * 0.25;
329 >                                        div[ne].k += b2;
330                                          div[ne].n++;
331 <                                        div[ne-np].k += yd;
331 >                                        div[ne-np].k += b2;
332                                          div[ne-np].n++;
333                                  }
334                                  if (j > 0) {            /* from behind */
335 <                                        yd = bright(div[ne-1].v) - xd;
336 <                                        yd *= yd * 0.25;
337 <                                        div[ne].k += yd;
335 >                                        b2 = bright(div[ne-1].v) - b;
336 >                                        b2 *= b2 * 0.25;
337 >                                        div[ne].k += b2;
338                                          div[ne].n++;
339 <                                        div[ne-1].k += yd;
339 >                                        div[ne-1].k += b2;
340                                          div[ne-1].n++;
341                                  }
342                                  if (j == np-1) {        /* around */
343 <                                        yd = bright(div[ne-(np-1)].v) - xd;
344 <                                        yd *= yd * 0.25;
345 <                                        div[ne].k += yd;
343 >                                        b2 = bright(div[ne-(np-1)].v) - b;
344 >                                        b2 *= b2 * 0.25;
345 >                                        div[ne].k += b2;
346                                          div[ne].n++;
347 <                                        div[ne-(np-1)].k += yd;
347 >                                        div[ne-(np-1)].k += b2;
348                                          div[ne-(np-1)].n++;
349                                  }
350                                  ne++;
# Line 380 | Line 381 | register RAY  *r;
381                  addcolor(dnew.v, ar.rcol);
382                  dnew.n = div[0].n + 1;
383                  dnew.t = div[0].t; dnew.p = div[0].p;
384 <                yd = bright(dnew.v)/dnew.n - bright(ar.rcol);
385 <                yd = yd*yd + div[0].k*(div[0].n*div[0].n);
386 <                dnew.k = yd/(dnew.n*dnew.n);
384 >                b2 = bright(dnew.v)/dnew.n - bright(ar.rcol);
385 >                b2 = b2*b2 + div[0].k*(div[0].n*div[0].n);
386 >                dnew.k = b2/(dnew.n*dnew.n);
387                                                  /* reinsert */
388                  for (k = 0; k < ne-1 && dnew.k < div[k+1].k; k++)
389                          bcopy(&div[k+1], &div[k], sizeof(AMBSAMP));

Diff Legend

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