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.92 by greg, Fri Apr 5 01:10:26 2024 UTC vs.
Revision 2.105 by greg, Thu Aug 21 20:38:41 2025 UTC

#	Line 24 | Line 24 | static const char      RCSid[] = "$Id$";
24		#ifndef MINADIV
25		#define MINADIV         7       /* minimum # divisions in each dimension */
26		#endif
27	+	#ifndef MINSDIST
28	+	#define MINSDIST        0.2     /* def. min. spacing = 1/5th division */
29	+	#endif
30
31		typedef struct {
32		FVECT   p;              /* intersection point */
#	Line 52 | Line 55 | typedef struct {
55		} FFTRI;                /* vectors and coefficients for Hessian calculation */
56
57
58	+	#define XLOTSIZ         512             /* size of used car lot */
59	+	#define CFIRST          0               /* first corner */
60	+	#define COTHER          (CFIRST+4)      /* non-corner sample */
61	+	#define CMAXTARGET      (int)(XLOTSIZ*MINSDIST/(1-MINSDIST))
62	+
63		static int
64	<	ambcollision(                           /* proposed direciton collides? */
64	>	psample_class(double ss[2])             /* classify patch sample */
65	>	{
66	>	if (ss[0] < MINSDIST) {
67	>	if (ss[1] < MINSDIST)
68	>	return(CFIRST);
69	>	if (ss[1] > 1.-MINSDIST)
70	>	return(CFIRST+2);
71	>	} else if (ss[0] > 1.-MINSDIST) {
72	>	if (ss[1] < MINSDIST)
73	>	return(CFIRST+1);
74	>	if (ss[1] > 1.-MINSDIST)
75	>	return(CFIRST+3);
76	>	}
77	>	return(COTHER);                 /* not in a corner */
78	>	}
79	>
80	>	static void
81	>	trade_patchsamp(double ss[2])           /* trade in problem patch position */
82	>	{
83	>	static float    tradelot[XLOTSIZ][2];
84	>	static int      gterm[COTHER+1];
85	>	double          repl[2];
86	>	int             sclass, rclass;
87	>	int             x;
88	>	re_initialize:                          /* initialize lot? */
89	>	while (gterm[COTHER] < XLOTSIZ) {
90	>	tradelot[gterm[COTHER]][0] = frandom();
91	>	tradelot[gterm[COTHER]][1] = frandom();
92	>	++gterm[COTHER];
93	>	}
94	>	/* get trade-in candidate... */
95	>	sclass = psample_class(ss);     /* submitted corner or not? */
96	>	switch (sclass) {
97	>	case COTHER:                    /* trade mid-edge with corner/any */
98	>	x = irandom( gterm[COTHER-1] > CMAXTARGET
99	>	? gterm[COTHER-1] : XLOTSIZ );
100	>	break;
101	>	case CFIRST:                    /* kick out of first corner */
102	>	x = gterm[CFIRST] + irandom(XLOTSIZ - gterm[CFIRST]);
103	>	break;
104	>	default:                        /* kick out of 2nd-4th corner */
105	>	x = irandom(XLOTSIZ - (gterm[sclass] - gterm[sclass-1]));
106	>	x += (x >= gterm[sclass-1])*(gterm[sclass] - gterm[sclass-1]);
107	>	break;
108	>	}
109	>	if (x >= XLOTSIZ) {             /* uh-oh... trapped in a corner! */
110	>	memset(gterm, 0, sizeof(gterm));
111	>	goto re_initialize;
112	>	}
113	>	repl[0] = tradelot[x][0];       /* save selected replacement (result) */
114	>	repl[1] = tradelot[x][1];
115	>	/* identify replacement class */
116	>	for (rclass = CFIRST; rclass < COTHER; rclass++)
117	>	if (x < gterm[rclass])
118	>	break;          /* repark to keep classes grouped */
119	>	while (rclass > sclass) {       /* replacement group after submitted? */
120	>	tradelot[x][0] = tradelot[gterm[rclass-1]][0];
121	>	tradelot[x][1] = tradelot[gterm[rclass-1]][1];
122	>	x = gterm[--rclass]++;
123	>	}
124	>	while (rclass < sclass) {       /* replacement group before submitted? */
125	>	tradelot[x][0] = tradelot[--gterm[rclass]][0];
126	>	tradelot[x][1] = tradelot[gterm[rclass]][1];
127	>	x = gterm[rclass++];
128	>	}
129	>	tradelot[x][0] = ss[0];         /* complete the trade-in */
130	>	tradelot[x][1] = ss[1];
131	>	ss[0] = repl[0];
132	>	ss[1] = repl[1];
133	>	}
134	>
135	>	#undef XLOTSIZ
136	>	#undef COTHER
137	>	#undef CFIRST
138	>
139	>
140	>	static int
141	>	ambcollision(                           /* proposed direction collides? */
142		AMBHEMI *hp,
143		int     i,
144		int     j,
145	<	FVECT   dv
145	>	RREAL   spt[2]
146		)
147		{
63	–	double  cos_thresh;
148		int     ii, jj;
65	–	/* min. spacing = 1/4th division */
66	–	cos_thresh = (PI/4.)/(double)hp->ns;
67	–	cos_thresh = 1. - .5*cos_thresh*cos_thresh;
149		/* check existing neighbors */
150		for (ii = i-1; ii <= i+1; ii++) {
151		if (ii < 0) continue;
#	Line 72 | Line 153 | ambcollision(                          /* proposed direciton collides? */
153		for (jj = j-1; jj <= j+1; jj++) {
154		AMBSAMP *ap;
155		FVECT   avec;
156	<	double  dprod;
156	>	double  dx, dy;
157		if (jj < 0) continue;
158		if (jj >= hp->ns) break;
159		if ((ii==i) & (jj==j)) continue;
#	Line 80 | Line 161 | ambcollision(                          /* proposed direciton collides? */
161		if (ap->d <= .5/FHUGE)
162		continue;       /* no one home */
163		VSUB(avec, ap->p, hp->rp->rop);
164	<	dprod = DOT(avec, dv);
165	<	if (dprod >= cos_thresh*VLEN(avec))
166	<	return(1);      /* collision */
164	>	normalize(avec);        /* use diskworld distance */
165	>	dx = DOT(avec, hp->ux) - spt[0];
166	>	dy = DOT(avec, hp->uy) - spt[1];
167	>	if ((dx*dx + dy*dy)*(hp->ns*hp->ns) <
168	>	PI*MINSDIST*MINSDIST)
169	>	return(1);      /* too close */
170		}
171		}
172		return(0);                      /* nothing to worry about */
#	Line 97 | Line 181 | ambsample(                             /* initial ambient division sample */
181		int     n
182		)
183		{
184	+	int     trade_ok = (!n & (hp->ns >= 4))*21;
185		AMBSAMP *ap = &ambsam(hp,i,j);
186		RAY     ar;
187		int     hlist[3], ii;
188	+	double  ss[2];
189		RREAL   spt[2];
190		double  zd;
191		/* generate hemispherical sample */
#	Line 115 | Line 201 | ambsample(                             /* initial ambient division sample */
201		scalescolor(ar.rcoef, 1./AVGREFL);
202		}
203		hlist[0] = hp->rp->rno;
204	<	hlist[1] = j;
205	<	hlist[2] = i;
206	<	multisamp(spt, 2, urand(ilhash(hlist,3)+n));
207	<	resample:
208	<	square2disk(spt, (j+spt[1])/hp->ns, (i+spt[0])/hp->ns);
204	>	hlist[1] = AI(hp,i,j);
205	>	hlist[2] = samplendx;
206	>	multisamp(ss, 2, urand(ilhash(hlist,3)+n));
207	>	square2disk(spt, (j+ss[1])/hp->ns, (i+ss[0])/hp->ns);
208	>	/* avoid coincident samples? */
209	>	while (trade_ok-- && ambcollision(hp, i, j, spt)) {
210	>	if (trade_ok) {
211	>	trade_patchsamp(ss);
212	>	} else {                /* punting... */
213	>	ss[0] = MINSDIST + (1-2*MINSDIST)*frandom();
214	>	ss[1] = MINSDIST + (1-2*MINSDIST)*frandom();
215	>	}
216	>	square2disk(spt, (j+ss[1])/hp->ns, (i+ss[0])/hp->ns);
217	>	}
218		zd = sqrt(1. - spt[0]*spt[0] - spt[1]*spt[1]);
219		for (ii = 3; ii--; )
220		ar.rdir[ii] =   spt[0]*hp->ux[ii] +
221		spt[1]*hp->uy[ii] +
222		zd*hp->onrm[ii];
223		checknorm(ar.rdir);
224	<	/* avoid coincident samples */
130	<	if (!n && ambcollision(hp, i, j, ar.rdir)) {
131	<	spt[0] = frandom(); spt[1] = frandom();
132	<	goto resample;          /* reject this sample */
133	<	}
134	<	dimlist[ndims++] = AI(hp,i,j) + 90171;
224	>	dimlist[ndims_inc()] = AI(hp,i,j) + 90171;
225		rayvalue(&ar);                  /* evaluate ray */
226	<	ndims--;
226	>	dec_ndims();
227		zd = raydistance(&ar);
228		if (zd <= FTINY)
229		return(0);              /* should never happen */
#	Line 162 | Line 252 | resample:
252		static float *
253		getambdiffs(AMBHEMI *hp)
254		{
255	<	const double    normf = 1./bright(hp->acoef);
256	<	float   *earr = (float *)calloc(hp->ns*hp->ns, sizeof(float));
255	>	const double    normf = 1./(pbright(hp->acoef) + FTINY);
256	>	float   *earr = (float *)calloc(2*hp->ns*hp->ns, sizeof(float));
257		float   *ep;
258		AMBSAMP *ap;
259		double  b, b1, d2;
#	Line 172 | Line 262 | getambdiffs(AMBHEMI *hp)
262		if (earr == NULL)               /* out of memory? */
263		return(NULL);
264		/* sum squared neighbor diffs */
265	<	for (ap = hp->sa, ep = earr, i = 0; i < hp->ns; i++)
265	>	ap = hp->sa;
266	>	ep = earr + hp->ns*hp->ns;      /* original estimates to scratch */
267	>	for (i = 0; i < hp->ns; i++)
268		for (j = 0; j < hp->ns; j++, ap++, ep++) {
269		b = pbright(ap[0].v);
270		if (i) {                /* from above */
#	Line 198 | Line 290 | getambdiffs(AMBHEMI *hp)
290		ep[-hp->ns-1] += d2;
291		}
292		/* correct for number of neighbors */
293	<	earr[0] *= 8./3.;
294	<	earr[hp->ns-1] *= 8./3.;
295	<	earr[(hp->ns-1)*hp->ns] *= 8./3.;
296	<	earr[(hp->ns-1)*hp->ns + hp->ns-1] *= 8./3.;
293	>	ep = earr + hp->ns*hp->ns;
294	>	ep[0] *= 6./3.;
295	>	ep[hp->ns-1] *= 6./3.;
296	>	ep[(hp->ns-1)*hp->ns] *= 6./3.;
297	>	ep[(hp->ns-1)*hp->ns + hp->ns-1] *= 6./3.;
298		for (i = 1; i < hp->ns-1; i++) {
299	<	earr[i*hp->ns] *= 8./5.;
300	<	earr[i*hp->ns + hp->ns-1] *= 8./5.;
299	>	ep[i*hp->ns] *= 6./5.;
300	>	ep[i*hp->ns + hp->ns-1] *= 6./5.;
301		}
302		for (j = 1; j < hp->ns-1; j++) {
303	<	earr[j] *= 8./5.;
304	<	earr[(hp->ns-1)*hp->ns + j] *= 8./5.;
303	>	ep[j] *= 6./5.;
304	>	ep[(hp->ns-1)*hp->ns + j] *= 6./5.;
305		}
306	+	/* blur final map to reduce bias */
307	+	for (i = 0; i < hp->ns-1; i++) {
308	+	float  *ep2;
309	+	ep = earr + i*hp->ns;
310	+	ep2 = ep + hp->ns*hp->ns;
311	+	for (j = 0; j < hp->ns-1; j++, ep++, ep2++) {
312	+	ep[0] += .5*ep2[0] + .125*(ep2[1] + ep2[hp->ns]);
313	+	ep[1] += .125*ep2[0];
314	+	ep[hp->ns] += .125*ep2[0];
315	+	}
316	+	}
317		return(earr);
318		}
319
#	Line 261 | Line 365 | samp_hemi(                             /* sample indirect hemisphere */
365		/* set number of divisions */
366		if (backside) wt = -wt;
367		if (ambacc <= FTINY &&
368	<	wt > (d *= 0.8*r->rweight/(ambdiv*minweight)))
368	>	wt > (d *= 0.8*r->rweight/(ambdiv*minweight + 1e-20)))
369		wt = d;                 /* avoid ray termination */
370		n = sqrt(ambdiv * wt) + 0.5;
371		i = 1 + (MINADIV-1)*(ambacc > FTINY);
#	Line 310 | Line 414 | samp_hemi(                             /* sample indirect hemisphere */
414		if (hp->sampOK <= MINADIV*MINADIV)
415		return(hp);             /* don't bother super-sampling */
416		n = ambssamp*wt + 0.5;
417	<	if (n > 8) {                    /* perform super-sampling? */
417	>	if (n >= 4*hp->ns) {            /* perform super-sampling? */
418		ambsupersamp(hp, n);
419		copyscolor(rcol, hp->acol);
420		}

Diff Legend

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