ViewVC Help

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

root/Development/ray/src/hd/rholo3.c

Comparing ray/src/hd/rholo3.c (file contents):
Revision 3.1 by gregl, Fri Oct 31 10:23:29 1997 UTC vs.
Revision 3.7 by gregl, Wed Nov 19 17:05:16 1997 UTC

#	Line 15 | Line 15 | static char SCCSid[] = "$SunId$ SGI";
15		#define sgn(x)          ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)
16
17
18	<	static PACKHEAD *complist;      /* list of beams to compute */
19	<	static int      complen;        /* length of complist */
20	<	static int      listpos;        /* current list position for next_pack */
21	<	static int      lastin;         /* last ordered position in list */
18	>	static PACKHEAD *complist=NULL; /* list of beams to compute */
19	>	static int      complen=0;      /* length of complist */
20	>	static int      listpos=0;      /* current list position for next_packet */
21	>	static int      lastin= -1;     /* last ordered position in list */
22
23
24		int
25	+	beamcmp(b0, b1)                 /* comparison for descending compute order */
26	+	register PACKHEAD       *b0, *b1;
27	+	{
28	+	return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
29	+	b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
30	+	}
31	+
32	+
33	+	bundle_set(op, clist, nents)    /* bundle set operation */
34	+	int     op;
35	+	PACKHEAD        *clist;
36	+	int     nents;
37	+	{
38	+	BEAM    *b;
39	+	PACKHEAD        *p;
40	+	register int    i, n;
41	+
42	+	switch (op) {
43	+	case BS_NEW:                    /* new computation set */
44	+	if (complen)
45	+	free((char *)complist);
46	+	if (nents <= 0) {
47	+	complist = NULL;
48	+	listpos = complen = 0;
49	+	lastin = -1;
50	+	return;
51	+	}
52	+	complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
53	+	if (complist == NULL)
54	+	goto memerr;
55	+	bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
56	+	complen = nents;
57	+	listpos = 0;
58	+	lastin = -1;            /* flag for initial sort */
59	+	break;
60	+	case BS_ADD:                    /* add to computation set */
61	+	if (nents <= 0)
62	+	return;
63	+	/* merge any common members */
64	+	for (i = 0; i < complen; i++)
65	+	for (n = 0; n < nents; n++)
66	+	if (clist[n].bi == complist[i].bi &&
67	+	clist[n].hd == complist[i].hd) {
68	+	complist[i].nr += clist[n].nr;
69	+	clist[n].nr = 0;
70	+	lastin = -1;    /* flag full sort */
71	+	break;
72	+	}
73	+	/* sort updated list */
74	+	sortcomplist();
75	+	/* sort new entries */
76	+	qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
77	+	/* what can't we satisfy? */
78	+	for (n = 0; n < nents && clist[n].nr >
79	+	bnrays(hdlist[clist[n].hd],clist[n].bi); n++)
80	+	;
81	+	if (n) {                /* allocate space for merged list */
82	+	PACKHEAD        *newlist;
83	+	newlist = (PACKHEAD *)malloc(
84	+	(complen+n)*sizeof(PACKHEAD) );
85	+	if (newlist == NULL)
86	+	goto memerr;
87	+	/* merge lists */
88	+	mergeclists(newlist, clist, n, complist, complen);
89	+	if (complen)
90	+	free((char *)complist);
91	+	complist = newlist;
92	+	complen += n;
93	+	}
94	+	listpos = 0;
95	+	lastin = complen-1;     /* list is now sorted */
96	+	break;
97	+	case BS_DEL:                    /* delete from computation set */
98	+	if (nents <= 0)
99	+	return;
100	+	/* find each member */
101	+	for (i = 0; i < complen; i++)
102	+	for (n = 0; n < nents; n++)
103	+	if (clist[n].bi == complist[i].bi &&
104	+	clist[n].hd == complist[i].hd) {
105	+	if (clist[n].nr == 0 ||
106	+	clist[n].nr >= complist[i].nr)
107	+	complist[i].nr = 0;
108	+	else
109	+	complist[i].nr -= clist[n].nr;
110	+	lastin = -1;    /* flag full sort */
111	+	break;
112	+	}
113	+	if (lastin < 0)         /* sort updated list */
114	+	sortcomplist();
115	+	return;                 /* no display */
116	+	default:
117	+	error(CONSISTENCY, "bundle_set called with unknown operation");
118	+	}
119	+	n = RPACKSIZ;                           /* allocate packet holder */
120	+	for (i = 0; i < nents; i++)
121	+	if (clist[i].nr > n)
122	+	n = clist[i].nr;
123	+	p = (PACKHEAD *)malloc(packsiz(n));
124	+	if (p == NULL)
125	+	goto memerr;
126	+	/* display what we have */
127	+	for (i = 0; i < nents; i++)
128	+	if ((b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
129	+	if (b->nrm > n) {
130	+	n = b->nrm;
131	+	p = (PACKHEAD *)realloc((char *)p, packsiz(n));
132	+	if (p == NULL)
133	+	goto memerr;
134	+	}
135	+	bcopy((char *)hdbray(b), (char *)packra(p),
136	+	(p->nr=b->nrm)*sizeof(RAYVAL));
137	+	p->hd = clist[i].hd;
138	+	p->bi = clist[i].bi;
139	+	disp_packet(p);
140	+	}
141	+	free((char *)p);                /* clean up */
142	+	return;
143	+	memerr:
144	+	error(SYSTEM, "out of memory in bundle_set");
145	+	}
146	+
147	+
148	+	int
149		weightf(hp, x0, x1, x2)         /* voxel weighting function */
150		register HOLO   *hp;
151		register int    x0, x1, x2;
#	Line 82 | Line 206 | int    x, y, z, dx, dy, dz;
206		}
207
208
85	–	int
86	–	beamcmp(b0, b1)                 /* comparison for descending compute order */
87	–	register PACKHEAD       *b0, *b1;
88	–	{
89	–	return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
90	–	b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
91	–	}
92	–
93	–
209		init_global()                   /* initialize global ray computation */
210		{
211		long    wtotal = 0;
#	Line 98 | Line 213 | init_global()                  /* initialize global ray computation *
213		int     lseg[2][3];
214		double  frac;
215		register int    k;
216	+	/* free old list */
217	+	if (complen > 0)
218	+	free((char *)complist);
219		/* allocate beam list */
220		complen = 0;
221		for (j = 0; hdlist[j] != NULL; j++)
#	Line 126 | Line 244 | init_global()                  /* initialize global ray computation *
244		while (k--)
245		complist[k].nr = frac * complist[k].nr;
246		}
247	<	listpos = 0; lastin = -1;
247	>	listpos = 0; lastin = -1;       /* flag initial sort */
248		}
249
250
#	Line 156 | Line 274 | int    n1, n2;
274		sortcomplist()                  /* fix our list order */
275		{
276		PACKHEAD        *list2;
277	+	register int    i;
278	+
279		/* empty queue */
280		done_packets(flush_queue());
281	<	if (lastin < 0)         /* flag to sort entire list */
281	>	if (complen <= 0)       /* check to see if there is even a list */
282	>	return;
283	>	if (lastin < 0 || listpos*4 >= complen*3)
284		qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
285		else if (listpos) {     /* else sort and merge sublist */
286		list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
#	Line 170 | Line 292 | sortcomplist()                 /* fix our list order */
292		complist+listpos, complen-listpos);
293		free((char *)list2);
294		}
295	<	listpos = 0; lastin = complen-1;
295	>	/* check for all finished */
296	>	if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
297	>	free((char *)complist);
298	>	complist = NULL;
299	>	complen = 0;
300	>	}
301	>	/* drop satisfied requests */
302	>	for (i = complen; i-- && complist[i].nr <=
303	>	bnrays(hdlist[complist[i].hd],complist[i].bi); )
304	>	;
305	>	if (i < 0) {
306	>	free((char *)complist);
307	>	complist = NULL;
308	>	complen = 0;
309	>	} else if (i < complen-1) {
310	>	list2 = (PACKHEAD *)realloc((char *)complist,
311	>	(i+1)*sizeof(PACKHEAD));
312	>	if (list2 != NULL) {
313	>	complist = list2;
314	>	complen = i+1;
315	>	}
316	>	}
317	>	listpos = 0; lastin = i;
318		}
319
320

Diff Legend

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