ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/ambcomp.c

Comparing ray/src/rt/ambcomp.c (file contents):
Revision 2.66 by greg, Thu Sep 4 09:09:08 2014 UTC vs.
Revision 2.84 by greg, Tue Feb 26 00:37:54 2019 UTC

#	Line 27 | Line 27 | extern void            SDsquare2disk(double ds[2], double seedx,
27
28		typedef struct {
29		COLOR   v;              /* hemisphere sample value */
30	<	float   d;              /* reciprocal distance (1/rt) */
30	>	float   d;              /* reciprocal distance */
31		FVECT   p;              /* intersection point */
32		} AMBSAMP;              /* sample value */
33
#	Line 51 | Line 51 | typedef struct {
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,
#	Line 78 | Line 115 | ambsample(                             /* initial ambient division sample */
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--; )
#	Line 93 | Line 123 | ambsample(                             /* initial ambient division sample */
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--;
134	<	if (ar.rt <= FTINY)
134	>	zd = raydistance(&ar);
135	>	if (zd <= FTINY)
136		return(0);              /* should never happen */
137		multcolor(ar.rcol, ar.rcoef);   /* apply coefficient */
138	<	if (ar.rt*ap->d < 1.0)          /* new/closer distance? */
139	<	ap->d = 1.0/ar.rt;
138	>	if (zd*ap->d < 1.0)             /* new/closer distance? */
139	>	ap->d = 1.0/zd;
140		if (!n) {                       /* record first vertex & value */
141	<	if (ar.rt > 10.0*thescene.cusize)
142	<	ar.rt = 10.0*thescene.cusize;
143	<	VSUM(ap->p, ar.rorg, ar.rdir, ar.rt);
141	>	if (zd > 10.0*thescene.cusize + 1000.)
142	>	zd = 10.0*thescene.cusize + 1000.;
143	>	VSUM(ap->p, ar.rorg, ar.rdir, zd);
144		copycolor(ap->v, ar.rcol);
145		} else {                        /* else update recorded value */
146		hp->acol[RED] -= colval(ap->v,RED);
#	Line 121 | Line 157 | ambsample(                             /* initial ambient division sample */
157		}
158
159
160	<	/* Estimate errors based on ambient division differences */
160	>	/* Estimate variance based on ambient division differences */
161		static float *
162		getambdiffs(AMBHEMI *hp)
163		{
164	+	const double    normf = 1./bright(hp->acoef);
165		float   *earr = (float *)calloc(hp->ns*hp->ns, sizeof(float));
166		float   *ep;
167		AMBSAMP *ap;
168	<	double  b, d2;
168	>	double  b, b1, d2;
169		int     i, j;
170
171		if (earr == NULL)               /* out of memory? */
172		return(NULL);
173	<	/* compute squared neighbor diffs */
173	>	/* sum squared neighbor diffs */
174		for (ap = hp->sa, ep = earr, i = 0; i < hp->ns; i++)
175		for (j = 0; j < hp->ns; j++, ap++, ep++) {
176		b = bright(ap[0].v);
177		if (i) {                /* from above */
178	<	d2 = b - bright(ap[-hp->ns].v);
179	<	d2 *= d2;
178	>	b1 = bright(ap[-hp->ns].v);
179	>	d2 = b - b1;
180	>	d2 *= d2*normf/(b + b1);
181		ep[0] += d2;
182		ep[-hp->ns] += d2;
183		}
184		if (!j) continue;
185		/* from behind */
186	<	d2 = b - bright(ap[-1].v);
187	<	d2 *= d2;
186	>	b1 = bright(ap[-1].v);
187	>	d2 = b - b1;
188	>	d2 *= d2*normf/(b + b1);
189		ep[0] += d2;
190		ep[-1] += d2;
191		if (!i) continue;
192		/* diagonal */
193	<	d2 = b - bright(ap[-hp->ns-1].v);
194	<	d2 *= d2;
193	>	b1 = bright(ap[-hp->ns-1].v);
194	>	d2 = b - b1;
195	>	d2 *= d2*normf/(b + b1);
196		ep[0] += d2;
197		ep[-hp->ns-1] += d2;
198		}
#	Line 179 | Line 219 | ambsupersamp(AMBHEMI *hp, int cnt)
219		{
220		float   *earr = getambdiffs(hp);
221		double  e2rem = 0;
182	–	AMBSAMP *ap;
183	–	RAY     ar;
222		float   *ep;
223		int     i, j, n, nss;
224
#	Line 190 | Line 228 | ambsupersamp(AMBHEMI *hp, int cnt)
228		for (ep = earr + hp->ns*hp->ns; ep > earr; )
229		e2rem += *--ep;
230		ep = earr;                      /* perform super-sampling */
231	<	for (ap = hp->sa, i = 0; i < hp->ns; i++)
232	<	for (j = 0; j < hp->ns; j++, ap++) {
231	>	for (i = 0; i < hp->ns; i++)
232	>	for (j = 0; j < hp->ns; j++) {
233		if (e2rem <= FTINY)
234		goto done;      /* nothing left to do */
235		nss = *ep/e2rem*cnt + frandom();
236		for (n = 1; n <= nss && ambsample(hp,i,j,n); n++)
237	<	--cnt;
237	>	if (!--cnt) goto done;
238		e2rem -= *ep++;         /* update remainder */
239		}
240		done:
#	Line 214 | Line 252 | samp_hemi(                             /* sample indirect hemisphere */
252		AMBHEMI *hp;
253		double  d;
254		int     n, i, j;
255	+	/* insignificance check */
256	+	if (bright(rcol) <= FTINY)
257	+	return(NULL);
258		/* set number of divisions */
259		if (ambacc <= FTINY &&
260		wt > (d = 0.8*intens(rcol)*r->rweight/(ambdiv*minweight)))
261		wt = d;                 /* avoid ray termination */
262		n = sqrt(ambdiv * wt) + 0.5;
263	<	i = 1 + 8*(ambacc > FTINY);     /* minimum number of samples */
263	>	i = 1 + 5*(ambacc > FTINY);     /* minimum number of samples */
264		if (n < i)
265		n = i;
266		/* allocate sampling array */
#	Line 236 | Line 277 | samp_hemi(                             /* sample indirect hemisphere */
277		d = 1.0/(n*n);
278		scalecolor(hp->acoef, d);
279		/* make tangent plane axes */
280	<	hp->uy[0] = 0.5 - frandom();
240	<	hp->uy[1] = 0.5 - frandom();
241	<	hp->uy[2] = 0.5 - frandom();
242	<	for (i = 3; i--; )
243	<	if ((-0.6 < r->ron[i]) & (r->ron[i] < 0.6))
244	<	break;
245	<	if (i < 0)
280	>	if (!getperpendicular(hp->ux, r->ron, 1))
281		error(CONSISTENCY, "bad ray direction in samp_hemi");
247	–	hp->uy[i] = 1.0;
248	–	VCROSS(hp->ux, hp->uy, r->ron);
249	–	normalize(hp->ux);
282		VCROSS(hp->uy, r->ron, hp->ux);
283		/* sample divisions */
284		for (i = hp->ns; i--; )
#	Line 261 | Line 293 | samp_hemi(                             /* sample indirect hemisphere */
293		hp->sampOK *= -1;       /* soft failure */
294		return(hp);
295		}
296	+	if (hp->sampOK < 64)
297	+	return(hp);             /* insufficient for super-sampling */
298		n = ambssamp*wt + 0.5;
299		if (n > 8) {                    /* perform super-sampling? */
300		ambsupersamp(hp, n);
#	Line 619 | Line 653 | ambcorral(AMBHEMI *hp, FVECT uv[2], const double r0, c
653		double          ang, a1;
654		int             i, j;
655		/* don't bother for a few samples */
656	<	if (hp->ns < 12)
656	>	if (hp->ns < 8)
657		return(0);
658		/* check distances overhead */
659		for (i = hp->ns*3/4; i-- > hp->ns>>2; )
#	Line 645 | Line 679 | ambcorral(AMBHEMI *hp, FVECT uv[2], const double r0, c
679		for (a1 = ang-ang_res; a1 <= ang+ang_res; a1 += ang_step)
680		flgs |= 1L<<(int)(16/PI*(a1 + 2.*PI*(a1 < 0)));
681		}
648	–	/* add low-angle incident (< 20deg) */
649	–	if (fabs(hp->rp->rod) <= 0.342) {
650	–	u = -DOT(hp->rp->rdir, uv[0]);
651	–	v = -DOT(hp->rp->rdir, uv[1]);
652	–	if ((r0*r0*u*u + r1*r1*v*v) > hp->rp->rot*hp->rp->rot) {
653	–	ang = atan2a(v, u);
654	–	ang += 2.*PI*(ang < 0);
655	–	ang *= 16/PI;
656	–	if ((ang < .5) | (ang >= 31.5))
657	–	flgs |= 0x80000001;
658	–	else
659	–	flgs |= 3L<<(int)(ang-.5);
660	–	}
661	–	}
682		return(flgs);
683		}
684
#	Line 695 | Line 715 | doambient(                             /* compute ambient component */
715		return(0);
716
717		if ((ra == NULL) & (pg == NULL) & (dg == NULL) ||
718	<	(hp->sampOK < 0) | (hp->ns < 9)) {
718	>	(hp->sampOK < 0) | (hp->ns < 6)) {
719		free(hp);               /* Hessian not requested/possible */
720		return(-1);             /* value-only return value */
721		}
#	Line 743 | Line 763 | doambient(                             /* compute ambient component */
763		ra[0] = maxarad;
764		}
765		/* flag encroached directions */
766	<	if ((wt >= 0.89*AVGREFL) & (crlp != NULL))
766	>	if (crlp != NULL)
767		*crlp = ambcorral(hp, uv, ra[0]*ambacc, ra[1]*ambacc);
768		if (pg != NULL) {       /* cap gradient if necessary */
769		d = pg[0]*pg[0]*ra[0]*ra[0] + pg[1]*pg[1]*ra[1]*ra[1];
#	Line 846 | Line 866 | divsample(                             /* sample a division */
866		ndims--;
867		multcolor(ar.rcol, ar.rcoef);   /* apply coefficient */
868		addcolor(dp->v, ar.rcol);
869	<	/* use rt to improve gradient calc */
870	<	if (ar.rt > FTINY && ar.rt < FHUGE)
871	<	dp->r += 1.0/ar.rt;
869	>	/* use rxt to improve gradient calc */
870	>	if (ar.rxt > FTINY && ar.rxt < FHUGE)
871	>	dp->r += 1.0/ar.rxt;
872		/* (re)initialize error */
873		if (dp->n++) {
874		b2 = bright(dp->v)/dp->n - bright(ar.rcol);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)