ViewVC Help

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

root/Development/ray/src/cv/bsdfrbf.c

Comparing ray/src/cv/bsdfrbf.c (file contents):
Revision 2.10 by greg, Fri Oct 18 02:49:30 2013 UTC vs.
Revision 2.11 by greg, Sat Oct 19 00:11:50 2013 UTC

#	Line 15 | Line 15 | static const char RCSid[] = "$Id$";
15		#include "bsdfrep.h"
16
17		#ifndef MINRSCA
18	<	#define MINRSCA         0.5             /* minimum radius scaling factor */
18	>	#define MINRSCA         1.0             /* minimum radius scaling factor */
19		#endif
20		#ifndef MAXRSCA
21		#define MAXRSCA         2.7             /* maximum radius scaling factor */
22		#endif
23	<	#ifndef DIFFTHRESH
24	<	#define DIFFTHRESH      0.2             /* culling difference threshold */
23	>	#ifndef VARTHRESH
24	>	#define VARTHRESH       0.0015          /* culling variance threshold */
25		#endif
26	+	#ifndef DIFFMAX2
27	+	#define DIFFMAX2        (16.*VARTHRESH) /* maximum ignored sample variance */
28	+	#endif
29		#ifndef MAXFRAC
30		#define MAXFRAC         0.5             /* maximum contribution to neighbor */
31		#endif
#	Line 75 | Line 78 | add_bsdf_data(double theta_out, double phi_out, double
78		dsf_grid[pos[0]][pos[1]].nval++;
79		}
80
78	–	/* Check if the two DSF values are significantly different */
79	–	static int
80	–	big_diff(double ref, double tst)
81	–	{
82	–	if (ref > 0) {
83	–	tst = tst/ref - 1.;
84	–	if (tst < 0) tst = -tst;
85	–	} else
86	–	tst *= 50.;
87	–	return(tst > DIFFTHRESH);
88	–	}
89	–
81		/* Compute radii for non-empty bins */
82		/* (distance to furthest empty bin for which non-empty test bin is closest) */
83		static void
#	Line 139 | Line 130 | compute_radii(void)
130		}
131		for (i = 0; i < GRIDRES; i++)           /* grow radii where uniform */
132		for (j = 0; j < GRIDRES; j++) {
133	<	double  midmean;
133	>	double  midmean = 0.0;
134	>	int     nsum = 0;
135		if (!dsf_grid[i][j].nval)
136		continue;
137	<	midmean = dsf_grid[i][j].vsum / (double)dsf_grid[i][j].nval;
138	<	r = R2ANG(dsf_grid[i][j].crad)*(MAXRSCA*GRIDRES/M_PI);
137	>	r = 1;                          /* avg. immediate neighbors */
138	>	for (ii = i-r; ii <= i+r; ii++) {
139	>	if (ii < 0) continue;
140	>	if (ii >= GRIDRES) break;
141	>	for (jj = j-r; jj <= j+r; jj++) {
142	>	if (jj < 0) continue;
143	>	if (jj >= GRIDRES) break;
144	>	midmean += dsf_grid[ii][jj].vsum;
145	>	nsum += dsf_grid[ii][jj].nval;
146	>	}
147	>	}
148	>	midmean /= (double)nsum;
149		while (++r < GRIDRES) {         /* attempt to grow perimeter */
150	+	double      diff2sum = 0.0;
151	+	nsum = 0;
152		for (ii = i-r; ii <= i+r; ii++) {
153		int     jstep = 1;
154		if (ii < 0) continue;
#	Line 152 | Line 156 | compute_radii(void)
156		if ((i-r < ii) & (ii < i+r))
157		jstep = r<<1;
158		for (jj = j-r; jj <= j+r; jj += jstep) {
159	+	double  d2;
160		if (jj < 0) continue;
161		if (jj >= GRIDRES) break;
162	<	if (dsf_grid[ii][jj].nval && big_diff(midmean,
163	<	dsf_grid[ii][jj].vsum /
164	<	(double)dsf_grid[ii][jj].nval))
165	<	goto hit_diff;
162	>	if (!dsf_grid[ii][jj].nval)
163	>	continue;
164	>	d2 = midmean - dsf_grid[ii][jj].vsum /
165	>	(double)dsf_grid[ii][jj].nval;
166	>	d2 *= d2;
167	>	if (d2 > DIFFMAX2*midmean*midmean)
168	>	goto escape;
169	>	diff2sum += d2;
170	>	++nsum;
171		}
172		}
173	+	if (diff2sum > VARTHRESH*midmean*midmean*(double)nsum)
174	+	break;
175		}
176	<	hit_diff:       --r;
177	<	dsf_grid[i][j].crad = ANG2R(r*(M_PI/MAXRSCA/GRIDRES));
178	<	if (dsf_grid[i][j].crad < cradmin)
179	<	dsf_grid[i][j].crad = cradmin;
176	>	escape:         --r;
177	>	r = ANG2R(r*(M_PI/MAXRSCA/GRIDRES));
178	>	if (r < cradmin)
179	>	r = cradmin;
180	>	if (dsf_grid[i][j].crad < r)
181	>	dsf_grid[i][j].crad = r;
182		}
183		/* blur radii over hemisphere */
184		memset(fill_grid, 0, sizeof(fill_grid));
#	Line 194 | Line 208 | hit_diff:      --r;
208		dsf_grid[i][j].crad = fill_grid[i][j]/fill_cnt[i][j];
209		}
210
211	+	/* Radius comparison for qsort() */
212	+	static int
213	+	radius_cmp(const void *p1, const void *p2)
214	+	{
215	+	return( (int)dsf_grid[0][*(const int *)p1].crad -
216	+	(int)dsf_grid[0][*(const int *)p2].crad );
217	+	}
218	+
219		/* Cull points for more uniform distribution, leave all nval 0 or 1 */
220		static void
221		cull_values(void)
222		{
223	+	int     indx[GRIDRES*GRIDRES];
224		FVECT   ovec0, ovec1;
225		double  maxang, maxang2;
226	<	int     i, j, ii, jj, r;
226	>	int     i, j, k, ii, jj, r;
227	>	/* sort by radius first */
228	>	for (k = GRIDRES*GRIDRES; k--; )
229	>	indx[k] = k;
230	>	qsort(indx, GRIDRES*GRIDRES, sizeof(int), &radius_cmp);
231		/* simple greedy algorithm */
232	<	for (i = 0; i < GRIDRES; i++)
233	<	for (j = 0; j < GRIDRES; j++) {
232	>	for (k = GRIDRES*GRIDRES; k--; ) {
233	>	i = indx[k]/GRIDRES;            /* from biggest radius down */
234	>	j = indx[k] - i*GRIDRES;
235		if (!dsf_grid[i][j].nval)
236		continue;
237		if (!dsf_grid[i][j].crad)
238	<	continue;               /* shouldn't happen */
238	>	break;          /* shouldn't happen */
239		ovec_from_pos(ovec0, i, j);
240		maxang = 2.*R2ANG(dsf_grid[i][j].crad);
241		/* clamp near horizon */
#	Line 236 | Line 264 | cull_values(void)
264		dsf_grid[ii][jj].nval = 0;
265		}
266		}
267	<	}
267	>	}
268		/* final averaging pass */
269		for (i = 0; i < GRIDRES; i++)
270		for (j = 0; j < GRIDRES; j++)
#	Line 246 | Line 274 | cull_values(void)
274		}
275		}
276
277	<	/* Compute minimum BSDF from histogram and clear it */
277	>	/* Compute minimum BSDF from histogram (does not clear) */
278		static void
279		comp_bsdf_min()
280		{
#	Line 265 | Line 293 | comp_bsdf_min()
293		for (i = 0; cnt <= target; i++)
294		cnt += bsdf_hist[i];
295		bsdf_min = histval(i-1);
268	–	memset(bsdf_hist, 0, sizeof(bsdf_hist));
296		}
297
298		/* Find n nearest sub-sampled neighbors to the given grid position */

Diff Legend

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