| 51 |
|
|
| 52 |
|
|
| 53 |
|
static int |
| 54 |
+ |
ambcollision( /* proposed direciton collides? */ |
| 55 |
+ |
AMBHEMI *hp, |
| 56 |
+ |
int i, |
| 57 |
+ |
int j, |
| 58 |
+ |
FVECT dv |
| 59 |
+ |
) |
| 60 |
+ |
{ |
| 61 |
+ |
double cos_thresh; |
| 62 |
+ |
int ii, jj; |
| 63 |
+ |
/* min. spacing = 1/4th division */ |
| 64 |
+ |
cos_thresh = (PI/4.)/(double)hp->ns; |
| 65 |
+ |
cos_thresh = 1. - .5*cos_thresh*cos_thresh; |
| 66 |
+ |
/* check existing neighbors */ |
| 67 |
+ |
for (ii = i-1; ii <= i+1; ii++) { |
| 68 |
+ |
if (ii < 0) continue; |
| 69 |
+ |
if (ii >= hp->ns) break; |
| 70 |
+ |
for (jj = j-1; jj <= j+1; jj++) { |
| 71 |
+ |
AMBSAMP *ap; |
| 72 |
+ |
FVECT avec; |
| 73 |
+ |
double dprod; |
| 74 |
+ |
if (jj < 0) continue; |
| 75 |
+ |
if (jj >= hp->ns) break; |
| 76 |
+ |
if ((ii==i) & (jj==j)) continue; |
| 77 |
+ |
ap = &ambsam(hp,ii,jj); |
| 78 |
+ |
if (ap->d <= .5/FHUGE) |
| 79 |
+ |
continue; /* no one home */ |
| 80 |
+ |
VSUB(avec, ap->p, hp->rp->rop); |
| 81 |
+ |
dprod = DOT(avec, dv); |
| 82 |
+ |
if (dprod >= cos_thresh*VLEN(avec)) |
| 83 |
+ |
return(1); /* collision */ |
| 84 |
+ |
} |
| 85 |
+ |
} |
| 86 |
+ |
return(0); /* nothing to worry about */ |
| 87 |
+ |
} |
| 88 |
+ |
|
| 89 |
+ |
|
| 90 |
+ |
static int |
| 91 |
|
ambsample( /* initial ambient division sample */ |
| 92 |
|
AMBHEMI *hp, |
| 93 |
|
int i, |
| 115 |
|
hlist[1] = j; |
| 116 |
|
hlist[2] = i; |
| 117 |
|
multisamp(spt, 2, urand(ilhash(hlist,3)+n)); |
| 118 |
< |
/* avoid coincident samples */ |
| 82 |
< |
if (!n && (0 < i) & (i < hp->ns-1) && |
| 83 |
< |
(0 < j) & (j < hp->ns-1)) { |
| 84 |
< |
if ((spt[0] < 0.1) | (spt[0] >= 0.9)) |
| 85 |
< |
spt[0] = 0.1 + 0.8*frandom(); |
| 86 |
< |
if ((spt[1] < 0.1) | (spt[1] >= 0.9)) |
| 87 |
< |
spt[1] = 0.1 + 0.8*frandom(); |
| 88 |
< |
} |
| 118 |
> |
resample: |
| 119 |
|
SDsquare2disk(spt, (j+spt[1])/hp->ns, (i+spt[0])/hp->ns); |
| 120 |
|
zd = sqrt(1. - spt[0]*spt[0] - spt[1]*spt[1]); |
| 121 |
|
for (ii = 3; ii--; ) |
| 123 |
|
spt[1]*hp->uy[ii] + |
| 124 |
|
zd*hp->rp->ron[ii]; |
| 125 |
|
checknorm(ar.rdir); |
| 126 |
+ |
/* avoid coincident samples */ |
| 127 |
+ |
if (!n && ambcollision(hp, i, j, ar.rdir)) { |
| 128 |
+ |
spt[0] = frandom(); spt[1] = frandom(); |
| 129 |
+ |
goto resample; /* reject this sample */ |
| 130 |
+ |
} |
| 131 |
|
dimlist[ndims++] = AI(hp,i,j) + 90171; |
| 132 |
|
rayvalue(&ar); /* evaluate ray */ |
| 133 |
|
ndims--; |
| 137 |
|
if (ar.rt*ap->d < 1.0) /* new/closer distance? */ |
| 138 |
|
ap->d = 1.0/ar.rt; |
| 139 |
|
if (!n) { /* record first vertex & value */ |
| 140 |
< |
if (ar.rt > 10.0*thescene.cusize) |
| 141 |
< |
ar.rt = 10.0*thescene.cusize; |
| 140 |
> |
if (ar.rt > 10.0*thescene.cusize + 1000.) |
| 141 |
> |
ar.rt = 10.0*thescene.cusize + 1000.; |
| 142 |
|
VSUM(ap->p, ar.rorg, ar.rdir, ar.rt); |
| 143 |
|
copycolor(ap->v, ar.rcol); |
| 144 |
|
} else { /* else update recorded value */ |
| 253 |
|
wt > (d = 0.8*intens(rcol)*r->rweight/(ambdiv*minweight))) |
| 254 |
|
wt = d; /* avoid ray termination */ |
| 255 |
|
n = sqrt(ambdiv * wt) + 0.5; |
| 256 |
< |
i = 1 + 8*(ambacc > FTINY); /* minimum number of samples */ |
| 256 |
> |
i = 1 + 5*(ambacc > FTINY); /* minimum number of samples */ |
| 257 |
|
if (n < i) |
| 258 |
|
n = i; |
| 259 |
|
/* allocate sampling array */ |
| 270 |
|
d = 1.0/(n*n); |
| 271 |
|
scalecolor(hp->acoef, d); |
| 272 |
|
/* make tangent plane axes */ |
| 273 |
< |
hp->uy[0] = 0.5 - frandom(); |
| 239 |
< |
hp->uy[1] = 0.5 - frandom(); |
| 240 |
< |
hp->uy[2] = 0.5 - frandom(); |
| 241 |
< |
for (i = 3; i--; ) |
| 242 |
< |
if ((-0.6 < r->ron[i]) & (r->ron[i] < 0.6)) |
| 243 |
< |
break; |
| 244 |
< |
if (i < 0) |
| 273 |
> |
if (!getperpendicular(hp->ux, r->ron, 1)) |
| 274 |
|
error(CONSISTENCY, "bad ray direction in samp_hemi"); |
| 246 |
– |
hp->uy[i] = 1.0; |
| 247 |
– |
VCROSS(hp->ux, hp->uy, r->ron); |
| 248 |
– |
normalize(hp->ux); |
| 275 |
|
VCROSS(hp->uy, r->ron, hp->ux); |
| 276 |
|
/* sample divisions */ |
| 277 |
|
for (i = hp->ns; i--; ) |
| 644 |
|
double ang, a1; |
| 645 |
|
int i, j; |
| 646 |
|
/* don't bother for a few samples */ |
| 647 |
< |
if (hp->ns < 12) |
| 647 |
> |
if (hp->ns < 8) |
| 648 |
|
return(0); |
| 649 |
|
/* check distances overhead */ |
| 650 |
|
for (i = hp->ns*3/4; i-- > hp->ns>>2; ) |
| 720 |
|
return(0); |
| 721 |
|
|
| 722 |
|
if ((ra == NULL) & (pg == NULL) & (dg == NULL) || |
| 723 |
< |
(hp->sampOK < 0) | (hp->ns < 9)) { |
| 723 |
> |
(hp->sampOK < 0) | (hp->ns < 6)) { |
| 724 |
|
free(hp); /* Hessian not requested/possible */ |
| 725 |
|
return(-1); /* value-only return value */ |
| 726 |
|
} |
| 768 |
|
ra[0] = maxarad; |
| 769 |
|
} |
| 770 |
|
/* flag encroached directions */ |
| 771 |
< |
if ((wt >= 0.89*AVGREFL) & (crlp != NULL)) |
| 771 |
> |
if (crlp != NULL) |
| 772 |
|
*crlp = ambcorral(hp, uv, ra[0]*ambacc, ra[1]*ambacc); |
| 773 |
|
if (pg != NULL) { /* cap gradient if necessary */ |
| 774 |
|
d = pg[0]*pg[0]*ra[0]*ra[0] + pg[1]*pg[1]*ra[1]*ra[1]; |
