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.99 by greg, Sun Apr 27 20:20:01 2025 UTC vs.
Revision 2.103 by greg, Fri Jun 20 16:48:39 2025 UTC

#	Line 55 | Line 55 | typedef struct {
55		} FFTRI;                /* vectors and coefficients for Hessian calculation */
56
57
58	<	static int
59	<	ambcollision(                           /* proposed direciton collides? */
60	<	AMBHEMI *hp,
61	<	int     i,
62	<	int     j,
63	<	FVECT   dv
64	<	)
65	<	{
66	<	double  cos_thresh;
67	<	int     ii, jj;
68	<
69	<	cos_thresh = (PI*MINSDIST)/(double)hp->ns;
70	<	cos_thresh = 1. - .5*cos_thresh*cos_thresh;
71	<	/* check existing neighbors */
72	<	for (ii = i-1; ii <= i+1; ii++) {
73	<	if (ii < 0) continue;
74	<	if (ii >= hp->ns) break;
75	<	for (jj = j-1; jj <= j+1; jj++) {
76	<	AMBSAMP *ap;
77	<	FVECT   avec;
78	<	double  dprod;
79	<	if (jj < 0) continue;
80	<	if (jj >= hp->ns) break;
81	<	if ((ii==i) & (jj==j)) continue;
82	<	ap = &ambsam(hp,ii,jj);
83	<	if (ap->d <= .5/FHUGE)
84	<	continue;       /* no one home */
85	<	VSUB(avec, ap->p, hp->rp->rop);
86	<	dprod = DOT(avec, dv);
87	<	if (dprod >= cos_thresh*VLEN(avec))
88	<	return(1);      /* collision */
89	<	}
90	<	}
91	<	return(0);                      /* nothing to worry about */
92	<	}
93	<
94	<
95	<	#define XLOTSIZ         251             /* size of used car lot */
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))
99	–	#define CXCOPY(d,s)     (excharr[d][0]=excharr[s][0], excharr[d][1]=excharr[s][1])
62
63		static int
64		psample_class(double ss[2])             /* classify patch sample */
#	Line 118 | Line 80 | psample_class(double ss[2])            /* classify patch sample
80		static void
81		trade_patchsamp(double ss[2])           /* trade in problem patch position */
82		{
83	<	static float    excharr[XLOTSIZ][2];
83	>	static float    tradelot[XLOTSIZ][2];
84		static short    gterm[COTHER+1];
85	<	double          srep[2];
85	>	double          repl[2];
86		int             sclass, rclass;
87		int             x;
88	<	/* reset on corner overload */
127	<	if (gterm[COTHER-1] >= (CMAXTARGET+XLOTSIZ)/2)
128	<	memset(gterm, 0, sizeof(gterm));
129	<	/* (re-)initialize? */
88	>	/* initialize lot? */
89		while (gterm[COTHER] < XLOTSIZ) {
90	<	excharr[gterm[COTHER]][0] = frandom();
91	<	excharr[gterm[COTHER]][1] = frandom();
90	>	tradelot[gterm[COTHER]][0] = frandom();
91	>	tradelot[gterm[COTHER]][1] = frandom();
92		++gterm[COTHER];
93	<	}                               /* get trade-in candidate... */
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 */
#	Line 146 | Line 106 | trade_patchsamp(double ss[2])          /* trade in problem pat
106		x += (x >= gterm[sclass-1])*(gterm[sclass] - gterm[sclass-1]);
107		break;
108		}
109	<	srep[0] = excharr[x][0];        /* save selected trade output */
110	<	srep[1] = excharr[x][1];
111	<	/* adjust our lot groups */
109	>	repl[0] = tradelot[x][0];       /* save selected replacement (result) */
110	>	repl[1] = tradelot[x][1];
111	>	/* identify replacement class */
112		for (rclass = CFIRST; rclass < COTHER; rclass++)
113		if (x < gterm[rclass])
114	<	break;
115	<	if (sclass < rclass) {          /* submitted group before replacement? */
116	<	CXCOPY(x, gterm[rclass-1]);
117	<	while (--rclass > sclass) {
118	<	CXCOPY(gterm[rclass], gterm[rclass-1]);
159	<	++gterm[rclass];
160	<	}
161	<	x = gterm[sclass]++;
162	<	} else if (sclass > rclass) {   /* submitted group after replacement? */
163	<	--gterm[rclass];
164	<	CXCOPY(x, gterm[rclass]);
165	<	while (++rclass < sclass) {
166	<	--gterm[rclass];
167	<	CXCOPY(gterm[rclass-1], gterm[rclass]);
168	<	}
169	<	x = gterm[sclass-1];
114	>	break;          /* repark to keep classes grouped */
115	>	while (rclass > sclass) {       /* replacement group after submitted? */
116	>	tradelot[x][0] = tradelot[gterm[rclass-1]][0];
117	>	tradelot[x][1] = tradelot[gterm[rclass-1]][1];
118	>	x = gterm[--rclass]++;
119		}
120	<	excharr[x][0] = ss[0];          /* complete the transaction */
121	<	excharr[x][1] = ss[1];
122	<	ss[0] = srep[0];
123	<	ss[1] = srep[1];
120	>	while (rclass < sclass) {       /* replacement group before submitted? */
121	>	tradelot[x][0] = tradelot[--gterm[rclass]][0];
122	>	tradelot[x][1] = tradelot[gterm[rclass]][1];
123	>	x = gterm[rclass++];
124	>	}
125	>	tradelot[x][0] = ss[0];         /* complete the trade-in */
126	>	tradelot[x][1] = ss[1];
127	>	ss[0] = repl[0];
128	>	ss[1] = repl[1];
129		}
130
177	–	#undef CXCOPY
131		#undef XLOTSIZ
132		#undef COTHER
133		#undef CFIRST
134
135
136		static int
137	+	ambcollision(                           /* proposed direction collides? */
138	+	AMBHEMI *hp,
139	+	int     i,
140	+	int     j,
141	+	RREAL   spt[2]
142	+	)
143	+	{
144	+	int     ii, jj;
145	+	/* check existing neighbors */
146	+	for (ii = i-1; ii <= i+1; ii++) {
147	+	if (ii < 0) continue;
148	+	if (ii >= hp->ns) break;
149	+	for (jj = j-1; jj <= j+1; jj++) {
150	+	AMBSAMP *ap;
151	+	FVECT   avec;
152	+	double  dx, dy;
153	+	if (jj < 0) continue;
154	+	if (jj >= hp->ns) break;
155	+	if ((ii==i) & (jj==j)) continue;
156	+	ap = &ambsam(hp,ii,jj);
157	+	if (ap->d <= .5/FHUGE)
158	+	continue;       /* no one home */
159	+	VSUB(avec, ap->p, hp->rp->rop);
160	+	normalize(avec);        /* use diskworld distance */
161	+	dx = DOT(avec, hp->ux) - spt[0];
162	+	dy = DOT(avec, hp->uy) - spt[1];
163	+	if ((dx*dx + dy*dy)*(hp->ns*hp->ns) <
164	+	PI*MINSDIST*MINSDIST)
165	+	return(1);      /* too close */
166	+	}
167	+	}
168	+	return(0);                      /* nothing to worry about */
169	+	}
170	+
171	+
172	+	static int
173		ambsample(                              /* initial ambient division sample */
174		AMBHEMI *hp,
175		int     i,
#	Line 188 | Line 177 | ambsample(                             /* initial ambient division sample */
177		int     n
178		)
179		{
180	+	int     trade_ok = (!n & (hp->ns >= 4))*21;
181		AMBSAMP *ap = &ambsam(hp,i,j);
182		RAY     ar;
183		int     hlist[3], ii;
#	Line 210 | Line 200 | ambsample(                             /* initial ambient division sample */
200		hlist[1] = AI(hp,i,j);
201		hlist[2] = samplendx;
202		multisamp(ss, 2, urand(ilhash(hlist,3)+n));
213	–	patch_redo:
203		square2disk(spt, (j+ss[1])/hp->ns, (i+ss[0])/hp->ns);
204	+	/* avoid coincident samples? */
205	+	while (trade_ok-- && ambcollision(hp, i, j, spt)) {
206	+	if (trade_ok) {
207	+	trade_patchsamp(ss);
208	+	} else {                /* punting... */
209	+	ss[0] = MINSDIST + (1-2*MINSDIST)*frandom();
210	+	ss[1] = MINSDIST + (1-2*MINSDIST)*frandom();
211	+	}
212	+	square2disk(spt, (j+ss[1])/hp->ns, (i+ss[0])/hp->ns);
213	+	}
214		zd = sqrt(1. - spt[0]*spt[0] - spt[1]*spt[1]);
215		for (ii = 3; ii--; )
216		ar.rdir[ii] =   spt[0]*hp->ux[ii] +
217		spt[1]*hp->uy[ii] +
218		zd*hp->onrm[ii];
219		checknorm(ar.rdir);
220	<	/* avoid coincident samples */
222	<	if (!n & (hp->ns >= 4) && ambcollision(hp, i, j, ar.rdir)) {
223	<	trade_patchsamp(ss);
224	<	goto patch_redo;
225	<	}
226	<	dimlist[ndims++] = AI(hp,i,j) + 90171;
220	>	dimlist[ndims_inc] = AI(hp,i,j) + 90171;
221		rayvalue(&ar);                  /* evaluate ray */
222	<	ndims--;
222	>	dec_ndims;
223		zd = raydistance(&ar);
224		if (zd <= FTINY)
225		return(0);              /* should never happen */

Diff Legend

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