ViewVC Help

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

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

Comparing ray/src/rt/srcdraw.c (file contents):
Revision 2.5 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.11 by schorsch, Tue Mar 30 16:13:01 2004 UTC

#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*  External symbols declared in ray.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"
68	–
13		#include  "view.h"
70	–
14		#include  "source.h"
15
16
#	Line 82 | Line 25 | typedef struct splist {
25		struct splist   *next;                  /* next source in list */
26		int     sn;                             /* source number */
27		short   nv;                             /* number of vertices */
28	<	FLOAT   vl[3][2];                       /* vertex array (last) */
28	>	RREAL   vl[3][2];                       /* vertex array (last) */
29		} SPLIST;                               /* source polygon list */
30
31		extern VIEW     ourview;                /* our view parameters */
32		extern int      hres, vres;             /* our image resolution */
33		static SPLIST   *sphead = NULL;         /* our list of source polys */
34
35	+	static int inregion(RREAL p[2], double cv, int crit);
36	+	static void clipregion(RREAL a[2], RREAL b[2], double cv, int crit, RREAL r[2]);
37	+	static int hp_clip_poly(RREAL vl[][2], int nv, double cv, int crit,
38	+	RREAL vlo[][2]);
39	+	static int box_clip_poly(RREAL vl[MAXVERT][2], int nv,
40	+	double xl, double xr, double yb, double ya, RREAL vlo[MAXVERT][2]);
41	+	static double minw2(RREAL vl[][2], int nv, double ar2);
42	+	static void convex_center(RREAL vl[][2], int nv, RREAL cv[2]);
43	+	static double poly_area(RREAL vl[][2], int nv);
44	+	static int convex_hull(RREAL vl[][2], int nv, RREAL vlo[][2]);
45	+	static void spinsert(int sn, RREAL vl[][2], int nv);
46	+	static int sourcepoly(int sn, RREAL sp[MAXVERT][2]);
47
48	+
49		static int
50	<	inregion(p, cv, crit)                   /* check if vertex is in region */
51	<	FLOAT   p[2];
52	<	double  cv;
53	<	int     crit;
50	>	inregion(                       /* check if vertex is in region */
51	>	RREAL   p[2],
52	>	double  cv,
53	>	int     crit
54	>	)
55		{
56		switch (crit) {
57		case CLIP_ABOVE:
#	Line 110 | Line 67 | int    crit;
67		}
68
69
70	<	static
71	<	clipregion(a, b, cv, crit, r)           /* find intersection with boundary */
72	<	register FLOAT  a[2], b[2];
73	<	double  cv;
74	<	int     crit;
75	<	FLOAT   r[2];   /* return value */
70	>	static void
71	>	clipregion(             /* find intersection with boundary */
72	>	register RREAL  a[2],
73	>	register RREAL  b[2],
74	>	double  cv,
75	>	int     crit,
76	>	RREAL   r[2]    /* return value */
77	>	)
78		{
79		switch (crit) {
80		case CLIP_ABOVE:
#	Line 133 | Line 92 | FLOAT  r[2];   /* return value */
92
93
94		static int
95	<	hp_clip_poly(vl, nv, cv, crit, vlo)     /* clip polygon to half-plane */
96	<	FLOAT   vl[][2];
97	<	int     nv;
98	<	double  cv;
99	<	int     crit;
100	<	FLOAT   vlo[][2];       /* return value */
95	>	hp_clip_poly(   /* clip polygon to half-plane */
96	>	RREAL   vl[][2],
97	>	int     nv,
98	>	double  cv,
99	>	int     crit,
100	>	RREAL   vlo[][2]        /* return value */
101	>	)
102		{
103	<	FLOAT   *s, *p;
103	>	RREAL   *s, *p;
104		register int    j, nvo;
105
106		s = vl[nv-1];
#	Line 160 | Line 120 | FLOAT  vlo[][2];       /* return value */
120
121
122		static int
123	<	box_clip_poly(vl, nv, xl, xr, yb, ya, vlo)      /* clip polygon to box */
124	<	FLOAT   vl[MAXVERT][2];
125	<	int     nv;
126	<	double  xl, xr, yb, ya;
127	<	FLOAT   vlo[MAXVERT][2];        /* return value */
123	>	box_clip_poly(  /* clip polygon to box */
124	>	RREAL   vl[MAXVERT][2],
125	>	int     nv,
126	>	double  xl,
127	>	double  xr,
128	>	double  yb,
129	>	double  ya,
130	>	RREAL   vlo[MAXVERT][2] /* return value */
131	>	)
132		{
133	<	FLOAT   vlt[MAXVERT][2];
133	>	RREAL   vlt[MAXVERT][2];
134		int     nvt, nvo;
135
136		nvt = hp_clip_poly(vl, nv, yb, CLIP_BELOW, vlt);
#	Line 179 | Line 143 | FLOAT  vlo[MAXVERT][2];        /* return value */
143
144
145		static double
146	<	minw2(vl, nv, ar2)                      /* compute square of minimum width */
147	<	FLOAT   vl[][2];
148	<	int     nv;
149	<	double  ar2;
146	>	minw2(                  /* compute square of minimum width */
147	>	RREAL   vl[][2],
148	>	int     nv,
149	>	double  ar2
150	>	)
151		{
152		double  d2, w2, w2min, w2max;
153	<	register FLOAT  *p0, *p1, *p2;
153	>	register RREAL  *p0, *p1, *p2;
154		int     i, j;
155		/* find minimum for all widths */
156		w2min = FHUGE;
#	Line 211 | Line 176 | double ar2;
176		}
177
178
179	<	static
180	<	convex_center(vl, nv, cv)               /* compute center of convex polygon */
181	<	register FLOAT  vl[][2];
182	<	int     nv;
183	<	FLOAT   cv[2];          /* return value */
179	>	static void
180	>	convex_center(          /* compute center of convex polygon */
181	>	register RREAL  vl[][2],
182	>	int     nv,
183	>	RREAL   cv[2]           /* return value */
184	>	)
185		{
186		register int    i;
187		/* simple average (suboptimal) */
#	Line 230 | Line 196 | FLOAT  cv[2];          /* return value */
196
197
198		static double
199	<	poly_area(vl, nv)                       /* compute area of polygon */
200	<	register FLOAT  vl[][2];
201	<	int     nv;
199	>	poly_area(                      /* compute area of polygon */
200	>	register RREAL  vl[][2],
201	>	int     nv
202	>	)
203		{
204		double  a;
205	<	FLOAT   v0[2], v1[2];
205	>	RREAL   v0[2], v1[2];
206		register int    i;
207
208		a = 0.;
#	Line 252 | Line 219 | int    nv;
219
220
221		static int
222	<	convex_hull(vl, nv, vlo)                /* compute polygon's convex hull */
223	<	FLOAT   vl[][2];
224	<	int     nv;
225	<	FLOAT   vlo[][2];       /* return value */
222	>	convex_hull(            /* compute polygon's convex hull */
223	>	RREAL   vl[][2],
224	>	int     nv,
225	>	RREAL   vlo[][2]        /* return value */
226	>	)
227		{
228		int     nvo, nvt;
229	<	FLOAT   vlt[MAXVERT][2];
229	>	RREAL   vlt[MAXVERT][2];
230		double  voa, vta;
231		register int    i, j;
232		/* start with original polygon */
#	Line 287 | Line 255 | FLOAT  vlo[][2];       /* return value */
255		}
256
257
258	<	static
259	<	spinsert(sn, vl, nv)                    /* insert new source polygon */
260	<	int     sn;
261	<	FLOAT   vl[][2];
262	<	int     nv;
258	>	static void
259	>	spinsert(                       /* insert new source polygon */
260	>	int     sn,
261	>	RREAL   vl[][2],
262	>	int     nv
263	>	)
264		{
265		register SPLIST *spn;
266		register int    i;
#	Line 299 | Line 268 | int    nv;
268		if (nv < 3)
269		return;
270		if (nv > 3)
271	<	spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(FLOAT)*2*(nv-3));
271	>	spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(RREAL)*2*(nv-3));
272		else
273		spn = (SPLIST *)malloc(sizeof(SPLIST));
274		if (spn == NULL)
#	Line 313 | Line 282 | int    nv;
282		}
283
284
285	<	int
286	<	sourcepoly(sn, sp)                      /* compute image polygon for source */
287	<	int     sn;
288	<	FLOAT   sp[MAXVERT][2];
285	>	static int
286	>	sourcepoly(                     /* compute image polygon for source */
287	>	int     sn,
288	>	RREAL   sp[MAXVERT][2]
289	>	)
290		{
291	<	static char     cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2},
291	>	static short    cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2},
292		{0,1,3,7,6,4},{0,1,5,7,6,2},
293		{0,2,6,7,5,1},{0,4,6,7,3,1},
294		{0,2,3,7,5,4},{1,5,4,6,2,3}};
295		register SRCREC *s = source + sn;
296		FVECT   ap, ip;
297	<	FLOAT   pt[6][2];
297	>	RREAL   pt[6][2];
298		int     dir;
299		register int    i, j;
300
#	Line 340 | Line 310 | FLOAT  sp[MAXVERT][2];
310		for (j = 0; j < 4; j++) {       /* four corners */
311		for (i = 0; i < 3; i++) {
312		ap[i] = s->sloc[i];
313	<	if (j==1|j==2) ap[i] += s->ss[SU][i];
313	>	if ((j==1)|(j==2)) ap[i] += s->ss[SU][i];
314		else ap[i] -= s->ss[SU][i];
315	<	if (j==2|j==3) ap[i] += s->ss[SV][i];
315	>	if ((j==2)|(j==3)) ap[i] += s->ss[SV][i];
316		else ap[i] -= s->ss[SV][i];
317		if (s->sflags & SDISTANT) {
318		ap[i] *= 1. + ourview.vfore;
#	Line 383 | Line 353 | FLOAT  sp[MAXVERT][2];
353
354
355		/* initialize by finding sources smaller than rad */
356	<	init_drawsources(rad)
357	<	int     rad;                            /* source sample size */
356	>	extern void
357	>	init_drawsources(
358	>	int     rad                             /* source sample size */
359	>	)
360		{
361	<	FLOAT   spoly[MAXVERT][2];
361	>	RREAL   spoly[MAXVERT][2];
362		int     nsv;
363		register SPLIST *sp;
364		register int    i;
#	Line 412 | Line 384 | int    rad;                            /* source sample size */
384		}
385		}
386
387	<	void                    /* add sources smaller than rad to computed subimage */
388	<	drawsources(pic, zbf, x0, xsiz, y0, ysiz)
389	<	COLOR   *pic[];                         /* subimage pixel value array */
390	<	float   *zbf[];                         /* subimage distance array (opt.) */
391	<	int     x0, xsiz, y0, ysiz;             /* origin and size of subimage */
387	>	extern void                     /* add sources smaller than rad to computed subimage */
388	>	drawsources(
389	>	COLOR   *pic[],                         /* subimage pixel value array */
390	>	float   *zbf[],                         /* subimage distance array (opt.) */
391	>	int     x0,                             /* origin and size of subimage */
392	>	int     xsiz,
393	>	int     y0,
394	>	int     ysiz
395	>	)
396		{
397	<	FLOAT   spoly[MAXVERT][2], ppoly[MAXVERT][2];
397	>	RREAL   spoly[MAXVERT][2], ppoly[MAXVERT][2];
398		int     nsv, npv;
399		int     xmin, xmax, ymin, ymax, x, y;
400	<	FLOAT   cxy[2];
400	>	RREAL   cxy[2];
401		double  w;
402		RAY     sr;
403		register SPLIST *sp;
#	Line 464 | Line 440 | int    x0, xsiz, y0, ysiz;             /* origin and size of subimag
440		if (source[sp->sn].sflags & SSPOT &&
441		spotout(&sr, source[sp->sn].sl.s))
442		continue;       /* outside spot */
443	<	rayorigin(&sr, NULL, SHADOW, 1.0);
444	<	sr.rsrc = sp->sn;
443	>	w = poly_area(ppoly, npv) * hres * vres;
444	>	if (w < .95) {          /* subpixel source */
445	>	rayorigin(&sr, NULL, SHADOW, 1.0);
446	>	sr.rsrc = sp->sn;
447	>	} else
448	>	rayorigin(&sr, NULL, PRIMARY, 1.0);
449		rayvalue(&sr);          /* compute value */
450		if (bright(sr.rcol) <= FTINY)
451		continue;       /* missed/blocked */
452		/* modify pixel */
453		if (zbf[y-y0] != NULL &&
454	<	sr.rt < 0.999*zbf[y-y0][x-x0])
454	>	sr.rt < 0.99*zbf[y-y0][x-x0])
455		zbf[y-y0][x-x0] = sr.rt;
456		else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
457	<	0.001)) /* source sample */
457	>	0.01))  /* source sample */
458		setcolor(pic[y-y0][x-x0], 0., 0., 0.);
479	–	w = poly_area(ppoly, npv) * hres * vres;
459		scalecolor(sr.rcol, w);
460		scalecolor(pic[y-y0][x-x0], 1.-w);
461		addcolor(pic[y-y0][x-x0], sr.rcol);

Diff Legend

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