| 21 |
|
#include "ambient.h" |
| 22 |
|
#include "random.h" |
| 23 |
|
|
| 24 |
< |
#ifdef NEWAMB |
| 24 |
> |
#ifndef OLDAMB |
| 25 |
|
|
| 26 |
|
extern void SDsquare2disk(double ds[2], double seedx, double seedy); |
| 27 |
|
|
| 33 |
|
|
| 34 |
|
typedef struct { |
| 35 |
|
RAY *rp; /* originating ray sample */ |
| 36 |
– |
FVECT ux, uy; /* tangent axis unit vectors */ |
| 36 |
|
int ns; /* number of samples per axis */ |
| 37 |
+ |
int sampOK; /* acquired full sample set? */ |
| 38 |
|
COLOR acoef; /* division contribution coefficient */ |
| 39 |
+ |
double acol[3]; /* accumulated color */ |
| 40 |
+ |
FVECT ux, uy; /* tangent axis unit vectors */ |
| 41 |
|
AMBSAMP sa[1]; /* sample array (extends struct) */ |
| 42 |
|
} AMBHEMI; /* ambient sample hemisphere */ |
| 43 |
|
|
| 50 |
|
} FFTRI; /* vectors and coefficients for Hessian calculation */ |
| 51 |
|
|
| 52 |
|
|
| 53 |
< |
static AMBHEMI * |
| 54 |
< |
inithemi( /* initialize sampling hemisphere */ |
| 55 |
< |
COLOR ac, |
| 56 |
< |
RAY *r, |
| 57 |
< |
double wt |
| 53 |
> |
static int |
| 54 |
> |
ambcollision( /* proposed direciton collides? */ |
| 55 |
> |
AMBHEMI *hp, |
| 56 |
> |
int i, |
| 57 |
> |
int j, |
| 58 |
> |
FVECT dv |
| 59 |
|
) |
| 60 |
|
{ |
| 61 |
< |
AMBHEMI *hp; |
| 62 |
< |
double d; |
| 63 |
< |
int n, i; |
| 64 |
< |
/* set number of divisions */ |
| 65 |
< |
if (ambacc <= FTINY && |
| 66 |
< |
wt > (d = 0.8*intens(ac)*r->rweight/(ambdiv*minweight))) |
| 67 |
< |
wt = d; /* avoid ray termination */ |
| 68 |
< |
n = sqrt(ambdiv * wt) + 0.5; |
| 69 |
< |
i = 1 + 5*(ambacc > FTINY); /* minimum number of samples */ |
| 70 |
< |
if (n < i) |
| 71 |
< |
n = i; |
| 72 |
< |
/* allocate sampling array */ |
| 73 |
< |
hp = (AMBHEMI *)malloc(sizeof(AMBHEMI) + sizeof(AMBSAMP)*(n*n - 1)); |
| 74 |
< |
if (hp == NULL) |
| 75 |
< |
return(NULL); |
| 76 |
< |
hp->rp = r; |
| 77 |
< |
hp->ns = n; |
| 78 |
< |
/* assign coefficient */ |
| 79 |
< |
copycolor(hp->acoef, ac); |
| 80 |
< |
d = 1.0/(n*n); |
| 81 |
< |
scalecolor(hp->acoef, d); |
| 82 |
< |
/* make tangent plane axes */ |
| 83 |
< |
hp->uy[0] = 0.5 - frandom(); |
| 84 |
< |
hp->uy[1] = 0.5 - frandom(); |
| 85 |
< |
hp->uy[2] = 0.5 - frandom(); |
| 86 |
< |
for (i = 3; i--; ) |
| 84 |
< |
if ((-0.6 < r->ron[i]) & (r->ron[i] < 0.6)) |
| 85 |
< |
break; |
| 86 |
< |
if (i < 0) |
| 87 |
< |
error(CONSISTENCY, "bad ray direction in inithemi"); |
| 88 |
< |
hp->uy[i] = 1.0; |
| 89 |
< |
VCROSS(hp->ux, hp->uy, r->ron); |
| 90 |
< |
normalize(hp->ux); |
| 91 |
< |
VCROSS(hp->uy, r->ron, hp->ux); |
| 92 |
< |
/* we're ready to sample */ |
| 93 |
< |
return(hp); |
| 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 |
|
|
| 97 |
– |
/* Sample ambient division and apply weighting coefficient */ |
| 90 |
|
static int |
| 91 |
< |
getambsamp(RAY *arp, AMBHEMI *hp, int i, int j, int n) |
| 91 |
> |
ambsample( /* initial ambient division sample */ |
| 92 |
> |
AMBHEMI *hp, |
| 93 |
> |
int i, |
| 94 |
> |
int j, |
| 95 |
> |
int n |
| 96 |
> |
) |
| 97 |
|
{ |
| 98 |
+ |
AMBSAMP *ap = &ambsam(hp,i,j); |
| 99 |
+ |
RAY ar; |
| 100 |
|
int hlist[3], ii; |
| 101 |
|
double spt[2], zd; |
| 102 |
+ |
/* generate hemispherical sample */ |
| 103 |
|
/* ambient coefficient for weight */ |
| 104 |
|
if (ambacc > FTINY) |
| 105 |
< |
setcolor(arp->rcoef, AVGREFL, AVGREFL, AVGREFL); |
| 105 |
> |
setcolor(ar.rcoef, AVGREFL, AVGREFL, AVGREFL); |
| 106 |
|
else |
| 107 |
< |
copycolor(arp->rcoef, hp->acoef); |
| 108 |
< |
if (rayorigin(arp, AMBIENT, hp->rp, arp->rcoef) < 0) |
| 107 |
> |
copycolor(ar.rcoef, hp->acoef); |
| 108 |
> |
if (rayorigin(&ar, AMBIENT, hp->rp, ar.rcoef) < 0) |
| 109 |
|
return(0); |
| 110 |
|
if (ambacc > FTINY) { |
| 111 |
< |
multcolor(arp->rcoef, hp->acoef); |
| 112 |
< |
scalecolor(arp->rcoef, 1./AVGREFL); |
| 111 |
> |
multcolor(ar.rcoef, hp->acoef); |
| 112 |
> |
scalecolor(ar.rcoef, 1./AVGREFL); |
| 113 |
|
} |
| 114 |
|
hlist[0] = hp->rp->rno; |
| 115 |
|
hlist[1] = j; |
| 116 |
|
hlist[2] = i; |
| 117 |
|
multisamp(spt, 2, urand(ilhash(hlist,3)+n)); |
| 118 |
< |
if (!n) { /* avoid border samples for n==0 */ |
| 119 |
< |
if ((spt[0] < 0.1) | (spt[0] >= 0.9)) |
| 120 |
< |
spt[0] = 0.1 + 0.8*frandom(); |
| 121 |
< |
if ((spt[1] < 0.1) | (spt[1] >= 0.9)) |
| 122 |
< |
spt[1] = 0.1 + 0.8*frandom(); |
| 123 |
< |
} |
| 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--; ) |
| 122 |
< |
arp->rdir[ii] = spt[0]*hp->ux[ii] + |
| 122 |
> |
ar.rdir[ii] = spt[0]*hp->ux[ii] + |
| 123 |
|
spt[1]*hp->uy[ii] + |
| 124 |
|
zd*hp->rp->ron[ii]; |
| 125 |
< |
checknorm(arp->rdir); |
| 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(arp); /* evaluate ray */ |
| 133 |
< |
ndims--; /* apply coefficient */ |
| 134 |
< |
multcolor(arp->rcol, arp->rcoef); |
| 132 |
> |
rayvalue(&ar); /* evaluate ray */ |
| 133 |
> |
ndims--; |
| 134 |
> |
if (ar.rt <= FTINY) |
| 135 |
> |
return(0); /* should never happen */ |
| 136 |
> |
multcolor(ar.rcol, ar.rcoef); /* apply coefficient */ |
| 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; |
| 142 |
> |
VSUM(ap->p, ar.rorg, ar.rdir, ar.rt); |
| 143 |
> |
copycolor(ap->v, ar.rcol); |
| 144 |
> |
} else { /* else update recorded value */ |
| 145 |
> |
hp->acol[RED] -= colval(ap->v,RED); |
| 146 |
> |
hp->acol[GRN] -= colval(ap->v,GRN); |
| 147 |
> |
hp->acol[BLU] -= colval(ap->v,BLU); |
| 148 |
> |
zd = 1.0/(double)(n+1); |
| 149 |
> |
scalecolor(ar.rcol, zd); |
| 150 |
> |
zd *= (double)n; |
| 151 |
> |
scalecolor(ap->v, zd); |
| 152 |
> |
addcolor(ap->v, ar.rcol); |
| 153 |
> |
} |
| 154 |
> |
addcolor(hp->acol, ap->v); /* add to our sum */ |
| 155 |
|
return(1); |
| 156 |
|
} |
| 157 |
|
|
| 158 |
|
|
| 139 |
– |
static AMBSAMP * |
| 140 |
– |
ambsample( /* initial ambient division sample */ |
| 141 |
– |
AMBHEMI *hp, |
| 142 |
– |
int i, |
| 143 |
– |
int j |
| 144 |
– |
) |
| 145 |
– |
{ |
| 146 |
– |
AMBSAMP *ap = &ambsam(hp,i,j); |
| 147 |
– |
RAY ar; |
| 148 |
– |
/* generate hemispherical sample */ |
| 149 |
– |
if (!getambsamp(&ar, hp, i, j, 0) || ar.rt <= FTINY) { |
| 150 |
– |
memset(ap, 0, sizeof(AMBSAMP)); |
| 151 |
– |
return(NULL); |
| 152 |
– |
} |
| 153 |
– |
ap->d = 1.0/ar.rt; /* limit vertex distance */ |
| 154 |
– |
if (ar.rt > 10.0*thescene.cusize) |
| 155 |
– |
ar.rt = 10.0*thescene.cusize; |
| 156 |
– |
VSUM(ap->p, ar.rorg, ar.rdir, ar.rt); |
| 157 |
– |
copycolor(ap->v, ar.rcol); |
| 158 |
– |
return(ap); |
| 159 |
– |
} |
| 160 |
– |
|
| 161 |
– |
|
| 159 |
|
/* Estimate errors based on ambient division differences */ |
| 160 |
|
static float * |
| 161 |
|
getambdiffs(AMBHEMI *hp) |
| 210 |
|
|
| 211 |
|
/* Perform super-sampling on hemisphere (introduces bias) */ |
| 212 |
|
static void |
| 213 |
< |
ambsupersamp(double acol[3], AMBHEMI *hp, int cnt) |
| 213 |
> |
ambsupersamp(AMBHEMI *hp, int cnt) |
| 214 |
|
{ |
| 215 |
|
float *earr = getambdiffs(hp); |
| 216 |
|
double e2rem = 0; |
| 217 |
|
AMBSAMP *ap; |
| 221 |
– |
RAY ar; |
| 222 |
– |
double asum[3]; |
| 218 |
|
float *ep; |
| 219 |
|
int i, j, n, nss; |
| 220 |
|
|
| 229 |
|
if (e2rem <= FTINY) |
| 230 |
|
goto done; /* nothing left to do */ |
| 231 |
|
nss = *ep/e2rem*cnt + frandom(); |
| 232 |
< |
asum[0] = asum[1] = asum[2] = 0.0; |
| 233 |
< |
for (n = 1; n <= nss; n++) { |
| 234 |
< |
if (!getambsamp(&ar, hp, i, j, n)) { |
| 240 |
< |
nss = n-1; |
| 241 |
< |
break; |
| 242 |
< |
} |
| 243 |
< |
addcolor(asum, ar.rcol); |
| 244 |
< |
} |
| 245 |
< |
if (nss) { /* update returned ambient value */ |
| 246 |
< |
const double ssf = 1./(nss + 1.); |
| 247 |
< |
for (n = 3; n--; ) |
| 248 |
< |
acol[n] += ssf*asum[n] + |
| 249 |
< |
(ssf - 1.)*colval(ap->v,n); |
| 250 |
< |
} |
| 251 |
< |
e2rem -= *ep++; /* update remainders */ |
| 252 |
< |
cnt -= nss; |
| 232 |
> |
for (n = 1; n <= nss && ambsample(hp,i,j,n); n++) |
| 233 |
> |
--cnt; |
| 234 |
> |
e2rem -= *ep++; /* update remainder */ |
| 235 |
|
} |
| 236 |
|
done: |
| 237 |
|
free(earr); |
| 238 |
|
} |
| 239 |
|
|
| 240 |
|
|
| 241 |
+ |
static AMBHEMI * |
| 242 |
+ |
samp_hemi( /* sample indirect hemisphere */ |
| 243 |
+ |
COLOR rcol, |
| 244 |
+ |
RAY *r, |
| 245 |
+ |
double wt |
| 246 |
+ |
) |
| 247 |
+ |
{ |
| 248 |
+ |
AMBHEMI *hp; |
| 249 |
+ |
double d; |
| 250 |
+ |
int n, i, j; |
| 251 |
+ |
/* set number of divisions */ |
| 252 |
+ |
if (ambacc <= FTINY && |
| 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 + 5*(ambacc > FTINY); /* minimum number of samples */ |
| 257 |
+ |
if (n < i) |
| 258 |
+ |
n = i; |
| 259 |
+ |
/* allocate sampling array */ |
| 260 |
+ |
hp = (AMBHEMI *)malloc(sizeof(AMBHEMI) + sizeof(AMBSAMP)*(n*n - 1)); |
| 261 |
+ |
if (hp == NULL) |
| 262 |
+ |
error(SYSTEM, "out of memory in samp_hemi"); |
| 263 |
+ |
hp->rp = r; |
| 264 |
+ |
hp->ns = n; |
| 265 |
+ |
hp->acol[RED] = hp->acol[GRN] = hp->acol[BLU] = 0.0; |
| 266 |
+ |
memset(hp->sa, 0, sizeof(AMBSAMP)*n*n); |
| 267 |
+ |
hp->sampOK = 0; |
| 268 |
+ |
/* assign coefficient */ |
| 269 |
+ |
copycolor(hp->acoef, rcol); |
| 270 |
+ |
d = 1.0/(n*n); |
| 271 |
+ |
scalecolor(hp->acoef, d); |
| 272 |
+ |
/* make tangent plane axes */ |
| 273 |
+ |
if (!getperpendicular(hp->ux, r->ron, 1)) |
| 274 |
+ |
error(CONSISTENCY, "bad ray direction in samp_hemi"); |
| 275 |
+ |
VCROSS(hp->uy, r->ron, hp->ux); |
| 276 |
+ |
/* sample divisions */ |
| 277 |
+ |
for (i = hp->ns; i--; ) |
| 278 |
+ |
for (j = hp->ns; j--; ) |
| 279 |
+ |
hp->sampOK += ambsample(hp, i, j, 0); |
| 280 |
+ |
copycolor(rcol, hp->acol); |
| 281 |
+ |
if (!hp->sampOK) { /* utter failure? */ |
| 282 |
+ |
free(hp); |
| 283 |
+ |
return(NULL); |
| 284 |
+ |
} |
| 285 |
+ |
if (hp->sampOK < hp->ns*hp->ns) { |
| 286 |
+ |
hp->sampOK *= -1; /* soft failure */ |
| 287 |
+ |
return(hp); |
| 288 |
+ |
} |
| 289 |
+ |
n = ambssamp*wt + 0.5; |
| 290 |
+ |
if (n > 8) { /* perform super-sampling? */ |
| 291 |
+ |
ambsupersamp(hp, n); |
| 292 |
+ |
copycolor(rcol, hp->acol); |
| 293 |
+ |
} |
| 294 |
+ |
return(hp); /* all is well */ |
| 295 |
+ |
} |
| 296 |
+ |
|
| 297 |
+ |
|
| 298 |
|
/* Return brightness of farthest ambient sample */ |
| 299 |
|
static double |
| 300 |
|
back_ambval(AMBHEMI *hp, const int n1, const int n2, const int n3) |
| 635 |
|
ambcorral(AMBHEMI *hp, FVECT uv[2], const double r0, const double r1) |
| 636 |
|
{ |
| 637 |
|
const double max_d = 1.0/(minarad*ambacc + 0.001); |
| 638 |
< |
const double ang_res = 0.5*PI/(hp->ns-1); |
| 639 |
< |
const double ang_step = ang_res/((int)(16/PI*ang_res) + (1+FTINY)); |
| 638 |
> |
const double ang_res = 0.5*PI/hp->ns; |
| 639 |
> |
const double ang_step = ang_res/((int)(16/PI*ang_res) + 1.01); |
| 640 |
|
double avg_d = 0; |
| 641 |
|
uint32 flgs = 0; |
| 642 |
+ |
FVECT vec; |
| 643 |
+ |
double u, v; |
| 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; ) |
| 659 |
|
for (i = 0; i < hp->ns; i++) |
| 660 |
|
for (j = 0; j < hp->ns; j += !i|(i==hp->ns-1) ? 1 : hp->ns-1) { |
| 661 |
|
AMBSAMP *ap = &ambsam(hp,i,j); |
| 620 |
– |
FVECT vec; |
| 621 |
– |
double u, v; |
| 622 |
– |
double ang, a1; |
| 623 |
– |
int abp; |
| 662 |
|
if ((ap->d <= FTINY) | (ap->d >= max_d)) |
| 663 |
|
continue; /* too far or too near */ |
| 664 |
|
VSUB(vec, ap->p, hp->rp->rop); |
| 665 |
< |
u = DOT(vec, uv[0]) * ap->d; |
| 666 |
< |
v = DOT(vec, uv[1]) * ap->d; |
| 667 |
< |
if ((r0*r0*u*u + r1*r1*v*v) * ap->d*ap->d <= 1.0) |
| 665 |
> |
u = DOT(vec, uv[0]); |
| 666 |
> |
v = DOT(vec, uv[1]); |
| 667 |
> |
if ((r0*r0*u*u + r1*r1*v*v) * ap->d*ap->d <= u*u + v*v) |
| 668 |
|
continue; /* occluder outside ellipse */ |
| 669 |
|
ang = atan2a(v, u); /* else set direction flags */ |
| 670 |
< |
for (a1 = ang-.5*ang_res; a1 <= ang+.5*ang_res; a1 += ang_step) |
| 670 |
> |
for (a1 = ang-ang_res; a1 <= ang+ang_res; a1 += ang_step) |
| 671 |
|
flgs |= 1L<<(int)(16/PI*(a1 + 2.*PI*(a1 < 0))); |
| 672 |
|
} |
| 673 |
+ |
/* add low-angle incident (< 20deg) */ |
| 674 |
+ |
if (fabs(hp->rp->rod) <= 0.342) { |
| 675 |
+ |
u = -DOT(hp->rp->rdir, uv[0]); |
| 676 |
+ |
v = -DOT(hp->rp->rdir, uv[1]); |
| 677 |
+ |
if ((r0*r0*u*u + r1*r1*v*v) > hp->rp->rot*hp->rp->rot) { |
| 678 |
+ |
ang = atan2a(v, u); |
| 679 |
+ |
ang += 2.*PI*(ang < 0); |
| 680 |
+ |
ang *= 16/PI; |
| 681 |
+ |
if ((ang < .5) | (ang >= 31.5)) |
| 682 |
+ |
flgs |= 0x80000001; |
| 683 |
+ |
else |
| 684 |
+ |
flgs |= 3L<<(int)(ang-.5); |
| 685 |
+ |
} |
| 686 |
+ |
} |
| 687 |
|
return(flgs); |
| 688 |
|
} |
| 689 |
|
|
| 700 |
|
uint32 *crlp /* returned (optional) */ |
| 701 |
|
) |
| 702 |
|
{ |
| 703 |
< |
AMBHEMI *hp = inithemi(rcol, r, wt); |
| 652 |
< |
int cnt; |
| 703 |
> |
AMBHEMI *hp = samp_hemi(rcol, r, wt); |
| 704 |
|
FVECT my_uv[2]; |
| 705 |
< |
double d, K, acol[3]; |
| 705 |
> |
double d, K; |
| 706 |
|
AMBSAMP *ap; |
| 707 |
< |
int i, j; |
| 708 |
< |
/* check/initialize */ |
| 658 |
< |
if (hp == NULL) |
| 659 |
< |
return(0); |
| 707 |
> |
int i; |
| 708 |
> |
/* clear return values */ |
| 709 |
|
if (uv != NULL) |
| 710 |
|
memset(uv, 0, sizeof(FVECT)*2); |
| 711 |
|
if (ra != NULL) |
| 716 |
|
dg[0] = dg[1] = 0.0; |
| 717 |
|
if (crlp != NULL) |
| 718 |
|
*crlp = 0; |
| 719 |
< |
/* sample the hemisphere */ |
| 720 |
< |
acol[0] = acol[1] = acol[2] = 0.0; |
| 721 |
< |
cnt = 0; |
| 722 |
< |
for (i = hp->ns; i--; ) |
| 723 |
< |
for (j = hp->ns; j--; ) |
| 724 |
< |
if ((ap = ambsample(hp, i, j)) != NULL) { |
| 725 |
< |
addcolor(acol, ap->v); |
| 677 |
< |
++cnt; |
| 678 |
< |
} |
| 679 |
< |
if (!cnt) { |
| 680 |
< |
setcolor(rcol, 0.0, 0.0, 0.0); |
| 681 |
< |
free(hp); |
| 682 |
< |
return(0); /* no valid samples */ |
| 719 |
> |
if (hp == NULL) /* sampling falure? */ |
| 720 |
> |
return(0); |
| 721 |
> |
|
| 722 |
> |
if ((ra == NULL) & (pg == NULL) & (dg == NULL) || |
| 723 |
> |
(hp->sampOK < 0) | (hp->ns < 6)) { |
| 724 |
> |
free(hp); /* Hessian not requested/possible */ |
| 725 |
> |
return(-1); /* value-only return value */ |
| 726 |
|
} |
| 727 |
< |
if (cnt < hp->ns*hp->ns) { /* incomplete sampling? */ |
| 685 |
< |
copycolor(rcol, acol); |
| 686 |
< |
free(hp); |
| 687 |
< |
return(-1); /* return value w/o Hessian */ |
| 688 |
< |
} |
| 689 |
< |
cnt = ambssamp*wt + 0.5; /* perform super-sampling? */ |
| 690 |
< |
if (cnt > 8) |
| 691 |
< |
ambsupersamp(acol, hp, cnt); |
| 692 |
< |
copycolor(rcol, acol); /* final indirect irradiance/PI */ |
| 693 |
< |
if ((ra == NULL) & (pg == NULL) & (dg == NULL)) { |
| 694 |
< |
free(hp); |
| 695 |
< |
return(-1); /* no radius or gradient calc. */ |
| 696 |
< |
} |
| 697 |
< |
if ((d = bright(acol)) > FTINY) { /* normalize Y values */ |
| 727 |
> |
if ((d = bright(rcol)) > FTINY) { /* normalize Y values */ |
| 728 |
|
d = 0.99*(hp->ns*hp->ns)/d; |
| 729 |
|
K = 0.01; |
| 730 |
|
} else { /* or fall back on geometric Hessian */ |
| 759 |
|
if (ra[1] < minarad) |
| 760 |
|
ra[1] = minarad; |
| 761 |
|
} |
| 762 |
< |
ra[0] *= d = 1.0/sqrt(sqrt(wt)); |
| 762 |
> |
ra[0] *= d = 1.0/sqrt(wt); |
| 763 |
|
if ((ra[1] *= d) > 2.0*ra[0]) |
| 764 |
|
ra[1] = 2.0*ra[0]; |
| 765 |
|
if (ra[1] > maxarad) { |
| 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]; |
