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.9 by greg, Sat Feb 22 02:07:28 2003 UTC vs.
Revision 2.23 by greg, Tue Feb 5 05:40:06 2013 UTC

#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*  Declarations of external symbols in ambient.h
8		*/
9
10	<	/* ====================================================================
11	<	* The Radiance Software License, Version 1.0
12	<	*
13	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
14	<	* through Lawrence Berkeley National Laboratory.   All rights reserved.
15	<	*
16	<	* Redistribution and use in source and binary forms, with or without
17	<	* modification, are permitted provided that the following conditions
18	<	* are met:
19	<	*
20	<	* 1. Redistributions of source code must retain the above copyright
21	<	*         notice, this list of conditions and the following disclaimer.
22	<	*
23	<	* 2. Redistributions in binary form must reproduce the above copyright
24	<	*       notice, this list of conditions and the following disclaimer in
25	<	*       the documentation and/or other materials provided with the
26	<	*       distribution.
27	<	*
28	<	* 3. The end-user documentation included with the redistribution,
29	<	*           if any, must include the following acknowledgment:
30	<	*             "This product includes Radiance software
31	<	*                 (http://radsite.lbl.gov/)
32	<	*                 developed by the Lawrence Berkeley National Laboratory
33	<	*               (http://www.lbl.gov/)."
34	<	*       Alternately, this acknowledgment may appear in the software itself,
35	<	*       if and wherever such third-party acknowledgments normally appear.
36	<	*
37	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38	<	*       and "The Regents of the University of California" must
39	<	*       not be used to endorse or promote products derived from this
40	<	*       software without prior written permission. For written
41	<	*       permission, please contact [email protected].
42	<	*
43	<	* 5. Products derived from this software may not be called "Radiance",
44	<	*       nor may "Radiance" appear in their name, without prior written
45	<	*       permission of Lawrence Berkeley National Laboratory.
46	<	*
47	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50	<	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58	<	* SUCH DAMAGE.
59	<	* ====================================================================
60	<	*
61	<	* This software consists of voluntary contributions made by many
62	<	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63	<	* information on Lawrence Berkeley National Laboratory, please see
64	<	* <http://www.lbl.gov/>.
65	<	*/
10	>	#include "copyright.h"
11
12		#include  "ray.h"
13
#	Line 71 | Line 16 | static const char      RCSid[] = "$Id$";
16		#include  "random.h"
17
18
19	<	static int
20	<	ambcmp(d1, d2)                          /* decreasing order */
21	<	AMBSAMP  *d1, *d2;
19	>	void
20	>	inithemi(                       /* initialize sampling hemisphere */
21	>	AMBHEMI  *hp,
22	>	COLOR ac,
23	>	RAY  *r,
24	>	double  wt
25	>	)
26		{
27	<	if (d1->k < d2->k)
28	<	return(1);
29	<	if (d1->k > d2->k)
30	<	return(-1);
31	<	return(0);
27	>	double  d;
28	>	int  i;
29	>	/* set number of divisions */
30	>	if (ambacc <= FTINY &&
31	>	wt > (d = 0.8*intens(ac)*r->rweight/(ambdiv*minweight)))
32	>	wt = d;                 /* avoid ray termination */
33	>	hp->nt = sqrt(ambdiv * wt / PI) + 0.5;
34	>	i = ambacc > FTINY ? 3 : 1;     /* minimum number of samples */
35	>	if (hp->nt < i)
36	>	hp->nt = i;
37	>	hp->np = PI * hp->nt + 0.5;
38	>	/* set number of super-samples */
39	>	hp->ns = ambssamp * wt + 0.5;
40	>	/* assign coefficient */
41	>	copycolor(hp->acoef, ac);
42	>	d = 1.0/(hp->nt*hp->np);
43	>	scalecolor(hp->acoef, d);
44	>	/* make axes */
45	>	VCOPY(hp->uz, r->ron);
46	>	hp->uy[0] = hp->uy[1] = hp->uy[2] = 0.0;
47	>	for (i = 0; i < 3; i++)
48	>	if (hp->uz[i] < 0.6 && hp->uz[i] > -0.6)
49	>	break;
50	>	if (i >= 3)
51	>	error(CONSISTENCY, "bad ray direction in inithemi");
52	>	hp->uy[i] = 1.0;
53	>	fcross(hp->ux, hp->uy, hp->uz);
54	>	normalize(hp->ux);
55	>	fcross(hp->uy, hp->uz, hp->ux);
56		}
57
58
86	–	static int
87	–	ambnorm(d1, d2)                         /* standard order */
88	–	AMBSAMP  *d1, *d2;
89	–	{
90	–	register int  c;
91	–
92	–	if (c = d1->t - d2->t)
93	–	return(c);
94	–	return(d1->p - d2->p);
95	–	}
96	–
97	–
59		int
60	<	divsample(dp, h, r)                     /* sample a division */
61	<	register AMBSAMP  *dp;
62	<	AMBHEMI  *h;
63	<	RAY  *r;
60	>	divsample(                              /* sample a division */
61	>	AMBSAMP  *dp,
62	>	AMBHEMI  *h,
63	>	RAY  *r
64	>	)
65		{
66		RAY  ar;
67		int  hlist[3];
#	Line 107 | Line 69 | RAY  *r;
69		double  xd, yd, zd;
70		double  b2;
71		double  phi;
72	<	register int  i;
73	<
74	<	if (rayorigin(&ar, r, AMBIENT, AVGREFL) < 0)
72	>	int  i;
73	>	/* ambient coefficient for weight */
74	>	if (ambacc > FTINY)
75	>	setcolor(ar.rcoef, AVGREFL, AVGREFL, AVGREFL);
76	>	else
77	>	copycolor(ar.rcoef, h->acoef);
78	>	if (rayorigin(&ar, AMBIENT, r, ar.rcoef) < 0)
79		return(-1);
80	+	if (ambacc > FTINY) {
81	+	multcolor(ar.rcoef, h->acoef);
82	+	scalecolor(ar.rcoef, 1./AVGREFL);
83	+	}
84		hlist[0] = r->rno;
85		hlist[1] = dp->t;
86		hlist[2] = dp->p;
#	Line 124 | Line 94 | RAY  *r;
94		ar.rdir[i] =    xd*h->ux[i] +
95		yd*h->uy[i] +
96		zd*h->uz[i];
97	+	checknorm(ar.rdir);
98		dimlist[ndims++] = dp->t*h->np + dp->p + 90171;
99		rayvalue(&ar);
100		ndims--;
101	+	multcolor(ar.rcol, ar.rcoef);   /* apply coefficient */
102		addcolor(dp->v, ar.rcol);
103		/* use rt to improve gradient calc */
104		if (ar.rt > FTINY && ar.rt < FHUGE)
#	Line 142 | Line 114 | RAY  *r;
114		}
115
116
117	+	static int
118	+	ambcmp(                                 /* decreasing order */
119	+	const void *p1,
120	+	const void *p2
121	+	)
122	+	{
123	+	const AMBSAMP   *d1 = (const AMBSAMP *)p1;
124	+	const AMBSAMP   *d2 = (const AMBSAMP *)p2;
125	+
126	+	if (d1->k < d2->k)
127	+	return(1);
128	+	if (d1->k > d2->k)
129	+	return(-1);
130	+	return(0);
131	+	}
132	+
133	+
134	+	static int
135	+	ambnorm(                                /* standard order */
136	+	const void *p1,
137	+	const void *p2
138	+	)
139	+	{
140	+	const AMBSAMP   *d1 = (const AMBSAMP *)p1;
141	+	const AMBSAMP   *d2 = (const AMBSAMP *)p2;
142	+	int     c;
143	+
144	+	if ( (c = d1->t - d2->t) )
145	+	return(c);
146	+	return(d1->p - d2->p);
147	+	}
148	+
149	+
150		double
151	<	doambient(acol, r, wt, pg, dg)          /* compute ambient component */
152	<	COLOR  acol;
153	<	RAY  *r;
154	<	double  wt;
155	<	FVECT  pg, dg;
151	>	doambient(                              /* compute ambient component */
152	>	COLOR  rcol,
153	>	RAY  *r,
154	>	double  wt,
155	>	FVECT  pg,
156	>	FVECT  dg
157	>	)
158		{
159		double  b, d;
160		AMBHEMI  hemi;
161		AMBSAMP  *div;
162		AMBSAMP  dnew;
163	<	register AMBSAMP  *dp;
163	>	double  acol[3];
164	>	AMBSAMP  *dp;
165		double  arad;
166	<	int  ndivs, ns;
167	<	register int  i, j;
160	<	/* initialize color */
161	<	setcolor(acol, 0.0, 0.0, 0.0);
166	>	int  divcnt;
167	>	int  i, j;
168		/* initialize hemisphere */
169	<	inithemi(&hemi, r, wt);
170	<	ndivs = hemi.nt * hemi.np;
171	<	if (ndivs == 0)
169	>	inithemi(&hemi, rcol, r, wt);
170	>	divcnt = hemi.nt * hemi.np;
171	>	/* initialize */
172	>	if (pg != NULL)
173	>	pg[0] = pg[1] = pg[2] = 0.0;
174	>	if (dg != NULL)
175	>	dg[0] = dg[1] = dg[2] = 0.0;
176	>	setcolor(rcol, 0.0, 0.0, 0.0);
177	>	if (divcnt == 0)
178		return(0.0);
179	<	/* set number of super-samples */
180	<	ns = ambssamp * wt + 0.5;
181	<	if (ns > 0 || pg != NULL || dg != NULL) {
170	<	div = (AMBSAMP *)malloc(ndivs*sizeof(AMBSAMP));
179	>	/* allocate super-samples */
180	>	if (hemi.ns > 0 || pg != NULL || dg != NULL) {
181	>	div = (AMBSAMP *)malloc(divcnt*sizeof(AMBSAMP));
182		if (div == NULL)
183		error(SYSTEM, "out of memory in doambient");
184		} else
185		div = NULL;
186		/* sample the divisions */
187		arad = 0.0;
188	+	acol[0] = acol[1] = acol[2] = 0.0;
189		if ((dp = div) == NULL)
190		dp = &dnew;
191	+	divcnt = 0;
192		for (i = 0; i < hemi.nt; i++)
193		for (j = 0; j < hemi.np; j++) {
194		dp->t = i; dp->p = j;
195		setcolor(dp->v, 0.0, 0.0, 0.0);
196		dp->r = 0.0;
197		dp->n = 0;
198	<	if (divsample(dp, &hemi, r) < 0)
199	<	goto oopsy;
198	>	if (divsample(dp, &hemi, r) < 0) {
199	>	if (div != NULL)
200	>	dp++;
201	>	continue;
202	>	}
203		arad += dp->r;
204	+	divcnt++;
205		if (div != NULL)
206		dp++;
207		else
208		addcolor(acol, dp->v);
209		}
210	<	if (ns > 0 && arad > FTINY && ndivs/arad < minarad)
211	<	ns = 0;                 /* close enough */
212	<	else if (ns > 0) {              /* else perform super-sampling */
210	>	if (!divcnt) {
211	>	if (div != NULL)
212	>	free((void *)div);
213	>	return(0.0);            /* no samples taken */
214	>	}
215	>	if (divcnt < hemi.nt*hemi.np) {
216	>	pg = dg = NULL;         /* incomplete sampling */
217	>	hemi.ns = 0;
218	>	} else if (arad > FTINY && divcnt/arad < minarad) {
219	>	hemi.ns = 0;            /* close enough */
220	>	} else if (hemi.ns > 0) {       /* else perform super-sampling? */
221		comperrs(div, &hemi);                   /* compute errors */
222	<	qsort(div, ndivs, sizeof(AMBSAMP), ambcmp);     /* sort divs */
222	>	qsort(div, divcnt, sizeof(AMBSAMP), ambcmp);    /* sort divs */
223		/* super-sample */
224	<	for (i = ns; i > 0; i--) {
225	<	copystruct(&dnew, div);
226	<	if (divsample(&dnew, &hemi, r) < 0)
227	<	goto oopsy;
228	<	/* reinsert */
229	<	dp = div;
230	<	j = ndivs < i ? ndivs : i;
224	>	for (i = hemi.ns; i > 0; i--) {
225	>	dnew = *div;
226	>	if (divsample(&dnew, &hemi, r) < 0) {
227	>	dp++;
228	>	continue;
229	>	}
230	>	dp = div;               /* reinsert */
231	>	j = divcnt < i ? divcnt : i;
232		while (--j > 0 && dnew.k < dp[1].k) {
233	<	copystruct(dp, dp+1);
233	>	*dp = *(dp+1);
234		dp++;
235		}
236	<	copystruct(dp, &dnew);
236	>	*dp = dnew;
237		}
238		if (pg != NULL || dg != NULL)   /* restore order */
239	<	qsort(div, ndivs, sizeof(AMBSAMP), ambnorm);
239	>	qsort(div, divcnt, sizeof(AMBSAMP), ambnorm);
240		}
241		/* compute returned values */
242		if (div != NULL) {
243	<	arad = 0.0;
244	<	for (i = ndivs, dp = div; i-- > 0; dp++) {
243	>	arad = 0.0;             /* note: divcnt may be < nt*np */
244	>	for (i = hemi.nt*hemi.np, dp = div; i-- > 0; dp++) {
245		arad += dp->r;
246		if (dp->n > 1) {
247		b = 1.0/dp->n;
#	Line 227 | Line 253 | FVECT  pg, dg;
253		}
254		b = bright(acol);
255		if (b > FTINY) {
256	<	b = ndivs/b;
256	>	b = 1.0/b;      /* compute & normalize gradient(s) */
257		if (pg != NULL) {
258		posgradient(pg, div, &hemi);
259		for (i = 0; i < 3; i++)
#	Line 238 | Line 264 | FVECT  pg, dg;
264		for (i = 0; i < 3; i++)
265		dg[i] *= b;
266		}
241	–	} else {
242	–	if (pg != NULL)
243	–	for (i = 0; i < 3; i++)
244	–	pg[i] = 0.0;
245	–	if (dg != NULL)
246	–	for (i = 0; i < 3; i++)
247	–	dg[i] = 0.0;
267		}
268		free((void *)div);
269		}
270	<	b = 1.0/ndivs;
252	<	scalecolor(acol, b);
270	>	copycolor(rcol, acol);
271		if (arad <= FTINY)
272		arad = maxarad;
273		else
274	<	arad = (ndivs+ns)/arad;
274	>	arad = (divcnt+hemi.ns)/arad;
275		if (pg != NULL) {               /* reduce radius if gradient large */
276		d = DOT(pg,pg);
277		if (d*arad*arad > 1.0)
#	Line 270 | Line 288 | FVECT  pg, dg;
288		if ((arad /= sqrt(wt)) > maxarad)
289		arad = maxarad;
290		return(arad);
273	–	oopsy:
274	–	if (div != NULL)
275	–	free((void *)div);
276	–	return(0.0);
291		}
292
293
294		void
295	<	inithemi(hp, r, wt)             /* initialize sampling hemisphere */
296	<	register AMBHEMI  *hp;
297	<	RAY  *r;
298	<	double  wt;
295	>	comperrs(                       /* compute initial error estimates */
296	>	AMBSAMP  *da,   /* assumes standard ordering */
297	>	AMBHEMI  *hp
298	>	)
299		{
286	–	register int  i;
287	–	/* set number of divisions */
288	–	if (wt < (.25*PI)/ambdiv+FTINY) {
289	–	hp->nt = hp->np = 0;
290	–	return;                 /* zero samples */
291	–	}
292	–	hp->nt = sqrt(ambdiv * wt / PI) + 0.5;
293	–	hp->np = PI * hp->nt + 0.5;
294	–	/* make axes */
295	–	VCOPY(hp->uz, r->ron);
296	–	hp->uy[0] = hp->uy[1] = hp->uy[2] = 0.0;
297	–	for (i = 0; i < 3; i++)
298	–	if (hp->uz[i] < 0.6 && hp->uz[i] > -0.6)
299	–	break;
300	–	if (i >= 3)
301	–	error(CONSISTENCY, "bad ray direction in inithemi");
302	–	hp->uy[i] = 1.0;
303	–	fcross(hp->ux, hp->uy, hp->uz);
304	–	normalize(hp->ux);
305	–	fcross(hp->uy, hp->uz, hp->ux);
306	–	}
307	–
308	–
309	–	void
310	–	comperrs(da, hp)                /* compute initial error estimates */
311	–	AMBSAMP  *da;           /* assumes standard ordering */
312	–	register AMBHEMI  *hp;
313	–	{
300		double  b, b2;
301		int  i, j;
302	<	register AMBSAMP  *dp;
302	>	AMBSAMP  *dp;
303		/* sum differences from neighbors */
304		dp = da;
305		for (i = 0; i < hp->nt; i++)
#	Line 358 | Line 344 | register AMBHEMI  *hp;
344
345
346		void
347	<	posgradient(gv, da, hp)                         /* compute position gradient */
348	<	FVECT  gv;
349	<	AMBSAMP  *da;                   /* assumes standard ordering */
350	<	register AMBHEMI  *hp;
347	>	posgradient(                                    /* compute position gradient */
348	>	FVECT  gv,
349	>	AMBSAMP  *da,                   /* assumes standard ordering */
350	>	AMBHEMI  *hp
351	>	)
352		{
353	<	register int  i, j;
353	>	int  i, j;
354		double  nextsine, lastsine, b, d;
355		double  mag0, mag1;
356		double  phi, cosp, sinp, xd, yd;
357	<	register AMBSAMP  *dp;
357	>	AMBSAMP  *dp;
358
359		xd = yd = 0.0;
360		for (j = 0; j < hp->np; j++) {
#	Line 410 | Line 397 | register AMBHEMI  *hp;
397		yd += mag0*sinp + mag1*cosp;
398		}
399		for (i = 0; i < 3; i++)
400	<	gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])/PI;
400	>	gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])*(hp->nt*hp->np)/PI;
401		}
402
403
404		void
405	<	dirgradient(gv, da, hp)                         /* compute direction gradient */
406	<	FVECT  gv;
407	<	AMBSAMP  *da;                   /* assumes standard ordering */
408	<	register AMBHEMI  *hp;
405	>	dirgradient(                                    /* compute direction gradient */
406	>	FVECT  gv,
407	>	AMBSAMP  *da,                   /* assumes standard ordering */
408	>	AMBHEMI  *hp
409	>	)
410		{
411	<	register int  i, j;
411	>	int  i, j;
412		double  mag;
413		double  phi, xd, yd;
414	<	register AMBSAMP  *dp;
414	>	AMBSAMP  *dp;
415
416		xd = yd = 0.0;
417		for (j = 0; j < hp->np; j++) {
#	Line 444 | Line 432 | register AMBHEMI  *hp;
432		yd += mag * tsin(phi);
433		}
434		for (i = 0; i < 3; i++)
435	<	gv[i] = (xd*hp->ux[i] + yd*hp->uy[i])/(hp->nt*hp->np);
435	>	gv[i] = xd*hp->ux[i] + yd*hp->uy[i];
436		}

Diff Legend

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